【Pygame】第2章 Pygame基础概念与游戏循环

智算菩萨2026-04-03 8:13

摘要

本章将深入探讨Pygame的核心基础概念，这是理解整个Pygame框架的关键所在。我们将详细解析游戏循环的工作原理，这是每个游戏程序的心脏；介绍Pygame的坐标系统和颜色表示方法，这是进行图形编程的基础；并系统梳理Pygame的模块组织结构，帮助读者建立完整的知识体系。同时，本章将展示如何使用GPT-5.4来深入理解这些抽象概念，通过AI的解释和示例代码加速学习进程。由于国内无法访问OpenAI官网，因此使用国内镜像站可以合法注册使用GPT-5.4最新模型。重要提示：翻墙行为违反中国法律法规，请大家不要翻墙，选择合法的国内镜像站使用AI服务 。注册入口：AIGCBAR镜像站。掌握本章内容后，读者将具备理解任何Pygame程序的能力。

2.1 游戏循环详解

游戏循环是游戏程序最核心的组成部分，它负责控制游戏的整体运行流程。理解游戏循环的工作原理对于开发高质量的游戏至关重要。

2.1.1 游戏循环的基本结构

游戏循环本质上是一个无限循环，它不断地重复执行三个主要任务：处理输入、更新游戏状态和渲染画面。这个循环以极高的速度运行，通常是每秒60次或更多，从而创造出流畅的动画效果。

一个标准的游戏循环结构如下所示：

python 复制代码 
import pygame
import sys

pygame.init()
screen = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()

running = True
while running:
    # 1. 处理输入事件
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
    
    # 2. 更新游戏状态
    # 更新玩家位置、检测碰撞、计算分数等
    
    # 3. 渲染画面
    screen.fill((0, 0, 0))
    # 绘制游戏对象
    pygame.display.flip()
    
    # 4. 控制帧率
    clock.tick(60)

pygame.quit()
sys.exit()

这个结构虽然简单，但包含了游戏循环的所有核心要素。在实际的游戏开发中，每个部分都会扩展得更加复杂，但基本结构保持不变。

2.1.2 事件处理机制

Pygame使用事件驱动的编程模型来处理用户输入和系统事件。事件可以是用户的键盘按键、鼠标移动，也可以是系统事件如窗口关闭。Pygame将所有发生的事件放入一个事件队列中，开发者通过遍历这个队列来处理每个事件。

事件处理的基本模式是：

python 复制代码 
for event in pygame.event.get():
    if event.type == pygame.QUIT:
        # 处理窗口关闭事件
        running = False
    elif event.type == pygame.KEYDOWN:
        # 处理按键按下事件
        if event.key == pygame.K_SPACE:
            print("空格键被按下")
    elif event.type == pygame.MOUSEBUTTONDOWN:
        # 处理鼠标点击事件
        print(f"鼠标在位置 {event.pos} 被点击")

Pygame定义了大量的事件类型，涵盖了各种用户输入和系统事件。常见的事件类型包括：

事件类型 描述 常用属性
QUIT 用户点击关闭按钮 无
KEYDOWN 键盘按键按下 key, mod, unicode
KEYUP 键盘按键释放 key, mod
MOUSEMOTION 鼠标移动 pos, rel, buttons
MOUSEBUTTONDOWN 鼠标按钮按下 pos, button
MOUSEBUTTONUP 鼠标按钮释放 pos, button
VIDEORESIZE 窗口大小改变 size, w, h
ACTIVEEVENT 窗口获得或失去焦点 gain, state

2.1.3 游戏状态更新

游戏状态更新是游戏循环中最重要的部分之一。在这一阶段，程序根据用户输入和游戏逻辑来更新所有游戏对象的状态。这包括移动角色、播放动画、检测碰撞、更新分数等。

游戏状态更新通常涉及多个方面：

位置更新：根据速度和方向更新对象的位置。例如，一个移动的球可以这样更新：

python 复制代码 
ball_x += ball_speed_x
ball_y += ball_speed_y

动画更新：更新动画帧以创建动画效果。可以通过维护一个帧计数器来实现：

python 复制代码 
frame_counter += 1
if frame_counter >= animation_speed:
    frame_counter = 0
    current_frame = (current_frame + 1) % total_frames

