Python 打造俄罗斯方块:从0到1的游戏开发之旅

off999 2025-05-08 20:45 35 浏览 0 评论

开发前的准备

俄罗斯方块作为一款经典的益智游戏，承载了许多人的童年回忆。用 Python 开发俄罗斯方块，不仅能重温这款游戏的魅力，还能深入理解游戏开发的原理和逻辑，提升编程技能。

在开始开发之前，我们需要确保已经安装了 Python 环境。如果还没有安装，可以前往 Python 官方网站（
https://www.python.org/downloads/ ）下载并安装最新版本的 Python。

此外，我们还需要安装 Pygame 库。Pygame 是一个用于开发 2D 游戏的 Python 库，提供了丰富的功能，如图形绘制、声音播放、用户输入处理等，非常适合用于开发俄罗斯方块这样的小游戏。安装 Pygame 库的方法很简单，打开命令行工具，输入以下命令即可：

pip install pygame

如果安装过程中遇到问题，可以参考 Pygame 官方文档（
https://www.pygame.org/docs/ ）进行解决。

游戏框架设计

我们使用 Pygame 库来构建游戏窗口。首先，导入 Pygame 库并初始化：

import pygame
pygame.init()

然后，设置游戏窗口的大小。这里我们设置窗口宽度为 300 像素，高度为 600 像素：

# 定义窗口的宽高
SCREEN_WIDTH = 300
SCREEN_HEIGHT = 600
# 创建游戏窗口
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption('俄罗斯方块')

接下来，定义游戏区域。游戏区域是玩家放置方块的地方，我们可以用一个二维列表来表示。这里我们定义游戏区域的宽度为 10 个方块，高度为 20 个方块：

# 游戏区域宽度和高度
GAME_WIDTH = 10
GAME_HEIGHT = 20
# 初始化游戏区域，0表示空，非0表示有方块
game_area = [[0] * GAME_WIDTH for _ in range(GAME_HEIGHT)]

俄罗斯方块有 7 种不同的形状，每种形状由 4 个小方块组成。我们可以用二维列表来表示这些形状。例如，以下是 7 种形状的定义：

# 定义方块形状
SHAPES = [
    [[1, 1, 1, 1]],  # I 形
    [[2, 2], [2, 2]],  # O 形
    [[3, 3, 3], [0, 3, 0]],  # T 形
    [[4, 4, 4], [4, 0, 0]],  # J 形
    [[5, 5, 5], [0, 0, 5]],  # L 形
    [[6, 6, 0], [0, 6, 6]],  # S 形
    [[7, 7, 0], [7, 7, 0]]  # Z 形
]

为了让游戏更加美观，我们可以为每种形状设置不同的颜色。这里我们定义了 7 种颜色，分别对应 7 种形状：

# 定义颜色
COLORS = [
    (0, 255, 255),  # 青色
    (255, 255, 0),  # 黄色
    (128, 0, 128),  # 紫色
    (0, 0, 255),  # 蓝色
    (255, 165, 0),  # 橙色
    (0, 255, 0),  # 绿色
    (255, 0, 0)  # 红色
]

核心功能实现

（一）方块的生成与下落

在俄罗斯方块游戏中，方块的生成与下落是最基础的功能之一。首先，我们需要随机生成方块。在 Python 中，使用random库来实现这一功能。random.choice()函数可以从给定的序列中随机选择一个元素。在我们的游戏中，这个序列就是前面定义的SHAPES列表，它包含了 7 种不同形状的方块。通过random.choice(SHAPES)，我们就能随机生成一个方块形状。

import random
# 随机生成方块形状
current_shape = random.choice(SHAPES)

方块的自动下落功能通过一个循环来实现。在每次循环中，我们检查方块是否可以继续下落。如果可以，就将方块的 y 坐标增加 1，实现下落效果；如果不能，说明方块已经到达底部或碰到了其他方块，此时需要将方块固定在当前位置，并生成新的方块。为了控制下落速度，我们可以使用pygame.time.wait()函数来设置一个时间间隔，让方块每隔一段时间下落一次。

# 方块自动下落
while True:
    new_y = current_y + 1
    if check_collision(current_x, new_y, current_shape):
        break
    current_y = new_y
    pygame.time.wait(500)

（二）方块的移动与旋转

