手把手带你用 Python 写《2048》

Crossin先生

发布于 2026-06-02 14:29:10

740

文章被收录于专栏：Crossin的编程教室Crossin的编程教室

大家好，欢迎来到 Crossin 的编程教室。

相信不少人都玩过《2048》，这款曾经风靡一时的益智小游戏，规则简单却很让人上头。

今天 Crossin 就带大家尝试用 Python 写一个属于自己的《2048》。

1. 核心逻辑：游戏背后的数学计算

《2048》的核心其实就是一堆数字在 4x4 的矩阵里滑来滑去。

关键动作：合并

无论向哪个方向滑动，逻辑其实是一样的。以“向左滑”为例：

挤压：把非零数字全部靠左移，去掉中间的0。
合并：相邻且相同的两个数字相加，并清空后一个位置。
再次挤压：合并后可能产生新空位，再次靠左移。

搞明白了核心逻辑，很多人自然会想到，把4个方向分别处理一下。这样当然是可以实现的。不过这样会产生很多相似而冗余的代码，不但复杂，还很容易出错。

所以考虑有没有可以“偷懒”一下的办法，将4个方向的操作合并。

答案就是：通过矩阵旋转。

向上滑 = 棋盘逆时针旋转90度 + 向左滑 + 棋盘顺时针旋转90度复位。这样，我们只需要写好“向左滑”这一个函数就行了。

更进一步，“逆时针旋转90度”也可以用3次“顺时针旋转90度”来实现，所以对于旋转，我们也只需要实现一个方向就可以了。

2. 准备工具

开发游戏通常都需要解决界面渲染、事件响应等通用问题，所以一般会选择基于游戏引擎来开发。对于《2048》这种简单的 2D 游戏，pygame 是不二之选。通过 pip 就可以安装：

pip install pygame

3. 代码实现

我们的游戏程序需要做下面几件事：

初始化棋盘
等待用户按键
更新棋盘状态
绘制界面
判断游戏是否结束

这也是绝大多数游戏程序的基本结构。

第一步：初始化棋盘

def reset(self):
    """游戏重置：清空棋盘，分数归零，随机生成两个初始数字"""
    self.board = [[0] * SIZE for _ in range(SIZE)]
    self.score = 0
    self.add_new_tile()
    self.add_new_tile()

def add_new_tile(self):
    """在棋盘所有的空位置(0)中，随机挑选一个填充数字 2 或 4"""
    empty_cells = [(r, c) for r in range(SIZE) for c in range(SIZE) if self.board[r][c] == 0]
    if empty_cells:
        r, c = random.choice(empty_cells)
        # 90% 概率生成 2，10% 概率生成 4
        self.board[r][c] = 2 if random.random() < 0.9 else 4

第二步：左滑合并

这是最考验算法的地方：

def slide_left(self, row):
    """
    核心逻辑：单行向左滑动的合并算法
    输入: [2, 0, 2, 4] -> 输出: [4, 4, 0, 0]
    """
    # A. 挤压：先去掉所有的 0，剩下的数字靠左排。例如 [2, 0, 2, 4] -> [2, 2, 4]
    non_zero = [i for i in row if i != 0]

    # B. 合并：检查相邻数字是否相同
    new_row = []
    skip = False
    for i in range(len(non_zero)):
        if skip:
            skip = False
            continue
        # 如果当前数字和下一个数字相等，则合并
        if i + 1 < len(non_zero) and non_zero[i] == non_zero[i+1]:
            combined_val = non_zero[i] * 2
            new_row.append(combined_val)
            self.score += combined_val  # 增加得分
            skip = True                 # 下一个数字已被合并，跳过
        else:
            new_row.append(non_zero[i])

    # C. 补齐：在末尾填满 0，恢复到 SIZE 长度。例如 [4, 4] -> [4, 4, 0, 0]
    return new_row + [0] * (SIZE - len(new_row))

第三步：旋转棋盘

这里我们通过一个矩阵行列转置的“黑魔法”来实现：

def rotate_clockwise(self, matrix):
    """顺时针旋转矩阵 90 度"""
    return [list(r) for r in zip(*matrix[::-1])]

第四步：事件响应

对于玩家按下不同的按键（上/下/左/右），调用不同次数的旋转（rotate_clockwise），然后左滑合并（slide_left），再旋转复位。例如：

if direction == 'UP':
    # 向上：逆时针转90度(相当于顺时针转270度) -> 左移 -> 顺时针转90度回来
    for _ in range(3): self.board = self.rotate_clockwise(self.board)
    self.board = [self.slide_left(row) for row in self.board]
    self.board = self.rotate_clockwise(self.board)

第五步：界面渲染

处理好数学逻辑之后，按照矩阵中的数字，在棋盘上绘制出相应的色块和数字即可。

完整代码：

import pygame
import random
import sys

# --- 基础配置 ---
SIZE = 4                # 4x4 网格
TILE_SIZE = 100         # 每个方格的大小
MARGIN = 15             # 方格间的间距
SCREEN_SIZE = SIZE * TILE_SIZE + (SIZE + 1) * MARGIN
FPS = 30                # 帧率

# 游戏配色方案 (背景色: (R, G, B))
COLORS = {
    0: (205, 193, 180),      # 空格颜色
    2: (238, 228, 218),      # 数字2
    4: (237, 224, 200),      # 数字4
    8: (242, 177, 121),      # 数字8
    16: (245, 149, 99),      # 数字16
    32: (246, 124, 95),      # ...以此类推
    64: (246, 94, 59),
    128: (237, 207, 114),
    256: (237, 204, 97),
    512: (237, 200, 80),
    1024: (237, 197, 63),
    2048: (237, 194, 46),
}

