Python Pygame实战：从零构建“下一百层”游戏，掌握物理交互与碰撞检测

1. 项目概述：从“下一百层”到可交互的物理世界

“下一百层”这个游戏概念，对于很多老玩家来说，是童年电脑课上的经典记忆。它的核心玩法简单到极致：控制一个角色（通常是个小球或小人），在不断下坠的随机平台间跳跃，目标是尽可能地下到更深的层数，同时避开各种致命的障碍物。这个游戏的精髓在于其看似简单的规则下，隐藏着对玩家反应速度、节奏感和预判能力的综合考验。今天，我们不谈那些复杂的3A大作，就用Python和Pygame这个轻量级的2D游戏开发库，亲手把这个经典玩法从零构建出来，并深入探讨其背后小球与障碍物交互的逻辑内核。

为什么选择Pygame？对于Python开发者，尤其是刚入门游戏编程的朋友来说，Pygame是一个绝佳的起点。它屏蔽了底层图形、声音、事件处理的复杂性，提供了一套直观的API，让你能专注于游戏逻辑本身。我们的目标不仅仅是复现一个“能玩”的版本，而是要构建一个拥有真实物理反馈（如重力、弹跳）、丰富障碍物类型（静止的尖刺、移动的摆锤、突然消失的平台等）以及流畅交互体验的完整游戏原型。通过这个项目，你将掌握游戏循环（Game Loop）的构建、精灵（Sprite）与碰撞检测的应用、事件驱动的用户输入处理，以及如何用代码模拟一个有趣的物理系统。无论你是想给编程学习增添乐趣，还是为未来的游戏开发打下基础，这个“下一百层”的实现过程都是一次绝佳的实战演练。

2. 核心设计思路与架构拆解

在动手写代码之前，我们必须把游戏的整体架构和核心运行逻辑想清楚。一个典型的“下一百层”游戏可以分解为几个相互协作的模块，理解这些模块如何协同工作，是项目成功的关键。

2.1 游戏核心循环与状态管理

游戏的心脏是“游戏循环”（Game Loop）。这是一个无限循环，在每一帧（Frame）中按顺序执行以下任务：

1. 处理事件：检查玩家的输入，比如键盘按键（左、右、空格跳跃）。
2. 更新游戏状态：根据输入和游戏规则，计算所有对象的新位置、速度等。这是物理和逻辑演算发生的地方。
3. 渲染画面：将更新后的所有游戏对象（背景、小球、平台、障碍物）绘制到屏幕上。

在Pygame中，我们通过pygame.time.Clock()对象来控制循环的速度，确保游戏在任何电脑上都能以基本一致的帧率运行，避免“有时快有时慢”的问题。状态管理则涉及游戏的不同阶段，比如“开始菜单”、“游戏中”、“游戏结束（失败/胜利）”。我们需要一个清晰的变量（如game_state）来标识当前状态，并在游戏循环中根据这个状态决定执行哪部分逻辑。

2.2 游戏对象抽象：精灵（Sprite）系统

Pygame内置的pygame.sprite.Sprite类是我们的得力助手。我们将游戏中的每个独立实体都定义为继承自Sprite的类。这样做的好处是标准化和高效管理。

• 玩家小球（PlayerBall）：这是最重要的精灵。它需要属性：位置（rect）、速度（velocity_x,velocity_y）、是否在地面上（on_ground）等。它需要方法：处理键盘输入更新水平速度，应用重力更新垂直速度，以及与其他精灵的碰撞检测。
• 平台（Platform）：这是小球可以站立的基础。属性包括位置、宽度、高度，可能还有类型（普通固定平台、移动平台、一次性消失平台等）。
• 障碍物（Obstacle）：这是小球需要避开的对象。它可以是尖刺（Spike）、摆锤（SwingHammer）、移动的锯齿等。障碍物本身可能也有自己的运动逻辑。

我们将所有平台和障碍物分别放入pygame.sprite.Group()中。群组（Group）可以方便地对一批精灵进行统一的更新和绘制，更重要的是，它提供了高效的碰撞检测方法，比如pygame.sprite.spritecollide()，可以快速检测玩家小球与平台群组或障碍物群组是否发生了碰撞。

