1. 俄罗斯方块游戏开发概述
俄罗斯方块作为经典游戏的代表，其简洁的规则和上瘾的游戏性使其成为编程初学者理想的练手项目。使用Python开发俄罗斯方块不仅能掌握基础语法，还能深入理解游戏循环、碰撞检测等核心概念。
Python凭借其简洁语法和丰富的第三方库（如Pygame），让游戏开发变得异常简单。我选择Python 3.8+版本进行开发，这个版本在性能优化和类型提示方面都有显著改进，特别适合中小型游戏项目。
提示：本项目的完整代码约200行，包含了游戏所有核心功能，可直接复制运行。但建议先理解实现原理再使用，这样遇到问题时才能自主调试。
2. 开发环境准备与配置
2.1 Python环境搭建
首先需要安装Python解释器。推荐从Python官网下载最新稳定版（目前是3.10+），安装时务必勾选"Add Python to PATH"选项，这样可以在任何目录下运行Python。
验证安装是否成功：
bash复制python --version
pip --version
2.2 安装Pygame库
Pygame是Python最流行的游戏开发库，提供了图像渲染、声音播放、事件处理等游戏开发必需的功能：
bash复制pip install pygame
2.3 开发工具选择
VSCode是理想的Python开发环境，安装Python扩展后可以获得代码补全、调试等强大功能。配置步骤：
- 安装VSCode
- 安装Python扩展
- 创建项目文件夹
- 新建.py文件开始编码
3. 游戏核心架构设计
3.1 游戏对象建模
俄罗斯方块包含几个核心对象：
- 方块(Tetromino)：7种基本形状（I, J, L, O, S, T, Z）
- 游戏板(Board)：10x20的网格
- 游戏状态(Game)：控制游戏流程
python复制class Tetromino:
shapes = [
[[1, 1, 1, 1]], # I
[[1, 0, 0], [1, 1, 1]], # J
[[0, 0, 1], [1, 1, 1]], # L
[[1, 1], [1, 1]], # O
[[0, 1, 1], [1, 1, 0]], # S
[[0, 1, 0], [1, 1, 1]], # T
[[1, 1, 0], [0, 1, 1]] # Z
]
3.2 游戏主循环
游戏主循环是任何游戏的核心，负责处理输入、更新状态和渲染画面：
python复制def run_game():
clock = pygame.time.Clock()
while not game_over:
handle_events()
update_game_state()
render()
clock.tick(FPS) # 控制帧率
4. 关键功能实现细节
4.1 方块旋转算法
方块旋转是俄罗斯方块最复杂的部分之一。我采用矩阵转置+行反转的方法实现：
python复制def rotate(self):
# 转置矩阵
rows = len(self.shape)
cols = len(self.shape[0])
rotated = [[0]*rows for _ in range(cols)]
for r in range(rows):
for c in range(cols):
rotated[c][rows-1-r] = self.shape[r][c]
return rotated
4.2 碰撞检测系统
碰撞检测决定方块能否移动或旋转。需要检查：
- 是否超出边界
- 是否与已有方块重叠
python复制def is_collision(self, board, offset):
off_x, off_y = offset
for y, row in enumerate(self.shape):
for x, cell in enumerate(row):
if cell:
board_x = x + off_x
board_y = y + off_y
if (board_x < 0 or board_x >= BOARD_WIDTH or
board_y >= BOARD_HEIGHT or
(board_y >= 0 and board[board_y][board_x])):
return True
return False
4.3 消行计分逻辑
当一行被填满时需要消除并计分：
python复制def clear_lines(self):
lines_cleared = 0
for y in range(BOARD_HEIGHT):
if all(self.board[y]):
lines_cleared += 1
# 移动上方行下来
for y2 in range(y, 0, -1):
self.board[y2] = self.board[y2-1][:]
self.board[0] = [0] * BOARD_WIDTH
# 计分规则：消除行数越多分数越高
score_table = {1:100, 2:300, 3:500, 4:800}
self.score += score_table.get(lines_cleared, 0)
self.level = self.score // 2000 + 1
5. 完整代码实现与优化
5.1 游戏主程序
以下是完整的游戏实现代码（约200行）：
python复制import pygame
import random
# 初始化
pygame.init()
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
GRID_SIZE = 30
BOARD_WIDTH = 10
BOARD_HEIGHT = 20
FPS = 60
# 颜色定义
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
COLORS = [
(0, 255, 255), # I - 青色
(0, 0, 255), # J - 蓝色
(255, 165, 0), # L - 橙色
(255, 255, 0), # O - 黄色
(0, 255, 0), # S - 绿色
(128, 0, 128), # T - 紫色
(255, 0, 0) # Z - 红色
]
class Tetromino:
shapes = [
[[1, 1, 1, 1]], # I
[[1, 0, 0], [1, 1, 1]], # J
[[0, 0, 1], [1, 1, 1]], # L
[[1, 1], [1, 1]], # O
[[0, 1, 1], [1, 1, 0]], # S
[[0, 1, 0], [1, 1, 1]], # T
[[1, 1, 0], [0, 1, 1]] # Z
]
def __init__(self):
self.shape_idx = random.randint(0, len(self.shapes)-1)
self.shape = self.shapes[self.shape_idx]
self.color = COLORS[self.shape_idx]
self.x = BOARD_WIDTH // 2 - len(self.shape[0]) // 2
self.y = 0
def rotate(self):
rows = len(self.shape)
cols = len(self.shape[0])
rotated = [[0]*rows for _ in range(cols)]
for r in range(rows):
for c in range(cols):
rotated[c][rows-1-r] = self.shape[r][c]
return rotated
class Game:
def __init__(self):
self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Python俄罗斯方块")
self.clock = pygame.time.Clock()
self.font = pygame.font.SysFont('Arial', 25)
self.reset_game()
def reset_game(self):
self.board = [[0]*BOARD_WIDTH for _ in range(BOARD_HEIGHT)]
self.current_piece = Tetromino()
self.next_piece = Tetromino()
self.score = 0
self.level = 1
self.fall_speed = 0.5 # 秒
self.fall_time = 0
self.game_over = False
def is_collision(self, shape, offset):
off_x, off_y = offset
for y, row in enumerate(shape):
for x, cell in enumerate(row):
if cell:
board_x = x + off_x
board_y = y + off_y
if (board_x < 0 or board_x >= BOARD_WIDTH or
board_y >= BOARD_HEIGHT or
(board_y >= 0 and self.board[board_y][board_x])):
return True
return False
def merge_piece(self):
for y, row in enumerate(self.current_piece.shape):
for x, cell in enumerate(row):
if cell:
self.board[y+self.current_piece.y][x+self.current_piece.x] = self.current_piece.color
def clear_lines(self):
lines_cleared = 0
for y in range(BOARD_HEIGHT):
if all(self.board[y]):
lines_cleared += 1
for y2 in range(y, 0, -1):
self.board[y2] = self.board[y2-1][:]
self.board[0] = [0] * BOARD_WIDTH
score_table = {1:100, 2:300, 3:500, 4:800}
self.score += score_table.get(lines_cleared, 0)
self.level = self.score // 2000 + 1
self.fall_speed = max(0.05, 0.5 - (self.level-1)*0.05)
def new_piece(self):
self.current_piece = self.next_piece
self.next_piece = Tetromino()
if self.is_collision(self.current_piece.shape, (self.current_piece.x, self.current_piece.y)):
self.game_over = True
def draw_grid(self):
for y in range(BOARD_HEIGHT):
for x in range(BOARD_WIDTH):
pygame.draw.rect(self.screen, WHITE,
[x*GRID_SIZE+1, y*GRID_SIZE+1, GRID_SIZE-1, GRID_SIZE-1], 1)
if self.board[y][x]:
pygame.draw.rect(self.screen, self.board[y][x],
[x*GRID_SIZE+1, y*GRID_SIZE+1, GRID_SIZE-1, GRID_SIZE-1])
def draw_piece(self, piece):
for y, row in enumerate(piece.shape):
for x, cell in enumerate(row):
if cell:
pygame.draw.rect(self.screen, piece.color,
[(piece.x+x)*GRID_SIZE+1, (piece.y+y)*GRID_SIZE+1,
GRID_SIZE-1, GRID_SIZE-1])
def draw_next_piece(self):
next_text = self.font.render("下一个:", True, WHITE)
self.screen.blit(next_text, [BOARD_WIDTH*GRID_SIZE+50, 20])
for y, row in enumerate(self.next_piece.shape):
for x, cell in enumerate(row):
if cell:
pygame.draw.rect(self.screen, self.next_piece.color,
[BOARD_WIDTH*GRID_SIZE+50 + x*GRID_SIZE,
60 + y*GRID_SIZE, GRID_SIZE-1, GRID_SIZE-1])
def draw_score(self):
score_text = self.font.render(f"分数: {self.score}", True, WHITE)
level_text = self.font.render(f"等级: {self.level}", True, WHITE)
self.screen.blit(score_text, [BOARD_WIDTH*GRID_SIZE+50, 200])
self.screen.blit(level_text, [BOARD_WIDTH*GRID_SIZE+50, 240])
def handle_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
return False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
if not self.is_collision(self.current_piece.shape,
(self.current_piece.x-1, self.current_piece.y)):
self.current_piece.x -= 1
elif event.key == pygame.K_RIGHT:
if not self.is_collision(self.current_piece.shape,
(self.current_piece.x+1, self.current_piece.y)):
self.current_piece.x += 1
elif event.key == pygame.K_DOWN:
if not self.is_collision(self.current_piece.shape,
(self.current_piece.x, self.current_piece.y+1)):
self.current_piece.y += 1
elif event.key == pygame.K_UP:
rotated = self.current_piece.rotate()
if not self.is_collision(rotated,
(self.current_piece.x, self.current_piece.y)):
self.current_piece.shape = rotated
elif event.key == pygame.K_SPACE:
while not self.is_collision(self.current_piece.shape,
(self.current_piece.x, self.current_piece.y+1)):
self.current_piece.y += 1
self.merge_piece()
self.clear_lines()
self.new_piece()
elif event.key == pygame.K_r and self.game_over:
self.reset_game()
return True
def update(self, dt):
if self.game_over:
return
self.fall_time += dt
if self.fall_time >= self.fall_speed:
self.fall_time = 0
if not self.is_collision(self.current_piece.shape,
(self.current_piece.x, self.current_piece.y+1)):
self.current_piece.y += 1
else:
self.merge_piece()
self.clear_lines()
self.new_piece()
def render(self):
self.screen.fill(BLACK)
self.draw_grid()
self.draw_piece(self.current_piece)
self.draw_next_piece()
self.draw_score()
if self.game_over:
game_over_text = self.font.render("游戏结束! 按R键重新开始", True, WHITE)
self.screen.blit(game_over_text, [SCREEN_WIDTH//2-150, SCREEN_HEIGHT//2])
pygame.display.flip()
def run(self):
running = True
last_time = pygame.time.get_ticks()
while running:
dt = (pygame.time.get_ticks() - last_time) / 1000.0
last_time = pygame.time.get_ticks()
running = self.handle_events()
self.update(dt)
self.render()
self.clock.tick(FPS)
pygame.quit()
if __name__ == "__main__":
game = Game()
game.run()
5.2 性能优化技巧
- 双缓冲技术：Pygame默认使用双缓冲，避免画面闪烁
- 脏矩形渲染：只重绘发生变化的部分，减少渲染开销
- 事件处理优化：使用
pygame.event.get()而非pygame.event.poll() - 表面缓存：将不变的元素（如背景）渲染到Surface缓存
6. 常见问题与调试技巧
6.1 方块旋转异常
症状：旋转后方块位置偏移或形状不正确
解决方法：
- 检查旋转中心点计算
- 验证旋转后的碰撞检测
- 确保旋转矩阵计算正确
6.2 游戏卡顿
可能原因：
- 帧率设置过高
- 未限制游戏循环执行频率
- 存在内存泄漏
调试步骤：
python复制# 添加性能监控
import time
start = time.time()
# 执行代码
end = time.time()
print(f"执行时间: {end-start}秒")
6.3 打包为可执行文件
使用PyInstaller将游戏打包为exe：
bash复制pip install pyinstaller
pyinstaller --onefile --windowed tetris.py
7. 游戏功能扩展思路
- 多人对战模式：通过网络套接字实现双人对战
- 存档系统：使用pickle模块保存游戏状态
- 音效系统：添加背景音乐和音效
- AI自动玩家：实现自动玩俄罗斯方块的算法
- 皮肤系统：允许玩家自定义方块外观
实现AI玩家的基本思路：
python复制def ai_move(self):
# 评估所有可能的移动和旋转
best_score = -float('inf')
best_move = None
for rotation in range(4):
test_piece = copy.deepcopy(self.current_piece)
for _ in range(rotation):
test_piece.shape = test_piece.rotate()
for x in range(BOARD_WIDTH):
test_piece.x = x
# 模拟下落到底部
while not self.is_collision(test_piece.shape, (test_piece.x, test_piece.y+1)):
test_piece.y += 1
# 评估这个位置的得分
score = self.evaluate_position(test_piece)
if score > best_score:
best_score = score
best_move = (rotation, x)
# 执行最佳移动
self.execute_ai_move(best_move)
8. 项目学习价值与进阶方向
这个俄罗斯方块项目虽然代码量不大，但涵盖了游戏开发的多个核心概念：
- 游戏循环：理解帧率控制与状态更新
- 碰撞系统：掌握2D碰撞检测原理
- 用户输入：处理键盘事件与游戏控制
- 状态管理：维护游戏各种状态（分数、等级等）
对于想进一步学习Python游戏开发的读者，建议：
- 研究Pygame的Sprite系统
- 学习更高级的渲染技术（如粒子效果）
- 探索物理引擎（如Pymunk）
- 尝试3D游戏开发（如Panda3D）
注意：在实际开发中，建议将游戏逻辑与渲染分离，采用MVC等设计模式，这样项目更易于维护和扩展。我在实际项目中发现，良好的代码组织结构可以节省大量调试时间。