当前位置：首页 > news >正文

Python Pygame实战：从零复刻《造梦西游》天宫道关卡

news 2026/8/14 10:34:48

1. 项目缘起与目标设定

最近在整理旧电脑，翻出来一个十几年前玩过的Flash小游戏《造梦西游》的截图，突然就来了兴致。当年为了刷“天宫道”的装备，不知道熬了多少个通宵。现在Flash时代早已落幕，但那份想亲手“造梦”的冲动还在。作为一个用Python搞过不少小东西的开发者，我第一个念头就是：能不能用Python，特别是Pygame这个经典的2D游戏库，把“天宫道”这个经典关卡给复刻出来？哪怕只是实现最基础的跑跳、攻击和几个小怪，也算是对青春的一种致敬，同时也是一个绝佳的练手项目。

这个系列笔记，就是我尝试用Pygame一步步搭建“天宫道”的过程实录。它不是一份面面俱到的官方教程，而更像是一个开发者的实战手记，里面会记录我的思路、踩过的坑、以及那些Pygame官方文档里不会告诉你的细节。比如，如何处理精灵动画的流畅切换？游戏中的物理碰撞怎么做得既真实又高效？关卡数据用什么结构来组织最方便后续扩展？这些都是在真正动手时才会遇到的具体问题。

如果你也对用Python做小游戏感兴趣，或者曾经是《造梦西游》的玩家，想看看熟悉的场景如何用代码“复活”，那么这个系列应该能给你一些参考。我们不追求一步到位做出一个商业级的完整游戏，而是聚焦于核心玩法的实现，享受从零搭建一个可交互世界的乐趣。整个过程需要的Python基础并不高，只要你对面向对象编程有基本了解，能看懂if-else和for循环，就可以跟着一起折腾。当然，过程中我们会大量使用Pygame，所以最好对它有个初步印象——知道它是个用来画图、播声音、处理键盘鼠标事件的库就够了，具体的用法，我们边做边学。

2. 环境搭建与Pygame初探

动手之前，得先把“工地”平整好。我们的核心工具是Python和Pygame。Python版本建议使用3.8及以上，兼容性和库支持都比较好。安装Python本身很简单，去官网下载安装包一路下一步就行，这里就不赘述了。关键是安装完Python后，要确保pip（Python的包管理工具）可用。打开你的命令行（Windows上是CMD或PowerShell，Mac/Linux上是Terminal），输入python --version和pip --version，能正确显示版本号就说明环境没问题。

接下来安装Pygame。这里有个小坑需要注意：直接pip install pygame安装的通常是最新版本。对于新手或者追求绝对稳定的项目，我建议指定一个稍旧但久经考验的版本，比如2.1.3。命令是：

pip install pygame==2.1.3

为什么是2.1.3？因为这个版本在Windows、macOS和主流Linux发行版上的兼容性都非常好，相关的教程和问题解答也最丰富。我们做这个复刻项目，稳定压倒一切，没必要追求最新版。安装成功后，可以写个几行代码的小程序验证一下：

import pygame pygame.init() screen = pygame.display.set_mode((800, 600)) pygame.display.set_caption("天宫道测试窗口") running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False screen.fill((0, 0, 0)) # 用黑色填充屏幕 pygame.display.flip() # 更新屏幕显示 pygame.quit()

运行这段代码，应该会弹出一个黑色的800x600的窗口，点击关闭按钮可以正常退出。如果成功了，那么恭喜你，Pygame的基本工作环境已经搭建完毕。

关于开发工具，我个人强烈推荐VSCode。它轻量、免费，而且通过安装Python扩展和Pylance扩展后，对Python的代码提示、调试支持都非常友好。你不需要一开始就配置复杂的项目结构，新建一个.py文件就可以开始写了。当然，如果你习惯用PyCharm，那也完全没问题，只是它相对重一些。工具的选择原则就一条：你自己用得顺手，能专注于代码逻辑而不是折腾工具本身。

3. 项目结构与核心模块设计

在写第一行游戏逻辑代码之前，花点时间思考一下项目结构，能为后续开发省下无数麻烦。我们不能把所有代码都堆在一个文件里，那样很快就会变成一团乱麻。参考一些经典的Pygame项目结构，我为“天宫道”设计了如下模块划分：