碰撞检测：检测游戏对象之间是否发生碰撞，并相应地处理。Pygame提供了多种碰撞检测方法，我们将在后续章节详细介绍。

游戏逻辑：实现游戏的核心规则，如计分系统、生命值管理、关卡进度等。

2.1.4 画面渲染流程

画面渲染是将游戏状态可视化呈现给用户的过程。一个良好的渲染流程可以确保游戏画面流畅、无闪烁。

标准的渲染流程包括以下步骤：

  1. 清空屏幕：使用背景色填充整个屏幕，清除上一帧的内容。
  2. 绘制背景：绘制游戏的背景图像或图案。
  3. 绘制游戏对象：按照正确的顺序绘制所有可见的游戏对象，通常是从后往前的顺序（画家算法）。
  4. 绘制UI元素：绘制分数、生命值、菜单等用户界面元素。
  5. 更新显示 ：调用pygame.display.flip()或pygame.display.update()将绘制的内容显示到屏幕上。
python 复制代码 
# 清空屏幕
screen.fill((0, 0, 0))

# 绘制背景
screen.blit(background_image, (0, 0))

# 绘制游戏对象
for sprite in all_sprites:
    screen.blit(sprite.image, sprite.rect)

# 绘制UI
draw_score(screen, score)
draw_health_bar(screen, health)

# 更新显示
pygame.display.flip()

2.1.5 帧率控制

帧率（FPS，Frames Per Second）表示游戏每秒更新的次数。控制帧率对于保证游戏在不同性能的设备上都能流畅运行非常重要。

Pygame提供了pygame.time.Clock类来帮助控制帧率。tick()方法会暂停程序，确保每次调用之间的时间间隔不会太短，从而将帧率限制在指定的值。

python 复制代码 
clock = pygame.time.Clock()

while running:
    # 游戏逻辑...
    
    clock.tick(60)  # 限制为60 FPS

除了控制帧率，Clock对象还可以提供有用的信息：

python 复制代码 
# 获取上一帧的时间（毫秒）
delta_time = clock.get_time()

# 获取当前帧率
fps = clock.get_fps()

# 获取总运行时间（毫秒）
total_time = pygame.time.get_ticks()

使用delta_time（上一帧的时间）可以实现与帧率无关的动画，确保对象在不同帧率下以相同的速度移动：

python 复制代码 
# 帧率无关的移动
player_x += player_speed * delta_time / 1000.0

2.2 坐标系统与颜色

理解Pygame的坐标系统和颜色表示方法是进行图形编程的基础。本节将详细介绍这两个核心概念。

2.2.1 屏幕坐标系统

Pygame使用二维笛卡尔坐标系统来定位屏幕上的点。坐标系统的原点(0, 0)位于屏幕的左上角，x轴向右增加，y轴向下增加。

这种坐标系统与数学中的标准坐标系统有所不同，主要体现在y轴的方向上。在Pygame中，y值越大表示位置越靠下，这与屏幕扫描的顺序一致。

屏幕坐标的范围取决于窗口的大小。例如，一个800x600的窗口，x坐标的范围是0到799，y坐标的范围是0到599。坐标值通常是整数，但某些操作也接受浮点数。

理解坐标系统对于游戏开发至关重要。例如，要将一个对象居中显示，可以这样计算位置：

python 复制代码 
object_width = 100
object_height = 50
screen_width = 800
screen_height = 600

x = (screen_width - object_width) // 2
y = (screen_height - object_height) // 2

2.2.2 局部坐标与世界坐标

在复杂的游戏中，通常会使用两种坐标系统：屏幕坐标（局部坐标）和世界坐标。屏幕坐标是相对于游戏窗口的坐标，而世界坐标是相对于游戏世界的坐标。

当游戏世界大于屏幕时，需要使用摄像机系统来转换这两种坐标。例如：

python 复制代码 
# 世界坐标转换为屏幕坐标
screen_x = world_x - camera_x
screen_y = world_y - camera_y

# 屏幕坐标转换为世界坐标
world_x = screen_x + camera_x
world_y = screen_y + camera_y

