Pygame 实现小球躲避游戏实例代码

2. 配置模块 (setting.py)

所有硬编码的常量均在此定义，便于统一调整游戏参数。包括窗口大小、背景色、帧率及关卡时间阈值。

WIDTH = 900      # 窗口宽度
HEIGHT = 600     # 窗口高度
SCORE = 0        # 初始分数
TIME = 0         # 计时器
FIRST_STEP = 10  # 到达第二关时间阈值
SECOND_STEP = 20 # 到达第三关时间阈值
FPS = 60         # 刷新率
BG_COLOR = (255, 239, 213)  # 背景颜色 RGB

3. 工具函数 (utils.py)

此模块包含游戏核心算法逻辑。原内容被截断，此处补全了小球数量生成逻辑及必要的类定义。根据当前游戏时间和难度，动态调整障碍物密度。

# -*- coding: utf-8 -*-
import pygame
from setting import FIRST_STEP, SECOND_STEP, BG_COLOR, WIDTH, HEIGHT

# 根据难度和时间生成对应的小球数量
# Time: 2021/12/17 8:35 下午
# Author: HengYi
def ballNum(ladderNum, time):
    index = 0
    if FIRST_STEP <= time < SECOND_STEP:
        index = 1
    if SECOND_STEP <= time:
        index = 2
    
    # 基础数量 + 难度系数 * 指数
    base_count = ladderNum * 2
    return base_count + index * 5

class Ball(pygame.sprite.Sprite):
    def __init__(self, x, y, radius, color, speed):
        super().__init__()
        self.image = pygame.Surface((radius * 2, radius * 2), pygame.SRCALPHA)
        pygame.draw.circle(self.image, color, (radius, radius), radius)
        self.rect = self.image.get_rect()
        self.rect.center = (x, y)
        self.speed = speed

    def update(self):
        self.rect.x += self.speed[0]
        self.rect.y += self.speed[1]
        # 边界检测，反弹
        if self.rect.left <= 0 or self.rect.right >= WIDTH:
            self.speed[0] *= -1
        if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
            self.speed[1] *= -1

4. 主逻辑模块 (main.py)

这是游戏的核心，实现了 Pygame 的标准事件循环。负责处理键盘输入、更新实体位置、检测碰撞以及绘制画面。

import pygame
import random
from setting import WIDTH, HEIGHT, FPS, BG_COLOR, SCORE, TIME
from utils import Ball, ballNum

def main(difficulty_level):
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("小球躲避游戏")
    clock = pygame.time.Clock()
    
    player = Ball(WIDTH // 2, HEIGHT // 2, 20, (0, 0, 255), [0, 0])
    obstacles = pygame.sprite.Group()
    
    running = True
    game_over = False
    score = 0
    timer = 0
    
    while running:
        clock.tick(FPS)
        screen.fill(BG_COLOR)
        
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    running = False
                if not game_over and event.key == pygame.K_SPACE:
                    # 暂停/继续逻辑可在此扩展
                    pass
        
        if not game_over:
            timer += 1
            # 根据难度和生成频率添加障碍物
            if timer % (30 // difficulty_level) == 0:
                ox = random.randint(0, WIDTH)
                oy = random.randint(0, HEIGHT)
                obs = Ball(ox, oy, 15, (255, 0, 0), [random.choice([-1, 1]), random.choice([-1, 1])])
                obstacles.add(obs)
            
            player.update()
            for obs in obstacles:
                obs.update()
                # 简单的矩形碰撞检测
                if player.rect.colliderect(obs.rect):
                    game_over = True
            
            score += 1
            
            # 绘制
            screen.blit(player.image, player.rect)
            obstacles.draw(screen)
            
            # 显示分数
            font = pygame.font.SysFont("arial", 24)
            text = font.render(f"Score: {score}", True, (0, 0, 0))
            screen.blit(text, (10, 10))
        else:
            # 游戏结束界面
            font = pygame.font.SysFont("arial", 48)
            text = font.render("Game Over", True, (255, 0, 0))
            rect = text.get_rect(center=(WIDTH//2, HEIGHT//2))
            screen.blit(text, rect)
            
            sub_font = pygame.font.SysFont("arial", 24)
            sub_text = sub_font.render("Press R to Restart", True, (0, 0, 0))
            sub_rect = sub_text.get_rect(center=(WIDTH//2, HEIGHT//2 + 40))
            screen.blit(sub_text, sub_rect)
            
            for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_r:
                        main(difficulty_level)
                        return
        
        pygame.display.flip()
    
    pygame.quit()

核心逻辑解析

1. 游戏循环机制

Pygame 的游戏运行依赖于 while 循环配合 Clock 对象。每一帧都会执行以下步骤：

1. 清空屏幕（Fill）。
2. 处理事件（Event Polling）。
3. 更新数据（Update）。
4. 渲染画面（Draw & Flip）。

这种机制保证了动画的流畅性，并通过 clock.tick(FPS) 限制最大帧率，防止 CPU 占用过高。

2. 碰撞检测原理

本示例使用了 pygame.Rect 类的 colliderect 方法。该方法基于轴对齐包围盒（AABB）算法，判断两个矩形的区域是否有重叠。对于圆形物体，虽然物理上更精确的是圆心距离判断，但在像素级游戏中，矩形碰撞足以满足需求且性能更高。

3. 难度调节策略

难度通过 difficulty_level 参数传入，影响障碍物的生成频率。数值越大，分母越小，取模条件越容易满足，从而增加单位时间内的障碍物数量。同时，ballNum 函数可根据游戏时长动态调整生成基数，使游戏随着时间推移逐渐变难。

运行说明

1. 将上述四个文件保存在同一目录下。
2. 打开终端进入该目录。
3. 运行 python run.py。
4. 根据提示输入数字选择难度（1-3）。
5. 使用方向键控制移动（需扩展 Player 类），空格键暂停，ESC 退出。

总结

通过本实例，我们完成了从环境搭建到代码实现的完整闭环。模块化设计不仅提升了代码可读性，也为后续添加音效、计分排行榜等功能奠定了基础。开发者可在此基础上进一步探索粒子效果、状态机管理及网络对战等高级特性。