萍乡李兴球的博客_信奥C++/Python/Scratch | 萍乡信息学奥赛科技特长生培育，报名电话:13507998321

arcade角色面向左或右造型示例

发表于28 2 月, 2019由李兴球

以下是部分代码预览:

"""
Sprite Facing Left or Right
角色面向左或右造型示例，这个程序需要街机模块支持。2019-2-28最新版本安装方法：
在命令提示符中输入以下命令：pip install arcade==2.0.0b4
如果缺少ffmpeg，则再次用pip命令安装即可。
Arcade模块是用来制作街机游戏的一个库。
"""

import arcade      # 导入街机模块
import os          # 导入os模块

SPRITE_SCALING = 0.5 # 常量定义，角色比例

SCREEN_WIDTH = 800   # 常量定义，屏幕宽度
SCREEN_HEIGHT = 600  # 常量定义，屏幕高度
SCREEN_TITLE = "角色面向左或右造型示例"

MOVEMENT_SPEED = 5

TEXTURE_LEFT = 0
TEXTURE_RIGHT = 1

class Player(arcade.Sprite):

    def __init__(self):
        super().__init__()
        # 缺省是朝右方向的
        self.set_texture(TEXTURE_RIGHT) #  TEXTURE_RIGHT就是1
        
    def update(self):
        self.center_x += self.change_x
        self.center_y += self.change_y

class MyGame(arcade.Window):
    """
    Main application class.
    """

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

        # 调用父类初始化方法
        super().__init__(width, height, title)

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

        # 所有角色列表的定义
        self.all_sprites_list = None

        # 玩家角色的定义
        self.player_sprite = None

        # 背景颜色的设置
        arcade.set_background_color(arcade.color.AMAZON)

    def setup(self):
        """ 设置游戏，初始化变量. """

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

        # 实例化玩家对象
        self.player_sprite = Player()
        self.player_sprite.center_x = SCREEN_WIDTH / 2  # 屏幕x中央
        self.player_sprite.center_y = SCREEN_HEIGHT / 2 # 屏幕y中央
        self.all_sprites_list.append(self.player_sprite)# 添加到所有角色列表

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

        # 开始重画所有
        arcade.start_render()

        # 正式地画所有角色.
        self.all_sprites_list.draw()

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

        # 所有角色更新坐标等等
        self.all_sprites_list.update()

    def on_key_press(self, key, modifiers):
        """按键检测 """      

    def on_key_release(self, key, modifiers):
        """松键检测 """

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


if __name__ == "__main__":
    main()

如需要查看完整代码,请

成为会员后，登陆才能继续浏览！联系微信scratch8即可办理会员。
(会员专属：能浏览所有文章，下载所有带链接的Python资源。)

发表在 arcade, python | 已关闭评论

可旋转的顶点缓冲对象和彩色折线条示例

发表于26 2 月, 2019由李兴球

"""
顶点缓冲对象和彩色折线条示例
"""
import arcade
import random

# Do the math to figure out our screen dimensions
SCREEN_WIDTH = 480
SCREEN_HEIGHT = 360
SCREEN_TITLE = "顶点缓冲对象和彩色折线条示例,www.lixingqiu.com"

class MyGame(arcade.Window):
    """
    Main application class.
    """

    def __init__(self, width, height, title):
        """
        设置应用程序
        """
        super().__init__(width, height, title)

        self.shape_list = arcade.ShapeElementList() # 形状项目列表
        point_list = ((0, 50),
                      (10, 10),
                      (50, 0),
                      (10, -10),
                      (0, -50),
                      (-10, -10),
                      (-50, 0),
                      (-10, 10),
                      (0, 50))
        # 获取所有颜色列表
        colors = [ getattr(arcade.color, color) for color in dir(arcade.color) if not color.startswith("__") ]
        print(colors)
        for i in range(200):
            x = SCREEN_WIDTH // 2 - random.randrange(SCREEN_WIDTH)
            y = SCREEN_HEIGHT // 2 - random.randrange(SCREEN_HEIGHT)
            color = random.choice(colors)
            points = [(px + x, py + y) for px, py in point_list]

            my_line_strip = arcade.create_line_strip(points, color, 5)
            self.shape_list.append(my_line_strip)

        self.shape_list.center_x = SCREEN_WIDTH // 2
        self.shape_list.center_y = SCREEN_HEIGHT // 2
        self.shape_list.angle = 0

        arcade.set_background_color(arcade.color.BLACK)

    def on_draw(self):
        """
        Render the screen.
        """
        # 开始渲染
        arcade.start_render()

        self.shape_list.draw()

    def update(self, delta_time):
        self.shape_list.angle += 1
        self.shape_list.center_x += 0.1
        self.shape_list.center_y += 0.1


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


if __name__ == "__main__":
    main()

顶点缓冲对象和彩色折线条示例,www.lixingqiu.com

发表在 arcade | 已关闭评论

游戏介绍封面制作示例，本程序会教你如何制作游戏封面与游戏结束，充许重启游戏

发表于26 2 月, 2019由李兴球

"""

游戏介绍封面制作示例，本程序会教你如何制作游戏封面与游戏结束，充许重启游戏


"""

import arcade
import random
import os

SPRITE_SCALING = 0.5

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
SCREEN_TITLE = "游戏介绍封面制作示例,注释：李兴球"

