萍乡李兴球的博客_信奥C++/Python/Scratch

以下是部分代码预览:

"""
Octopus demo in sea  by lixingqiu
python街机模块arcade制作的模拟海底动画章鱼哥

"""

__author__ = "lixingqiu"
__date__ = "2014/4/3"
__url__ = "https://www.lixingqiu.com/?p=313"
__qq__ = "406273900"

import os
import arcade
import random

SCREEN_WIDTH = 500
SCREEN_HEIGHT = 685
SCREEN_TITLE = "Octopus demo python街机模块arcade制作的模拟海底动画章鱼哥 "

COIN_SCALE = 1.0
COIN_COUNT = 50

MOVEMENT_SPEED = 5

class Actor(arcade.AnimatedTimeSprite):
    def __init__(self,images,scale):
        super().__init__()
        while images:self.textures.append(arcade.load_texture(images.pop(0),scale= scale))

class Octopus(arcade.Sprite):
    def __init__(self,images):
        super().__init__()
        self.costume_amount = len(images)

        
    def alt_costume(self):
        self.frame_counter += 1
       
            
        
class MyGame(arcade.Window): 

    def __init__(self, width, height, title):
        """ 初始化方法      """
        super().__init__(width, height, title)

        self.background = None
        self.octopus = None
        # 定义所有角色列表                    
        self.all_actor_list = None 
 
    def setup(self):
        self.all_actor_list = arcade.SpriteList() 

        bgimages = ["images/bg2" + os.sep  + f"{index:04d}"  + ".png" for index in range(1,16)]
        self.background = Actor(bgimages,1.0)
        self.background.center_x = SCREEN_WIDTH//2
        self.background.center_y = SCREEN_HEIGHT//2
        self.all_actor_list.append(self.background)

        octopus_images = ["images/octopus/" +  str(i) + ".png" for i in range(1,82)]
        self.octopus = Octopus(octopus_images)
        
        self.octopus.center_x = SCREEN_WIDTH//2
        self.octopus.center_y = SCREEN_HEIGHT//2
        self.octopus.alpha =  80
        self.all_actor_list.append(self.octopus)

    def on_draw(self):
        """   渲染屏幕       """
   
        arcade.start_render() 
        self.all_actor_list.draw()   

    def update(self, delta_time):
        """ 更新角色"""

        self.all_actor_list.update()
        self.all_actor_list.update_animation()
        self.octopus.alt_costume()
 

def main():
    """ 主要方法 """
    window = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
    window.setup()
    arcade.run()


if __name__ == "__main__":
    main()

下载完整源代码与素材，请扫码付款。

由于gif截屏软件对图片进行了压缩，所以gif图不怎么漂亮哟。
以下是部分代码预览:

"""
学习Python本领高.py，本程序操作一个小人上下午左右移动收集Python本领。
"""
import os
import time
import arcade
import random


TOTAL_TIME = 100            # 100秒时间
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
SCREEN_TITLE = "学习Python本领高"

COIN_SCALE = 0.5
COIN_COUNT = 2

MOVEMENT_SPEED = 2         # 移动速度常量

SKILLS = ['自动写作业','游戏开发','网站编程','数据库开发','指挥机器人']
SKILLS.extend(['人脸识别','自动下载','自动点赞','识别假粉丝','自动登陆'])
SKILLS.extend(['自动发帖子','自动买零食','自动点赞','识别假粉丝','自动登陆'])
SKILLS.extend(['数据处理','图形处理','自动控制','科学计算','成批处理文件'])
SKILLS.extend(['自动打怪','软件开发','手机APP制作','大型网站开发','制作搜索引擎'])
SKILLS.extend(['语音识别','自动加密','破解密码','数据采集','远程控制'])
SKILLS.extend(['趣味绘画','无人机控制','数据可视化','远程监控','系统运维'])
SKILLS.extend(['远程登陆','硬件开发','大数据统计','人工智能','教别人编程'])
SKILLS.extend(['音乐谱曲','网络安全','大数据统计','人工智能','教别人编程'])

class Explosion(arcade.Sprite):
    """ 创建可爆炸的角色 """ 

    def __init__(self, texture_list,x,y):
        """texture_list是已经load了的造型列表"""
        super().__init__()

        self.center_x = x
        self.center_y = y
        # 第一帧
        self.current_texture = 0      # 这是造型索引号
        self.textures = texture_list  # 这是每帧图片列表
        self.set_texture(self.current_texture)

    def update(self):

        # 更新每帧的图片，到了最后一帧后就会删除自己。
        self.current_texture += 1
        if self.current_texture < len(self.textures):
            self.set_texture(self.current_texture)
        else:
            self.kill()

class Effect(arcade.Sprite):
    def __init__(self,x,y,sc):
        super().__init__("images/lovely_turtle.png",scale=sc)
        self.alpha = 50
        self.center_x = x
        self.center_y = y
        self.change_y = 2
        
    def update(self):
        super().update()
        if self.bottom > SCREEN_HEIGHT :self.kill()        
    
    
