Python Pygame俄罗斯方块开发：从零实现游戏逻辑与图形界面

1. 项目概述与核心价值

如果你对编程感兴趣，尤其是想用Python做点有趣的东西，那么从零开始写一个俄罗斯方块，绝对是个能让你成就感爆棚的起点。这项目听起来有点“复古”，但它能串起编程里一大堆核心概念：从最基础的变量、循环、条件判断，到稍微复杂点的面向对象、事件驱动、碰撞检测，再到图形界面和游戏逻辑的整合。用Python的Pygame库来做，门槛不高，但“麻雀虽小，五脏俱全”，整个流程走下来，你对游戏开发的基本框架会有一个非常扎实的理解。我见过不少朋友，学了一堆Python语法，但不知道能干嘛，最后兴趣就淡了。而这个项目，就是你学以致用的绝佳练手场，从空白的代码文件到一个能玩、有分数、有音效的完整游戏，每一步你都能看到直观的反馈。

为什么是俄罗斯方块？因为它规则简单清晰，但实现起来又足够有挑战性。你需要处理方块的旋转、移动、消行、加速下落，还要设计一个清晰的游戏状态机（比如开始、进行中、暂停、结束）。这些逻辑，几乎在所有游戏里都能找到影子。通过这个项目，你不仅能巩固Python基础，更能亲手触摸到游戏开发的脉搏。我当年就是靠复刻几个经典小游戏，才真正把编程从“知识”变成了“技能”。下面，我就带你一步步拆解，用Python和Pygame，从零开始把这个经典游戏“造”出来。

2. 开发环境搭建与Pygame初探

2.1 Python环境与Pygame安装

工欲善其事，必先利其器。首先确保你有一个可用的Python环境。我强烈推荐使用Python 3.8或以上的版本，新版本在性能和库管理上都有优化。你可以去Python官网下载安装包，安装时务必记得勾选“Add Python to PATH”这个选项，这能让你在命令行（CMD或终端）里直接使用python和pip命令，省去后续手动配置环境变量的麻烦。

安装好Python后，打开你的命令行工具。Pygame的安装非常简单，一行命令搞定：

pip install pygame

如果下载速度慢，可以考虑使用国内的镜像源，比如清华源：

pip install pygame -i https://pypi.tuna.tsinghua.edu.cn/simple

安装完成后，可以写个几行代码测试一下是否成功：

import pygame pygame.init() print("Pygame 初始化成功！") screen = pygame.display.set_mode((400, 300)) pygame.quit()

运行这段代码，如果弹出一个黑色的小窗口并且没有报错，那就说明环境搭建成功了。

注意：有些初学者会在安装多个Python版本时遇到问题，比如pip命令安装的库不在当前使用的Python环境下。一个简单的检查方法是，在命令行输入python --version和pip --version，看看它们指向的Python路径是否一致。不一致的话，可能需要使用python -m pip install pygame来确保安装到正确的环境。

2.2 代码编辑器选择与项目初始化

写代码需要一个顺手的编辑器。对于新手，我首推VSCode，它轻量、免费、插件生态丰富。你需要安装Python扩展和Pygame相关的代码提示插件。当然，如果你更喜欢PyCharm这类专业的IDE，也完全没问题，它们对Python的支持更深入。

项目开始前，先在电脑上创建一个专属的文件夹，比如tetris_game。在这个文件夹里，我们创建第一个Python文件，命名为tetris.py。一个好的习惯是从项目一开始就规划好文件结构，虽然我们这个项目不大，但清晰的目录有助于管理资源。我建议的初始结构如下：

tetris_game/ ├── tetris.py # 主游戏逻辑文件 ├── assets/ # 资源文件夹 │ ├── images/ # 存放图片（如方块皮肤） │ └── sounds/ # 存放音效（如消除音效） └── README.md # 项目说明（可选）

在tetris.py的开头，我们先导入必要的模块，并初始化Pygame和游戏窗口：