# 这些常量代表游戏的状态
INSTRUCTIONS_PAGE_0 = 0
INSTRUCTIONS_PAGE_1 = 1
GAME_RUNNING = 2
GAME_OVER = 3


class MyGame(arcade.Window):
    """
    Main application class.
    """

    def __init__(self, screen_width, screen_height, title):
        """ 构造方法 """
        # 调用父类方法创建窗口
        super().__init__(screen_width, screen_height, title)

        # 设置工作目录，为用python -m 启动游戏而设
        file_path = os.path.dirname(os.path.abspath(__file__))
        os.chdir(file_path)

        # 设置背景颜色
        arcade.set_background_color(arcade.color.AMAZON)

        # 起动游戏将会显示第一页，这就是一个列表的索引号
        self.current_state = INSTRUCTIONS_PAGE_0

        self.player_list = None
        self.coin_list = None

        # Set up the player
        self.score = 0
        self.player_sprite = None

        # 第一步：把每页指令图像放到列表，大小要和屏幕一样，否则会被拉伸而变得难看。
        # STEP 1: Put each instruction page in an image. Make sure the image
        # matches the dimensions of the window, or it will stretch and look
        # ugly. You can also do something similar if you want a page between
        # each level.
        self.instructions = []       # 这个列表存放每个介绍页
        texture = arcade.load_texture("images/instructions_0.png")
        self.instructions.append(texture)

        texture = arcade.load_texture("images/instructions_1.png")
        self.instructions.append(texture)

    def setup(self):
        """
        设置游戏
        """
        # 新建玩家角色列表
        self.player_list = arcade.SpriteList()
        self.coin_list = arcade.SpriteList()

        # 设置玩家
        self.score = 0
        self.player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING)
        self.player_sprite.center_x = 50
        self.player_sprite.center_y = 50
        self.player_list.append(self.player_sprite)

        for i in range(50):

            # 创建金币实例
            coin = arcade.Sprite("images/coin_01.png", SPRITE_SCALING / 3)

            # 随机放置
            coin.center_x = random.randrange(SCREEN_WIDTH)
            coin.center_y = random.randrange(SCREEN_HEIGHT)

            # 增加到金币列表
            self.coin_list.append(coin)

        # 不显示鼠标
        self.set_mouse_visible(False)

    # 第2步: 增加此函数
    def draw_instructions_page(self, page_number):
        """根据索引号取纹理图，画纹理图
        Draw an instruction page. Load the page as an image.
        """
        page_texture = self.instructions[page_number]
        arcade.draw_texture_rectangle(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2,
                                      page_texture.width,
                                      page_texture.height, page_texture, 0)


    # 第3步: 增加此函数
    def draw_game_over(self):
        """在屏幕上画 游戏结束 和 单击重启
        Draw "Game over" across the screen.
        """
        output = "Game Over"
        arcade.draw_text(output, 240, 400, arcade.color.WHITE, 54)

        output = "Click to restart"
        arcade.draw_text(output, 310, 300, arcade.color.WHITE, 24)

    # 第4步: 定义画游戏中的角色的函数。
    # Take the drawing code you currently have in your
    # on_draw method AFTER the start_render call and MOVE to a new
    # method called draw_game.
    def draw_game(self):
        """
        画所有的角色和在得分文本
        """
        # 画所有的角色
        self.player_list.draw()
        self.coin_list.draw()

        # 把得分放在屏幕上
        output = f"Score: {self.score}"
        arcade.draw_text(output, 10, 20, arcade.color.WHITE, 14)

    # 第5步: 根据current_state索引号画不同的画面
    def on_draw(self):
        """
        Render the screen.
        """

        # 开始画
        arcade.start_render()
        # 如果是第一页，则画第一张纹理图
        if self.current_state == INSTRUCTIONS_PAGE_0:
            self.draw_instructions_page(0)

        elif self.current_state == INSTRUCTIONS_PAGE_1:
            self.draw_instructions_page(1)

        elif self.current_state == GAME_RUNNING:
            self.draw_game()

        else:                       
            self.draw_game()
            self.draw_game_over()

    # 第6步: Do something like adding this to your on_mouse_press to flip
    # between instruction pages.
    def on_mouse_press(self, x, y, button, modifiers):
        """
        单击事件，游戏启动时显示第一页，单击后显示第二页，再单击显示游戏画面。
        """

        # 单击后，如果索引号为0，则把它的值设为.INSTRUCTIONS_PAGE_1
        if self.current_state == INSTRUCTIONS_PAGE_0:
           
            self.current_state = INSTRUCTIONS_PAGE_1
        elif self.current_state == INSTRUCTIONS_PAGE_1:
            # 启动游戏
            self.setup()
            self.current_state = GAME_RUNNING
        elif self.current_state == GAME_OVER:
            # 重启游戏
            self.setup()
            self.current_state = GAME_RUNNING

    def on_mouse_motion(self, x, y, dx, dy):
        """
        当鼠标移动时调用此函数
        """
        # 角色跟随鼠标
        if self.current_state == GAME_RUNNING:
            self.player_sprite.center_x = x
            self.player_sprite.center_y = y

    # 第7步: 只有当currrent_state这个索引号为GAME_RUNNING时才更新
    def update(self, delta_time):
        """ Movement and game logic """

        # 如果current_state的值等于GAME_RUNNING
        if self.current_state == GAME_RUNNING:
            # 更新角色组
            self.coin_list.update()
            self.player_list.update()

            # 玩家和金币组的碰撞检测，返回列表
            hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.coin_list)

            # 遍历碰到的金币，删除它们并加分
            for coin in hit_list:
                coin.kill()
                self.score += 1

            # 金币组长度为0，重启游戏
            if len(self.coin_list) == 0:
                self.current_state = GAME_OVER
                self.set_mouse_visible(True)


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