main.py：程序的入口，负责初始化Pygame、创建游戏窗口、管理最高层的游戏循环（Game Loop）。它就像游戏的总指挥，协调各个模块的工作。
settings.py：存放所有的游戏配置参数。比如窗口的宽度和高度（SCREEN_WIDTH,SCREEN_HEIGHT）、游戏帧率（FPS）、重力加速度（GRAVITY）、玩家角色的移动速度、跳跃力度等等。把魔法数字（Magic Number）集中放在这里，以后想调整游戏难度或手感时，只需要改这个文件，而不用满世界去搜代码里的具体数值。
sprites文件夹：存放所有“精灵”（Sprite）类。精灵是Pygame中代表游戏内可移动、可绘制对象的核心概念。这个文件夹下预计会有：
- player.py：定义玩家角色类，包含移动、跳跃、攻击、动画更新等所有逻辑。
- enemy.py：定义敌人基类，以及“天宫道”里具体的小怪（比如天兵、蟠桃猴）类。
- platform.py：定义平台类，也就是玩家和怪物可以站立的地面、台阶。
- item.py：定义道具类，比如血瓶、魔法瓶、装备等。
assets文件夹：存放所有的游戏资源。下面再分子文件夹：
- images/：存放所有的图片素材，如角色精灵图（Sprite Sheet）、背景图、武器图标等。
- sounds/：存放音效和背景音乐。
- fonts/：存放游戏用到的字体文件。
utils.py：存放一些工具函数。比如从精灵图中裁剪帧的函数、加载和缩放图片的函数、处理文本显示的函数等。让主逻辑代码保持清爽。

这样的结构清晰明了，符合“高内聚、低耦合”的原则。main.py只知道调用player.update()，而不关心玩家内部是怎么实现动画的；player.py需要图片时，会通过utils.load_image()去加载，而不需要自己处理文件路径。这种分工协作的模式，在项目规模逐渐变大时会显得尤为重要。

4. 游戏窗口、主循环与事件处理

万事俱备，让我们开始构建游戏的引擎核心——游戏窗口和主循环。在main.py里，我们首先导入必要的模块，并从settings.py读取配置。

# main.py import pygame import sys from settings import * class Game: def __init__(self): pygame.init() # 创建游戏窗口，使用设置文件中定义的尺寸 self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption("造梦西游 - 天宫道 (Python复刻版)") self.clock = pygame.time.Clock() # 创建时钟对象，用于控制帧率 self.running = True # 游戏运行标志 # 这里后续会初始化精灵组、关卡等 self.all_sprites = pygame.sprite.Group() self.platforms = pygame.sprite.Group() def run(self): # 游戏主循环 while self.running: self.dt = self.clock.tick(FPS) / 1000.0 # 计算上一帧到这一帧的时间差（秒），用于实现与帧率无关的平滑运动 self.events() self.update() self.draw() self.quit_game() def events(self): # 处理所有事件 for event in pygame.event.get(): if event.type == pygame.QUIT: self.running = False # 后续会在这里处理键盘按键按下和释放事件 # if event.type == pygame.KEYDOWN: # if event.key == pygame.K_SPACE: # self.player.jump() def update(self): # 更新所有游戏对象的状态 self.all_sprites.update(self.dt) # 传入时间差，实现基于时间的运动 def draw(self): # 绘制每一帧 self.screen.fill((30, 30, 50)) # 用一个深蓝色填充背景，模拟天空 self.all_sprites.draw(self.screen) # 绘制精灵组中的所有精灵 pygame.display.flip() # 将绘制好的内容更新到屏幕上 def quit_game(self): pygame.quit() sys.exit() if __name__ == "__main__": game = Game() game.run()

这就是一个最精简但功能完整的Pygame游戏骨架。Game类封装了游戏的生命周期。run()方法里的while循环就是游戏主循环，每一帧都依次执行三个核心步骤：处理事件（events）、更新状态（update）、绘制画面（draw）。

这里有几个关键点需要理解：