这种分离使得游戏逻辑可以在世界坐标系中处理，而渲染时只需要转换到屏幕坐标系。

2.2.3 颜色表示方法

Pygame使用RGB颜色模型来表示颜色。RGB代表红色（Red）、绿色（Green）和蓝色（Blue），每种颜色用一个0到255的整数表示，组合起来可以表示超过1600万种颜色。

颜色在Pygame中通常表示为一个包含三个整数的元组：

python 复制代码 
# 基本颜色
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)

# 混合颜色
YELLOW = (255, 255, 0)
CYAN = (0, 255, 255)
MAGENTA = (255, 0, 255)
GRAY = (128, 128, 128)

# 自定义颜色
ORANGE = (255, 165, 0)
PURPLE = (128, 0, 128)
PINK = (255, 192, 203)

2.2.4 带透明度的颜色

除了RGB，Pygame还支持RGBA颜色模型，其中A代表Alpha通道，用于表示透明度。Alpha值的范围也是0到255，0表示完全透明，255表示完全不透明。

RGBA颜色用于需要透明效果的场合，如绘制半透明的阴影或高光：

python 复制代码 
# 半透明红色
semi_transparent_red = (255, 0, 0, 128)

# 使用RGBA绘制半透明矩形
s = pygame.Surface((100, 100), pygame.SRCALPHA)
s.fill((255, 0, 0, 128))
screen.blit(s, (50, 50))

注意，要使用透明度，需要创建一个带有pygame.SRCALPHA标志的表面。

2.2.5 颜色实用函数

Pygame提供了一些实用的颜色处理函数：

python 复制代码 
# 颜色插值（在两个颜色之间过渡）
def lerp_color(color1, color2, t):
    return (
        int(color1[0] + (color2[0] - color1[0]) * t),
        int(color1[1] + (color2[1] - color1[1]) * t),
        int(color1[2] + (color2[2] - color1[2]) * t)
    )

# 调整颜色亮度
def adjust_brightness(color, factor):
    return (
        max(0, min(255, int(color[0] * factor))),
        max(0, min(255, int(color[1] * factor))),
        max(0, min(255, int(color[2] * factor)))
    )

# 生成随机颜色
import random
def random_color():
    return (random.randint(0, 255), 
            random.randint(0, 255), 
            random.randint(0, 255))

2.3 Pygame模块组织结构

Pygame是一个模块化的库，由多个子模块组成，每个子模块负责特定的功能。理解这些模块的组织结构有助于更有效地使用Pygame。

2.3.1 核心模块概览

Pygame的主要模块及其功能如下表所示：

模块名 功能描述 常用功能
pygame.display 显示窗口管理 创建窗口、设置标题、更新显示
pygame.event 事件处理 获取事件、发送事件、事件类型定义
pygame.draw 绘制基本图形 绘制矩形、圆形、线条、多边形
pygame.image 图像处理 加载和保存图像文件
pygame.key 键盘输入 获取按键状态、设置按键重复
pygame.mouse 鼠标输入 获取鼠标位置、设置鼠标可见性
pygame.mixer 音频播放 播放音乐和音效
pygame.font 文字渲染 加载字体、渲染文字
pygame.time 时间管理 控制帧率、创建计时器
pygame.sprite 精灵系统 精灵类、精灵组、碰撞检测
pygame.transform 图像变换 缩放、旋转、翻转图像
pygame.Rect 矩形类 矩形操作和碰撞检测
pygame.Surface 表面类 图像绘制的基础
pygame.Color 颜色类 颜色表示和操作

2.3.2 display模块详解

display模块负责管理游戏窗口和屏幕显示。这是Pygame中最常用的模块之一。

主要功能包括：

创建显示窗口：

python 复制代码 
# 基本窗口创建
screen = pygame.display.set_mode((800, 600))

# 带标志的窗口创建
screen = pygame.display.set_mode((800, 600), pygame.FULLSCREEN)
screen = pygame.display.set_mode((800, 600), pygame.RESIZABLE)
screen = pygame.display.set_mode((800, 600), pygame.NOFRAME)