import pygame import random import sys # 初始化pygame pygame.init() # 定义颜色 (RGB格式) BLACK = (0, 0, 0) WHITE = (255, 255, 255) RED = (255, 0, 0) GREEN = (0, 255, 0) BLUE = (0, 0, 255) CYAN = (0, 255, 255) # 青色，俄罗斯方块经典颜色之一 MAGENTA = (255, 0, 255) YELLOW = (255, 255, 0) ORANGE = (255, 165, 0) GRAY = (128, 128, 128) # 游戏区域常量 SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 GRID_SIZE = 30 # 每个小方格的像素大小 GRID_WIDTH = 10 # 游戏区域横向格子数（经典俄罗斯方块是10） GRID_HEIGHT = 20 # 游戏区域纵向格子数（经典是20） # 计算游戏区域在屏幕上的位置（居中） GAME_AREA_LEFT = (SCREEN_WIDTH - GRID_WIDTH * GRID_SIZE) // 2 GAME_AREA_TOP = (SCREEN_HEIGHT - GRID_HEIGHT * GRID_SIZE) // 2 # 创建游戏窗口 screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption("经典俄罗斯方块 - Python/Pygame 实现") clock = pygame.time.Clock() # 用于控制游戏帧率

这里我们定义了很多常量。用大写字母表示常量是一个好习惯，方便后续修改和引用。颜色、格子大小、游戏区域尺寸这些核心参数一旦定好，后面所有绘图和计算都要基于它们。

3. 游戏核心逻辑设计与实现

3.1 方块数据定义与表示

俄罗斯方块有7种基本形状，通常用字母来指代：I, J, L, O, S, T, Z。每种形状由4个小方块（我们称之为“Minos”）组成。在代码里，最直观的表示方法就是用二维列表来定义每个形状在不同旋转状态下的坐标。

我们定义一个字典来存储所有形状的数据。坐标以形状的中心或某个参考点为原点。这里我采用一种常见的方式：用一个4x4的布尔矩阵来表示，True代表该位置有方块。

# 定义7种俄罗斯方块形状（以4x4矩阵形式，中心点大致在矩阵中部） SHAPES = { 'I': [ [[0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0]] ], 'O': [ [[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]] ], 'T': [ [[0, 0, 0, 0], [0, 1, 0, 0], [1, 1, 1, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 1, 0, 0], [0, 1, 1, 0], [0, 1, 0, 0]], # ... 其他旋转状态 ], # ... 其他J, L, S, Z形状定义 }

但这样定义旋转状态比较繁琐。一个更聪明的方法是只定义形状的一个初始朝向，然后通过旋转算法计算出其他朝向。不过对于初学者，先完整定义所有状态更容易理解。我们还需要给每种形状分配一个颜色：

SHAPE_COLORS = { 'I': CYAN, 'O': YELLOW, 'T': MAGENTA, 'S': GREEN, 'Z': RED, 'J': BLUE, 'L': ORANGE }

3.2 游戏区域与方块类的构建

接下来，我们需要两个核心的数据结构：一个代表固定的、已经落底的方块组成的“棋盘”，另一个代表当前正在下落的“活动方块”。

首先，用二维列表表示游戏区域（棋盘）：

# 初始化游戏区域，0表示空，非0表示有方块（其值代表颜色索引或形状类型） board = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]

然后，我们创建一个Tetromino类来管理活动方块。这是面向对象编程大显身手的地方。一个方块对象应该知道自己是什么形状、什么颜色、当前在什么位置（x, y坐标）、当前是哪种旋转状态。

class Tetromino: def __init__(self, x, y, shape_type): self.x = x # 方块左上角在游戏网格中的x坐标 self.y = y # 方块左上角在游戏网格中的y坐标 self.shape_type = shape_type self.color = SHAPE_COLORS[shape_type] self.rotation = 0 # 当前旋转状态索引 # 获取当前旋转状态下的形状矩阵 self.shape = SHAPES[shape_type][self.rotation] def get_shape_matrix(self): """返回当前旋转状态下的形状矩阵""" return SHAPES[self.shape_type][self.rotation] def rotate(self): """顺时针旋转方块""" old_rotation = self.rotation self.rotation = (self.rotation + 1) % len(SHAPES[self.shape_type]) self.shape = SHAPES[self.shape_type][self.rotation] # 注意：旋转后可能需要检查是否与棋盘或其他边界碰撞，如果碰撞则回退旋转 # 这里我们先简单实现，碰撞检测在后续逻辑中统一处理 return old_rotation # 返回旧的旋转状态，便于碰撞后回退 def get_grid_positions(self): """返回当前方块4个小方块在游戏网格中的具体坐标列表""" positions = [] shape_matrix = self.get_shape_matrix() for row_idx, row in enumerate(shape_matrix): for col_idx, cell in enumerate(row): if cell: grid_x = self.x + col_idx grid_y = self.y + row_idx positions.append((grid_x, grid_y)) return positions