实现方块的左右移动功能相对简单。以向左移动为例，当玩家按下向左的方向键时，我们将方块的 x 坐标减 1，然后检查新的位置是否合法。如果合法，就更新方块的位置；如果不合法，说明方块已经到达边界或与其他方块重叠，此时不进行移动。向右移动的原理与向左移动类似，只是将 x 坐标加 1。

# 向左移动方块
def move_left():
    global current_x
    new_x = current_x - 1
    if not check_collision(new_x, current_y, current_shape):
        current_x = new_x


# 向右移动方块
def move_right():
    global current_x
    new_x = current_x + 1
    if not check_collision(new_x, current_y, current_shape):
        current_x = new_x

方块的旋转功能则需要一些数学知识。我们可以使用矩阵变换的原理来实现方块的旋转。具体来说，就是将方块的形状矩阵进行转置和翻转操作。以顺时针旋转 90 度为例，先对形状矩阵进行转置，即将矩阵的行和列互换，然后再对转置后的矩阵进行水平翻转，就可以得到旋转后的形状矩阵。在代码实现中，我们可以使用 Python 的列表推导式来实现矩阵的转置和翻转操作。

# 旋转方块
def rotate():
    global current_shape
    new_shape = list(map(list, zip(*current_shape[::-1])))
    if not check_collision(current_x, current_y, new_shape):
        current_shape = new_shape

（三）碰撞检测与行消除

碰撞检测是俄罗斯方块游戏中非常重要的一个功能，它关系到方块的移动、下落以及游戏的结束判断。在我们的游戏中，需要检测方块与边界以及已放置方块的碰撞。检测与边界的碰撞比较简单，只需要检查方块的坐标是否超出了游戏区域的范围即可。例如，当方块的 x 坐标小于 0 或者大于等于游戏区域的宽度，或者 y 坐标大于等于游戏区域的高度时，就说明方块与边界发生了碰撞。

# 检测碰撞
def check_collision(x, y, shape):
    for i in range(len(shape)):
        for j in range(len(shape[i])):
            if shape[i][j]:
                if x + j < 0 or x + j >= GAME_WIDTH or y + i >= GAME_HEIGHT or game_area[y + i][x + j]:
                    return True
    return False

检测与已放置方块的碰撞时，我们需要遍历当前方块的每个小方块，检查它在新位置上是否与游戏区域中已有的方块重叠。如果重叠，就说明发生了碰撞。

行消除功能的实现思路是遍历游戏区域的每一行，检查该行是否被完全填满。如果某一行的所有元素都不为 0，就说明该行被填满了，需要将该行消除。消除该行后，需要将上面的所有行向下移动一行，以填补空白位置。为了实现这一功能，我们可以使用一个新的二维列表来存储消除行后的游戏区域，然后将这个新的列表赋值给原来的游戏区域。

# 消除满行
def clear_lines():
    global game_area
    full_lines = []
    for i in range(len(game_area)):
        if all(game_area[i]):
            full_lines.append(i)
    for line in full_lines:
        del game_area[line]
        game_area = [[0] * GAME_WIDTH] + game_area

游戏控制与交互

在游戏中，玩家通过键盘来控制方块的移动、旋转和加速下落。我们使用pygame.key.get_pressed()函数来获取键盘按键的状态。例如，当玩家按下向左箭头键时，调用move_left()函数实现方块的左移；按下向右箭头键时，调用move_right()函数实现右移；按下上箭头键时，调用rotate()函数实现方块的旋转；按下下箭头键时，增加方块的下落速度，实现加速下落。

# 游戏主循环
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]:
        move_left()
    elif keys[pygame.K_RIGHT]:
        move_right()
    elif keys[pygame.K_UP]:
        rotate()
    elif keys[pygame.K_DOWN]:
        # 加速下落逻辑，这里简单示例为增加下落速度
        speed_up_fall()

为了增强游戏的趣味性和沉浸感，我们还可以为游戏添加音效。在 Pygame 中，使用pygame.mixer.Sound()函数来加载音效文件，然后在相应的操作发生时播放音效。例如，在方块移动时播放移动音效，旋转时播放旋转音效，消除行时播放消除音效。

# 加载音效
move_sound = pygame.mixer.Sound('move.wav')
rotate_sound = pygame.mixer.Sound('rotate.wav')
clear_sound = pygame.mixer.Sound('clear.wav')


# 在移动函数中添加音效播放
def move_left():
    global current_x
    new_x = current_x - 1
    if not check_collision(new_x, current_y, current_shape):
        current_x = new_x
        move_sound.play()