2.3 物理系统模拟：跳跃与重力的实现

游戏的“手感”很大程度上由物理系统决定。我们不需要复杂的物理引擎，一个简化的模型足以创造有趣的体验。

• 重力：在每一帧的更新中，给小球一个向下的垂直速度增量，即velocity_y += GRAVITY。GRAVITY是一个常量，比如0.5，它模拟了持续的下拉力。
• 跳跃：当玩家按下跳跃键且小球在地面上时，我们给小球一个向上的初始速度，即velocity_y = -JUMP_STRENGTH（例如-12）。这个负值意味着向上运动。
• 运动合成：每一帧，小球的新位置由旧位置加上速度向量得到：rect.x += velocity_x;rect.y += velocity_y。
• 摩擦力与空气阻力：为了让运动更真实，当小球在水平方向运动且没有按键输入时，我们可以让水平速度逐渐衰减至零，模拟地面的摩擦力或空气阻力。

这个简单的模型，配合精确的碰撞检测与响应，就能产生非常令人满意的跳跃和下落体验。

3. 核心模块实现详解

有了清晰的设计图，我们现在开始用代码搭建游戏的骨架和血肉。我们将分模块实现，并解释每个关键代码段背后的意图。

3.1 初始化与主游戏循环搭建

首先，我们完成Pygame的初始化，创建游戏窗口，并搭建主循环的骨架。

import pygame import sys import random # 初始化pygame pygame.init() # 游戏窗口尺寸 SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption("下一百层 - Python Pygame 实现") # 颜色定义 BACKGROUND = (30, 30, 50) WHITE = (255, 255, 255) RED = (255, 50, 50) GREEN = (50, 255, 100) BLUE = (80, 180, 255) # 游戏时钟，用于控制帧率 clock = pygame.time.Clock() FPS = 60 # 目标帧率 # 游戏状态 GAME_MENU = 0 GAME_PLAYING = 1 GAME_OVER = 2 game_state = GAME_MENU # 主游戏循环 running = True while running: # 1. 处理事件 for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # 根据游戏状态处理不同输入（后续补充） if game_state == GAME_MENU and event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: game_state = GAME_PLAYING # 这里需要初始化游戏对象（小球、平台等） if game_state == GAME_PLAYING: # 处理游戏中的按键（后续在PlayerBall类中处理） pass if game_state == GAME_OVER and event.type == pygame.KEYDOWN and event.key == pygame.K_r: game_state = GAME_MENU # 按R键返回菜单重新开始 # 2. 更新游戏状态 if game_state == GAME_PLAYING: # 更新所有精灵（小球、平台、障碍物） all_sprites.update() # 这里进行碰撞检测和游戏逻辑判断（如是否掉出屏幕） # ... # 3. 渲染画面 screen.fill(BACKGROUND) # 填充背景色 if game_state == GAME_MENU: # 绘制开始菜单文字 font = pygame.font.SysFont(None, 64) title = font.render("下一百层", True, BLUE) instruction = font.render("按 SPACE 开始游戏", True, WHITE) screen.blit(title, (SCREEN_WIDTH//2 - title.get_width()//2, 200)) screen.blit(instruction, (SCREEN_WIDTH//2 - instruction.get_width()//2, 300)) elif game_state == GAME_PLAYING: # 绘制所有游戏精灵 all_sprites.draw(screen) # 绘制UI，如当前层数、分数 # ... elif game_state == GAME_OVER: # 绘制游戏结束画面 font = pygame.font.SysFont(None, 72) over_text = font.render("游戏结束！", True, RED) restart_text = font.render("按 R 键返回菜单", True, WHITE) screen.blit(over_text, (SCREEN_WIDTH//2 - over_text.get_width()//2, 250)) screen.blit(restart_text, (SCREEN_WIDTH//2 - restart_text.get_width()//2, 350)) pygame.display.flip() # 更新整个屏幕显示 clock.tick(FPS) # 确保循环每秒运行不超过FPS次 pygame.quit() sys.exit()