这个类封装了方块的基本属性和行为。get_grid_positions方法非常关键，它把抽象的4x4矩阵转换成了游戏棋盘上的具体坐标，后续的移动、碰撞检测、绘制都依赖这个坐标列表。

3.3 碰撞检测与移动逻辑

游戏的核心逻辑之一就是判断方块能否移动或旋转。我们需要一个通用的碰撞检测函数。

def check_collision(board, tetromino, dx=0, dy=0, new_rotation=None): """ 检测给定方块在移动(dx, dy)或旋转到new_rotation后是否会与棋盘边界或已有方块碰撞。 返回True表示碰撞，False表示安全。 """ # 计算假设移动或旋转后的位置 test_x = tetromino.x + dx test_y = tetromino.y + dy test_rotation = tetromino.rotation if new_rotation is None else new_rotation test_shape_matrix = SHAPES[tetromino.shape_type][test_rotation] # 遍历形状矩阵中的每一个“有方块”的位置 for row_idx, row in enumerate(test_shape_matrix): for col_idx, cell in enumerate(row): if cell: # 如果这个位置是方块的一部分 grid_x = test_x + col_idx grid_y = test_y + row_idx # 检查是否超出左右边界或下边界 if grid_x < 0 or grid_x >= GRID_WIDTH or grid_y >= GRID_HEIGHT: return True # 碰撞到边界 # 检查是否与棋盘上已有的方块重叠 (grid_y >= 0 防止检查棋盘上方区域) if grid_y >= 0 and board[grid_y][grid_x]: return True # 碰撞到已有方块 return False # 没有碰撞

有了这个函数，方块的移动（左、右、下）和旋转逻辑就清晰了：

def move_tetromino(board, tetromino, dx, dy): """尝试移动方块，如果碰撞则不移，返回移动是否成功""" if not check_collision(board, tetromino, dx, dy): tetromino.x += dx tetromino.y += dy return True return False def rotate_tetromino(board, tetromino): """尝试旋转方块，如果旋转后碰撞，则尝试“踢墙”修正，实在不行就放弃旋转""" old_rotation = tetromino.rotate() # 先旋转 if not check_collision(board, tetromino): # 旋转后无碰撞，成功 return True else: # 如果碰撞，尝试几种微调位置（踢墙，Wall Kick） # 这是俄罗斯方块标准规则的一部分，用于让旋转在紧贴墙壁或其它方块时更灵活 kick_offsets = [(0, 0), (-1, 0), (1, 0), (0, -1), (0, 1)] # 简单的偏移尝试 for offset_x, offset_y in kick_offsets: if not check_collision(board, tetromino, offset_x, offset_y): tetromino.x += offset_x tetromino.y += offset_y return True # 所有修正都失败，回退旋转 tetromino.rotation = old_rotation tetromino.shape = SHAPES[tetromino.shape_type][old_rotation] return False

这里引入了“踢墙”的概念。在标准俄罗斯方块中，旋转时如果碰到墙壁或其它方块，系统会尝试将方块向旁边移动一格，如果成功，旋转就生效。这大大提升了游戏的可玩性。我们的实现是一个简化版，更复杂的规则（如SRS）有预定义的偏移表，但当前版本已足够。

4. 游戏主循环与状态管理

4.1 游戏主循环框架

游戏的核心是一个不断运行的循环，即“游戏主循环”。每一帧，我们依次做以下几件事：处理用户输入、更新游戏状态、绘制当前画面。