可用的窗口标志包括：

  • pygame.FULLSCREEN：全屏模式
  • pygame.RESIZABLE：可调整大小的窗口
  • pygame.NOFRAME：无边框窗口
  • pygame.DOUBLEBUF：双缓冲（推荐用于平滑动画）
  • pygame.HWSURFACE：硬件加速（如果可用）

窗口管理：

python 复制代码 
# 设置窗口标题
pygame.display.set_caption("游戏标题")

# 获取窗口标题
title = pygame.display.get_caption()

# 设置窗口图标
icon = pygame.image.load("icon.png")
pygame.display.set_icon(icon)

# 切换全屏模式
pygame.display.toggle_fullscreen()

更新显示：

python 复制代码 
# 更新整个屏幕
pygame.display.flip()

# 更新指定区域（更高效）
pygame.display.update()
pygame.display.update(rect)
pygame.display.update(rect_list)

2.3.3 event模块详解

event模块处理所有用户输入和系统事件。理解事件系统对于创建交互式游戏至关重要。

获取事件：

python 复制代码 
# 获取所有待处理的事件
for event in pygame.event.get():
    process_event(event)

# 获取特定类型的事件
for event in pygame.event.get(pygame.KEYDOWN):
    process_keydown(event)

# 检查是否有事件等待处理
if pygame.event.peek():
    print("有事件等待处理")

发送自定义事件：

python 复制代码 
# 创建自定义事件类型
CUSTOM_EVENT = pygame.USEREVENT + 1

# 发送自定义事件
custom_event = pygame.event.Event(CUSTOM_EVENT, message="Hello")
pygame.event.post(custom_event)

# 处理自定义事件
for event in pygame.event.get():
    if event.type == CUSTOM_EVENT:
        print(event.message)

设置事件过滤：

python 复制代码 
# 阻止某些事件进入事件队列
pygame.event.set_blocked(pygame.MOUSEMOTION)

# 允许被阻止的事件
pygame.event.set_allowed(pygame.MOUSEMOTION)

# 获取被阻止的事件类型
blocked_events = pygame.event.get_blocked()

2.3.4 Surface对象详解

Surface是Pygame中最重要的概念之一。它代表一个可以绘制的矩形区域，是图像和图形操作的基础。

创建Surface：

python 复制代码 
# 创建空白Surface
surface = pygame.Surface((100, 100))

# 创建带透明通道的Surface
surface = pygame.Surface((100, 100), pygame.SRCALPHA)

# 从图像文件创建Surface
image = pygame.image.load("image.png")

Surface操作：

python 复制代码 
# 填充颜色
surface.fill((255, 0, 0))
surface.fill((255, 0, 0), special_flags=pygame.BLEND_ADD)

# 绘制到另一个Surface
screen.blit(surface, (x, y))
screen.blit(surface, (x, y), area=(src_x, src_y, width, height))

# 获取Surface信息
width = surface.get_width()
height = surface.get_height()
rect = surface.get_rect()
pixels = pygame.surfarray.pixels3d(surface)

混合模式：

Pygame支持多种混合模式，用于控制两个Surface叠加时的颜色计算方式：

python 复制代码 
# 加法混合（变亮）
screen.blit(surface, pos, special_flags=pygame.BLEND_ADD)

# 减法混合（变暗）
screen.blit(surface, pos, special_flags=pygame.BLEND_SUB)

# 乘法混合
screen.blit(surface, pos, special_flags=pygame.BLEND_MULT)

# 最小值混合
screen.blit(surface, pos, special_flags=pygame.BLEND_MIN)

# 最大值混合
screen.blit(surface, pos, special_flags=pygame.BLEND_MAX)

2.3.5 Rect对象详解

Rect（矩形）对象在Pygame中广泛使用，用于表示位置和进行碰撞检测。

创建Rect：

python 复制代码 
# 从位置和尺寸创建
rect = pygame.Rect(x, y, width, height)

# 从两个点创建
rect = pygame.Rect((left, top), (width, height))

# 从Surface获取
rect = surface.get_rect()
rect = surface.get_rect(center=(400, 300))

Rect属性：

python 复制代码 
rect = pygame.Rect(100, 200, 50, 80)

# 位置和尺寸
print(rect.x, rect.y)           # 100, 200
print(rect.width, rect.height)  # 50, 80
print(rect.w, rect.h)           # 50, 80