# 在旋转函数中添加音效播放
def rotate():
    global current_shape
    new_shape = list(map(list, zip(*current_shape[::-1])))
    if not check_collision(current_x, current_y, new_shape):
        current_shape = new_shape
        rotate_sound.play()


# 在消除行函数中添加音效播放
def clear_lines():
    global game_area
    full_lines = []
    for i in range(len(game_area)):
        if all(game_area[i]):
            full_lines.append(i)
    for line in full_lines:
        del game_area[line]
        game_area = [[0] * GAME_WIDTH] + game_area
    if full_lines:
        clear_sound.play()

优化与扩展

（一）性能优化

随着游戏的进行，尤其是在方块下落、移动和旋转操作较为频繁时，画面闪烁的问题可能会影响玩家的游戏体验。为了解决这个问题，我们可以采用双缓冲技术。双缓冲技术的原理是在内存中创建两个缓冲区，一个用于绘制图形，另一个用于显示。在绘制过程中，所有的图形绘制操作都在后台缓冲区进行，当绘制完成后，再将后台缓冲区的内容一次性复制到前台缓冲区进行显示。这样可以避免在绘制过程中出现画面闪烁的情况，使游戏画面更加流畅。在 Pygame 中，可以通过创建一个与屏幕大小相同的 Surface 对象作为后台缓冲区，然后在这个缓冲区上进行绘制，最后使用screen.blit()函数将缓冲区的内容复制到屏幕上显示。

为了进一步提升游戏性能，我们可以引入预生成形状的缓存机制。在游戏开始前，预先随机生成一定数量的方块形状，并将它们存储在一个列表中。当需要生成新的方块时，直接从缓存列表中取出一个形状，而不是每次都重新随机生成。这样可以减少随机生成形状的计算开销，提高游戏的响应速度。同时，当缓存列表中的形状使用完后，再重新生成一批新的形状，以保证缓存的持续性。

精确的计时器控制对于游戏的流畅性和稳定性也非常重要。在前面的实现中，我们使用pygame.time.wait()函数来控制方块的下落速度，但这种方式不够精确，可能会导致下落速度不均匀。为了实现更精确的计时器控制，我们可以使用pygame.time.Clock()类。Clock类提供了tick()方法，可以控制游戏循环的帧率。通过设置合适的帧率，我们可以精确地控制方块的下落速度，使游戏更加稳定和流畅。例如，将帧率设置为 30，表示每秒更新 30 次游戏画面，这样可以根据帧率来计算方块下落的时间间隔，从而实现精确的下落控制。

（二）功能扩展

在原有的单人游戏基础上添加多人对战功能，可以极大地增加游戏的趣味性和竞技性。实现多人对战功能需要解决网络通信和同步的问题。我们可以使用 Python 的socket库来实现网络通信。每个玩家的游戏客户端通过socket连接到服务器，服务器负责接收和转发玩家的操作信息，如方块的移动、旋转等。同时，服务器还需要同步各个玩家的游戏状态，确保每个玩家看到的游戏画面是一致的。为了实现同步，可以使用时间戳或序列号来标记每个操作，服务器根据这些标记来按顺序处理操作，保证各个客户端的游戏状态同步。

AI 自动游戏功能可以让玩家观察 AI 的操作策略，或者与 AI 进行对战。实现 AI 自动游戏需要设计智能算法，让 AI 能够自动判断方块的最佳下落位置和旋转角度。一种常见的方法是使用搜索算法，如深度优先搜索（DFS）或广度优先搜索（BFS）。这些算法可以遍历所有可能的方块放置位置和旋转状态，根据一定的评估函数来选择最优解。评估函数可以考虑多个因素，如消除的行数、方块的堆积高度、空洞的数量等。通过综合评估这些因素，AI 可以做出最优的决策，实现自动游戏。

为了让玩家能够记录自己的游戏成绩，我们可以添加保存游戏记录的功能。使用数据库来存储玩家的游戏记录，如最高分、游戏时间、消除的行数等。Python 中有许多数据库库可供选择，如 SQLite、MySQL 等。以 SQLite 为例，它是一个轻量级的嵌入式数据库，非常适合用于小型项目。我们可以使用sqlite3库来操作 SQLite 数据库。在游戏结束时，将玩家的成绩插入到数据库中，当玩家再次启动游戏时，可以从数据库中读取历史成绩进行展示。这样玩家可以随时查看自己的游戏进步情况，增加游戏的成就感和挑战性。