这段代码建立了游戏的基本框架。我们定义了窗口、颜色、游戏状态和一个清晰的事件处理-更新-渲染循环。clock.tick(FPS)是保证游戏流畅度的关键，它会让每次循环暂停足够的时间，使得一秒钟内循环大约执行60次。

3.2 玩家小球（PlayerBall）类的实现

接下来，我们实现游戏的主角——小球。我们将它定义为一个精灵类。

class PlayerBall(pygame.sprite.Sprite): def __init__(self, x, y): super().__init__() # 创建一个圆形的表面作为图像 self.radius = 15 self.image = pygame.Surface((self.radius*2, self.radius*2), pygame.SRCALPHA) pygame.draw.circle(self.image, BLUE, (self.radius, self.radius), self.radius) # 获取图像的矩形区域，用于定位和碰撞 self.rect = self.image.get_rect(center=(x, y)) # 物理属性 self.velocity_x = 0 self.velocity_y = 0 self.on_ground = False # 物理常量 self.GRAVITY = 0.5 self.JUMP_STRENGTH = -12 self.MAX_SPEED_X = 8 self.ACCELERATION_X = 0.5 self.FRICTION = 0.85 # 地面摩擦力，小于1的值会使速度衰减 def update(self, platforms, obstacles): """每帧更新小球状态""" # 处理水平方向输入 keys = pygame.key.get_pressed() if keys[pygame.K_LEFT]: self.velocity_x = max(self.velocity_x - self.ACCELERATION_X, -self.MAX_SPEED_X) elif keys[pygame.K_RIGHT]: self.velocity_x = min(self.velocity_x + self.ACCELERATION_X, self.MAX_SPEED_X) else: # 没有水平输入时，应用摩擦力 self.velocity_x *= self.FRICTION if abs(self.velocity_x) < 0.2: # 速度很小时直接归零，防止无限微小移动 self.velocity_x = 0 # 处理跳跃输入 if keys[pygame.K_SPACE] and self.on_ground: self.velocity_y = self.JUMP_STRENGTH self.on_ground = False # 起跳后立刻离开地面状态 # 应用重力 self.velocity_y += self.GRAVITY # 先应用水平位移，并检测水平碰撞（可选，用于处理狭窄通道，本例简化） self.rect.x += self.velocity_x # 应用垂直位移 self.rect.y += self.velocity_y # 重置地面状态，假设本帧不在地面，后续碰撞检测会修正 self.on_ground = False # --- 与平台的碰撞检测与响应（核心！）--- # 检测与哪些平台发生了碰撞 collisions = pygame.sprite.spritecollide(self, platforms, False) for platform in collisions: # 关键：判断碰撞来自上方还是下方 # 如果小球的下落速度为正（向下运动），且小球的底部与平台的顶部发生重叠 if self.velocity_y > 0 and self.rect.bottom > platform.rect.top and self.rect.centery < platform.rect.centery: # 将小球“放置”在平台顶部 self.rect.bottom = platform.rect.top self.velocity_y = 0 # 垂直速度清零 self.on_ground = True # 标记为在地面上 # 如果小球向上运动时撞到平台底部（比如顶头），则将其拉下来 elif self.velocity_y < 0 and self.rect.top < platform.rect.bottom and self.rect.centery > platform.rect.centery: self.rect.top = platform.rect.bottom self.velocity_y = 0 # 防止“粘”在天花板上 # --- 与障碍物的碰撞检测 --- if pygame.sprite.spritecollideany(self, obstacles): # 碰到任何障碍物，游戏结束 global game_state game_state = GAME_OVER # 可以在这里添加音效或粒子效果 # --- 边界检查 --- # 如果小球掉出屏幕底部，游戏结束 if self.rect.top > SCREEN_HEIGHT: game_state = GAME_OVER # 防止小球移出屏幕左右两侧（可选） self.rect.left = max(self.rect.left, 0) self.rect.right = min(self.rect.right, SCREEN_WIDTH)

这个PlayerBall类是游戏逻辑的核心。update方法包含了输入处理、物理模拟和碰撞检测。其中，与平台的碰撞响应逻辑是重点：我们通过比较小球和平台的相对位置和速度方向，来判断是“踩在”平台上还是“顶到”了平台，并做出相应的位置修正。这种处理方法比简单的“碰到就弹开”要真实得多。

