企业官网建设流程全解析

1. 项目概述与核心价值

如果你正在寻找一个能串联起Python基础语法、数据结构、算法逻辑和图形界面编程的实战项目，用Pygame复刻经典的2048游戏绝对是一个绝佳的选择。这不仅仅是一个“小游戏”，它更像是一个微型的软件工程沙盘。我见过很多初学者在学完Python语法后，面对Pygame的API和游戏循环概念感到迷茫，而2048项目恰好提供了一个复杂度适中、逻辑闭环的练手场景。通过它，你能亲手实践从零搭建一个可交互应用的全过程，理解事件驱动、状态管理、渲染管线这些核心概念，而不仅仅是停留在书本理论。

这个项目的核心价值在于它的“麻雀虽小，五脏俱全”。它不涉及复杂的物理引擎或3D渲染，但完整涵盖了游戏开发的几个关键阶段：环境搭建、数据结构设计、核心算法实现、用户交互处理和视觉呈现。更重要的是，2048的移动合并算法本身就是一个经典的编程思维训练，如何高效地处理二维数组、判断游戏状态，这些技巧在解决其他算法问题时也极具参考价值。对于想踏入游戏开发、GUI应用开发，或者单纯想提升Python工程能力的开发者来说，这是一个性价比极高的练手项目。

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

2.1 Python与Pygame安装避坑指南

工欲善其事，必先利其器。第一步是确保你的Python环境就绪。我强烈建议使用Python 3.7及以上版本，因为新版本对包管理和一些语法特性的支持更好。如果你还没有安装Python，去官网下载安装包时，务必勾选“Add Python to PATH”这个选项，这能省去后续手动配置环境变量的麻烦。

接下来是安装Pygame。打开你的命令行终端（Windows上是CMD或PowerShell，macOS/Linux上是Terminal），输入以下命令：

pip install pygame

这看起来很简单，但却是新手最容易踩坑的地方。如果你遇到诸如“error: failed to build ‘pygame’ when getting requirements to build wheel”之类的错误，别慌，这通常是因为缺少编译Pygame所需的系统依赖。在Windows上，一个常见的解决方法是安装Microsoft Visual C++ Build Tools。更省事的办法是使用预编译的wheel文件。你可以尝试指定一个更兼容的版本，或者使用国内的镜像源加速下载并规避一些网络问题：

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

在macOS上，你可能需要先通过Homebrew安装一些库，比如brew install sdl2 sdl2_image sdl2_mixer sdl2_ttf。在Linux上（如Ubuntu），则需要安装类似libsdl2-dev这样的开发包。我的经验是，如果pip install报错，仔细阅读错误信息，它通常会告诉你缺少哪个库，然后根据你的操作系统去搜索对应的安装方法，这比盲目尝试要高效得多。

2.2 创建你的第一个Pygame窗口

安装成功后，让我们用最少的代码验证一下环境，并理解Pygame程序的基本骨架。创建一个名为2048.py的新文件，输入以下代码：

import pygame import sys # 初始化Pygame的所有模块 pygame.init() # 设置窗口尺寸 SCREEN_WIDTH = 400 SCREEN_HEIGHT = 500 screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption("我的2048") # 游戏主循环 running = True while running: # 处理事件队列 for event in pygame.event.get(): if event.type == pygame.QUIT: # 用户点击了窗口关闭按钮 running = False # 用白色填充屏幕（RGB值：255,255,255） screen.fill((255, 255, 255)) # 更新屏幕显示 pygame.display.flip() # 退出Pygame并关闭程序 pygame.quit() sys.exit()

运行这个脚本，你应该能看到一个400x500像素的白色窗口，标题是“我的2048”。点击窗口的关闭按钮，程序会正常退出。这段代码虽然简单，却包含了Pygame程序的三个核心部分：初始化、主循环和退出清理。

注意：pygame.init()会初始化Pygame的所有子模块（如显示、字体、声音等）。pygame.event.get()会获取并清空当前的事件队列，你必须在一个循环中不断调用它来响应用户输入。pygame.display.flip()（或update()）则是将你在内存中绘制的内容真正更新到屏幕上，没有这行代码，你画了什么用户都看不到。记住这个“事件处理 -> 逻辑更新 -> 画面渲染”的循环模式，它是几乎所有Pygame游戏的心脏。

3. 游戏数据结构与核心状态管理

3.1 棋盘的数据结构选择：为什么是二维列表？