if __name__ == "__main__":
    main()

发表在 arcade | 已关闭评论

如何用Python的街机游戏模块创建2D游戏

发表于23 2 月, 2019由李兴球

本篇介绍的街机模块入门，这是创建2D视频游戏的一个Python库。译者：李兴球，原作者：Paul Vincent Craven。

python街机模块游戏库入门案例图片跳跃的小人

python街机模块游戏库入门案例图片跳跃的小人对于学习编程的人来说，Python是一种出色的计算机语言，对于那些想“完成工作”而不想花大量时间来研究所谓样板代码上的人来说，它是非常不错的。Arcade是一个用于创建二维视频游戏的python库，它很容易地就能开始使用，并且在获得体验时非常有用。在本文中，我将解释如何开始使用Python和Arcade模块来编写视频游戏。

在教学生使用Pyaame游戏库后，我开始开发街机模块。我亲自使用Pygame教了将近10年，我开发了programmarcadegames.com网站进行Python游戏编程在线教学。Pygame很好，但最终我觉得我在浪费时间去弥补那些从未修复过的漏洞。

比如事件循环这样的编码，我觉得不必教了，这不再是我们编码的方式了。经常需要解释为什么y坐标是颠倒的。pygame很少更新，它是基于一个旧的SDL 1库，而不是像OpenGL这样更现代的库，所以我对Pygame的未来没有抱太大的希望。

我想要一个更容易使用、更强大的库，并使用了Python3的一些新特性，比如装饰和类型暗示。Arcade街机模块就是这样的，现在让我们开始入门吧。

安装：

和许多其他软件包一样，Arcade模块可通过pypi提供，这意味着您可以使用pip命令（或pipenv命令）安装Arcade。如果已经安装了python，则可能只需在Windows上打开命令提示符并键入：pip install arcade，或者在苹果机和Linux机器上通过以下命令安装：pip3 install arcade ，单击这个链接可查看更多的安装信息：http://arcade.academy/installation.html。

简单绘画：

您可以打开一个窗口，用几行代码创建简单的图形。让我们创建一个例子来画一个笑脸，如下图所示：

python街机游戏模块画笑脸

下面的脚本显示了如何使用Arcade的绘图命令来执行此操作。注意，您不需要知道如何使用类，甚至不需要定义函数。用快速的视觉反馈编程对于任何想开始学习编程的人都是很好的。

import arcade

# Set constants for the screen size
SCREEN_WIDTH = 600
SCREEN_HEIGHT = 600

# Open the window. Set the window title and dimensions (width and height)
arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, "Drawing Example")

# Set the background color to white.
# For a list of named colors see:
# http://arcade.academy/arcade.color.html
# Colors can also be specified in (red, green, blue) format and
# (red, green, blue, alpha) format.
arcade.set_background_color(arcade.color.WHITE)

# Start the render process. This must be done before any drawing commands.
arcade.start_render()

# Draw the face
x = 300
y = 300
radius = 200
arcade.draw_circle_filled(x, y, radius, arcade.color.YELLOW)

# Draw the right eye
x = 370
y = 350
radius = 20
arcade.draw_circle_filled(x, y, radius, arcade.color.BLACK)

# Draw the left eye
x = 230
y = 350
radius = 20
arcade.draw_circle_filled(x, y, radius, arcade.color.BLACK)

# Draw the smile
x = 300
y = 280
width = 120
height = 100
start_angle = 190
end_angle = 350
arcade.draw_arc_outline(x, y, width, height, arcade.color.BLACK, start_angle, end_angle, 10)

# Finish drawing and display the result
arcade.finish_render()

# Keep the window open until the user hits the 'close' button
arcade.run()

使用函数：

当然，使用全局变量在编程中不是个好习惯。幸运的是，通过使用函数来改善程序是很容易的。这里我们可以看到一个使用函数在特定（x，y）位置绘制松树的示例：

"""
Example "Arcade" library code.

This example shows how to use functions to draw a scene.
It does not assume that the programmer knows how to use classes yet.

A video walk-through of this code is available at:


If Python and Arcade are installed, this example can be run from the command line with:
python -m arcade.examples.drawing_with_functions
"""

# Library imports
import arcade

# Constants - variables that do not change
SCREEN_WIDTH = 600
SCREEN_HEIGHT = 600
SCREEN_TITLE = "Drawing With Functions Example"

def draw_background():
    """
    This function draws the background. Specifically, the sky and ground.
    """
    # Draw the sky in the top two-thirds
    arcade.draw_lrtb_rectangle_filled(0,
                                      SCREEN_WIDTH,
                                      SCREEN_HEIGHT,
                                      SCREEN_HEIGHT * (1 / 3),
                                      arcade.color.SKY_BLUE)

    # Draw the ground in the bottom third
    arcade.draw_lrtb_rectangle_filled(0,
                                      SCREEN_WIDTH,
                                      SCREEN_HEIGHT / 3,
                                      0,
                                      arcade.color.DARK_SPRING_GREEN)