帧率控制：self.clock.tick(FPS)这行代码确保了游戏每秒最多运行FPS（比如60）帧。它通过在每帧循环末尾引入一个微小的延迟来实现。返回的值是自上次调用tick()以来经过的毫秒数。我们将其除以1000转换为秒，得到dt（delta time）。
基于时间的运动：这是避免游戏在不同性能电脑上速度不一致的关键。想象一下，如果你的移动速度是“每帧向右移动5像素”，在一台每秒跑60帧的电脑上，角色一秒移动300像素；在一台只能跑30帧的电脑上，一秒只移动150像素，游戏体验就完全不同了。正确的做法是使用dt：速度定义为“每秒300像素”，那么每帧的移动距离就是300 * dt像素。这样无论帧率高低，角色每秒移动的实际距离都是恒定的。这就是为什么我们在update()方法中把dt传给了所有精灵。
事件处理：pygame.event.get()会获取从上一帧到现在发生的所有事件（按键、鼠标点击、窗口关闭等）。我们遍历这个事件列表，对每种事件做出响应。目前只处理了QUIT事件（点击窗口关闭按钮）。后续处理玩家输入时，我们会用到KEYDOWN和KEYUP事件。
双缓冲与flip()：pygame.display.flip()的作用是将我们之前在内存中绘制好的整个画面（self.screen）一次性更新到显示器上。Pygame使用双缓冲技术，我们在一个“后台”缓冲区（self.screen所代表的内存区域）上作画，画完一整帧后，通过flip()交换到“前台”显示。这能有效避免屏幕闪烁。

现在运行main.py，你应该能看到一个深蓝色的窗口，并且可以正常关闭。一个安静的游戏世界已经创建好了，接下来就是往里面添加会动的内容。

5. 玩家角色：精灵、动画与状态机

游戏的主角——玩家角色，是我们第一个要实现的复杂精灵。在sprites/player.py中，我们创建一个Player类，继承自Pygame的pygame.sprite.Sprite。

首先，我们需要一张精灵图（Sprite Sheet）。你可以通过网络搜索“造梦西游悟空精灵图”找到素材，或者用简单的几何图形代替。假设我们有一张图片，包含了悟空站立、奔跑、跳跃、攻击等动作的每一帧。我们将这张图片加载进来。

# sprites/player.py import pygame from settings import * from utils import load_sprite_sheet_frames class Player(pygame.sprite.Sprite): def __init__(self, game, x, y): super().__init__() self.game = game # 保留对主游戏对象的引用，方便后续交互 self.load_images() self.current_frame = 0 self.last_update = 0 self.image = self.standing_frames[0] # 初始图像为站立第一帧 self.rect = self.image.get_rect() # 获取图像的矩形区域，用于定位和碰撞检测 self.rect.center = (x, y) # 物理属性 self.vel = pygame.math.Vector2(0, 0) # 速度向量 (x, y) self.acc = pygame.math.Vector2(0, 0) # 加速度向量 self.on_ground = False # 状态机 self.state = "STANDING" self.facing_right = True def load_images(self): # 假设我们的精灵图是单行多帧，每个帧大小是 64x64 sprite_sheet = load_sprite_sheet_frames('assets/images/player_sheet.png', frame_width=64, frame_height=64) # 手动或按顺序分配帧到不同动作 # 这是一个简化示例，实际可能需要根据精灵图布局计算 self.standing_frames = sprite_sheet[0:4] # 前4帧为站立动画 self.running_frames = sprite_sheet[4:12] # 接下来8帧为奔跑动画 self.jumping_frames = sprite_sheet[12:14] # 2帧跳跃动画 # 注意：所有帧的方向是朝右的，朝左的帧可以通过pygame.transform.flip获得 def update(self, dt): self.handle_input() self.apply_physics(dt) self.animate(dt) self.check_collisions() def handle_input(self): # 获取当前所有按键的持续按压状态 keys = pygame.key.get_pressed() self.acc.x = 0 # 每帧重置水平加速度 if keys[pygame.K_LEFT]: self.acc.x = -PLAYER_ACC self.facing_right = False if keys[pygame.K_RIGHT]: self.acc.x = PLAYER_ACC self.facing_right = True # 跳跃键处理，通常放在事件循环中更精确，这里为简化放在状态判断里 # 更佳实践是在Game.events()中设置一个跳跃标志，在这里判断标志和是否在地面 def apply_physics(self, dt): # 应用加速度到速度 self.acc.x += self.vel.x * PLAYER_FRICTION # 加入摩擦力，使角色停下 self.vel.x += self.acc.x * dt self.vel.y += GRAVITY * dt # 应用重力 # 应用速度到位置 (使用向量乘法) self.rect.x += self.vel.x * dt * 1000 # 乘以1000将速度单位从 像素/秒 转换回来 self.rect.y += self.vel.y * dt * 1000 # 简单防止掉出屏幕底部 if self.rect.bottom > SCREEN_HEIGHT: self.rect.bottom = SCREEN_HEIGHT self.on_ground = True self.vel.y = 0 def animate(self, dt): now = pygame.time.get_ticks() # 根据状态选择动画帧列表 if self.state == "STANDING": frame_list = self.standing_frames animation_speed = 200 # 毫秒每帧 elif self.state == "RUNNING": frame_list = self.running_frames animation_speed = 100 elif self.state == "JUMPING": frame_list = self.jumping_frames animation_speed = 150 else: frame_list = self.standing_frames # 判断是否需要切换到下一帧 if now - self.last_update > animation_speed: self.last_update = now self.current_frame = (self.current_frame + 1) % len(frame_list) self.image = frame_list[self.current_frame] # 根据朝向翻转图像 if not self.facing_right: self.image = pygame.transform.flip(self.image, True, False) def check_collisions(self): # 与平台的碰撞检测（后续实现） pass def jump(self): if self.on_ground: self.vel.y = -PLAYER_JUMP_POWER self.on_ground = False self.state = "JUMPING"