游戏的核心是那个4x4的棋盘。在代码中，我们用一个二维列表（list of lists）来表示它：

BOARD_SIZE = 4 board = [[0] * BOARD_SIZE for _ in range(BOARD_SIZE)]

这行代码创建了一个4行4列，所有元素初始值都为0的矩阵。为什么选择二维列表而不是一维列表或者NumPy数组？对于2048这种规模的项目，二维列表是最直观、最符合人类思维（行和列）且无需额外依赖的选择。board[r][c]就能直接访问第r行、第c列的格子，非常清晰。虽然NumPy在数值计算上效率更高，但对于一个4x4的网格，其性能优势可以忽略不计，而引入额外依赖反而增加了项目的复杂度。

这里有一个关键细节：注意我们使用的是列表推导式[[0] * BOARD_SIZE for _ in range(BOARD_SIZE)]，而不是[[0] * BOARD_SIZE] * BOARD_SIZE。后者是初学者常犯的错误，它创建了BOARD_SIZE个对同一个列表的引用。修改board[0][0]会导致board[1][0]、board[2][0]等全部被修改，因为它们指向的是同一个内存地址！而列表推导式确保了每一行都是独立创建的新列表，避免了这种副作用。

3.2 全局状态变量：分数与游戏结束标志

除了棋盘本身，我们还需要跟踪两个重要的游戏状态：

score = 0 # 累计得分 game_over = False # 游戏是否结束

将score和game_over设为全局变量，在小型项目中是可行的，因为它简单直接，所有函数都能方便地访问和修改它们。但在更大型、更结构化的项目中，更好的做法是创建一个GameState类，将这些状态封装为实例属性。这样做的好处是状态管理更清晰，避免了全局变量的潜在混乱，也更容易进行单元测试。不过对于我们的2048入门项目，全局变量的简洁性更有优势。

初始化棋盘：游戏开始时，棋盘不是完全空白的。按照2048的规则，我们需要在随机两个空白位置生成初始方块（通常是2，小概率是4）。这通过一个reset_game函数来实现，它会在游戏开始和重新开始时被调用。

def reset_game(): global board, score, game_over board = [[0] * BOARD_SIZE for _ in range(BOARD_SIZE)] score = 0 game_over = False add_new_tile(board) # 添加第一个方块 add_new_tile(board) # 添加第二个方块

4. 核心游戏逻辑：移动与合并算法深度剖析

这是整个游戏最核心、最有趣的部分。2048的规则是：每次向一个方向滑动，所有方块会朝该方向移动直到被棋盘边界或其他方块挡住。如果两个相同数字的方块在移动方向上相邻，它们会合并成一个数值翻倍的新方块，合并的数值会计入分数。

4.1 向左移动的算法实现与思想

我们以move_left函数为例，深入拆解其算法步骤。理解了这个方向，其他三个方向只是在此基础上进行坐标变换。

def move_left(current_board): global score moved = False # 1. 创建新棋盘副本，避免直接修改原数据 new_board = [[0] * BOARD_SIZE for _ in range(BOARD_SIZE)] for r in range(BOARD_SIZE): # 遍历每一行 # 2. 提取当前行所有非零元素（即“压实”操作） row_data = [tile for tile in current_board[r] if tile != 0] merged_row = [] i = 0 # 3. 合并相邻的相同数字 while i < len(row_data): if i + 1 < len(row_data) and row_data[i] == row_data[i + 1]: merged_value = row_data[i] * 2 merged_row.append(merged_value) score += merged_value # 加分 i += 2 # 关键！跳过已合并的下一项 moved = True else: merged_row.append(row_data[i]) i += 1 # 4. 将合并后的行填充回新棋盘的左侧 for c in range(len(merged_row)): new_board[r][c] = merged_row[c] # 5. 判断棋盘状态是否真的发生了变化 if not moved: for r in range(BOARD_SIZE): for c in range(BOARD_SIZE): if current_board[r][c] != new_board[r][c]: moved = True break if moved: break return new_board, moved

算法步骤解析：