def draw_bird(x, y):
    """
    Draw a bird using a couple arcs.
    """
    arcade.draw_arc_outline(x, y, 20, 20, arcade.color.BLACK, 0, 90)
    arcade.draw_arc_outline(x + 40, y, 20, 20, arcade.color.BLACK, 90, 180)


def draw_pine_tree(x, y):
    """
    This function draws a pine tree at the specified location.
    """
    # Draw the triangle on top of the trunk
    arcade.draw_triangle_filled(x + 40, y,
                                x, y - 100,
                                x + 80, y - 100,
                                arcade.color.DARK_GREEN)

    # Draw the trunk
    arcade.draw_lrtb_rectangle_filled(x + 30, x + 50, y - 100, y - 140,
                                      arcade.color.DARK_BROWN)


def main():
    """
    This is the main program.
    """

    # Open the window
    arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)

    # Start the render process. This must be done before any drawing commands.
    arcade.start_render()

    # Call our drawing functions.
    draw_background()
    draw_pine_tree(50, 250)
    draw_pine_tree(350, 320)
    draw_bird(70, 500)
    draw_bird(470, 550)

    # Finish the render.
    # Nothing will be drawn without this.
    # Must happen after all draw commands
    arcade.finish_render()

    # Keep the window up until someone closes it.
    arcade.run()


if __name__ == "__main__":
    main()

更有经验的程序员会知道，现代的图形程序首先将绘图信息加载到图形卡上，然后要求图形卡稍后以批的形式绘制。Arcade街机模块也支持这一点。单独绘制10000个矩形大约需要0.800秒。将它们作为一批绘制不到0.001秒。

Window 类

较大的程序通常从arcade模块定义的window类派生，或者使用装饰器。这允许程序员编写代码来处理绘图、更新和处理来自用户的输入。下面是用于启动基于窗口的程序的模板。

import arcade

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


class MyGame(arcade.Window):
    """ Main application class. """

    def __init__(self, width, height):
        super().__init__(width, height)

        arcade.set_background_color(arcade.color.AMAZON)

    def setup(self):
        # Set up your game here
        pass

    def on_draw(self):
        """ Render the screen. """
        arcade.start_render()
        # Your drawing code goes here

    def update(self, delta_time):
        """ All the logic to move, and the game logic goes here. """
        pass


def main():
    game = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT)
    game.setup()
    arcade.run()


if __name__ == "__main__":
    main()

window类有几个方法，你的程序可以重写这些方法来为程序提供功能。以下是一些最常用的方法：

on_draw: 角色最终要重画，所有绘制角色的的代码都在这里写。
update: 所有移动和执行游戏逻辑的代码都应该写在这里。这个方法每秒执行60次。
on_key_press: 当按下一个键时会调用这个方法，例如这时可以给玩家设定速度或发射炮弹。
on_key_release: 当松开一个键时会调用这个方法，或许让玩家停止移动。
on_mouse_motion:鼠标移动时调用这个方法。
on_mouse_press:鼠标键按下时调用这个方法。
set_viewport: 这个功能用于滚动游戏，当你的世界比在一个屏幕上看到的要大得多的时候。调用set_viewport命令允许程序员设置当前可见的世界的那个部分。

角色(精灵)：

角色是在Arcade模块中创建图形对象的简单方法。Arcade有一些方法，使绘制、移动和动画角色变得容易。您还可以轻松地使用角色来检测对象之间的碰撞。

创建角色：

从图形中创建Arcade 角色很容易。一个程序员只需要一个图像的文件名就可以实例化一个角色，也可以选择一个数字来放大或缩小图像。例如：

SPRITE_SCALING_COIN = 0.2

coin = arcade.Sprite("coin_01.png", SPRITE_SCALING_COIN)

以上代码将使用coin_01.png中存储的图像创建角色coin。图像将缩小到原始高度和宽度的20%。

角色列表：

角色通常被组织成列表。这些列表使管理角色更加容易。列表中的角色将使用OpenGL批量绘制作为一个组的角色。下面的代码展示了一个游戏。它运行后来一堆金币供玩家收集。我们使用两个列表，一个是玩家列表，一个是金币列表。

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

    # Create the sprite lists
    self.player_list = arcade.SpriteList()
    self.coin_list = arcade.SpriteList()

    # Score
    self.score = 0

    # Set up the player
    # Character image from kenney.nl
    self.player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING_PLAYER)
    self.player_sprite.center_x = 50 # Starting position
    self.player_sprite.center_y = 50
    self.player_list.append(self.player_sprite)

    # Create the coins
    for i in range(COIN_COUNT):

        # Create the coin instance
        # Coin image from kenney.nl
        coin = arcade.Sprite("images/coin_01.png", SPRITE_SCALING_COIN)

        # Position the coin
        coin.center_x = random.randrange(SCREEN_WIDTH)
        coin.center_y = random.randrange(SCREEN_HEIGHT)

        # Add the coin to the lists
        self.coin_list.append(coin)

我们可以很容易地重画所有金币，以下是代码：

def on_draw(self):
    """ Draw everything """
    arcade.start_render()
    self.coin_list.draw()
    self.player_list.draw()

碰撞检测：