这个Player类已经具备了雏形。它通过load_images加载动画帧，通过handle_input响应键盘输入控制左右移动，通过apply_physics模拟基本的物理运动（加速度、速度、重力、摩擦力），通过animate方法根据角色的状态（站立、奔跑、跳跃）播放对应的动画序列。

这里引入了一个非常重要的概念：状态机（State Machine）。角色的行为（动画、物理响应）是由其当前状态决定的。比如，当state为”RUNNING”时，我们播放奔跑动画，并且允许通过左右键加速；当state为”JUMPING”时，我们播放跳跃动画，并且忽略左右键的移动输入（或者响应方式不同）。状态之间的转换需要明确的条件，例如从”STANDING”到”RUNNING”的条件是按下左右方向键，从”RUNNING”到”JUMPING”的条件是按下跳跃键且角色在地面上。在完整的实现中，我们需要一个更严谨的状态管理逻辑来维护这些转换。

现在，我们需要在main.py的Game类中创建玩家实例，并将其添加到all_sprites组中，这样它才会被更新和绘制。

# 在 Game.__init__ 方法中，初始化精灵组之后 from sprites.player import Player self.player = Player(self, SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2) self.all_sprites.add(self.player)

同时，需要在Game.events()方法中处理跳跃键的按下事件，因为跳跃通常需要瞬时响应，而不是持续按压检测。

# 在 Game.events 方法中，补充KEYDOWN事件处理 if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: self.player.jump()

运行游戏，你现在应该可以用左右方向键移动一个会播放简单动画的方块（或你加载的悟空图片），按空格键可以跳跃。基础的玩家控制就实现了。

6. 构建游戏世界：平台、碰撞与关卡数据

一个只有主角在空中飘荡的世界是孤独的。我们需要为“天宫道”搭建舞台——也就是平台。在sprites/platform.py中创建一个简单的平台类。

# sprites/platform.py import pygame class Platform(pygame.sprite.Sprite): def __init__(self, x, y, width, height): super().__init__() # 创建一个简单颜色的矩形表面代表平台 self.image = pygame.Surface((width, height)) self.image.fill((100, 70, 30)) # 土黄色 self.rect = self.image.get_rect(topleft=(x, y))

平台本身不需要复杂的逻辑，它只是一个静态的、有位置的矩形。接下来，我们要在游戏中创建一些平台实例。一种简单的方法是在Game.__init__里硬编码几个平台的位置和大小。但更好的做法是将关卡数据（平台位置、敌人出生点等）外部化。我们可以在settings.py里定义一个平台列表，或者单独创建一个level_data.py文件。

这里我们先采用简单的方式，在Game.__init__中创建：