class Coin(arcade.AnimatedTimeSprite):
    def __init__(self):
        super().__init__(scale=0.5)
        
        self.center_x = random.randrange(SCREEN_WIDTH)
        self.center_y = random.randrange(SCREEN_HEIGHT,SCREEN_HEIGHT*2)
        self.change_y = -1                      # 会往下掉
        self.textures = []
        self.textures.append(arcade.load_texture("images/gold_1.png", scale=COIN_SCALE))
        self.textures.append(arcade.load_texture("images/gold_2.png", scale=COIN_SCALE))
        self.textures.append(arcade.load_texture("images/gold_3.png", scale=COIN_SCALE))
        self.textures.append(arcade.load_texture("images/gold_4.png", scale=COIN_SCALE))
        self.textures.append(arcade.load_texture("images/gold_3.png", scale=COIN_SCALE))
        self.textures.append(arcade.load_texture("images/gold_2.png", scale=COIN_SCALE))
        self.cur_texture_index = random.randrange(len(self.textures))

        self.string =   random.choice(SKILLS)  # 金币顶上的字

    def update(self):
        super().update()
        if self.top < 0 :self.kill()        

class MyGame(arcade.Window):
    """ 继承自窗口的Window类. """

    def __init__(self, width, height, title):
        """
        初始化方法
        """
        super().__init__(width, height, title)
        self.frame_counter = 0                    # 帧计数器
        self.counter_down = TOTAL_TIME
        self.coin_sound =  arcade.sound.load_sound("images/recording1.wav")# 金币声
        self.bang_sound = arcade.sound.load_sound("images/explosion.wav")  # 爆炸声
        self.begin_time = time.time()
        self.game_over = False
 
    def setup(self):        
        
        self.explosion_images = []


        self.player.texture_change_distance = 20

        self.player.center_x = SCREEN_WIDTH // 2
        self.player.center_y = SCREEN_HEIGHT // 2 -100
        self.player.scale = 0.5
        self.player.lives = 3            # 还剩下的生命个数
        self.player.status = True        # 生命状态        
        self.player.reborn_time = 160    # 初始复活时间 

        for i in range(COIN_COUNT):
            coin = Coin()                
            self.coin_list.append(coin)
            self.all_sprites_list.append(coin)
            
        # 设置背景颜色
        arcade.set_background_color(arcade.color.AMAZON)

    def on_draw(self):
        """
        渲染屏幕
        """

        # 开始渲染屏幕
        arcade.start_render()

        self.background.draw()
        # 画所有的角色
        self.all_sprites_list.draw()

        beyond_border = self.player.left < 0 or self.player.right > SCREEN_WIDTH
        beyond_border = beyond_border or self.player.top < 0 or self.player.bottom > SCREEN_HEIGHT
        if not beyond_border:self.player.draw()
        
        for coin in self.coin_list:             
            x = coin.center_x -35
            y = coin.center_y + 25            
            arcade.draw_text(coin.string, x, y, arcade.color.WHITE, 14,font_name='simhei')            

        # 画文本在屏幕上
        output = f"当前得分: {int(self.score) }"
        arcade.draw_text(output, SCREEN_WIDTH//2-100, SCREEN_HEIGHT-100, arcade.color.CYAN, 24,font_name='simkai')

        # 画倒计时在屏幕上         
        arcade.draw_text(str(int(self.counter_down)), SCREEN_WIDTH//2, SCREEN_HEIGHT-50, arcade.color.WHITE, 14 )

        # 画游戏结束的字在屏幕上
        if self.game_over :                            
            arcade.draw_text(" 游 戏 结 束 ", SCREEN_WIDTH//2-150, SCREEN_HEIGHT//2, arcade.color.WHITE, 44 ,font_name='simkai')
            

    def on_key_release(self, key, modifiers):
        """
        当松开按键时会调用这个函数
        """
        
        if self.game_over : return
        
        if key == arcade.key.UP or key == arcade.key.DOWN:
            self.player.change_y = 0
        elif key == arcade.key.LEFT or key == arcade.key.RIGHT:
            self.player.change_x = 0

    def update(self, delta_time):
        """ 移动与更新游戏的代码在这里编写 """

        if random.randint(1,200) == 1 and not self.game_over : 
            bomb = arcade.Sprite("images/bomb.png")
            bomb.alpha = 50
            self.bomb_list.append(bomb)
            self.all_sprites_list.append(bomb)
            bomb.center_x = random.randrange(SCREEN_WIDTH)
            bomb.center_y = random.randrange(SCREEN_HEIGHT)
            if arcade.get_distance_between_sprites(bomb,self.player)< 100 : bomb.kill()           
            
       


def main():
    """ 主要函数"""
    window = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
     
    window.setup()
    arcade.run()


if __name__ == "__main__":
    main()

如需要查看完整代码,请

以下是部分代码预览:

"""
A Simple Version of Midway Island Naval Warfare with Pthon for Easy Learning by lixingqiu
这个射击游戏是使用Arcade模块制作的。这个版本是核心版本，演示了爆炸效果，类的继承，按键检测等。
其中滚动的背景是使用两张图片制作的，它们相隔SCREEN_HEIGHT的高度。如果图片的top到了最底下，也就是坐标为0了，那么它就瞬间移到最顶上去。
要注意Arcade的坐标系统和数学中的坐标系统一样，在本游戏中是以左下角为原点，y轴正向上。在Pygame中则是左上角为原点，y轴正向下。
"""

__author__ = "lixingqiu"
__date__ = "2019/3/13"
__url__ = "https://www.lixingqiu.com/?p=209"
__qq__ = "406273900"

import os
import random
import arcade

SPRITE_SCALING = 1.0

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
SCREEN_TITLE = "A Simple Version of Midway Island Naval Warfare with Pthon for Easy Learning(Python中途岛海战街机模拟)"
ENEMY_COUNT = 100
MOVEMENT_SPEED  = 5

class Explosion(arcade.Sprite):
    """ 创建可爆炸的角色 create explosion sprite""" 

    def __init__(self, texture_list,x,y):
        """texture_list是已经load了的造型列表"""
        super().__init__()

        self.center_x = x
        self.center_y = y
        # 第一帧
        self.current_texture = 0      # 这是造型索引号
        self.textures = texture_list  # 这是每帧图片列表
        self.set_texture(self.current_texture)

    def update(self):

        # 更新每帧的图片，到了最后一帧后就会删除自己。
        self.current_texture += 1
        if self.current_texture < len(self.textures):
            self.set_texture(self.current_texture)
        else:
            self.kill()

class Bullet(arcade.Sprite):
    """子弹类，继承自Arcade自带的角色类，它从飞机的坐标射出"""
    def __init__(self,image,plane):
        super().__init__(image)
        self.center_x = plane.center_x
        self.center_y = plane.center_y
        self.change_y = 20        

    def update(self):
        """每帧更新坐标 update coordinates"""
        self.center_x += self.change_x
        self.center_y += self.change_y
        if self.bottom >  SCREEN_HEIGHT: self.kill()
        
class Background(arcade.Sprite):
    
    def __init__(self,image):
        super().__init__(image)    
        self.change_y = -10       

    def update(self):
        self.center_x += self.change_x
        self.center_y += self.change_y
        if self.top <=0 : self.bottom = SCREEN_HEIGHT
        
class Enemy(arcade.Sprite):
    def __init__(self,image):
        super().__init__(image)
        self.center_x = random.randrange(SCREEN_WIDTH)
        self.center_y = random.randrange(SCREEN_HEIGHT,SCREEN_HEIGHT*30)

    def update(self):
        
        if self.top<=0:self.kill()
            
        
class MyGame(arcade.Window):
    """ 应用程序主要类. """

    def __init__(self, width, height, title):

        super().__init__(width, height, title)

        # 角色列表定义
        self.all_sprites_list = None
        self.enemy_list = None

        # 定义玩家的相关变量 
        self.score = 0
        self.player_sprite = None

    def start_new_game(self):
        """ 设置与初始化游戏 """            
        sea_image = "images/midway/sea.png"
        # Setting a Fixed Background 设置不动的背景 To cover up rolling background cracks
        self.background = arcade.Sprite(sea_image)
        self.background.center_x = SCREEN_WIDTH // 2
        self.background.bottom = 0
        
        # 设置滚动背景，两个最先画的角色往下移，移到一定坐标就到上面去
        self.background1 = Background(sea_image)
        self.background1.center_x = SCREEN_WIDTH // 2
        self.background1.bottom = 0
        self.all_sprites_list.append(self.background1)
        
        self.background2 = Background(sea_image)
        self.background2.center_x = SCREEN_WIDTH // 2
        self.background2.bottom = SCREEN_HEIGHT  
        self.all_sprites_list.append(self.background2)

        # 1943logo
        self.logo_1943 = arcade.Sprite("images/midway/1943Logo2.png")
        self.logo_1943.center_x  = SCREEN_WIDTH // 2
        self.logo_1943.center_y  = SCREEN_HEIGHT // 2
        self.interval = 60
        self.interval_counter = 0    

    def on_key_release(self, key, modifiers):
        """鼠标松开事件 """
        if self.player_sprite.health <=0 :return
        if key == arcade.key.W or key == arcade.key.S:
            self.player_sprite.change_y = 0
        elif key == arcade.key.A or key == arcade.key.D:
            self.player_sprite.change_x = 0


              
class Cover(arcade.Window):
    """封面类"""
    def __init__(self, width, height, title):

        super().__init__(width, height, title)


        
    def on_key_press(self, key, modifiers):
        """鼠标按键事件 """

        if key == arcade.key.SPACE: # 按空格键关闭窗口
            self.close()
                                        
    def update(self,delta_time):
        self.demo_plane.update()
        self.demo_plane.update_animation()
        
                                        
    def on_draw(self):
        """        渲染屏幕        """

        # 开始渲染，此命令要在所有重画命令之前
        arcade.start_render()
        self.background.draw()
        self.demo_plane.draw()         
        

def main():

    cover = Cover(800, 600, SCREEN_TITLE)
    cover.setup()
    arcade.run()
    
    window = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
    window.start_new_game()
    arcade.run()


if __name__ == "__main__":
    main()

如需要查看完整代码,请

以下是部分代码预览:

"""
小昆虫接金币闯关，这是用Python Arcade街机模块制作的一个多关卡小游戏。
相对于前一个版本，这个游戏有开始界面，不过是用海龟画图模块制作的。
每过一关还有“按空格键进入下一关的“的过关提示画面。

全部关卡过完后，有“通关界面”。本游戏需要先安装arcade模块和有相关素材才能正确运行。
作者是李兴球。
"""

import arcade
import time

SPRITE_SCALING = 1                    # 定义缩放比例
SCREEN_WIDTH = 960                    # 定义所渲染的屏幕宽度 
SCREEN_HEIGHT = 768                   # 定义所渲染的屏幕高度 
SCREEN_TITLE = "有封面和过关界面的_小昆虫接金币闯关_lixingqiu "
SPRITE_PIXEL_SIZE = 64               # 地图方块尺寸 

# 定义物理常数 
MOVEMENT_SPEED = 5
JUMP_SPEED = 23
GRAVITY = 1.1

class MyGame(arcade.Window):
    """ 继承自窗口的游戏类. """

    def __init__(self):
        """
        初始化方法
        """
        super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
        
        # 定义角色列表
        self.wall_list = None
        self.player_list = None
        self.coin_list = None

        # 定义玩家相关变量
        self.score = 0
        self.player_sprite = None

        self.physics_engine = None         
        self.game_over = False
        self.last_time = None       # 用来算fps的上次时间变量
        self.frame_count = 0        # 帧计数器
        self.fps_message = None     # fps字符串

        self.level = 1              # 开始关卡号
        self.max_level = 3          # 关卡数量

    def setup(self):
        """ 设置与初始化变量的值. """
        self.status = "level_end"
        self.level_cover = arcade.Sprite("过关界面.png")
        self.level_cover.textures.append(arcade.load_texture("通关界面.png"))
        self.level_cover.center_x = SCREEN_WIDTH//2
        self.level_cover.center_y = SCREEN_HEIGHT//2
        
        
        # 角色列表初始化
        self.player_list = arcade.SpriteList()
        self.coin_list = arcade.SpriteList()

        # 玩家操作的角色实例化，这里是一只昆虫
        self.player_sprite = arcade.Sprite("images/lixingqiu.png", SPRITE_SCALING*0.5)

        # 给昆虫设定坐标
        self.player_sprite.center_x = 128
        self.player_sprite.center_y = 64
        self.player_list.append(self.player_sprite)

        self.load_level(self.level) # 加载第一关

        self.game_over = False
   

    def on_draw(self):
        """
        渲染屏幕
        """
    
        
    def on_key_press(self, key, modifiers):
        """
        当按键时调用此方法
        """

    def on_key_release(self, key, modifiers):
        """
        当松开键时调用此方法
        """
        if key == arcade.key.LEFT or key == arcade.key.RIGHT:
            self.player_sprite.change_x = 0

    def update(self, delta_time):
        """ 移动与游戏的逻辑，这个方法不断地执行，如果本关金币数加载完了，那么此关结束 """

            
def display_cover(cover_image):
    """显示封面"""
    import turtle
    screen = turtle.Screen()
    screen.bgpic(cover_image)
    screen.setup(SCREEN_WIDTH,SCREEN_HEIGHT)
    screen.title(SCREEN_TITLE)
    screen.onkeypress(lambda:screen.bye(),"space") # 绑定空格键
    screen.listen()
    screen.mainloop()
    
def main():
     
    display_cover("封面.png") 
    window = MyGame()
    window.setup()
    arcade.run()

if __name__ == "__main__":
    main()

如需要查看完整代码,请

这是一个交互动画，本人用python的海龟模块，Pygame模块做过类似的动画，现在又用arcade模块做一下。不过编了个小故事。
以下是部分代码预览:

"""
巫婆和仙女漫游太阳系小故事动画。

仙女教她的外婆仙术，可是她的外婆由于年纪大了，只学了一半，总也飞不起来。所以仙女送了外婆一把天方夜谭里的神扫帚。
就这样，她们一起离开了地球，在太阳系漫游的不亦乐乎。可是，她们也要呼吸啊，带的氧气不多了。还好，西天取经回来的斗战圣佛孙悟空在暗中已经明察秋毫。
他是不是地变一瓶氧气给她们使用。聪明的仙女一子就发现了太阳系会冒出氧气瓶，她们一起收集了一些氧气，造访了水星、金星、火星、木星、土星、天王星之后，还是玩厌了。
空荡荡的太阳系好无聊，其它星球都不适合人也不适合地神仙玩，所以她们想回地球。可是那时候地球已经被邪恶的宇宙超级大BOSS灭霸给锁住了，她们接近地球时只会被撞死。
还好，有惊奇队长和神奇女侠来帮忙了。惊奇队长安装了一个按扭，只要碰到按扭，那么太阳系行星和太阳的时空就会变慢。
神奇女侠送了神秘香蕉，只要吃了香蕉就能进入地球了。快来玩下这个游戏吧，操作方法：
按上下左右方向箭头或awsd箭头一个角色碰触按钮，让另一个角色顺利的吃到香蕉，然后一起飞回地球。
 
"""
import time
import math
import arcade
import random

SCREEN_WIDTH = 1350
SCREEN_HEIGHT = 780
SCREEN_TITLE = "Python街机动画：巫婆和仙女漫游太阳系动画,作者：李兴球"
MOVEMENT_SPEED = 5

class Planet(arcade.Sprite):
   
    def __init__(self,image,position,period):
        """image:造型图片,position：初始坐标，初始角度"""
        super().__init__(image)
        x,y = position
        self.center_x = SCREEN_WIDTH / 2
        self.center_y = SCREEN_HEIGHT / 2           
        self.a = y * 1.5                        # 长半轴
        self.b = y                              # 短半轴
        self.period = period        
        self.direction = 90
        
class Oxygen(arcade.Sprite):
    """氧气瓶类"""
    def __init__(self,image):
        super().__init__(image,0.5)
        self.center_x = random.randrange(SCREEN_WIDTH)
        self.center_y = random.randrange(SCREEN_HEIGHT)
        self.alpha = 80
        
    
class MyGame(arcade.Window):
    """
    继承自窗口的MyGame类.
    """
    timespace = 1                                             # 游戏的时空变量
    can_home = False                                          # 能回家的逻辑变量
    def __init__(self, width, height, title):
        super().__init__(width, height, title)
        self.frame_counter = 0                                # 帧计数器
        self.planet_list = arcade.SpriteList()                # 新建角色列表，以便统一渲染
        self.all_stars_list = arcade.SpriteList()             # 所有星星列表，包括恒星和行星
        self.oxygen_list = arcade.SpriteList()                # 氧气瓶列表
        self.astronaut_list = arcade.SpriteList()             # 宇航员列表
        
    def setup(self):
        """ 这里是对游戏中的各个对象进行设置 """

        # 背景角色生成
        self.background = arcade.Sprite("bg.png")
        self.background.center_x = SCREEN_WIDTH / 2
        self.background.center_y = SCREEN_HEIGHT / 2

        # 太阳角色生成
        self.sun = arcade.AnimatedTimeSprite()                # 新建动画时序角色
        self.sun.center_x = SCREEN_WIDTH//2
        self.sun.center_y = SCREEN_HEIGHT//2   
            
        # 宇航员角色生成
        self.astronaut1 = arcade.Sprite("princess.png",0.25)  # 宇航员1角色,第二个参数是比例
        self.astronaut1.status = "live"                       # 自定义属生，
        self.astronaut1.oxygens = 1000                        # 自定义属性，氧气数量
        self.astronaut1.center_x = 100
        self.astronaut1.center_y = 100
        self.astronaut2 = arcade.Sprite("witch.png",0.25)     # 宇航员2角色,第二个参数是比例
        self.astronaut2.status = "live"                       # 自定义属生，
        self.astronaut2.oxygens = 1000                        # 自定义属性，氧气数量
        self.astronaut2.center_x = SCREEN_WIDTH-100
        self.astronaut2.center_y = SCREEN_HEIGHT-100
        self.astronaut_list.append(self.astronaut1)
        self.astronaut_list.append(self.astronaut2)

            
    def on_key_release(self, key, modifiers):
        """松开按键. """
            
        
    def update(self, x):
        """每帧更新游戏内在逻辑"""       

    
    def on_draw(self):
        """
        渲染屏幕        """            
 

def main():
    """ Main method """
    window = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
    window.setup()
    arcade.run()


if __name__ == "__main__":
    main()

如需要查看完整代码,请

以下是部分代码预览:

"""
小昆虫接金币闯关，这是用Python Arcade街机模块制作的一个多关卡小游戏。游戏虽然简单，但是它演示一个多关卡房间游戏的基本框架。
本游戏首先需要加载tmx格式的地图，它是由Tiled软件制作的。共有3个关卡，小昆虫接完所有道具后自动进入下一关卡。
下一个版本实现昆虫的造型能左右分开，再下一个版本安排一扇门，当接完所有道具后门就显示出来。小昆虫碰到了门才能进入下一关。
再下一个版本实现可移动的敌人，小昆虫碰到敌人游戏就会失败。再下一个版本加一个封面和结尾，剧终。

"""

import arcade
import time

SPRITE_SCALING = 1                    # 定义缩放比例
SCREEN_WIDTH = 960                    # 定义所渲染的屏幕宽度 
SCREEN_HEIGHT = 768                   # 定义所渲染的屏幕高度 
SCREEN_TITLE = "Python平铺地图多关卡示例_ "
SPRITE_PIXEL_SIZE = 64               # 地图方块尺寸 

# 定义物理常数 
MOVEMENT_SPEED = 5
JUMP_SPEED = 23
GRAVITY = 1.1

class MyGame(arcade.Window):
    """ 继承自窗口的游戏类. """

    def __init__(self):
        """
        初始化方法
        """
        super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
        
        # 定义角色列表
        self.wall_list = None
        self.player_list = None
        self.coin_list = None

        # 定义玩家相关变量
        self.score = 0
        self.player_sprite = None

        self.physics_engine = None         
        self.game_over = False
        self.last_time = None       # 用来算fps的上次时间变量
        self.frame_count = 0        # 帧计数器
        self.fps_message = None     # fps字符串

        self.level = 1              # 开始关卡号
        self.max_level = 3          # 关卡数量

    def setup(self):
        """ 设置与初始化变量的值. """

        # 角色列表初始化
        self.player_list = arcade.SpriteList()
        self.coin_list = arcade.SpriteList()

        # 玩家操作的角色实例化，这里是一只昆虫
        self.player_sprite = arcade.Sprite("images/lixingqiu.png", SPRITE_SCALING*0.5)

        # 给昆虫设定坐标
        self.player_sprite.center_x = 128
        self.player_sprite.center_y = 64
        self.player_list.append(self.player_sprite)

        self.load_level(self.level) # 加载第一关

        self.game_over = False
   

    def on_draw(self):
        """
        渲染屏幕
        """
        self.frame_count += 1      # 帧计数器

        # 开始渲染屏幕
        arcade.start_render()

    def on_key_press(self, key, modifiers):
        """
        当按键时调用此方法
        """
        if key == arcade.key.UP:
            if self.physics_engine.can_jump():          # 这里是检测有没有在地面
                self.player_sprite.change_y = JUMP_SPEED
        elif key == arcade.key.LEFT:
            self.player_sprite.change_x = -MOVEMENT_SPEED
        elif key == arcade.key.RIGHT:
            self.player_sprite.change_x = MOVEMENT_SPEED

    def on_key_release(self, key, modifiers):
        """
        当松开键时调用此方法
        """
        if key == arcade.key.LEFT or key == arcade.key.RIGHT:
            self.player_sprite.change_x = 0

    def update(self, delta_time):
        """ 移动与游戏的逻辑，这个方法不断地执行，如果本关金币数加载完了，那么此关结束 """

def main():
    window = MyGame()
    window.setup()
    arcade.run()


if __name__ == "__main__":
    main()

如需要查看完整代码,请

以下是部分代码预览:

"""本程序会不断地重画背景图片,定义了一个游戏类"""

import arcade

SCREEN_WIDTH = 500
SCREEN_HEIGHT = 685
SCREEN_TITLE = "arcade制作动态背景_使用面向对象编程方法继承Window类"

class MyGame(arcade.Window):    
    def __init__(self):         
        super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
        self.backgrounds = arcade.AnimatedTimeSprite()        # 新建时序角色
        
    def on_draw(self):
        """每帧都会自动重画所有对象 """
        arcade.start_render()    
        self.backgrounds.draw()
        
    def update(self,delta_time):
         
        self.backgrounds.update_animation()  # 更新动画
        

如需要查看完整代码,请

这个程序演示了用Arcade街机模块制作一个收集金币的游戏。通过鼠标操作角色去碰撞金币，金币就会消失。运用了角色实例化，角色列表实例化，鼠标移动事件，碰撞检测等“技术”。

以下是部分代码预览:

import arcade
import random

SCREEN_WIDTH = 800                                                    #  常量定义，屏幕宽度
SCREEN_HEIGHT = 600                                                   #   常量定义,屏幕高度
SCREEN_TITLE = "Arcade最简收集金币小程序_作者：李兴球"                # 常量定义,屏幕标题

class MyGame(arcade.Window):
    """    继承自窗口类的游戏类，在具体的游戏中，重写以下方法，删除不需要重写的方法。    """

    def __init__(self, width, height, title):
        super().__init__(width, height, title)                      #  调用父类的初始化方法新建一个窗口
        arcade.set_background_color(arcade.color.AMAZON)            #  设置背景颜色为亚马逊绿
        
    def setup(self):
        """ 这个方法是在实例化Mygame后对游戏进行一些设置。 """
        self.player = arcade.Sprite("characterx.png")               # 给游戏添加一个玩家控制的角色  
        self.coin_list = arcade.SpriteList()                        # 实例化一个金币列表
        for i in range(50):
            coin = arcade.Sprite("coin_01x.png")                    # 实例化一枚金币
            coin.center_x = random.randrange(SCREEN_WIDTH)
            coin.center_y = random.randrange(SCREEN_HEIGHT)
            self.coin_list.append(coin)
            

    def on_draw(self):
        """ 渲染屏幕  ，帧率为60左右，即每60份之一秒会自动调用此方法     """        
        arcade.start_render()                      # 此命令会用背景色填充屏幕，然后可以在这个代码下用draw命令画其它角色        
        self.coin_list.draw()                      # 先画所有金币
        self.player.draw()                         # 再画玩家

    def update(self, delta_time):
        """ 所有的角色移动等游戏逻辑都在这里编写代码   """

    
    def on_mouse_motion(self, x, y, delta_x, delta_y):
        """ 当鼠标移动时会自动地调用此方法 """


def main():
    """主要的函数"""
    game = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)  # 实例化一个游戏
    game.setup()                                              # 对游戏进行设置
    arcade.run()                                              # 进入循环

if __name__ == "__main__":  
      main()

如需要查看完整代码,请

以下是部分代码预览:

import arcade
 
class MyGame(arcade.Window):     

    def __init__(self):         
        super().__init__(600, 600, "arcade最简单的鼠标移动角色_lixingqiu")
        # 设置背景颜色
        arcade.set_background_color(arcade.color.AMAZON)
        # 实例化玩家
        self.player = arcade.Sprite("character.png")
        self.player.center_x = 50
        self.player.center_y = 50
        
    def on_draw(self):
        """每帧都会自动重画所有对象 """
        arcade.start_render()    
 
 
    def on_mouse_motion(self, x, y, dx, dy):
        """当鼠标指针移动时会自动调用此方法""" 


if __name__ == "__main__":
    
    window = MyGame()   
    arcade.run() 

如需要查看完整代码,请

以下是部分代码预览:

"""
Arcade街机平铺地图多关卡示例
本程序加载tmx地图，生成关卡，根据角色到达地图最右边界来决定进入下一关的。

"""

import arcade
import os
import time

SPRITE_SCALING = 0.5

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
SCREEN_TITLE = "Python平铺地图多关卡示例_by lixingqiu"
SPRITE_PIXEL_SIZE = 128
GRID_PIXEL_SIZE = (SPRITE_PIXEL_SIZE * SPRITE_SCALING)

# 视口边距
VIEWPORT_MARGIN_TOP = 60
VIEWPORT_MARGIN_BOTTOM = 60
VIEWPORT_RIGHT_MARGIN = 270
VIEWPORT_LEFT_MARGIN = 270

# Physics
MOVEMENT_SPEED = 5
JUMP_SPEED = 23
GRAVITY = 1.1


class MyGame(arcade.Window):
    """ 继承自窗口的游戏类. """

    def __init__(self):
        """
        初始化方法
        """
        super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
        
        # 定义角色列表
        self.wall_list = None
        self.player_list = None
        self.coin_list = None

        # 定义玩家相关变量
        self.score = 0
        self.player_sprite = None

        self.physics_engine = None
        self.view_left = 0
        self.view_bottom = 0
        self.game_over = False
        self.last_time = None       # 用来算fps的上次时间变量
        self.frame_count = 0        # 帧计数器
        self.fps_message = None     # fps字符串

        self.level = 1
        self.max_level = 2

    def setup(self):
        """ 设置与初始化变量的值. """

        # 角色列表初始化
        self.player_list = arcade.SpriteList()
        self.coin_list = arcade.SpriteList()

        # 玩家操作的角色实例化，这里是一只昆虫
        self.player_sprite = arcade.Sprite("images/lixingqiu.png", SPRITE_SCALING)

        # 给昆虫设定坐标
        self.player_sprite.center_x = 64
        self.player_sprite.center_y = 64
        self.player_list.append(self.player_sprite)

        self.load_level(self.level) # 加载第一关

        self.game_over = False

    def load_level(self, level):
        # 读取第一关的地图
        my_map = arcade.read_tiled_map(f"level_{level}.tmx", SPRITE_SCALING)

        # 其它情况，如有背景颜色属性
        if my_map.backgroundcolor:
            arcade.set_background_color(my_map.backgroundcolor)

        # 设置视口以便移动这个矩形
        self.view_left = 0
        self.view_bottom = 0

    def on_draw(self):
        """
        渲染屏幕
        """

        self.frame_count += 1      # 帧计数器

        # 开始渲染屏幕
        arcade.start_render()

        # 画所有的角色
        self.player_list.draw()
        self.wall_list.draw()
        self.coin_list.draw()


    def on_key_press(self, key, modifiers):
        """
        当按键时调用此方法
        """
        if key == arcade.key.UP:
            if self.physics_engine.can_jump():
                self.player_sprite.change_y = JUMP_SPEED
        elif key == arcade.key.LEFT:
            self.player_sprite.change_x = -MOVEMENT_SPEED
        elif key == arcade.key.RIGHT:
            self.player_sprite.change_x = MOVEMENT_SPEED

    def on_key_release(self, key, modifiers):
        """
        当松开键时调用此方法
        """
        if key == arcade.key.LEFT or key == arcade.key.RIGHT:
            self.player_sprite.change_x = 0

    def update(self, delta_time):
        """ 移动与游戏的逻辑 """


def main():
    window = MyGame()
    window.setup()
    arcade.run()


if __name__ == "__main__":
    main()

如需要查看完整代码,请

以下是部分代码预览:

"""
双人游戏Arcade街机模块让角色上下斜坡示例。
本程序加载csv地图，根据数字映射加载相应的图块，生成地图。
 
"""
import arcade
import os

SPRITE_SCALING = 0.5

SCREEN_WIDTH = 600
SCREEN_HEIGHT = 600
SCREEN_TITLE = "双人游戏让角色上下斜坡示例:lixingqiu译"
SPRITE_PIXEL_SIZE = 128
GRID_PIXEL_SIZE = (SPRITE_PIXEL_SIZE * SPRITE_SCALING)

# 视口边距
VIEWPORT_MARGIN = 40
RIGHT_MARGIN = 150

# 物理参数
MOVEMENT_SPEED = 5
JUMP_SPEED = 14
GRAVITY = 0.5


def get_map():
    """加载以逗号隔开的csv地图，它其实只是一个地图块的二维映射"""
    map_file = open("map_with_ramps_2.csv")
    map_array = []
    for line in map_file:
        line = line.strip()
        map_row = line.split(",")
        for index, item in enumerate(map_row):
            map_row[index] = int(item)
        map_array.append(map_row)
    return map_array


class MyGame(arcade.Window):
    """ 主应用程序类，继承自Arcade的窗口类. """

    def __init__(self, width, height, title):
        """
        初始化方法，参数为宽度，高度，标题
        """

        super().__init__(width, height, title)

        # 设置工作目录
        file_path = os.path.dirname(os.path.abspath(__file__))
        os.chdir(file_path)

        # 角色列表定义
        self.all_sprites_list = None
        self.coin_list = None
        self.player_list = None

        # 玩家定义
        self.player_sprite = None
        self.wall_list = None
        self.physics_engine = None
        self.physics_engine2 = None
        self.view_left = 0
        self.view_bottom = 0
        self.game_over = False

    def start_new_game(self):
        """ Set up the game and initialize the variables. """

        # 实例化角色列表
        self.all_sprites_list = arcade.SpriteList()
        self.wall_list = arcade.SpriteList()
        self.player_list = arcade.SpriteList()

        # 实例化玩家1
        self.player_sprite = arcade.Sprite("images/character.png",
                                           SPRITE_SCALING)
        self.player_sprite.center_x = 64
        self.player_sprite.center_y = 270
        self.player_list.append(self.player_sprite)
        self.all_sprites_list.append(self.player_sprite)

        
        # 实例化玩家2
        self.player_sprite2 = arcade.Sprite("images/character.png",
                                           SPRITE_SCALING)
        self.player_sprite2.center_x = 128
        self.player_sprite2.center_y = 270
        self.player_list.append(self.player_sprite2)
        self.all_sprites_list.append(self.player_sprite2)
        

        map_array = get_map()

        # 设置背景颜色为亚马逊深绿色
        arcade.set_background_color(arcade.color.AMAZON)

        # 设置初始的视口边界
        # 这些值就是我们要滚到的地方
        self.view_left = 0
        self.view_bottom = 0

        self.game_over = False

    def on_draw(self):
        """
        Render the screen.
        """

        # 在绘画之前此渲染命令要先执行
        arcade.start_render()

        # 画所有的角色
        self.wall_list.draw()
        self.player_list.draw()


    def on_key_press(self, key, modifiers):
        """
        按任意键时调用此方法
        """

    def on_key_release(self, key, modifiers):
        """
        松任意键时调用此方法.
        """
        if key == arcade.key.LEFT or key == arcade.key.RIGHT:
            self.player_sprite.change_x = 0
        if key == arcade.key.A or key == arcade.key.D:
            self.player_sprite2.change_x = 0

    def update(self, delta_time):
        """ Movement and game logic """

        if self.player_sprite.right >= self.end_of_map: # 玩家跳出地图总宽度游戏结束
            self.game_over = True
            
        if self.player_sprite2.right >= self.end_of_map: # 玩家跳出地图总宽度游戏结束
            self.game_over = True


        # 所有角色更新
        if not self.game_over:
            self.physics_engine.update()
            self.physics_engine2.update()



def main():
    window = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
    window.start_new_game()
    arcade.run()


if __name__ == "__main__":
    main()

如需要查看完整代码,请