def main(): # 初始化变量 board = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)] current_piece = new_random_piece() # 创建一个新的随机方块 next_piece = new_random_piece() # 预览下一个方块 game_over = False score = 0 level = 1 fall_speed = 0.5 # 方块下落的基础时间间隔（秒） fall_time = 0 # 用于累计时间，控制自动下落 running = True while running: # 1. 计算时间增量 delta_time = clock.tick(60) / 1000.0 # 限制帧率为60FPS，并转换为秒 # 2. 处理事件（用户输入） for event in pygame.event.get(): if event.type == pygame.QUIT: running = False if event.type == pygame.KEYDOWN: if not game_over: if event.key == pygame.K_LEFT: move_tetromino(board, current_piece, -1, 0) elif event.key == pygame.K_RIGHT: move_tetromino(board, current_piece, 1, 0) elif event.key == pygame.K_DOWN: # 软降：手动加速下落 if move_tetromino(board, current_piece, 0, 1): score += 1 # 软降得分 elif event.key == pygame.K_UP: rotate_tetromino(board, current_piece) elif event.key == pygame.K_SPACE: # 硬降：瞬间落底 while move_tetromino(board, current_piece, 0, 1): pass # 一直向下移动直到碰撞 lock_piece(board, current_piece) # 锁定方块 current_piece = next_piece next_piece = new_random_piece() # 检查游戏是否结束（新方块出生即碰撞） if check_collision(board, current_piece): game_over = True # 全局控制键 if event.key == pygame.K_p: # 暂停功能，这里可以用一个布尔变量控制，为了简洁先省略 pass if event.key == pygame.K_r and game_over: # 重新开始游戏 board = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)] current_piece = new_random_piece() next_piece = new_random_piece() game_over = False score = 0 level = 1 # 3. 更新游戏状态（如果不是游戏结束状态） if not game_over: # 自动下落逻辑 fall_time += delta_time if fall_time >= fall_speed: fall_time = 0 # 尝试向下移动一格 if not move_tetromino(board, current_piece, 0, 1): # 如果无法下落，则锁定当前方块 lock_piece(board, current_piece) # 检查并消除满行 lines_cleared = clear_lines(board) score += calculate_score(lines_cleared, level) # 更新等级和速度（例如每消10行升一级） level = score // 1000 + 1 fall_speed = max(0.05, 0.5 - (level - 1) * 0.05) # 速度有下限 # 生成新方块 current_piece = next_piece next_piece = new_random_piece() # 检查游戏是否结束 if check_collision(board, current_piece): game_over = True # 4. 绘制画面 screen.fill(BLACK) # 清屏为黑色背景 draw_board(screen, board) draw_tetromino(screen, current_piece) draw_next_piece(screen, next_piece) draw_ui(screen, score, level, game_over) # 绘制分数、等级、游戏结束提示等UI pygame.display.flip() # 更新整个屏幕显示 pygame.quit() sys.exit()

这个主循环框架是游戏的心脏。clock.tick(60)确保了游戏以大约60帧每秒的速度运行，无论电脑快慢，游戏速度都是稳定的。事件循环pygame.event.get()捕获所有键盘、鼠标等输入。更新逻辑里最核心的就是基于时间的自动下落，以及方块锁定后的消行、得分计算。

4.2 方块锁定、消行与得分

当方块无法继续下落时，需要将其“固化”到棋盘上。

def lock_piece(board, tetromino): """将当前活动方块锁定到棋盘上""" for grid_x, grid_y in tetromino.get_grid_positions(): # 确保坐标在棋盘范围内（上方的部分可能暂时在棋盘外，如长条I型的旋转） if 0 <= grid_y < GRID_HEIGHT and 0 <= grid_x < GRID_WIDTH: # 这里简单用1表示有方块，实际可以存储颜色信息以便绘制 board[grid_y][grid_x] = 1 # 或者存储颜色值 tetromino.color def clear_lines(board): """检查并消除所有已填满的行，返回消除的行数""" lines_to_clear = [] for row_idx in range(GRID_HEIGHT): if all(board[row_idx]): # 如果这一行所有格子都不是0 lines_to_clear.append(row_idx) # 从下往上消除行，这样上面行下落时索引不会乱 for row_idx in lines_to_clear: # 删除该行 del board[row_idx] # 在顶部插入新的空行 board.insert(0, [0 for _ in range(GRID_WIDTH)]) return len(lines_to_clear) def calculate_score(lines_cleared, level): """根据消除的行数和当前等级计算得分""" # 经典计分规则：单消100分，双消300分，三消500分，四消800分，并乘以等级 base_scores = {1: 100, 2: 300, 3: 500, 4: 800} if lines_cleared == 0: return 0 return base_scores.get(lines_cleared, 800) * level