1. 创建副本：首先创建一个全新的4x4零矩阵new_board。这是一个非常重要的设计模式。所有移动和合并操作都在这个副本上进行，最后再决定是否用副本替换原棋盘。这样做的好处是，如果玩家的操作是无效的（比如所有方块已经在最左边，再次按左键），我们可以通过比较new_board和current_board发现没有变化，从而拒绝这次操作，不添加新方块。这保证了游戏状态的原子性和一致性。
2. “压实”处理：对于每一行，我们先用列表推导式[tile for tile in current_board[r] if tile != 0]提取出所有非零数字。这个操作模拟了方块“向左滑动”的效果，去除了中间所有的空白格。例如，行[2, 0, 2, 4]经过此步变为[2, 2, 4]。
3. 合并相邻相同项：这是算法的核心。我们使用一个while循环遍历row_data。如果当前元素row_data[i]和下一个元素row_data[i+1]相等，就合并（数值乘2），将结果加入merged_row，并且i += 2跳过下一个元素。这里i += 2是关键，它确保了“一次移动中，一个方块只能被合并一次”的规则。如果不跳过，像[2, 2, 2]这样的行会被错误地合并成[8]（先合并前两个为4，再和第三个2合并为8），而正确结果应该是[4, 2]（只合并前两个）。
4. 对齐填充：将合并后的列表merged_row从左到右填充回new_board的对应行。因为列表本身已经“压实”并合并，直接按顺序填充就实现了左对齐。
5. 状态变化检测：最后，我们需要判断这次操作是否真的改变了棋盘。即使没有发生合并（moved标志在合并循环中可能仍为False），方块也可能因为“压实”而改变了位置（例如[0, 2, 0, 4]变成了[2, 4, 0, 0]）。所以我们需要逐格比较新旧棋盘。这个moved布尔值至关重要，它决定了本次操作后是否应该调用add_new_tile来生成新方块。

4.2 其他三个方向的算法变体

理解了向左移动，其他方向就是对这个算法的“旋转”和“镜像”处理。

• 向右移动 (move_right)：思路是先将每一行反转，然后应用和move_left完全相同的逻辑，最后将结果再反转回来，并右对齐填充。row_data.reverse()和merged_row.reverse()这两步反转是实现右移的精髓。
• 向上移动 (move_up)：将行操作改为列操作。我们需要遍历每一列（for c in range(BOARD_SIZE)），然后通过列表推导式[current_board[r][c] for r in range(BOARD_SIZE) if current_board[r][c] != 0]提取该列的非零元素。后续的合并逻辑与move_left完全一致，只是填充时是按行索引r来填充new_board[r][c]。
• 向下移动 (move_down)：这是move_up和move_right的结合体。对每一列，先提取非零元素，然后反转，应用合并逻辑，再将结果反转回来，最后从下往上（BOARD_SIZE - 1 - r）填充。

一个重要的优化思考：你有没有发现这四个函数有大量重复代码？实际上，我们可以只写一个通用的move函数，通过参数指定方向，然后通过坐标变换矩阵来统一处理。这对于代码的简洁性和可维护性是大有裨益的。例如，你可以定义一个方向向量，然后通过转置棋盘、反转行等操作，将其他方向的移动都转化为“向左移动”来处理。这是算法设计上的一种抽象，在理解了基础实现后，非常值得尝试重构。

5. 游戏状态判定与用户交互流程

5.1 如何判断游戏结束？

游戏结束的条件很明确：棋盘上没有空白格子，并且没有任何两个相邻的（上下或左右）方块数字相同。can_move函数就是用来判断这个条件的。

def can_move(current_board): # 条件一：检查是否有空白格 empty_cells = get_empty_cells(current_board) if empty_cells: # 列表非空即为True return True # 条件二：棋盘已满，检查是否有相邻相同数字 for r in range(BOARD_SIZE): for c in range(BOARD_SIZE): # 检查右侧邻居 if c < BOARD_SIZE - 1 and current_board[r][c] == current_board[r][c + 1]: return True # 检查下方邻居 if r < BOARD_SIZE - 1 and current_board[r][c] == current_board[r + 1][c]: return True # 两个条件都不满足，则无法移动 return False

这个函数的逻辑非常高效。它优先检查是否有空白格，只要有，游戏肯定能继续（至少可以等待新方块生成）。只有当棋盘全满时，才需要进行O(n²)的遍历来检查相邻关系。注意，我们只需要检查每个方块的右侧和下方邻居。因为对于任意一对相邻的相同方块，总有一个是另一个的右侧或下方邻居。检查左上和左下方是冗余的，会重复判断同一对方块。

5.2 Pygame事件处理：连接玩家与游戏逻辑

游戏逻辑是静态的，需要事件处理来让它“活”起来。Pygame的主循环不断从事件队列中获取用户输入。