check_for_collision_with_list函数允许我们查看是否有一个角色是否和另一组中的角色发生碰撞。我们可以用这个看到玩家所操作的角色碰撞到的所有硬币。使用一个简单的for循环，我们可以删除游戏中的硬币，提高我们的分数。

def update(self, delta_time):
    # Generate a list of all coin sprites that collided with the player.
    coins_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.coin_list)

    # Loop through each colliding sprite, remove it, and add to the score.
    for coin in coins_hit_list:
        coin.kill()
        self.score += 1

完整例子请查看： collect_coins.py.

许多游戏都包含了某种物理学上的现象。最简单的是自顶向下的程序，防止玩家通过墙壁。平台游戏则增加了重力和移动平台的复杂性。有些游戏使用一个完整的二维物理引擎，包括质量、摩擦力、弹簧等等。

自顶向下游戏：

对于简单的自顶向下的游戏，一个Arcade程序需要一个玩家（或其他任何人）无法通过的墙列表。我通常称之为“墙列表”。然后在窗口类的设置代码中创建一个物理引擎：

self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list)

玩家角色被赋予一个移动向量，它有两个属性：changex和changey。一个简单的例子就是让玩家用键盘移动。例如，这可能在window类的派生类中：

MOVEMENT_SPEED = 5

def on_key_press(self, key, modifiers):
    """Called whenever a key is pressed. """

    if key == arcade.key.UP:
        self.player_sprite.change_y = MOVEMENT_SPEED
    elif key == arcade.key.DOWN:
        self.player_sprite.change_y = -MOVEMENT_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):
    """Called when the user releases a key. """

    if key == arcade.key.UP or key == arcade.key.DOWN:
        self.player_sprite.change_y = 0
    elif key == arcade.key.LEFT or key == arcade.key.RIGHT:
        self.player_sprite.change_x = 0

虽然以上代码设置了玩家的速度，但它不会移动玩家。在window类的update方法中，调用physical_engine.update（）将移动玩家，但它不会穿过墙了。

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

     self.physics_engine.update()

完整例子请单击：sprite_move_walls.py.

平台游戏：

平台游戏也是相当容易制作的。程序员只需要将物理引擎切换到 PhysicsEnginePlatformer，并添加重力常数。

self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite, self.wall_list, gravity_constant=GRAVITY)

您可以使用名为：tiled 的程序设置关卡。请参见sprite_tiled_map.py。对于完整的二维物理，您可以集成Pymunk库。

通过例子学习：

最好的学习方法之一就是看例子。arcade库有很多的示例程序，我们可以利用这些程序来创建游戏。这些例子中的每一个都显示了一个游戏概念，这些都是我这些年授课时学生提出来的。一旦安装了Arcade，运行这些示例就很容易了。每个示例在程序开头都有一个注释，其中包含一个命令，您可以在命令行上键入命令来运行示例，例如：

python -m arcade.examples.sprite_moving_platforms

Arcade这个街机游戏模块能让您可以用易于理解的代码开始编程图形和游戏。许多新的程序员在开始后不久就创造了伟大的游戏。试试看！

发表在 arcade | 留下评论

python街机游戏模块arcade带屏幕滚动的角色移动游戏

发表于23 2 月, 2019由李兴球

"""arcade 带屏幕滚动的角色移动游戏.py ，使用方向箭头控制角色，背景会滚动，适合于大地图类游戏。 
"""

import random
import arcade
import os

SPRITE_SCALING = 0.5

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
SCREEN_TITLE = "带屏幕滚动的角色移动游戏"

# 当角色到达屏幕边缘时与边的距离 
VIEWPORT_MARGIN = 40

MOVEMENT_SPEED = 5