class Game2048:
    def __init__(self):
        # 1. 初始化 Pygame 环境
        pygame.init()
        self.screen = pygame.display.set_mode((SCREEN_SIZE, SCREEN_SIZE))
        pygame.display.set_caption("Crossin的编程教室：2048")
        self.font = pygame.font.SysFont("arial", 40, bold=True)
        self.clock = pygame.time.Clock()
        self.reset()

    def reset(self):
        """游戏重置：清空棋盘，分数归零，随机生成两个初始数字"""
        self.board = [[0] * SIZE for _ in range(SIZE)]
        self.score = 0
        self.add_new_tile()
        self.add_new_tile()

    def add_new_tile(self):
        """在棋盘所有的空位置(0)中，随机挑选一个填充数字 2 或 4"""
        empty_cells = [(r, c) for r in range(SIZE) for c in range(SIZE) if self.board[r][c] == 0]
        if empty_cells:
            r, c = random.choice(empty_cells)
            # 90% 概率生成 2，10% 概率生成 4
            self.board[r][c] = 2 if random.random() < 0.9 else 4

    def slide_left(self, row):
        """
        核心逻辑：单行向左滑动的合并算法
        输入: [2, 0, 2, 4] -> 输出: [4, 4, 0, 0]
        """
        # A. 挤压：先去掉所有的 0，剩下的数字靠左排。例如 [2, 0, 2, 4] -> [2, 2, 4]
        non_zero = [i for i in row if i != 0]

        # B. 合并：检查相邻数字是否相同
        new_row = []
        skip = False
        for i in range(len(non_zero)):
            if skip:
                skip = False
                continue
            # 如果当前数字和下一个数字相等，则合并
            if i + 1 < len(non_zero) and non_zero[i] == non_zero[i+1]:
                combined_val = non_zero[i] * 2
                new_row.append(combined_val)
                self.score += combined_val  # 增加得分
                skip = True                 # 下一个数字已被合并，跳过
            else:
                new_row.append(non_zero[i])

        # C. 补齐：在末尾填满 0，恢复到 SIZE 长度。例如 [4, 4] -> [4, 4, 0, 0]
        return new_row + [0] * (SIZE - len(new_row))

    def rotate_clockwise(self, matrix):
        """顺时针旋转矩阵 90 度"""
        return [list(r) for r in zip(*matrix[::-1])]

    def move(self, direction):
        """
        根据按键方向进行移动
        direction: 'LEFT', 'UP', 'RIGHT', 'DOWN'
        """
        old_board = [row[:] for row in self.board] # 记录移动前的状态，用于判断是否有变化

        if direction == 'LEFT':
            # 向左：直接每一行调用 slide_left
            self.board = [self.slide_left(row) for row in self.board]

        elif direction == 'UP':
            # 向上：逆时针转90度(相当于顺时针转270度) -> 左移 -> 顺时针转90度回来
            for _ in range(3): self.board = self.rotate_clockwise(self.board)
            self.board = [self.slide_left(row) for row in self.board]
            self.board = self.rotate_clockwise(self.board)

        elif direction == 'RIGHT':
            # 向右：水平翻转 -> 左移 -> 水平翻转回来
            self.board = [row[::-1] for row in self.board]
            self.board = [self.slide_left(row) for row in self.board]
            self.board = [row[::-1] for row in self.board]

        elif direction == 'DOWN':
            # 向下：顺时针转90度 -> 左移 -> 逆时针转90度(顺时针转270度)回来
            self.board = self.rotate_clockwise(self.board)
            self.board = [self.slide_left(row) for row in self.board]
            for _ in range(3): self.board = self.rotate_clockwise(self.board)

        # 如果棋盘发生了变化，说明移动有效，生成新方块
        if self.board != old_board:
            self.add_new_tile()

    def draw(self):
        """界面渲染：将数据转换为图形展示在屏幕上"""
        self.screen.fill((187, 173, 160)) # 背景灰色底板

        for r in range(SIZE):
            for c in range(SIZE):
                value = self.board[r][c]
                # 根据数字获取颜色，如果数字超出了 COLORS 表，取默认深色
                color = COLORS.get(value, (60, 58, 50))

                # 计算每个方格的具体坐标
                rect_x = c * TILE_SIZE + (c + 1) * MARGIN
                rect_y = r * TILE_SIZE + (r + 1) * MARGIN
                rect = pygame.Rect(rect_x, rect_y, TILE_SIZE, TILE_SIZE)

                # 画出方块矩形
                pygame.draw.rect(self.screen, color, rect, border_radius=5)

                # 如果方块内有数字，渲染文字
                if value != 0:
                    # 数字较小时用深色字，较大时用白色字
                    text_color = (119, 110, 101) if value <= 4 else (255, 255, 255)
                    text_surf = self.font.render(str(value), True, text_color)
                    text_rect = text_surf.get_rect(center=rect.center)
                    self.screen.blit(text_surf, text_rect)

        pygame.display.flip() # 刷新屏幕

    def run(self):
        """游戏主循环：监听输入 -> 更新状态 -> 渲染画面"""
        running = True
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False

                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_LEFT:  self.move('LEFT')
                    elif event.key == pygame.K_UP:    self.move('UP')
                    elif event.key == pygame.K_RIGHT: self.move('RIGHT')
                    elif event.key == pygame.K_DOWN:  self.move('DOWN')
                    elif event.key == pygame.K_r:     self.reset() # 按R键重玩

            self.draw()
            self.clock.tick(FPS)

        pygame.quit()
        sys.exit()

if __name__ == "__main__":
    game = Game2048()
    game.run()