注意：这里的碰撞检测pygame.sprite.spritecollide使用的是矩形检测。对于圆形小球和矩形平台，在角落处会有不精确的“嵌入”感。对于追求精确的2D物理，可以自己实现圆形-矩形的分离轴定理（SAT）检测，但当前矩形检测对于这个游戏风格来说已经足够直观和高效。

3.3 平台（Platform）与障碍物（Obstacle）类的实现

平台和障碍物是构成游戏关卡的基本元素。我们先实现一个基础平台。

class Platform(pygame.sprite.Sprite): def __init__(self, x, y, width, height, plat_type='normal'): super().__init__() self.type = plat_type # 根据类型决定颜色 if plat_type == 'normal': color = GREEN elif plat_type == 'moving': color = (200, 200, 100) # 黄色 elif plat_type == 'fragile': color = (150, 150, 150) # 灰色 else: color = WHITE self.image = pygame.Surface((width, height)) self.image.fill(color) self.rect = self.image.get_rect(topleft=(x, y)) # 移动平台的属性 if plat_type == 'moving': self.speed = random.choice([-2, -1, 1, 2]) self.move_range = 100 self.start_x = x elif plat_type == 'fragile': self.break_timer = 0 # 被踩后开始计时的破碎计时器 self.is_breaking = False def update(self): """更新平台状态，例如移动平台的来回移动""" if self.type == 'moving': self.rect.x += self.speed # 如果移动超出范围，调头 if self.rect.x > self.start_x + self.move_range or self.rect.x < self.start_x - self.move_range: self.speed *= -1 elif self.type == 'fragile' and self.is_breaking: self.break_timer += 1 # 例如，1秒后（60帧）平台消失 if self.break_timer > 60: self.kill() # 从所有精灵组中移除自己

障碍物可以设计得更有创意。我们实现一个简单的尖刺障碍。

class Spike(pygame.sprite.Sprite): def __init__(self, x, y, width=30, height=30): super().__init__() self.image = pygame.Surface((width, height), pygame.SRCALPHA) # 支持透明通道 # 绘制一个简单的红色三角形作为尖刺 points = [(width//2, 0), (0, height), (width, height)] pygame.draw.polygon(self.image, RED, points) self.rect = self.image.get_rect(topleft=(x, y))

3.4 关卡生成与动态滚动逻辑

“下一百层”的魅力在于无穷无尽的随机关卡。我们需要一个系统来动态生成平台和障碍物。