running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False pygame.quit() sys.exit() if not game_over: if event.type == pygame.KEYDOWN: new_board = None moved = False if event.key == pygame.K_LEFT: new_board, moved = move_left(board) elif event.key == pygame.K_RIGHT: new_board, moved = move_right(board) elif event.key == pygame.K_UP: new_board, moved = move_up(board) elif event.key == pygame.K_DOWN: new_board, moved = move_down(board) # 关键判断：只有棋盘真正发生了变化，才更新状态并添加新方块 if moved: board = new_board add_new_tile(board) # 每次有效移动后，检查游戏是否结束 if not can_move(board): game_over = True else: # 游戏结束状态，只响应‘R’键重新开始 if event.type == pygame.KEYDOWN and event.key == pygame.K_r: reset_game()

这段事件处理代码体现了清晰的状态机思想。游戏有两种主要状态：game_over == False（进行中）和game_over == True（已结束）。在不同状态下，程序对同一事件（如按键）的响应是不同的。进行中时，方向键触发移动逻辑；已结束时，方向键被忽略，只有R键能触发重置。这种设计保证了用户体验的合理性。

实操心得：在移动逻辑中，if moved:这个判断是防止无效操作的关键。想象一下，如果所有方块已经紧贴左侧，玩家再次按下左键，此时move_left函数返回的new_board将与原board完全相同，moved为False。如果没有这个判断，程序依然会执行add_new_tile(board)，这违反了2048的规则（只有有效移动后才生成新方块）。这个细节处理体现了对游戏规则理解的深度。

6. 视觉呈现与渲染系统设计

6.1 色彩系统与棋盘绘制

游戏的视觉吸引力很大程度上来自精心设计的色彩。代码中定义的COLOR_MAP字典为每个数字赋予了特定的RGB颜色。从0（空白）的浅米黄(204, 192, 179)，到2的(238, 228, 218)，4的(237, 224, 200)，一直到2048的深黄色(237, 188, 39)，形成了一个温暖、渐进的色系。这种设计不仅美观，更重要的是提供了直观的视觉反馈——数值越大，颜色越深越醒目，让玩家能快速感知棋盘局势。

draw_board函数负责将抽象的board数据转化为屏幕上的像素。其核心是两层循环遍历所有格子，计算每个格子的屏幕坐标(x, y)，然后绘制矩形和数字。

def draw_board(current_board): screen.fill(GRAY) # 填充背景色 for r in range(BOARD_SIZE): for c in range(BOARD_SIZE): # 计算格子左上角像素坐标 x = MARGIN + c * (TILE_SIZE + MARGIN) y = SCORE_HEIGHT + MARGIN + r * (TILE_SIZE + MARGIN) tile_value = current_board[r][c] tile_color = COLOR_MAP.get(tile_value, BLACK) # 获取颜色，默认为黑 pygame.draw.rect(screen, tile_color, (x, y, TILE_SIZE, TILE_SIZE)) if tile_value != 0: # 渲染数字文本 text_surface = font.render(str(tile_value), True, BLACK) # 获取文本矩形，并设置其中心点为格子中心 text_rect = text_surface.get_rect(center=(x + TILE_SIZE // 2, y + TILE_SIZE // 2)) screen.blit(text_surface, text_rect)

坐标计算解析：x = MARGIN + c * (TILE_SIZE + MARGIN)。MARGIN是格子间的间距。第一个格子的c=0，所以x = MARGIN，即左边距。第二个格子c=1，x = MARGIN + 1*(TILE_SIZE+MARGIN)，也就是第一个格子的右边界（MARGIN+TILE_SIZE）再加上一个间距MARGIN。y坐标的计算同理，只是额外加上了SCORE_HEIGHT为顶部的分数显示区留出空间。

字体处理的容错设计：原始代码中加载中文字体的部分体现了一个优秀程序员应有的防御性编程思维。它首先尝试加载指定的字体文件（如simhei.ttf），如果失败（文件不存在或格式错误），则捕获异常并回退到使用Pygame的默认字体（pygame.font.Font(None, size)）。同时，它还尝试渲染一个中文字符来测试默认字体是否支持中文，并给出相应的警告。这种“优雅降级”的策略确保了程序在不同操作系统和环境下的最大兼容性，不会因为一个字体问题就导致崩溃。

6.2 游戏结束画面的实现技巧