游戏源码

#生成游戏中所需的音频文件
# -*- coding: utf-8 -*-

import math
import struct
import wave

# 采样率
sample_rate = 44100
# 持续时间，单位秒
duration = 1
# 频率，单位Hz
frequency = 440

# 计算采样点数
num_samples = int(sample_rate * duration)
# 打开WAV文件进行写入
wav_file = wave.open('move.wav', 'w')
# 设置声道数为1（单声道）
wav_file.setnchannels(1)
# 设置样本宽度为2字节（16位）
wav_file.setsampwidth(2)
# 设置采样率
wav_file.setframerate(sample_rate)

for i in range(num_samples):
    # 生成正弦波样本值
    sample = int(32767.0 * math.sin(2 * math.pi * frequency * (i / sample_rate)))
    # 将样本值打包为二进制数据
    data = struct.pack('<h', sample)
    # 写入WAV文件
    wav_file.writeframesraw(data)

# 写入文件头信息
wav_file.writeframes(b'')
# 关闭WAV文件
wav_file.close()

# -*- coding: utf-8 -*-

import math
import struct
import wave

# 采样率
sample_rate = 44100
# 持续时间（秒）
duration = 1
# 频率（Hz）
frequency = 440

# 生成音频数据
frames = []
for i in range(int(sample_rate * duration)):
    t = i / sample_rate
    value = int(32767.0 * math.sin(2 * math.pi * frequency * t))
    data = struct.pack('<h', value)
    frames.append(data)

# 打开WAV文件进行写入
with wave.open('rotate.wav', 'wb') as wf:
    wf.setnchannels(1)  # 单声道
    wf.setsampwidth(2)  # 每个样本2字节
    wf.setframerate(sample_rate)
    wf.writeframes(b''.join(frames))

# -*- coding: utf-8 -*-


import math
import struct
import wave

# 生成简单的正弦波作为消除音效示例
sample_rate = 44100  # 采样率
duration = 1  # 时长1秒
frequency = 440  # 频率440Hz，对应A音

num_samples = duration * sample_rate
amplitude = 16000  # 振幅

# 打开wave文件进行写入
with wave.open('clear.wav', 'w') as wav_file:
    wav_file.setparams((1, 2, sample_rate, num_samples, 'NONE', 'not compressed'))
    for i in range(num_samples):
        t = float(i) / sample_rate
        value = int(amplitude * math.sin(2.0 * math.pi * frequency * t))
        data = struct.pack('<h', value)
        wav_file.writeframesraw(data)
    wav_file.close()

# -*- coding: utf-8 -*-

import random

import pygame
from pygame.locals import *

# 初始化Pygame
pygame.init()

# 定义颜色常量
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GRAY = (128, 128, 128)

# 游戏配置
SCREEN_WIDTH = 300
SCREEN_HEIGHT = 600
BLOCK_SIZE = 30
GAME_WIDTH = 10
GAME_HEIGHT = 20

# 方块形状定义
SHAPES = [
    [[1, 1, 1, 1]],  # I
    [[2, 2], [2, 2]],  # O
    [[3, 3, 3], [0, 3, 0]],  # T
    [[4, 4, 4], [4, 0, 0]],  # J
    [[5, 5, 5], [0, 0, 5]],  # L
    [[0, 6, 6], [6, 6, 0]],  # S
    [[7, 7, 0], [0, 7, 7]]  # Z
]

# 颜色定义（对应形状）
COLORS = [
    (0, 255, 255),  # 青色
    (255, 255, 0),  # 黄色
    (128, 0, 128),  # 紫色
    (0, 0, 255),  # 蓝色
    (255, 165, 0),  # 橙色
    (0, 255, 0),  # 绿色
    (255, 0, 0)  # 红色
]