# 在 Game.__init__ 方法中，创建玩家之后 # 创建一些平台 platform_list = [ (0, SCREEN_HEIGHT - 40, SCREEN_WIDTH, 40), # 底部地面 (200, SCREEN_HEIGHT - 150, 200, 20), (500, SCREEN_HEIGHT - 250, 150, 20), (100, SCREEN_HEIGHT - 350, 100, 20), ] for plat in platform_list: p = Platform(*plat) self.all_sprites.add(p) self.platforms.add(p) # 单独的平台组，用于碰撞检测

现在，游戏里有了几个悬浮的平台。但是玩家和怪物还不会站在上面，他们会直接穿过去。这就需要实现碰撞检测。我们回到Player类的check_collisions方法，实现与平台的碰撞。

Pygame提供了spritecollide()函数来检测一个精灵和一个精灵组之间的碰撞。但简单的矩形碰撞（rect.colliderect）对于平台游戏来说往往不够真实，比如角色会“粘”在平台的侧面。我们需要更精细的检测，通常是分别处理水平碰撞和垂直碰撞。

# 在 Player.check_collisions 方法中实现 def check_collisions(self): # 假设 self.game.platforms 是包含所有平台的精灵组 # 1. 垂直方向碰撞（主要处理站在平台上和头顶撞到平台） self.on_ground = False hits = pygame.sprite.spritecollide(self, self.game.platforms, False) for hit in hits: # 判断是从上方碰撞（即落到平台上） if self.vel.y > 0 and self.rect.bottom <= hit.rect.bottom: self.rect.bottom = hit.rect.top # 将玩家底部对齐平台顶部 self.vel.y = 0 # 垂直速度归零 self.on_ground = True if self.state == "JUMPING": self.state = "STANDING" # 落地后恢复站立状态 # 判断是从下方碰撞（头顶撞到平台） elif self.vel.y < 0 and self.rect.top >= hit.rect.top: self.rect.top = hit.rect.bottom self.vel.y = 0 # 2. 水平方向碰撞（防止穿墙） self.rect.x += 1 # 先向右试探性移动1像素 hits = pygame.sprite.spritecollide(self, self.game.platforms, False) for hit in hits: if self.vel.x > 0: # 向右移动时撞到 self.rect.right = hit.rect.left self.vel.x = 0 elif self.vel.x < 0: # 向左移动时撞到 self.rect.left = hit.rect.right self.vel.x = 0 self.rect.x -= 1 # 移回原位

这段碰撞逻辑是平台游戏的核心之一。它先检测垂直碰撞，通过判断速度方向（self.vel.y > 0表示正在下落）和相对位置，来确定是脚踩到了平台还是头撞到了平台，并相应地调整玩家的位置和速度状态。然后，它通过一个巧妙的“试探性移动”来检测水平碰撞，防止玩家嵌入平台内部。这种分离轴处理碰撞的方式，比简单的矩形碰撞要真实和稳定得多。

别忘了在Player.update()方法中调用self.check_collisions()。现在运行游戏，你的角色应该可以稳稳地站在平台上了，从平台边缘落下时会有重力加速度，撞到平台侧面也会被挡住。一个基本的可交互游戏世界就此诞生。

7. 敌人与基础战斗逻辑

有了舞台和主角，该反派登场了。天宫道里的小怪，比如天兵，我们可以在sprites/enemy.py中创建。敌人的逻辑会比平台复杂，但比玩家简单。它需要有基本的AI（比如来回巡逻），被攻击时的反应，以及生命值管理。

# sprites/enemy.py import pygame from settings import * import random class Enemy(pygame.sprite.Sprite): def __init__(self, game, x, y): super().__init__() self.game = game self.image = pygame.Surface((50, 60)) self.image.fill((255, 0, 0)) # 用红色方块代表敌人 self.rect = self.image.get_rect(midbottom=(x, y)) self.vel_x = random.choice([-ENEMY_SPEED, ENEMY_SPEED]) # 随机初始方向 self.health = ENEMY_MAX_HEALTH def update(self, dt): # 简单巡逻AI：来回移动，碰到边缘或平台边缘转向 self.rect.x += self.vel_x * dt * 1000 # 检查是否走到平台边缘（简化版：检测前方是否悬空） # 这里需要知道敌人脚下的平台，实现略复杂，我们先实现碰到屏幕边缘转向 if self.rect.left <= 0 or self.rect.right >= SCREEN_WIDTH: self.vel_x *= -1 # 反向 # 检查与玩家的碰撞（简易攻击判定） if pygame.sprite.collide_rect(self, self.game.player): # 对玩家造成伤害，具体实现放在Game类中协调更好 pass