class MyGame(arcade.Window):
    """主应用程序类. """

    def __init__(self, width, height, title):
        """
        初始化方法
        """
        super().__init__(width, height, title)
 
        # 新建角色列表
        self.player_list = None
        self.coin_list = None

        # 设置玩家
        self.score = 0
        self.player_sprite = None
        self.wall_list = None
        self.physics_engine = None
        self.view_bottom = 0
        self.view_left = 0

    def setup(self):
        """ 设置游戏和初始化变量. """

        # 新建角色列表
        self.player_list = arcade.SpriteList()
        self.wall_list = arcade.SpriteList()

        # 设置玩家操作的角色
        self.score = 0
        self.player_sprite = arcade.Sprite("images/character.png", 0.4)
        self.player_sprite.center_x = 64
        self.player_sprite.center_y = 270
        self.player_list.append(self.player_sprite)

        # -- 设置墙块
        for x in range(200, 1650, 210):
            for y in range(0, 1000, 64):
                # 随机跳过一个方块，这样角色就能过去
                if random.randrange(5) > 0:
                    wall = arcade.Sprite("images/boxCrate_double.png", SPRITE_SCALING)
                    wall.center_x = x
                    wall.center_y = y
                    self.wall_list.append(wall)

        self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list)

        # 设置背景颜色
        arcade.set_background_color(arcade.color.AMAZON)

        # 设置视区边界
        # These numbers set where we have 'scrolled' to.
        self.view_left = 0
        self.view_bottom = 0

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

        # 画角色之前这个命令要先执行
        arcade.start_render()

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

    def on_key_press(self, key, modifiers):
        """按键时这个方法执行 """

        if key == arcade.key.UP:
            self.player_sprite.change_y = MOVEMENT_SPEED
        elif key == arcade.key.DOWN:
            self.player_sprite.change_y = -MOVEMENT_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.UP or key == arcade.key.DOWN:
            self.player_sprite.change_y = 0
        elif key == arcade.key.LEFT or key == arcade.key.RIGHT:
            self.player_sprite.change_x = 0

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

        # 调用更新所有的角色 (在此例中角色无其它行为)
        self.physics_engine.update()

        # --- 管理滚动 ---

        # 跟踪以决定是否需要改变社区
        # arcade以左下角为坐标原点，y的最大值就是屏幕高度，x的最大值就是屏幕宽度。

        changed = False

        # Scroll left
        left_bndry = self.view_left + VIEWPORT_MARGIN
        if self.player_sprite.left < left_bndry:
            self.view_left -= left_bndry - self.player_sprite.left
            changed = True

        # Scroll right
        right_bndry = self.view_left + SCREEN_WIDTH - VIEWPORT_MARGIN
        if self.player_sprite.right > right_bndry:
            self.view_left += self.player_sprite.right - right_bndry
            changed = True

        # Scroll up
        top_bndry = self.view_bottom + SCREEN_HEIGHT - VIEWPORT_MARGIN
        if self.player_sprite.top > top_bndry:
            self.view_bottom += self.player_sprite.top - top_bndry
            changed = True

        # Scroll down
        bottom_bndry = self.view_bottom + VIEWPORT_MARGIN
        if self.player_sprite.bottom < bottom_bndry:
            self.view_bottom -= bottom_bndry - self.player_sprite.bottom
            changed = True

        if changed:             # 左视区最小值
            arcade.set_viewport(self.view_left,
                                SCREEN_WIDTH + self.view_left, # 右视区最大值
                                self.view_bottom,              # 下区最小值
                                SCREEN_HEIGHT + self.view_bottom)# 下区最大值


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

if __name__ == "__main__":
    main()

发表在 arcade | 留下评论

Python街机游戏模块arcade角色移动碰墙测试

发表于23 2 月, 2019由李兴球

"""arcade角色移动碰墙测试.py
简单的展示如何使用基本的角色的。如果安装了Python和Arcade街机游戏模块，那么支持它就能按上下左右键来操作小人。
由于内置了简单物理引擎，所以小人碰到墙不会前进。
"""

import arcade
import os

SPRITE_SCALING = 0.5

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
SCREEN_TITLE = "Python街机游戏模块arcade角色移动碰墙测试_翻译与改编：李兴球"

MOVEMENT_SPEED = 5


class MyGame(arcade.Window):
    """ 主应用程序类 """

    def __init__(self, width, height, title):
        """
        初始化器，首先初始化超类的同名方法。
        """
        super().__init__(width, height, title) 

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

        # 设置角色
        self.score = 0
        self.player_sprite = None
        self.physics_engine = None

    def setup(self):
        """ 对游戏进行设置与初始化变量们。 """

        # 新建角色列表
        self.player_list = arcade.SpriteList()
        self.wall_list = arcade.SpriteList()

        # 设置角色
        self.score = 0
        self.player_sprite = arcade.Sprite("images/character.png",SPRITE_SCALING*2)
        self.player_sprite.center_x = 50            # 设置角色的中心点x坐标
        self.player_sprite.center_y = 64            # 设置角色的中心点y坐标
        self.player_list.append(self.player_sprite) # 添加到角色列表

        # -- 设置墙，就是铺一些图片
        # 创建一行墙
        for x in range(173, 650, 52):
            wall = arcade.Sprite("images/boxCrate_double.png", SPRITE_SCALING )
            wall.center_x = x
            wall.center_y = 200
            self.wall_list.append(wall)             # 添加到墙列表

        # 创建一列墙
        for y in range(273, 500, 52):
            wall = arcade.Sprite("images/boxCrate_double.png", SPRITE_SCALING)
            wall.center_x = 465
            wall.center_y = y
            self.wall_list.append(wall)

        # 添加简单物理引擎
        self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite,self.wall_list)

        # 设置背景颜色
        arcade.set_background_color(arcade.color.AMAZON)

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

        # 此命令要写在开始画角色之前 
        arcade.start_render()

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

    def on_key_press(self, key, modifiers):
        """当有键按下时，会调用这个方法. """

        if key == arcade.key.UP:                         # 如果按了上方向箭头
            self.player_sprite.change_y = MOVEMENT_SPEED # 玩家角色上移
        elif key == arcade.key.DOWN:
            self.player_sprite.change_y = -MOVEMENT_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.UP or key == arcade.key.DOWN:
            self.player_sprite.change_y = 0
        elif key == arcade.key.LEFT or key == arcade.key.RIGHT:
            self.player_sprite.change_x = 0

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

        # 更新所有角色。 (此例中角色们并没有做什么.)
        self.physics_engine.update()


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


if __name__ == "__main__":
    main()

发表在 arcade | 留下评论

pygame最简贪吃蛇核心原理

发表于9 2 月, 2019由李兴球

python simplest snake game animation

以下是部分代码预览:

"""pygame最简贪吃蛇核心原理.py  通过对列表最后一个项目的弹出与在0索引插入新的项目演示贪吃蛇的基本原理。
   其实蛇本身并没有移动,所以在Segment类中并没有更新坐标的方法。snake_segments就是一个先进先出队列。

"""
 