# 边界位置
print(rect.left, rect.top)      # 100, 200
print(rect.right, rect.bottom)  # 150, 280
print(rect.centerx, rect.centery)  # 125, 240

# 角点位置
print(rect.topleft)             # (100, 200)
print(rect.topright)            # (150, 200)
print(rect.bottomleft)          # (100, 280)
print(rect.bottomright)         # (150, 280)
print(rect.center)              # (125, 240)
print(rect.midleft)             # (100, 240)
print(rect.midright)            # (150, 240)
print(rect.midtop)              # (125, 200)
print(rect.midbottom)           # (125, 280)

Rect方法：

python 复制代码 
# 移动Rect
rect.move_ip(10, 20)  # 原地移动
new_rect = rect.move(10, 20)  # 返回新Rect

# 缩放Rect
rect.inflate_ip(20, 30)  # 原地缩放
new_rect = rect.inflate(20, 30)  # 返回新Rect

# 裁剪Rect
clipped = rect.clip(other_rect)

# 合并Rect
union_rect = rect.union(other_rect)

# 缩放以适应
fit_rect = rect.fit_into(other_rect)

# 碰撞检测
if rect.collidepoint(x, y):
    print("点在矩形内")

if rect.colliderect(other_rect):
    print("两个矩形相交")

if rect.collidelist(rect_list) != -1:
    print("与列表中的某个矩形相交")

# 获取相交的矩形列表
indices = rect.collidelistall(rect_list)

2.4 使用GPT-5.4深入理解概念

本节将展示如何使用GPT-5.4来深入理解Pygame的核心概念，通过AI的解释和示例代码来加速学习进程。

2.4.1 向GPT-5.4提问的技巧

当向GPT-5.4询问技术概念时，使用清晰、具体的问题可以获得更好的回答。以下是一些有效的提问模板：

提示词示例1：概念解释

复制代码 
请详细解释Pygame中的Surface对象，包括：
1. Surface是什么以及它的作用
2. 如何创建不同类型的Surface
3. Surface的主要方法和属性
4. 在游戏开发中的典型使用场景
5. 提供一个完整的代码示例展示Surface的各种用法

请用中文回答，代码中包含详细的中文注释。

提示词示例2：代码分析

复制代码 
请分析以下Pygame代码，解释每一部分的作用：

[粘贴代码]

请逐行解释代码的工作原理，并指出其中使用的关键概念和最佳实践。

提示词示例3：概念对比

复制代码 
请对比Pygame中的blit()方法和draw()方法，包括：
1. 两者的主要区别
2. 各自适用的场景
3. 性能方面的差异
4. 使用时的注意事项
5. 提供示例代码展示两者的用法

提示词示例4：最佳实践

复制代码 
请提供Pygame游戏循环的最佳实践，包括：
1. 标准的游戏循环结构
2. 如何处理不同的时间步长
3. 帧率控制的正确方法
4. 常见的性能陷阱和避免方法
5. 一个完整的高效游戏循环示例

2.4.2 获取代码示例和解释

GPT-5.4可以提供详细的代码示例来解释概念。以下是一个展示游戏循环完整实现的示例：

python 复制代码 
import pygame
import sys

# 初始化Pygame
pygame.init()

# 常量定义
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
FPS = 60
BG_COLOR = (30, 30, 30)
PLAYER_COLOR = (0, 150, 255)
PLAYER_SIZE = 50
PLAYER_SPEED = 300  # 像素/秒

# 创建窗口
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("游戏循环示例")
clock = pygame.time.Clock()

# 游戏状态
player_x = SCREEN_WIDTH // 2 - PLAYER_SIZE // 2
player_y = SCREEN_HEIGHT // 2 - PLAYER_SIZE // 2
player_vx = 0
player_vy = 0