def generate_initial_platforms(): """生成初始的一批平台""" platform_group = pygame.sprite.Group() # 生成一个底部平台 platform_group.add(Platform(SCREEN_WIDTH//2 - 100, SCREEN_HEIGHT - 50, 200, 20)) # 在屏幕内随机生成一些起始平台 for _ in range(10): x = random.randint(0, SCREEN_WIDTH - 80) y = random.randint(SCREEN_HEIGHT // 2, SCREEN_HEIGHT - 100) width = random.randint(60, 120) plat_type = random.choices(['normal', 'moving', 'fragile'], weights=[0.7, 0.2, 0.1])[0] platform_group.add(Platform(x, y, width, 15, plat_type)) return platform_group def generate_new_platforms_on_scroll(player_y, platforms, all_obstacles): """当小球向上移动（屏幕向下滚动）时，在顶部生成新平台和障碍物""" # 这是一个简化的逻辑：当小球到达屏幕上半部分时，我们认为需要生成新内容 # 实际上，更好的方法是跟踪一个“世界坐标系”的相机偏移量 global score if player_y < SCREEN_HEIGHT * 0.3: # 如果小球位置高于屏幕的30% # 计算需要将世界下移多少 scroll_amount = SCREEN_HEIGHT * 0.3 - player_y # 1. 将所有现有平台和障碍物下移 for plat in platforms: plat.rect.y += scroll_amount # 如果平台移出屏幕底部，则删除它（节省资源） if plat.rect.top > SCREEN_HEIGHT: plat.kill() for obs in all_obstacles: obs.rect.y += scroll_amount if obs.rect.top > SCREEN_HEIGHT: obs.kill() # 2. 在顶部（y坐标较小处）生成新平台 # 我们需要知道当前所有平台的最高点，在其上方生成 if platforms: highest_platform = min(platforms, key=lambda p: p.rect.top) current_top = highest_platform.rect.top else: current_top = SCREEN_HEIGHT # 在屏幕上方（负y坐标）到当前顶部之间生成新平台 for _ in range(random.randint(2, 4)): # 每次生成2-4个新平台 x = random.randint(0, SCREEN_WIDTH - 80) y = random.randint(current_top - 400, current_top - 150) # 在上方150-400像素的区间生成 width = random.randint(60, 120) plat_type = random.choices(['normal', 'moving', 'fragile'], weights=[0.6, 0.25, 0.15])[0] new_plat = Platform(x, y, width, 15, plat_type) platforms.add(new_plat) # 有一定概率在平台附近生成障碍物 if random.random() < 0.3: # 30%的概率 # 障碍物可以放在平台上方或旁边 obs_x = new_plat.rect.centerx + random.choice([-40, 40]) obs_y = new_plat.rect.top - 40 all_obstacles.add(Spike(obs_x, obs_y)) # 3. 将小球“拉”回屏幕中下部，实际上是世界坐标改变了，但小球相对屏幕位置不变 # 我们通过给所有精灵下移来实现滚动，所以小球本身不需要动 # 但需要补偿小球的位置，使其视觉上保持在原处 # 更简单的做法：在PlayerBall.update的最后，反向调整小球位置（不推荐，容易乱） # 我们采用的标准做法是：在渲染时，根据一个“相机偏移量”来绘制所有物体。 # 为了简化，本例采用移动所有其他物体的方式，小球不动。这要求我们更新小球的位置判断逻辑。 # 这里我们采用一个全局变量 `camera_y` 来模拟相机偏移，是更清晰的做法。 return scroll_amount # 返回滚动的距离，可以用于更新分数 return 0

这个生成逻辑是游戏可玩性的核心。它确保了玩家在向上跳跃时，总有新的挑战（平台和障碍物）在屏幕上方生成，而旧的、已经落到底部屏幕之外的物体会被清理掉，保持游戏运行的效率。

4. 整合与核心交互逻辑实现

现在，我们将所有模块整合到主循环中，并实现相机滚动和分数系统。

4.1 整合游戏对象与主循环

我们需要在主循环开始前初始化所有精灵组和对象，并在游戏状态更新时调用它们。

# 在主循环之前初始化 all_sprites = pygame.sprite.Group() platforms = pygame.sprite.Group() obstacles = pygame.sprite.Group() player = None # 将在游戏开始时初始化 score = 0 camera_y = 0 # 相机偏移，正值表示世界向下移动 # 在游戏状态切换到 GAME_PLAYING 时初始化游戏 def init_game(): global player, platforms, obstacles, all_sprites, score, camera_y # 清空所有组 all_sprites.empty() platforms.empty() obstacles.empty() # 创建玩家 player = PlayerBall(SCREEN_WIDTH // 2, SCREEN_HEIGHT - 100) all_sprites.add(player) # 生成初始平台 platforms = generate_initial_platforms() all_sprites.add(platforms) # 可以生成一些初始障碍物 # ... all_sprites.add(obstacles) score = 0 camera_y = 0 # 在主循环的事件处理部分，当按下空格开始游戏时调用 # if game_state == GAME_MENU and event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: # game_state = GAME_PLAYING # init_game()

4.2 实现基于相机的滚动与分数计算

为了更优雅地实现世界滚动，我们引入一个“相机”概念。相机盯着小球，当小球向上移动时，相机也向上移动（即所有其他物体向下移动）。这样，小球在屏幕上的垂直位置可以保持相对固定，而世界在它脚下滚动。