class Tetris:
    def __init__(self):
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption('俄罗斯方块')
        self.clock = pygame.time.Clock()
        self.game_area = [[0] * GAME_WIDTH for _ in range(GAME_HEIGHT)]
        self.current_shape = None
        self.current_x = 0
        self.current_y = 0
        self.score = 0
        self.game_over = False
        self.new_block()

    def new_block(self):
        self.current_shape = random.choice(SHAPES)
        self.current_x = GAME_WIDTH // 2 - len(self.current_shape[0]) // 2
        self.current_y = 0
        if self.check_collision(self.current_x, self.current_y, self.current_shape):
            self.game_over = True

    def check_collision(self, x, y, shape):
        for i in range(len(shape)):
            for j in range(len(shape[i])):
                if shape[i][j]:
                    new_x = x + j
                    new_y = y + i
                    if new_x < 0 or new_x >= GAME_WIDTH or new_y >= GAME_HEIGHT:
                        return True
                    if new_y >= 0 and self.game_area[new_y][new_x]:
                        return True
        return False

    def move_left(self):
        if not self.check_collision(self.current_x - 1, self.current_y, self.current_shape):
            self.current_x -= 1

    def move_right(self):
        if not self.check_collision(self.current_x + 1, self.current_y, self.current_shape):
            self.current_x += 1

    def rotate(self):
        rotated = list(zip(*self.current_shape[::-1]))
        if not self.check_collision(self.current_x, self.current_y, rotated):
            self.current_shape = [list(row) for row in rotated]

    def drop(self):
        if not self.check_collision(self.current_x, self.current_y + 1, self.current_shape):
            self.current_y += 1
            return True
        self.place_block()
        return False

    def place_block(self):
        for i in range(len(self.current_shape)):
            for j in range(len(self.current_shape[i])):
                if self.current_shape[i][j]:
                    self.game_area[self.current_y + i][self.current_x + j] = self.current_shape[i][j]
        self.clear_lines()
        self.new_block()

    def clear_lines(self):
        lines_cleared = 0
        new_area = []
        for row in self.game_area:
            if all(row):
                lines_cleared += 1
            else:
                new_area.append(row)
        self.score += lines_cleared ** 2 * 100
        self.game_area = [[0] * GAME_WIDTH for _ in range(lines_cleared)] + new_area

    def draw_block(self, x, y, color):
        pygame.draw.rect(self.screen, color, (x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE - 1, BLOCK_SIZE - 1))

    def draw_game_area(self):
        # 绘制游戏区域边界
        pygame.draw.rect(self.screen, WHITE, (0, 0, GAME_WIDTH * BLOCK_SIZE, GAME_HEIGHT * BLOCK_SIZE), 1)

        # 绘制已落下的方块
        for y in range(GAME_HEIGHT):
            for x in range(GAME_WIDTH):
                if self.game_area[y][x]:
                    color = COLORS[self.game_area[y][x] - 1]
                    self.draw_block(x, y, color)

        # 绘制当前方块
        if self.current_shape:
            for y in range(len(self.current_shape)):
                for x in range(len(self.current_shape[y])):
                    if self.current_shape[y][x]:
                        color = COLORS[self.current_shape[y][x] - 1]
                        self.draw_block(self.current_x + x, self.current_y + y, color)

    def draw_score(self):
        font = pygame.font.SysFont('Arial', 24)
        text = font.render(f'Score: {self.score}', True, WHITE)
        self.screen.blit(text, (GAME_WIDTH * BLOCK_SIZE + 20, 20))

    def run(self):
        fall_speed = 500
        last_fall = pygame.time.get_ticks()

        while not self.game_over:
            self.screen.fill(BLACK)
            current_time = pygame.time.get_ticks()

            # 处理输入
            for event in pygame.event.get():
                if event.type == QUIT:
                    self.game_over = True
                elif event.type == KEYDOWN:
                    if event.key == K_LEFT:
                        self.move_left()
                    elif event.key == K_RIGHT:
                        self.move_right()
                    elif event.key == K_UP:
                        self.rotate()
                    elif event.key == K_DOWN:
                        self.drop()
                    elif event.key == K_SPACE:
                        while self.drop():
                            pass

            # 自动下落
            if current_time - last_fall > fall_speed:
                if not self.drop():
                    last_fall = current_time
                else:
                    last_fall = current_time

            self.draw_game_area()
            self.draw_score()
            pygame.display.update()
            self.clock.tick(30)

        # 游戏结束处理
        font = pygame.font.SysFont('Arial', 48)
        text = font.render('Game Over!', True, WHITE)
        self.screen.blit(text, (SCREEN_WIDTH // 2 - text.get_width() // 2, SCREEN_HEIGHT // 2 - text.get_height() // 2))
        pygame.display.update()
        pygame.time.wait(2000)


if __name__ == '__main__':
    game = Tetris()
    game.run()
    pygame.quit()