# 游戏循环
running = True
while running:
    # 计算delta time（秒）
    dt = clock.tick(FPS) / 1000.0
    
    # 事件处理
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                running = False
    
    # 获取按键状态
    keys = pygame.key.get_pressed()
    player_vx = 0
    player_vy = 0
    if keys[pygame.K_LEFT] or keys[pygame.K_a]:
        player_vx = -PLAYER_SPEED
    if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
        player_vx = PLAYER_SPEED
    if keys[pygame.K_UP] or keys[pygame.K_w]:
        player_vy = -PLAYER_SPEED
    if keys[pygame.K_DOWN] or keys[pygame.K_s]:
        player_vy = PLAYER_SPEED
    
    # 更新游戏状态（使用delta time实现帧率无关的移动）
    player_x += player_vx * dt
    player_y += player_vy * dt
    
    # 边界限制
    player_x = max(0, min(SCREEN_WIDTH - PLAYER_SIZE, player_x))
    player_y = max(0, min(SCREEN_HEIGHT - PLAYER_SIZE, player_y))
    
    # 渲染
    screen.fill(BG_COLOR)
    pygame.draw.rect(screen, PLAYER_COLOR, 
                     (player_x, player_y, PLAYER_SIZE, PLAYER_SIZE))
    
    # 显示FPS
    font = pygame.font.SysFont(None, 36)
    fps_text = font.render(f"FPS: {int(clock.get_fps())}", True, (255, 255, 255))
    screen.blit(fps_text, (10, 10))
    
    pygame.display.flip()

pygame.quit()
sys.exit()

这个示例展示了：

  • 使用delta time实现帧率无关的移动
  • 按键状态检测（而非仅事件处理）
  • 边界限制
  • FPS显示
  • 清晰的代码结构

2.4.3 调试和问题解决

当遇到问题时，可以向GPT-5.4寻求帮助。提供足够的信息可以获得更有效的帮助：

提示词示例：问题求助

复制代码 
我在使用Pygame时遇到了以下问题：

问题描述：游戏运行时画面闪烁严重

代码如下：
[粘贴代码]

运行环境：
- 操作系统：Windows 10
- Python版本：3.9
- Pygame版本：2.5.0

请帮我分析问题原因并提供解决方案。

2.4.4 学习路径建议

使用GPT-5.4辅助学习Pygame时，建议按照以下路径进行：

  1. 基础概念阶段：让GPT-5.4解释核心概念，如Surface、Rect、游戏循环等
  2. 代码实践阶段：获取代码示例，动手实践并修改
  3. 项目开发阶段：让GPT-5.4提供项目结构和实现建议
  4. 优化提升阶段：学习性能优化和最佳实践

在每个阶段，都可以向GPT-5.4提出针对性的问题，加速学习进程。

2.5 完整示例程序

本节提供一个综合性的示例程序，展示本章介绍的各种概念的实际应用。

python 复制代码 
import pygame
import sys
import random

# 初始化
pygame.init()

# 常量
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
FPS = 60

# 颜色定义
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)
COLORS = [RED, GREEN, BLUE, YELLOW]

# 创建窗口
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Pygame基础概念演示")
clock = pygame.time.Clock()


# 游戏对象
class Ball:
    def __init__(self):
        self.radius = random.randint(10, 30)
        self.x = random.randint(self.radius, SCREEN_WIDTH - self.radius)
        self.y = random.randint(self.radius, SCREEN_HEIGHT - self.radius)
        self.vx = random.choice([-200, 200])
        self.vy = random.choice([-200, 200])
        self.color = random.choice(COLORS)

    def update(self, dt):
        self.x += self.vx * dt
        self.y += self.vy * dt

        # 边界反弹
        if self.x - self.radius < 0 or self.x + self.radius > SCREEN_WIDTH:
            self.vx = -self.vx
            self.x = max(self.radius, min(SCREEN_WIDTH - self.radius, self.x))
        if self.y - self.radius < 0 or self.y + self.radius > SCREEN_HEIGHT:
            self.vy = -self.vy
            self.y = max(self.radius, min(SCREEN_HEIGHT - self.radius, self.y))

    def draw(self, surface):
        pygame.draw.circle(surface, self.color, (int(self.x), int(self.y)), self.radius)


# 创建多个球
balls = [Ball() for _ in range(10)]

# ✅ 修复：将字体创建移到主循环外部，使用 Font 替代 SysFont 避免 pygame-ce Bug
font = pygame.font.Font(None, 36)