import pygame
 
# 全局颜色常量定义
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
 
# 设置蛇身的宽度和高度
segment_width = 15
segment_height = 15
# 蛇身每段之间的间距
segment_margin = 1
 
# 设置初始速度
x_change = segment_width + segment_margin
y_change = 0 
 
class Segment(pygame.sprite.Sprite):
    """ 蛇的身体类. """
    def __init__(self, x, y):
        # 调用父类的初始化方法
        super().__init__() 
        # 蛇的身体是一个小方块
        self.image = pygame.Surface([segment_width, segment_height])
        self.image.fill(WHITE) 
        # 矩形对象的左上角坐标用来表示蛇身体的坐标
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y

# 初始化pygame引擎
pygame.init()
 
# 创建800x600分辨率的屏幕
screen = pygame.display.set_mode([800, 600])
 
# 设置窗口的标题
pygame.display.set_caption('pygame最简贪吃蛇核心原理代码_www.scratch8.net')

# 所有角色列表
allspriteslist = pygame.sprite.Group()
 
# 初始化贪吃蛇
snake_segments = []
for i in range(15):
    x = 250 - (segment_width + segment_margin) * i
    y = 30
    body = Segment(x, y)
    snake_segments.append(body)
    allspriteslist.add(body) 
 
clock = pygame.time.Clock()
done = False

while not done:
    # 迭代每个事件
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            done = True
 
 
    # 显示屏幕
    pygame.display.flip()
 
    # 时间未到则暂停，否则继续下一轮更新与重画
    clock.tick(10)
 
pygame.quit()

如需要查看完整代码,请

成为会员后，登陆才能继续浏览！联系微信scratch8即可办理会员。
(会员专属：能浏览所有文章，下载所有带链接的Python资源。)

发表在 pygame, python | 标签为 pygame snake, pygame先进先出队列, pygame贪吃蛇原理 | 留下评论

可发射子弹的最简太空飞船射击雏形.py

发表于9 2 月, 2019由李兴球

pygame space shoot最简太空飞船发射雏形

这是配了声音的,读者可以把它发展成一个太空射击小游戏。

"""可发射子弹的最简太空飞船射击雏形.py 演示了图像的显示，音效的播放与跟随鼠标移动最简方案。玩家操控的飞船可以改成用类来实现."""


__author__ = "李兴球"
__date__ = "2018年12月"
__company__ = "风火轮编程"

import pygame
 
# 定义颜色常量
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
CYAN = (0,255,255)

class Bullet(pygame.sprite.Sprite): 
    pass   # 子弹类的代码比较简单,相信读者根据上下文及参考其它文章可以自行编写:)
        
# 初始化派gei
pygame.init()
 
# 创建800x600的屏幕对象，它是一个surface
screen = pygame.display.set_mode([800, 600])
 
# 设置窗口的标题
pygame.display.set_caption('可发射子弹的最简太空飞船射击雏形_作者:李兴球,风火轮少儿编程')
 
clock = pygame.time.Clock()
 
# 生成声音对象
click_sound = pygame.mixer.Sound("laser5.ogg")
 
# 设置图像的坐标
background_position = [0, 0]
 
# 加载背景图像和玩家图像，把玩家图像的黑色设为不渲染颜色
background_image = pygame.image.load("saturn_family1.jpg").convert()
player_image = pygame.image.load("player.png").convert()
player_image.set_colorkey(BLACK)
player_rect = player_image.get_rect()

bullet_list = pygame.sprite.Group()

done = False

while not done:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:done = True
        
    
    # 把玩家图贴到screen上
    screen.blit(player_image, player_rect)
    bullet_list.draw(screen)
    pygame.display.flip()
 
    clock.tick(60)
 
pygame.quit()

下载完整源代码与素材，请

成为会员后，登陆才能继续浏览！联系微信scratch8即可办理会员。
(会员专属：能浏览所有文章，下载所有带链接的Python资源。)

发表在 pygame, python | 标签为 pygame star space shoot, pygame太空飞船, pygame射击原理, pygame星空射击 | 留下评论

最简方块射击游戏核心原理_方向.py

发表于9 2 月, 2019由李兴球

python simple square shoot demo方块射击演示

以下是部分代码预览:

"""最简方块射击游戏核心原理_方向.py"""
import pygame
import random
import math
 
# 定义颜色常量
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
BLUE = (0, 0, 255)
 
SCREEN_WIDTH = 700
SCREEN_HEIGHT = 400
 
 
class Block(pygame.sprite.Sprite):
    """ 定义方块类 """
    def __init__(self, color):
        # 调用父类的初始化方法
        pass
 
class Player(pygame.sprite.Sprite):
    """ 玩家类 """
 
    def __init__(self):
        """ 当玩家实例化时给它设定image和rect属性. """
        # 调用父类的初始化方法
        super().__init__()
        pass
 
 
class Bullet(pygame.sprite.Sprite):
    """ 此类代表子弹. """
 
    def __init__(self, start_x, start_y, dest_x, dest_y):
        """ 它有起点和终点坐标
        """
 
        # 调用父类型初始化方法
        super().__init__()
 
        # 给子弹设置图形对象
        self.image = pygame.Surface([4, 10])
        self.image.fill(BLACK)
 
        self.rect = self.image.get_rect()
 
        pass
 
    def update(self):
        """ 更新子弹坐标. """
 
        # 浮点数表示更精确
        pass
  
 