敌人的巡逻AI是一个可以深入优化的点。上面的简化版只会在碰到屏幕边界时转向。更真实的做法是，检测敌人前方一定距离（比如self.rect.centerx + self.vel_x * 10）的下方是否有平台，如果没有，就转身。这需要访问平台的精灵组进行碰撞检测，逻辑会稍复杂一些。

接下来是战斗。我们需要为玩家角色添加攻击能力。首先，在Player类中添加攻击状态、攻击动画帧和攻击判定框（一个比角色图像稍大的矩形，用于判断是否打中敌人）。

# 在 Player.__init__ 中补充 self.attacking = False self.attack_cooldown = 0 self.attack_frames = [] # 需要在load_images中加载 self.attack_hitbox = None # 攻击生效的矩形区域 # 在 Player.handle_input 中补充攻击键检测（例如按J键攻击） if keys[pygame.K_j] and self.attack_cooldown <= 0: self.attacking = True self.attack_cooldown = PLAYER_ATTACK_COOLDOWN # 设置攻击冷却时间 # 根据朝向设置攻击框的位置 offset = 30 if self.facing_right else -30 self.attack_hitbox = pygame.Rect(self.rect.centerx + offset - 25, self.rect.centery - 25, 50, 50) # 在 Player.update 中更新攻击冷却和攻击框 if self.attack_cooldown > 0: self.attack_cooldown -= dt * 1000 # 冷却时间递减 if self.attacking and self.attack_cooldown <= PLAYER_ATTACK_COOLDOWN * 0.5: # 假设攻击动画前半段是攻击生效期 # 检测攻击框与敌人的碰撞 hits = pygame.sprite.spritecollide(self, self.game.enemies, False, pygame.sprite.collide_rect) for enemy in hits: if hasattr(enemy, 'take_damage'): enemy.take_damage(PLAYER_ATTACK_DAMAGE) self.attacking = False # 攻击结束 self.attack_hitbox = None

同时，在Enemy类中添加take_damage方法：

def take_damage(self, amount): self.health -= amount if self.health <= 0: self.kill() # 从所有精灵组中移除 # 可以在这里播放死亡动画或生成掉落物

这样，一个最基础的“移动-攻击-受伤-死亡”的战斗循环就建立了。当然，真实的《造梦西游》战斗有技能、连击、受击硬直、伤害数字等复杂系统，这些都可以在这个基础上逐步扩展。例如，受击硬直可以通过给敌人添加一个stun_timer来实现，在硬直时间内，敌人无法移动和攻击。

8. 资源管理、音效与游戏状态

到目前为止，我们的游戏已经有了可玩的雏形。但要让它更像一个完整的游戏，我们还需要处理一些“后勤”工作。

资源管理：我们之前用load_sprite_sheet_frames这样的工具函数来加载图片。一个健壮的游戏应该有一个资源管理器，缓存所有加载过的图片和声音，避免同一资源被重复加载，浪费内存。我们可以创建一个ResourceManager类，或者简单地在utils.py里用一个字典来做缓存。

# utils.py _image_cache = {} _sound_cache = {} def load_image(path, scale=1.0): key = (path, scale) if key not in _image_cache: img = pygame.image.load(path).convert_alpha() # convert_alpha 保留透明通道 if scale != 1.0: new_size = (int(img.get_width() * scale), int(img.get_height() * scale)) img = pygame.transform.scale(img, new_size) _image_cache[key] = img return _image_cache[key]

音效：音效能极大提升游戏体验。Pygame播放音效很简单。首先在Game.__init__中初始化混音器（pygame.mixer.init()），然后在需要的地方加载和播放。

# 在需要播放音效的地方，比如Player.jump()方法中 jump_sound = pygame.mixer.Sound('assets/sounds/jump.wav') jump_sound.set_volume(0.3) # 设置音量 jump_sound.play()