当game_over为True时，我们需要绘制一个覆盖层来提示玩家。draw_game_over函数展示了如何创建一个半透明的覆盖层：

def draw_game_over(): # 创建一个带透明通道（SRCALPHA）的Surface，尺寸与游戏区域一致 overlay = pygame.Surface((GAME_WIDTH, GAME_HEIGHT), pygame.SRCALPHA) overlay.fill((0, 0, 0, 180)) # RGBA，A=180表示半透明 screen.blit(overlay, (0, 0)) # 将覆盖层绘制到屏幕上 # 在覆盖层上绘制结束文字和提示 game_over_text = game_over_font.render("游戏结束", True, WHITE) # ... 计算位置并绘制 ...

这里的关键是pygame.SRCALPHA参数，它告诉Pygame这个Surface支持每像素透明度。fill((0,0,0,180))中的180是Alpha值（0完全透明，255完全不透明），这样就得到了一个半透明的黑色蒙版。先绘制这个蒙版，再在上面画文字，就能实现“变暗背景，突出提示”的视觉效果，比直接画一个不透明的矩形要优雅得多。

7. 项目扩展与优化思路

一个基础版本完成后，你可以从多个角度对其进行扩展和优化，这能极大提升你的工程能力。

7.1 添加动画效果

目前的版本中，方块的移动和合并是瞬间完成的，缺乏视觉反馈。我们可以为每个方块添加位置和缩放动画。

• 思路：不再直接使用board来绘制，而是为每个格子维护一个Tile对象。这个对象包含其当前值、目标值、当前屏幕坐标、目标坐标等信息。在移动发生时，只更新board的逻辑状态和Tile的目标值、目标坐标。在主循环的渲染部分，每个Tile的当前坐标会以一定的速度（如线性插值Lerp）向目标坐标靠近，从而实现平滑移动。合并动画可以表现为一个方块逐渐缩小消失，另一个方块短暂放大再恢复。
• 挑战：这需要引入更复杂的状态管理和每帧更新逻辑，但能显著提升游戏质感。

7.2 实现分数存档与历史最高分

增加持久化存储，让玩家的成就得以保留。

• 实现：可以使用Python内置的json模块。在游戏初始化时，尝试从本地文件（如highscore.json）读取历史最高分。每次游戏结束时，如果当前分数score高于记录，就更新文件。你可以在draw_score函数旁再绘制一个“最高分：XXX”的文本。
• 代码片段：

  import json HIGHSCORE_FILE = "highscore.json" def load_highscore(): try: with open(HIGHSCORE_FILE, 'r') as f: return json.load(f).get('highscore', 0) except FileNotFoundError: return 0 def save_highscore(new_score): with open(HIGHSCORE_FILE, 'w') as f: json.dump({'highscore': new_score}, f)

7.3 代码重构：使用面向对象编程

如前所述，将全局状态和函数重组到一个Game类中，是迈向更规范软件工程的第一步。

• 示例：

  class Game2048: def __init__(self): self.board_size = 4 self.board = [] self.score = 0 self.game_over = False self.high_score = load_highscore() self.reset_game() def reset_game(self): self.board = [[0]*self.board_size for _ in range(self.board_size)] self.score = 0 self.game_over = False self.add_new_tile() self.add_new_tile() def move(self, direction): # 将四个方向的移动逻辑整合，通过参数判断 pass # ... 其他方法 ...

• 好处：状态封装更清晰，减少了全局变量的使用。更容易创建多个游戏实例（虽然2048通常不需要），也方便进行单元测试（例如，可以单独测试move方法而不启动整个Pygame循环）。

7.4 性能分析与优化点

对于4x4的棋盘，当前算法的性能完全足够。但如果棋盘变大（比如10x10），或者需要实现复杂的AI来玩这个游戏（需要模拟大量未来步骤），性能就可能成为瓶颈。

• 热点分析：最耗时的操作可能是can_move中的双重循环遍历，以及每次移动时创建新的棋盘副本new_board。
• 优化思路：
  1. 位运算表示：对于2048，每个格子上的数字都是2的幂。可以用一个16位的整数（如果棋盘是4x4）的每一位来表示一个格子的指数。例如，0表示空格，1表示2，2表示4，以此类推。这样，整个棋盘可以用一个64位整数表示，移动和合并操作可以通过位掩码和移位操作高效完成，速度极快。
  2. 预计算移动表：由于棋盘状态是离散的（每个格子只有有限种可能的值），可以预先计算所有可能的行/列状态在某个方向移动后的结果，存储在一个查找表中。游戏运行时，只需要查表即可，这是许多高性能2048 AI的基础。
  3. 避免全盘复制：在移动函数中，可以尝试在原棋盘上直接操作，或者使用更高效的数据结构如array或numpy.ndarray。