# 初始化派gei
pygame.init()
 
# 新建屏幕图层 
screen = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT])
pygame.display.set_caption("最简方块射击游戏核心原理_方向.py")
 
# 所有的角色列表，包括玩家，方块，当单击鼠标时也会把子弹加到此列表
all_sprites_list = pygame.sprite.Group()
 
# 所有方块列表
block_list = pygame.sprite.Group()
 
# 所有子弹列表
bullet_list = pygame.sprite.Group()
 
# 创建玩家对象，并添加到所有角色列表
player = Player()
all_sprites_list.add(player)
 
# 此变量用来结束while循环.
done = False
 
# 此变量用来设置帧率即fps(frame per second，每秒显示的帧图数)
clock = pygame.time.Clock()
 
score = 0
 
player.rect.x = SCREEN_WIDTH / 2
player.rect.y = SCREEN_HEIGHT / 2
 
# -------- 游戏主循环 -----------
while not done:
    # --- 事件处理
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            done = True
 
   
    # 调用update方法更新所有角色列表
    all_sprites_list.update()
 
    # 遍历每颗子弹，看看有没有碰到方块
    for bullet in bullet_list:
 
        # 检测有没有碰到方块列表中的方块，返回的是一个被击中的方块列表
        block_hit_list = pygame.sprite.spritecollide(bullet, block_list, True)
 
        # 对每个被击中的方块而言，都要把相应的子弹给从组中移除
        for block in block_hit_list:
            bullet_list.remove(bullet)
            all_sprites_list.remove(bullet)
            score += 1
            print(score)
 
        # 飞出屏幕的子弹也要把它从列表中移除
        if bullet.rect.y < -10:
            bullet_list.remove(bullet)
            all_sprites_list.remove(bullet)
 
    # --- 接下来是画一帧
 
    # 首先把背景填白
    screen.fill(WHITE)
 
    # 把所有角色画上去
    all_sprites_list.draw(screen)
 
    # 把所画的显示出来
    pygame.display.flip()
 
    # --- 设置帧率为60
    clock.tick(60)
 
pygame.quit()

如需要查看完整代码,请

成为会员后，登陆才能继续浏览！联系微信scratch8即可办理会员。
(会员专属：能浏览所有文章，下载所有带链接的Python资源。)

发表在 pygame, python | 标签为 pygame射击游戏 | 留下评论

pygame游戏模版框架_鼠标指针移动圆圈盖图章

发表于9 2 月, 2019由李兴球

pygame stamp demo盖图章演示

以下是部分代码预览:

"""游戏模版框架_鼠标指针移动圆圈盖图章.py
"""

__author__ = "李兴球"
__date__ = "2019年1月"
__company__ = "风火轮编程"

import pygame
 
# 定义颜色常量
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
CYAN = (0, 255, 255) 
 
def produce_stamp():

    surface = pygame.Surface((50,50))
    surface.set_colorkey((0,0,0))
    # 在这个面上画一个圆形
    pygame.draw.circle(surface, CYAN, (25,25),25)

    return surface
 
# 启动派gei引擎
pygame.init()
 
# 设置屏幕对象
size = [700, 500]
screen = pygame.display.set_mode(size) 
pygame.display.set_caption("游戏模版框架_鼠标指针移动圆圈盖图章_作者:李兴球")

circle = produce_stamp()
stamps = {}                # 记录图层和它的渲染坐标

# 退出while循环的利器，当单击窗口关闭按钮时的事件发生时它的值会为True
done = False
 
# 这是用来控制帧率的时钟变量
clock = pygame.time.Clock()
 
# 隐藏鼠标指针
pygame.mouse.set_visible(0)
 
# -------- Main Program Loop -----------
while not done:
    # 迭代所发生的每件事
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            done = True
    # 获取鼠标指针的坐标
    pos = pygame.mouse.get_pos()
    x = pos[0]
    y = pos[1]
    
    click = pygame.mouse.get_pressed()
    # 如果单击左键,则"盖一个图章",放入字典,键为surface,值为中心点坐标
    if click[0] : stamps[produce_stamp()] = x-25,y-25
    # 清屏幕为黑色，重画所有circle
    screen.fill(BLACK)
    screen.blit(circle, (x-25, y-25))
    for stamp in stamps:
        screen.blit(stamp,(stamps[stamp]))
    # 显示所画
    pygame.display.flip()
 
    # 设置帧率为60
    clock.tick(60)
 
# 安全退出到IDLE 
pygame.quit()

如需要查看完整代码,请

成为会员后，登陆才能继续浏览！联系微信scratch8即可办理会员。
(会员专属：能浏览所有文章，下载所有带链接的Python资源。)

发表在 pygame, python | 标签为 pygame stamp, pygame复制图层, pygame模拟图章, pygame鼠标移动, python stamp, 盖图章 | 已关闭评论

需要浏览更多吗？

安装：

简单绘画：

使用函数：

Window 类

角色(精灵)：

创建角色：

角色列表：

碰撞检测：

自顶向下游戏：

平台游戏：

通过例子学习：

需要浏览更多吗？

需要浏览更多吗？

需要浏览更多吗？

需要浏览更多吗？