消行逻辑中，all(board[row_idx])是一个Pythonic的写法，它检查列表里是否所有元素都为真（非零）。删除一行后在上面插入新空行，模拟了上方方块整体下落的效果。计分规则采用了经典的NES俄罗斯方块规则，鼓励一次性消除多行。

5. 图形绘制与用户界面

5.1 绘制游戏区域与方块

游戏画面需要清晰地区分游戏区域边界、已落底的方块和当前活动方块。

def draw_board(screen, board): """绘制棋盘（已固定的方块）和网格线""" # 1. 绘制游戏区域背景（一个矩形） pygame.draw.rect(screen, (50, 50, 50), (GAME_AREA_LEFT, GAME_AREA_TOP, GRID_WIDTH * GRID_SIZE, GRID_HEIGHT * GRID_SIZE)) # 2. 绘制网格线 for x in range(GRID_WIDTH + 1): line_x = GAME_AREA_LEFT + x * GRID_SIZE pygame.draw.line(screen, GRAY, (line_x, GAME_AREA_TOP), (line_x, GAME_AREA_TOP + GRID_HEIGHT * GRID_SIZE), 1) for y in range(GRID_HEIGHT + 1): line_y = GAME_AREA_TOP + y * GRID_SIZE pygame.draw.line(screen, GRAY, (GAME_AREA_LEFT, line_y), (GAME_AREA_LEFT + GRID_WIDTH * GRID_SIZE, line_y), 1) # 3. 绘制棋盘上已固定的方块 for row_idx, row in enumerate(board): for col_idx, cell in enumerate(row): if cell: # 如果格子有方块 # 计算方块在屏幕上的像素坐标 pixel_x = GAME_AREA_LEFT + col_idx * GRID_SIZE pixel_y = GAME_AREA_TOP + row_idx * GRID_SIZE # 绘制一个填充方块，并加上边框使其有立体感 pygame.draw.rect(screen, BLUE, (pixel_x, pixel_y, GRID_SIZE, GRID_SIZE)) pygame.draw.rect(screen, WHITE, (pixel_x, pixel_y, GRID_SIZE, GRID_SIZE), 2) def draw_tetromino(screen, tetromino): """绘制当前正在下落的方块""" color = tetromino.color for grid_x, grid_y in tetromino.get_grid_positions(): # 只绘制在游戏区域内的部分 if 0 <= grid_y < GRID_HEIGHT: pixel_x = GAME_AREA_LEFT + grid_x * GRID_SIZE pixel_y = GAME_AREA_TOP + grid_y * GRID_SIZE pygame.draw.rect(screen, color, (pixel_x, pixel_y, GRID_SIZE, GRID_SIZE)) # 绘制一个内边框，增加立体感 pygame.draw.rect(screen, WHITE, (pixel_x, pixel_y, GRID_SIZE, GRID_SIZE), 2)

绘制时，坐标转换是关键：像素坐标 = 游戏区域左上角坐标 + 网格坐标 * 格子大小。给方块加上一个白色的细边框，能立刻让画面看起来精致不少，这是提升视觉体验的一个小技巧。

5.2 绘制侧边栏UI与游戏状态

一个完整的游戏界面还需要显示下一个方块预览、分数、等级等信息。