# 修改 PlayerBall.update 的碰撞检测部分，考虑相机偏移 # 实际上，我们不需要修改碰撞检测，因为所有物体的rect位置都是世界坐标。 # 我们修改的是渲染部分。 # 在主循环的渲染部分 (GAME_PLAYING 状态) elif game_state == GAME_PLAYING: # 先更新相机位置：让相机跟随小球，但只在小球向上超过屏幕中心时跟随 if player.rect.top < SCREEN_HEIGHT // 3: # 计算需要滚动的距离 scroll = SCREEN_HEIGHT // 3 - player.rect.top camera_y += scroll # 将所有非玩家的物体下移，模拟相机向上移动 for sprite in all_sprites: if sprite != player: sprite.rect.y += scroll # 滚动距离可以转化为分数 score += scroll // 5 # 每滚动5像素得1分，具体比例可调 # 绘制所有精灵（此时它们的rect已经是根据相机偏移调整后的“屏幕坐标”） for sprite in all_sprites: # 只绘制在屏幕范围内的精灵，优化性能 if sprite.rect.bottom > 0 and sprite.rect.top < SCREEN_HEIGHT: screen.blit(sprite.image, sprite.rect) # 绘制UI（分数、层数） font = pygame.font.SysFont(None, 36) score_text = font.render(f"深度: {score}", True, WHITE) screen.blit(score_text, (10, 10))

这个实现中，camera_y累计了总的滚动距离，可以用来表示玩家下降的“深度”或分数。我们通过移动所有非玩家精灵来模拟相机滚动，这是一个简单有效的技巧。

4.3 小球与各类障碍物的深度交互逻辑

基础的碰撞检测（碰到即死）已经实现。我们可以让交互更丰富：

• 尖刺（Spike）：碰到即死。
• 移动摆锤：需要继承Sprite，并实现来回摆动的update逻辑。碰撞检测与尖刺相同。
• 一次性脆弱平台：当小球站在上面一段时间后，平台会闪烁然后消失。这需要在Platform类的update中实现，并在PlayerBall与平台的碰撞检测中，如果平台类型是fragile，则触发其is_breaking = True。
• 弹簧平台：当小球落在其上时，给予一个比普通跳跃更大的向上速度。这需要在碰撞响应中判断平台类型，并修改self.velocity_y。
• 左右移动平台：小球站在上面时，应随平台一起移动。这需要在PlayerBall与移动平台碰撞后，除了位置修正，还要在水平方向上继承平台的速度，即self.rect.x += platform.speed（需要小心处理，避免多重继承导致速度叠加异常）。

这些交互逻辑的添加，会极大增加游戏的策略性和趣味性。关键在于在PlayerBall.update的碰撞检测循环中，根据碰撞到的精灵类型，执行不同的逻辑分支。

5. 性能优化、调试与扩展建议

一个基本可玩的游戏已经成型，但要让它更流畅、更专业，我们还需要做一些工作。

5.1 性能优化与调试技巧

1. 精灵绘制优化：在主循环中，我们遍历all_sprites进行绘制。如果精灵数量很多（比如几百个），可以只绘制那些在相机视口（屏幕）内的精灵，如上面代码所示。这称为“视口裁剪”。
2. 碰撞检测优化：pygame.sprite.spritecollide默认会检查一个精灵与组内所有其他精灵的碰撞，是O(n)复杂度。如果精灵数量巨大，可以考虑空间划分算法，如四叉树（Quadtree），但Pygame未内置。一个折中方案是，只对玩家小球周围一定矩形区域内的平台和障碍物进行碰撞检测。我们可以先用pygame.sprite.spritecollide配合一个自定义的碰撞回调函数，或者先通过rect的colliderect粗略筛选。
3. 使用精灵图层（LayeredUpdates）：如果游戏有前景、背景、玩家、UI等多层元素，可以使用pygame.sprite.LayeredUpdates替代Group，它允许你指定精灵的绘制顺序（层）。
4. 调试信息显示：在开发过程中，可以在屏幕上实时打印一些变量，如小球速度、位置、是否在地面、碰撞到的平台数量等，这能快速帮你定位逻辑错误。

   # 在渲染部分添加调试信息 debug_font = pygame.font.SysFont(None, 24) debug_text = debug_font.render(f"Pos: ({player.rect.x}, {player.rect.y}) VelY: {player.velocity_y:.1f} OnGround: {player.on_ground}", True, WHITE) screen.blit(debug_text, (10, 50))