背景音乐则可以使用pygame.mixer.music模块来循环播放。

游戏状态：目前我们的游戏只有一个“游玩中”的状态。一个完整的游戏通常有开始菜单、暂停界面、游戏结束界面等。我们可以引入一个简单的游戏状态机来管理。在Game类中添加一个state属性，主循环中的events、update、draw方法根据不同的状态执行不同的逻辑。

# 在 Game 类中 def __init__(self): # ... self.state = "MENU" # 初始状态为菜单 def run(self): while self.running: self.dt = self.clock.tick(FPS) / 1000.0 if self.state == "MENU": self.menu_events() self.menu_update() self.menu_draw() elif self.state == "PLAYING": self.events() self.update() self.draw() elif self.state == "GAME_OVER": # ... 处理游戏结束逻辑

这样，我们就可以在menu_draw里绘制菜单按钮，在menu_events里检测鼠标点击来切换游戏状态到”PLAYING”。

9. 性能优化与调试技巧

当游戏内容越来越丰富，精灵数量增多时，性能就可能成为问题。这里有几个Pygame项目常用的优化和调试技巧：

脏矩形更新：默认情况下，pygame.display.flip()会更新整个屏幕。如果每一帧只有一小部分区域发生变化（比如角色移动），更新整个屏幕是浪费的。我们可以使用pygame.display.update(rect_list)，只更新那些发生变化的矩形区域。这需要你跟踪每一帧哪些精灵的rect位置或图像发生了变化。对于简单游戏，全屏更新通常也够用，但这是一个重要的优化方向。
精灵图集：将多个小图片（如角色的所有动画帧、各种道具图标）合并到一张大图上，通过坐标来裁剪。这能减少图片加载次数和GPU绘制调用，提升性能。我们之前用的load_sprite_sheet_frames函数就是在处理图集。
使用convert()和convert_alpha()：加载图片后，调用surface.convert()可以将图片转换为与当前显示模式相同的格式，大幅提升后续的blit（绘制）速度。对于带透明通道的图片，使用convert_alpha()。我们之前在load_image函数中已经用了convert_alpha()。
调试信息显示：在开发过程中，将一些关键变量（如玩家坐标、速度、状态、帧率）实时显示在屏幕上非常有用。你可以创建一个DebugInfo类，或者简单地在Game.draw()方法的最后，用pygame.font.Font渲染文字到屏幕上。

# 在 Game.draw 方法末尾 font = pygame.font.SysFont(None, 24) fps_text = font.render(f'FPS: {int(self.clock.get_fps())}', True, (255, 255, 255)) pos_text = font.render(f'Pos: ({self.player.rect.x:.1f}, {self.player.rect.y:.1f})', True, (255, 255, 255)) self.screen.blit(fps_text, (10, 10)) self.screen.blit(pos_text, (10, 40))

碰撞检测优化：当精灵数量很多时，两两检测碰撞（O(n²)复杂度）会非常慢。Pygame提供了pygame.sprite.collide_mask用于更精确的像素级碰撞，但更慢。对于大量精灵，可以使用空间分割技术，比如将屏幕划分为网格，只检测在同一网格或相邻网格内的精灵是否碰撞。Pygame本身没有内置这种优化，但你可以自己实现，或者使用pygame.Rect的collidelist等方法进行初步筛选。

至此，我们已经用Pygame搭建起了“造梦西游天宫道”的核心框架。从窗口、主循环到玩家控制、物理碰撞、敌人AI和基础战斗，涵盖了2D横版动作游戏最基础的模块。这个笔记（一）更像是一个引擎的搭建和核心玩法的验证。在后续的笔记中，我们可以深入更多细节：如何设计更流畅的动画状态机？如何实现《造梦西游》中特色的“浮空连击”手感？如何构建一个可编辑的关卡编辑器？如何添加更丰富的道具和技能系统？每一步的深入，都是对游戏开发不同层面的探索。代码从来不是一蹴而就的，不断迭代、重构、优化，才是项目推进的常态。希望这个开头，能为你用Python和Pygame实现自己的游戏梦，铺下一块坚实的基石。

查看全文

http://www.jsqmd.com/news/1391038/