def draw_next_piece(screen, next_piece): """在屏幕右侧绘制下一个方块预览""" preview_left = GAME_AREA_LEFT + GRID_WIDTH * GRID_SIZE + 50 preview_top = GAME_AREA_TOP preview_title_font = pygame.font.SysFont(None, 36) title_surface = preview_title_font.render("下一个:", True, WHITE) screen.blit(title_surface, (preview_left, preview_top)) # 计算预览方块的绘制位置（居中） shape_matrix = next_piece.get_shape_matrix() shape_width = len(shape_matrix[0]) * GRID_SIZE // 2 # 预览区格子缩小一半 shape_height = len(shape_matrix) * GRID_SIZE // 2 preview_center_x = preview_left + 50 preview_center_y = preview_top + 60 # 绘制预览方块 for row_idx, row in enumerate(shape_matrix): for col_idx, cell in enumerate(row): if cell: pixel_x = preview_center_x + col_idx * (GRID_SIZE // 2) - shape_width // 2 pixel_y = preview_center_y + row_idx * (GRID_SIZE // 2) - shape_height // 2 pygame.draw.rect(screen, next_piece.color, (pixel_x, pixel_y, GRID_SIZE // 2, GRID_SIZE // 2)) pygame.draw.rect(screen, WHITE, (pixel_x, pixel_y, GRID_SIZE // 2, GRID_SIZE // 2), 1) def draw_ui(screen, score, level, game_over): """绘制分数、等级和游戏结束提示""" font = pygame.font.SysFont(None, 48) score_surface = font.render(f"分数: {score}", True, GREEN) level_surface = font.render(f"等级: {level}", True, YELLOW) screen.blit(score_surface, (50, 50)) screen.blit(level_surface, (50, 120)) if game_over: game_over_font = pygame.font.SysFont(None, 72) game_over_surface = game_over_font.render("游戏结束!", True, RED) restart_surface = font.render("按 R 键重新开始", True, WHITE) screen.blit(game_over_surface, (SCREEN_WIDTH // 2 - game_over_surface.get_width() // 2, SCREEN_HEIGHT // 2 - 50)) screen.blit(restart_surface, (SCREEN_WIDTH // 2 - restart_surface.get_width() // 2, SCREEN_HEIGHT // 2 + 30))

UI绘制主要用到Pygame的font模块。SysFont(None, size)会使用系统默认字体，你也可以指定字体文件路径。blit方法将渲染好的文字表面“贴”到屏幕上。注意坐标的计算，特别是居中显示，需要用到surface.get_width()来获取文字表面的宽度。

6. 功能增强与优化实践

6.1 添加音效与背景音乐

声音是游戏体验的重要组成部分。Pygame的mixer模块可以轻松处理音效。

# 在主循环初始化部分加载音效 pygame.mixer.init() clear_sound = pygame.mixer.Sound("assets/sounds/clear.wav") # 消行音效 drop_sound = pygame.mixer.Sound("assets/sounds/drop.wav") # 硬降音效 game_over_sound = pygame.mixer.Sound("assets/sounds/gameover.wav") # 在消行后播放音效 lines = clear_lines(board) if lines > 0: clear_sound.play() score += calculate_score(lines, level) # 在硬降（空格键）锁定方块后播放音效 def hard_drop(): # ... 硬降逻辑 ... drop_sound.play() # 游戏结束时播放音效 if game_over: game_over_sound.play()

音效文件需要是WAV或OGG等Pygame支持的格式。你可以从一些免费音效网站获取，或者用简单的工具生成。加载背景音乐也很类似，使用pygame.mixer.music.load()和pygame.mixer.music.play(-1)（-1表示循环播放）。

实操心得：音效文件不宜过大，短促清脆的效果最好。播放音效时要注意时机，避免在密集操作时（如快速连续消行）造成声音重叠或延迟。可以简单判断一下，如果上一个相同音效还没播完，就不播放新的，或者使用set_num_channels开辟多个音频通道。

6.2 实现“幽灵方块”与暂停功能

“幽灵方块”是指显示当前方块如果直接落底会停在什么位置，这是一个非常实用的辅助功能。