8. 常见问题排查与调试技巧

在开发过程中，你肯定会遇到各种问题。这里记录一些我踩过的坑和解决方法。

8.1 方块移动或合并逻辑错误

• 症状：按下方向键后，方块行为异常，比如该合并的没合并，不该合并的合并了，或者移动方向不对。
• 排查步骤：
  1. 单元测试：不要依赖图形界面来调试核心逻辑。为move_left等函数编写简单的单元测试。例如，创建一个已知的棋盘状态test_board = [[2,2,0,0], [4,0,4,0], ...]，调用函数，然后打印或断言输出结果是否符合预期。
  2. 打印中间状态：在移动函数的关键步骤插入print语句，输出row_data、merged_row等中间变量的值，看数据转换是否正确。
  3. 重点检查合并循环：确保i += 2的逻辑正确，防止多次合并。用[2,2,2]这样的行进行测试，结果应为[4,2]而非[8]。

8.2 游戏无法结束或过早结束

• 症状：棋盘明明还有空格或可以合并，游戏却显示结束；或者棋盘已满且无法移动，游戏却不结束。
• 排查步骤：
  1. 验证can_move函数：手动构造几个测试用例：全满但有一对可合并的棋盘（应返回True），全满且无可合并的棋盘（应返回False），有空白格的棋盘（应返回True）。在函数开头和结尾打印返回值进行验证。
  2. 检查game_over标志的触发时机：确保只在if moved:分支内，且移动后立即调用if not can_move(board):来设置game_over = True。检查是否有其他地方错误地修改了game_over。
  3. 检查add_new_tile的调用：确保只在有效移动（moved == True）后才添加新方块。无效移动后添加新方块会导致游戏过早变得无法进行。

8.3 画面闪烁或渲染问题

• 症状：屏幕闪烁，或者方块、文字显示不全、位置不对。
• 排查步骤：
  1. 确保每次循环都重绘背景：screen.fill(GRAY)必须在draw_board的开始处调用，以清除上一帧的画面。
  2. 检查坐标计算：仔细核对draw_board中x和y的计算公式。确保MARGIN、TILE_SIZE、SCORE_HEIGHT等常量的值设置合理，不会导致格子画出屏幕外。
  3. 字体渲染问题：如果文字不显示或显示乱码，首先检查字体文件路径是否正确。使用pygame.font.get_fonts()打印系统可用字体列表，选择一个可靠的。对于中文，确保字体文件确实包含中文字形。
  4. 双缓冲：Pygame默认使用双缓冲，一般不会闪烁。如果仍有问题，可以尝试在创建屏幕时使用pygame.DOUBLEBUF标志：screen = pygame.display.set_mode((W, H), pygame.DOUBLEBUF)。

8.4 程序无响应或卡顿

• 症状：窗口卡住，或者操作响应迟钝。
• 排查步骤：
  1. 检查事件循环：确保pygame.event.get()在每次主循环迭代中都被调用。如果没有它，系统事件会堆积，导致窗口无法响应关闭等操作。
  2. 避免阻塞操作：不要在游戏主循环中执行耗时很长的操作（如大量文件IO、复杂网络请求）。如果必须做，考虑使用多线程或将任务拆分到多帧中完成。
  3. 限制帧率：当前代码没有限制帧率，循环会以尽可能快的速度运行，可能浪费CPU资源。可以在主循环末尾添加pygame.time.Clock().tick(60)来将帧率限制在60 FPS，这通常能提供流畅的体验并降低CPU占用。

开发这样一个完整的项目，从环境搭建到逻辑实现，再到视觉呈现和问题排查，是一个系统工程的小型演练。最重要的是理解每一步背后的“为什么”，而不仅仅是“怎么做”。当你能够流畅地解释为什么用二维列表、为什么移动算法里要i+=2、为什么需要moved标志时，你对编程和游戏开发的理解就已经上了一个台阶。这个项目代码是一个很好的起点，但不要止步于此，尝试去实现上面提到的扩展功能，甚至自己从头重写一遍，你会收获更多。