5.2 游戏性扩展与内容丰富

1. 关卡设计与主题：不要只使用随机生成。可以设计一些固定的“挑战房间”或“奖励房间”，在特定分数段出现。也可以更换背景、小球皮肤、平台和障碍物贴图来创造不同主题（如森林、太空、地狱）。
2. 道具系统：增加可以拾取的道具，如“临时无敌护盾”、“双倍跳跃”、“磁铁（吸引附近金币）”。这需要创建Item精灵类，并在与玩家碰撞时触发效果（通过修改玩家状态或全局变量）。
3. 粒子效果：当小球跳跃、落地、碰撞障碍物死亡时，添加简单的粒子效果（如迸发的小点）能极大提升视觉反馈。Pygame没有内置粒子系统，但可以自己用一堆小的、有生命周期的精灵来模拟。
4. 音效与背景音乐：使用pygame.mixer模块加载和播放音效（跳跃声、碰撞声、得分声）和背景音乐，让游戏更有沉浸感。
5. 游戏进度保存：将最高分记录到本地文件（如best_score.txt），每次游戏开始时读取并显示。

5.3 常见问题与排查实录

在开发过程中，你几乎一定会遇到下面这些问题：

1. 小球“抖动”或“卡进”平台：这是碰撞响应逻辑不严谨导致的。核心是要在垂直和水平两个方向分别进行碰撞检测和位置修正，并且修正的顺序很重要。通常先处理垂直碰撞（决定能否站在平台上），再处理水平碰撞（防止穿墙）。我们的代码先水平位移再垂直位移，并在垂直碰撞后修正位置，是常见且有效的顺序。如果仍有抖动，可以尝试在垂直碰撞后，将小球稍微向上“推”出平台几个像素（如self.rect.bottom = platform.rect.top - 1），确保它完全脱离碰撞区域。
2. 跳跃手感“粘滞”或“不跟手”：检查跳跃按键检测的逻辑。我们使用了pygame.key.get_pressed()在update中持续检测，这是正确的。确保on_ground判断准确。一个常见错误是，小球边缘刚碰到平台侧面就被判为on_ground，导致无法起跳。我们的碰撞检测通过判断self.velocity_y > 0（向下运动）和底部重叠来设置on_ground，相对准确。
3. 游戏越跑越卡：这是“内存泄漏”或对象未及时销毁的典型症状。确保将移出屏幕、不再需要的平台和障碍物用kill()方法从所有精灵组中移除。我们的generate_new_platforms_on_scroll函数中已经做了这个清理工作（if plat.rect.top > SCREEN_HEIGHT: plat.kill()）。
4. 移动平台上的小球滑落：如果小球站在左右移动的平台上，理想情况是应该随平台一起移动。我们的代码目前没有实现这个。需要在PlayerBall与平台碰撞检测中，如果碰撞的平台是移动类型，则在水平方向上给小球增加平台的速度分量。但要小心处理，避免每帧重复添加导致速度爆炸。一个更稳健的做法是，在判断小球站在移动平台上后，直接修改小球的rect.x使其与平台保持相对位置。
5. 一次性平台消失太快或太慢：这由fragile平台的break_timer阈值控制。我们设置了60帧（约1秒）。你可以根据游戏难度调整这个值，或者加入视觉反馈，如平台在消失前闪烁几次（通过改变image的透明度或颜色）。

从零开始实现一个“下一百层”游戏，最大的收获不是最终的那个可执行文件，而是这个过程中对游戏引擎基本工作原理的深刻理解。你亲手搭建了游戏循环，设计了物理规则，处理了输入与反馈，实现了复杂的碰撞交互。这些经验是通用的，无论是未来用更专业的引擎（如Unity, Godot），还是开发其他类型的交互式应用，都将是一笔宝贵的财富。这个项目代码还有很多可以打磨的地方，比如加入更多的障碍物动画、设计更平滑的相机跟随算法、实现关卡序列化等等。不妨以此为基础，加入你自己的创意，把它变成独一无二的游戏吧。