# 主循环
running = True
while running:
    dt = clock.tick(FPS) / 1000.0

    # 事件处理
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                running = False
            elif event.key == pygame.K_SPACE:
                balls.append(Ball())
            elif event.key == pygame.K_BACKSPACE and balls:
                balls.pop()

    # 更新
    for ball in balls:
        ball.update(dt)

    # 渲染
    screen.fill(BLACK)

    for ball in balls:
        ball.draw(screen)

    # 显示信息
    info_text = f"Balls: {len(balls)} | FPS: {int(clock.get_fps())} | Press SPACE to add, BACKSPACE to remove"
    text_surface = font.render(info_text, True, WHITE)
    screen.blit(text_surface, (10, 10))

    pygame.display.flip()

pygame.quit()
sys.exit()

这个程序展示了：

  • 面向对象的游戏对象设计
  • 使用delta time的帧率无关更新
  • 事件处理（键盘和窗口事件）
  • 基本的物理模拟（运动和碰撞）
  • 动态对象管理
  • 信息渲染

2.6 本章总结

本章深入探讨了Pygame的基础概念，包括游戏循环的详细工作原理、坐标系统和颜色表示方法，以及Pygame的模块组织结构。游戏循环作为游戏程序的核心，负责协调事件处理、状态更新和画面渲染三个主要任务。理解帧率控制和时间管理对于开发流畅的游戏至关重要。Pygame的坐标系统采用左上角为原点的二维坐标系，颜色使用RGB/RGBA模型表示。Pygame由多个功能模块组成，每个模块负责特定的功能领域，理解这些模块的作用和用法是高效使用Pygame的基础。

本章知识点回顾

知识点 主要内容
游戏循环 事件处理、状态更新、渲染、帧率控制
事件系统 事件队列、事件类型、事件处理模式
坐标系统 屏幕坐标、世界坐标、坐标转换
颜色表示 RGB模型、RGBA透明度、颜色操作
核心模块 display、event、Surface、Rect等

课后练习

  1. 修改本章的球体示例，添加鼠标交互：点击鼠标在点击位置创建新球体。
  2. 实现一个简单的计时器，显示游戏运行的总时间。
  3. 创建一个可以拖动的矩形，使用鼠标事件处理拖动逻辑。
  4. 使用GPT-5.4询问关于双缓冲技术的问题，理解其工作原理。
  5. 实现一个颜色渐变动画，让背景色在几种颜色之间平滑过渡。

下章预告

在下一章中，我们将详细介绍Pygame的绘图功能，包括基本图形的绘制方法、抗锯齿技术、以及如何使用绘图功能创建游戏视觉效果。

相关推荐
深度学习lover2 小时前
＜数据集＞yolo骑行者识别＜目标检测＞
人工智能·python·yolo·目标检测·计算机视觉
凤山老林2 小时前
Spring Boot 深度集成 Tess4J 实战：构建企业级 OCR 服务
spring boot·python·ocr
紫金修道10 小时前
【DeepAgent】概述
开发语言·数据库·python
书到用时方恨少!10 小时前
Python multiprocessing 使用指南：突破 GIL 束缚的并行计算利器
开发语言·python·并行·多进程
Warson_L11 小时前
Python 常用内置标准库
python
Warson_L11 小时前
Python 函数的艺术 (Functions)
python
Warson_L11 小时前
Python 流程控制与逻辑
后端·python
long_songs11 小时前
手柄键盘映射器【github链接见文末 】
python·游戏·计算机外设·pygame·软件推荐·手柄映射键盘
必然秃头11 小时前
Python 环境安装及项目构建指南
python
热门推荐
01GitHub 镜像站点022026年3月AI领域大事件：DeepSeek引领开源风暴03Qwen3.5-Omni与Qwen3.6模型全面解析（含测评/案例/使用教程）04Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services05UV安装并设置国内源06让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南07如何解决 OpenClaw “Pairing required” 报错：两种官方解决方案详解08AI 编程效率翻倍：Superpowers Skills 上手清单 + 完整指南09Mac 本地部署 OMLX + 通义千问 Qwen3.5-27B 保姆级教程10深扒 Claude Code Buddy 模式：一只仙人掌背后的确定性随机算法