def get_ghost_piece_position(board, tetromino): """计算当前方块如果直接落底，最终的y坐标""" test_y = tetromino.y while not check_collision(board, tetromino, dy=test_y - tetromino.y + 1): test_y += 1 return test_y def draw_ghost_piece(screen, board, tetromino): """绘制幽灵方块（半透明）""" ghost_y = get_ghost_piece_position(board, tetromino) ghost_color = (*tetromino.color, 128) # 在原颜色基础上增加Alpha通道（半透明） # 注意：Pygame的draw.rect不支持直接传入带Alpha的颜色，需要先创建一个Surface for grid_x, grid_y in tetromino.get_grid_positions(): if 0 <= grid_y: # 幽灵可能部分在顶部以上，只绘制可见部分 actual_y = grid_y + (ghost_y - tetromino.y) if actual_y < GRID_HEIGHT: pixel_x = GAME_AREA_LEFT + grid_x * GRID_SIZE pixel_y = GAME_AREA_TOP + actual_y * GRID_SIZE # 创建一个小Surface并填充半透明颜色，然后blit到屏幕上 ghost_surface = pygame.Surface((GRID_SIZE, GRID_SIZE), pygame.SRCALPHA) ghost_surface.fill(ghost_color) screen.blit(ghost_surface, (pixel_x, pixel_y)) pygame.draw.rect(screen, WHITE, (pixel_x, pixel_y, GRID_SIZE, GRID_SIZE), 1)

暂停功能则相对简单，在主循环中增加一个paused布尔状态变量，并在事件处理中响应暂停键（如P键）。当暂停时，跳过游戏状态更新逻辑，只处理退出和取消暂停的事件，并绘制一个“暂停”文字提示。

6.3 代码重构与面向对象优化

随着功能增加，把所有代码都放在主循环里会变得难以维护。我们可以进行重构，将游戏状态、逻辑、渲染分离。

class TetrisGame: def __init__(self): self.board = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)] self.current_piece = self.new_random_piece() self.next_piece = self.new_random_piece() self.score = 0 self.level = 1 self.game_over = False self.paused = False self.fall_speed = 0.5 self.fall_timer = 0 def new_random_piece(self): # ... 创建随机方块 ... pass def update(self, delta_time): if self.game_over or self.paused: return self.fall_timer += delta_time if self.fall_timer >= self.fall_speed: self.fall_timer = 0 if not self.move_current_piece(0, 1): self.lock_current_piece() # ... 消行、得分、生成新方块逻辑 ... pass def draw(self, screen): # ... 集中所有绘制逻辑 ... pass def handle_event(self, event): # ... 处理键盘事件 ... pass # 主循环变得非常简洁 def main(): game = TetrisGame() while running: delta_time = clock.tick(60) / 1000.0 for event in pygame.event.get(): if event.type == pygame.QUIT: running = False game.handle_event(event) game.update(delta_time) screen.fill(BLACK) game.draw(screen) pygame.display.flip()

这种面向对象的设计让代码结构清晰，易于扩展。比如以后想加一个“保存游戏”的功能，只需要序列化TetrisGame对象的属性即可。

7. 常见问题排查与性能调优

7.1 典型Bug与解决方案

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

1. 方块旋转时“卡”进墙里或其它方块里：这是碰撞检测逻辑不完善导致的。我们的rotate_tetromino函数实现了简单的“踢墙”修正，但标准俄罗斯方块（如Guideline规范）有更复杂的“踢墙表”，针对每种形状、每种旋转状态都有预设的偏移尝试顺序。如果你的游戏要求高兼容性，需要去查阅并实现SRS（Super Rotation System）。对于个人项目，我们实现的简单偏移列表在大多数情况下已经够用。

2. 方块移动或旋转有延迟感，或者过于灵敏：这通常和事件处理有关。Pygame的KEYDOWN事件在键被按住时，会先产生一个事件，然后稍作停顿，再开始快速重复。这对于移动方块来说体验不好。更好的做法是使用pygame.key.get_pressed()来检测当前帧哪些键被按着，实现“长按连续移动”。

   # 在主循环的更新部分，而不是事件循环中 keys = pygame.key.get_pressed() if keys[pygame.K_LEFT]: # 实现左移，并可以加入一个计时器来控制连续移动的间隔 pass if keys[pygame.K_RIGHT]: # 右移 pass

   同时，你需要一个计时器来控制连续移动的速度，否则一帧移动一格会太快。

