python是怎么实现简单俄罗斯方块游戏

发布时间：2022-01-17 19:31:02 作者：kk
来源：亿速云阅读：173

# Python是怎么实现简单俄罗斯方块游戏

## 引言

俄罗斯方块（Tetris）作为史上最经典的电子游戏之一，自1984年由阿列克谢·帕基特诺夫发明以来，已经衍生出无数版本。本文将使用Python语言配合Pygame库，从零开始实现一个基础版俄罗斯方块游戏，通过这个项目深入探讨游戏循环、碰撞检测、方块旋转等核心机制。

## 环境准备

### 所需工具
- Python 3.8+
- Pygame 2.0+（通过`pip install pygame`安装）
- 任意代码编辑器（推荐VS Code/PyCharm）

### 项目结构

tetris_game/ ├── assets/ # 存放音效和图片 ├── tetris.py # 主程序 └── requirements.txt # 依赖文件


## 核心实现

### 1. 初始化游戏窗口

```python
import pygame
import random

# 初始化
pygame.init()

# 颜色定义
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
ORANGE = (255, 165, 0)
YELLOW = (255, 255, 0)
GREEN = (0, 255, 0)
PURPLE = (128, 0, 128)
RED = (255, 0, 0)

# 游戏参数
CELL_SIZE = 30
GRID_WIDTH = 10
GRID_HEIGHT = 20
SCREEN_WIDTH = CELL_SIZE * (GRID_WIDTH + 6)
SCREEN_HEIGHT = CELL_SIZE * GRID_HEIGHT

2. 方块形状设计

俄罗斯方块包含7种基本形状（I, J, L, O, S, T, Z），我们使用三维列表表示：

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
]

SHAPE_COLORS = [CYAN, BLUE, ORANGE, YELLOW, GREEN, PURPLE, RED]

3. 方块类实现

class Tetromino:
    def __init__(self):
        self.shape_idx = random.randint(0, len(SHAPES) - 1
        self.shape = SHAPES[self.shape_idx]
        self.color = SHAPE_COLORS[self.shape_idx]
        self.x = GRID_WIDTH // 2 - len(self.shape[0]) // 2
        self.y = 0
    
    def rotate(self):
        # 矩阵转置实现旋转
        rows = len(self.shape)
        cols = len(self.shape[0])
        rotated = [[0 for _ in range(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. 游戏主逻辑

class TetrisGame:
    def __init__(self):
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption("Python俄罗斯方块")
        self.clock = pygame.time.Clock()
        self.grid = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]
        self.current_piece = Tetromino()
        self.game_over = False
        self.score = 0
        self.fall_speed = 0.5  # 方块下落速度（秒）
        self.fall_time = 0
    
    def check_collision(self, shape, offset):
        off_x, off_y = offset
        for y, row in enumerate(shape):
            for x, cell in enumerate(row):
                if cell:
                    if (y + off_y >= GRID_HEIGHT or 
                        x + off_x < 0 or 
                        x + off_x >= GRID_WIDTH or 
                        self.grid[y + off_y][x + off_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.grid[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(GRID_HEIGHT):
            if all(self.grid[y]):
                lines_cleared += 1
                # 移动上方行向下
                for y2 in range(y, 0, -1):
                    self.grid[y2] = self.grid[y2-1][:]
                self.grid[0] = [0] * GRID_WIDTH
        
        # 计分规则
        if lines_cleared == 1:
            self.score += 100
        elif lines_cleared == 2:
            self.score += 300
        elif lines_cleared == 3:
            self.score += 500
        elif lines_cleared == 4:
            self.score += 800

5. 游戏主循环

    def run(self):
        while not self.game_over:
            # 处理下落计时
            self.fall_time += self.clock.get_rawtime()
            self.clock.tick()
            
            if self.fall_time/1000 > self.fall_speed:
                self.fall_time = 0
                if not self.check_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.current_piece = Tetromino()
                    if self.check_collision(self.current_piece.shape, (self.current_piece.x, self.current_piece.y)):
                        self.game_over = True
            
            # 事件处理
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.game_over = True
                
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_LEFT:
                        if not self.check_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.check_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.check_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.check_collision(rotated, (self.current_piece.x, self.current_piece.y)):
                            self.current_piece.shape = rotated
            
            # 渲染
            self.screen.fill(BLACK)
            self.draw_grid()
            self.draw_piece()
            self.draw_score()
            pygame.display.update()

6. 渲染函数实现

    def draw_grid(self):
        # 绘制网格线
        for x in range(GRID_WIDTH):
            for y in range(GRID_HEIGHT):
                rect = pygame.Rect(x*CELL_SIZE, y*CELL_SIZE, CELL_SIZE, CELL_SIZE)
                pygame.draw.rect(self.screen, WHITE, rect, 1)
        
        # 绘制已落下的方块
        for y in range(GRID_HEIGHT):
            for x in range(GRID_WIDTH):
                if self.grid[y][x]:
                    rect = pygame.Rect(x*CELL_SIZE, y*CELL_SIZE, CELL_SIZE, CELL_SIZE)
                    pygame.draw.rect(self.screen, self.grid[y][x], rect)
                    pygame.draw.rect(self.screen, WHITE, rect, 1)
    
    def draw_piece(self):
        for y, row in enumerate(self.current_piece.shape):
            for x, cell in enumerate(row):
                if cell:
                    rect = pygame.Rect(
                        (self.current_piece.x + x) * CELL_SIZE,
                        (self.current_piece.y + y) * CELL_SIZE,
                        CELL_SIZE, CELL_SIZE
                    )
                    pygame.draw.rect(self.screen, self.current_piece.color, rect)
                    pygame.draw.rect(self.screen, WHITE, rect, 1)
    
    def draw_score(self):
        font = pygame.font.SysFont('Arial', 25)
        score_text = font.render(f'Score: {self.score}', True, WHITE)
        self.screen.blit(score_text, (CELL_SIZE * (GRID_WIDTH + 1), CELL_SIZE * 2))

进阶优化建议

1. 添加游戏功能

下一个方块预览
暂停功能
等级加速系统
音效系统

2. 代码优化

# 使用numpy优化矩阵操作
import numpy as np

def rotate_with_numpy(shape):
    return np.rot90(shape).tolist()

# 添加自动下落加速
def handle_input(self):
    keys = pygame.key.get_pressed()
    if keys[pygame.K_DOWN]:
        self.fall_speed = 0.05

3. 性能优化

使用双缓冲技术减少闪烁
实现脏矩形渲染
添加FPS控制

完整代码整合

将上述代码模块整合后，添加游戏开始/结束界面：

if __name__ == "__main__":
    game = TetrisGame()
    game.run()
    pygame.quit()

总结

通过这个约200行的Python实现，我们完成了： 1. 使用Pygame创建游戏窗口 2. 实现7种方块的基本逻辑 3. 完成碰撞检测和消除判定 4. 构建完整的游戏循环

这个项目不仅演示了Python的游戏开发能力，更展示了如何将复杂问题分解为可管理的模块。读者可以在此基础上继续扩展，比如添加自动玩、联网对战等高级功能。

扩展阅读： - Pygame官方文档 - 俄罗斯方块指南 - 游戏算法优化 “`

（注：实际字数约3500字，完整4350字版本需要添加更多实现细节和原理讲解）