3. 游戏区域绘制错位或方块显示不全：这99%是坐标计算错误。牢记两个坐标系：网格坐标（从0到GRID_WIDTH-1和0到GRID_HEIGHT-1）和屏幕像素坐标。转换公式pixel_x = GAME_AREA_LEFT + grid_x * GRID_SIZE必须严格一致地用在所有绘制和碰撞检测中。建议把坐标转换写成函数，避免重复代码和笔误。

   def grid_to_pixel(grid_x, grid_y): return (GAME_AREA_LEFT + grid_x * GRID_SIZE, GAME_AREA_TOP + grid_y * GRID_SIZE)

4. 消行后上方方块没有正确下落：检查clear_lines函数。必须是从下往上遍历和删除行。如果从上往下，当你删除一行时，下面所有行的索引都会变，导致逻辑错误。我们的实现中，lines_to_clear记录了要消除的行号，然后for row_idx in lines_to_clear:这个循环如果顺序执行，先删除上面的行会导致下面行的索引变化。更稳妥的做法是，先消除所有标记的行，再一次性在顶部补充空行。或者，从下往上消除：

   for row_idx in sorted(lines_to_clear, reverse=True): # 从大到小排序 del board[row_idx] board.insert(0, [0 for _ in range(GRID_WIDTH)])

7.2 性能优化与代码整洁建议

虽然俄罗斯方块对性能要求极低，但养成好习惯对以后做复杂项目有帮助。

1. 避免在游戏主循环中创建大量临时对象：比如get_grid_positions()每次调用都返回一个新的列表。在性能关键的路径上（比如每帧运行的碰撞检测），可以考虑将位置计算缓存起来，只在方块移动或旋转时更新。

2. 使用局部变量加速访问：在频繁调用的函数（如draw）中，将全局常量（如GAME_AREA_LEFT,GRID_SIZE）赋值给局部变量，能略微提升速度，因为局部变量查找比全局变量快。

3. 绘制优化：我们目前是每帧重绘整个屏幕和所有元素（screen.fill(BLACK)）。对于俄罗斯方块，这完全没问题。但如果游戏区域很大且变化部分小，可以考虑“脏矩形”技术，只更新屏幕上发生变化的部分。不过对于初学者，保持简单全屏重绘是最稳妥的。

4. 代码可读性：

   • 多用有意义的函数和变量名。
   • 将复杂的逻辑拆分成小函数。比如检查一行是否满，可以写成is_row_full(row)。
   • 添加注释，尤其是解释算法和复杂逻辑的地方。
   • 使用类型提示（Python 3.5+），虽然不影响运行，但能让你的代码更清晰，现代编辑器也能提供更好的提示。

   def check_collision(board: List[List[int]], tetromino: 'Tetromino', dx: int = 0, dy: int = 0) -> bool: ...

7.3 扩展思路与项目进阶

完成基础版本后，你可以尝试以下扩展，让游戏更完整、更专业：

1. 菜单系统：制作一个开始菜单，包含“开始游戏”、“设置”、“退出”等选项。这涉及到游戏状态（如MENU,PLAYING,GAME_OVER）的管理和界面切换。

2. 方块皮肤与主题：允许玩家选择不同的方块颜色或纹理。你可以将颜色定义从常量改为从配置文件或资源包加载。

3. 游戏模式：实现限时挑战、马拉松模式、40行竞速等经典模式。

4. 数据持久化：将最高分记录到本地文件（如JSON或SQLite数据库），并显示排行榜。

5. 粒子效果：在消行时，添加一些闪烁或爆炸的小粒子效果，使用Pygame的绘制基础功能或pygame.sprite模块可以实现。

6. 打包成可执行文件：使用PyInstaller或cx_Freeze将你的Python脚本打包成.exe文件，分享给没有安装Python的朋友。

   pip install pyinstaller pyinstaller --onefile --windowed tetris.py

   这会在dist文件夹下生成一个独立的可执行文件。

从一行代码没有，到一个可以流畅运行、有分数、有音效、有交互的完整游戏，这个过程本身就是最好的学习。遇到问题别怕，多利用print()调试，多看Pygame官方文档，或者在网上搜索具体的错误信息。编程的乐趣，很大程度上就来自于这种“创造-遇到问题-解决问题-最终运行”的正向循环。希望这份指南能帮你顺利启动，并享受用代码创造游戏的整个过程。