2048这个游戏，看着就是个4x4的格子，规则一句话能讲完，但想亲手合成一个8192，纯靠人肉操作基本都是地狱级难度。我试过网上各种“左上右下”玄学轨迹，最高也就在两三千分打转，后来索性把这事直接交给程序，写了一个2048游戏AI出来。跑起来之后别说8192，只要初始运气不算太差，上万分都很常见，经常能一路合出16384。这篇文章就把整个思路、关键算法、调参过程和踩过的坑全部摊开讲清楚，希望能帮你少走弯路。
如果你也想给自己的项目加一个“会玩2048的AI”，或者单纯想看一个传统启发式搜索怎么吊打人类操作，这篇文章都适合你。我尽量不堆公式，用能直接抄作业的方式来讲。
1. 整体设计与思路拆解
1.1 先搞清楚AI到底在解决什么问题
2048本质上是一个完全信息博弈：棋盘上所有数字都能看到，新方块出现的规则也完全明确，要么是2要么是4，概率大约是9比1。既然信息完全透明，那AI要做的就不是“猜测”，而是在每一步选择一个“期望收益最高”的方向。
这个问题的难点在于，玩家每走一步，棋盘上都会随机冒出一个新方块。你没法精确预测下一步棋盘是什么样，只能估计“平均来看哪个方向最赚”。这跟下棋、打扑克还不太一样，它更像是在一个随机环境里做决策。
我在最早实现时踩过一个典型误区：想用蒙特卡洛树搜，也就是随机模拟大量对局，再挑胜率最高的走法。理论上可行，但2048的状态空间比围棋小得多，可用纯随机模拟特别不准，模拟几千局也经常看不出哪个方向更优。后来我才确定主方案：期望最大化搜索 + 启发式评估。
1.2 为什么选期望搜索而不是暴力穷举
暴力穷举在2048面前基本行不通。每个棋盘平均有几十个空格，每个方向会产生新布局，再加上新方块2/4两种可能，搜索树会迅速爆炸。如果不做限制，几层之后就是天文数字。
期望搜索的思路是“带上概率去搜索”：AI走一步，玩家（随机方块）会以一定概率回应，AI再走，再回应……每次评估时把“AI的收益”和“随机方块出现的概率”同时考虑进去。这样做有两个很实际的好处：
- 可以看到未来几步的连锁反应，而不是只看当前棋盘有多“顺眼”。
- 可以把偶然出现的烂运气（比如随机方块出现在角落）纳入计算，决策更稳。
我用一个生活化类比来解释：你开车到路口，不知道下一秒会不会变灯，但你不会只根据当前一秒是绿灯就猛踩油门，你会综合考虑“如果马上变灯我该怎么停”。期望搜索干的就是这个事。
1.3 启发式评估函数是整台引擎的心脏
搜索只是“看得远”，真正决定一个方向好不好，还得靠评估函数来打分。一个典型的2048 AI评估函数，会同时关注四件事：
- 空位数：空格越多，灵活度越高，越不容易憋死。
- 平滑度：相邻方块差值越小，合并潜力越大。
- 单调性：数字沿一个方向递增/递减，能防止小数字被大数字堵死。
- 最大值位置：最大值最好贴边或贴角，这样它周围只会有有限几个方向需要处理。
这些不是玄学，每一个都对应真实对局中的死因。比如很多玩家卡死，是因为大数字在中间，四周全是小格子，任何一个方向移动都可能把局面搅乱。如果你能让大数字稳定在角落，整个棋盘就能围绕它规划。
评估函数的设计直接决定AI能不能上8192，我见过不少AI卡在4096附近，基本就是只看了空格数，完全没管单调性和最大值位置。
2. 核心细节解析与实操要点
2.1 评估函数每一项的权重怎么定
网上很多玩具AI会把评估函数写成：
score = 空位数 * 100 + 平滑度 * 10 - 单调性惩罚 * 50这种写法的确能跑，但想冲高分会很难受。我的经验是，权重必须量化，不能拍脑袋。下面是我调过的几组关键参数：
| 评估项 | 作用 | 权重方向 | 调参经验 |
|---|---|---|---|
| 空位数 | 避免堵死 | 正向加分 | 权重太高会让AI只求空格多，不敢合并，容易变成“慢性死亡” |
| 平滑度 | 保持合并潜力 | 正向加分 | 适度高权重能显著降低散乱局势 |
| 单调性 | 防止数字倒挂 | 负向惩罚 | 高权重容易导致AI只会往一个方向推，风险很大 |
| 最大值贴角 | 让大数字稳定 | 正向加分 | 权重略低一些，因为贴角之后还要靠其它项辅助 |
| 分数收益 | 实际得分 | 正向加分 | 不宜过高，否则AI为了眼前分数牺牲布局 |
你可以理解成在训练一个小型“择偶标准”，每一项都重要，但不能让某一项独大。我常用的做法是：先在固定深度（比如3层）下跑2000局，统计冲到1024、2048、4096的比例，然后手动微调权重。不要一上来就追求8192，先把1024通关率稳定住。
2.2 期望搜索的深度和剪枝策略
期望搜索每多一层，计算量就翻好几倍。我实测下来，深度3到5是性价比最高的区间。再深的话，单步决策时间可能超过500毫秒，在实时游戏里会显得很迟钝。
剪枝这块有几条很实用的经验：
- 分支降载：每个方向尝试后，如果棋盘没有变化，直接走。无效方向会极大浪费搜索资源。
- 概率过滤：随机方块出现时，2和4的概率是9比1，计算代价时不用等权。宁可多算2的情况，少算4的情况。
- 上限截断：搜索中如果某条线的评估分数已明显低于当前最优，提前放弃。
- 空位优先：空格越少，说明局面越危险，这时候搜索深度可以适当增加，优先找出逃生路线。
还有一个细节：在期望搜索里，随机节点不是“选择最优”，而是“计算期望”。也就是说，一个新2或新4落在哪里，都要加权算进去，而不是只考虑最坏情况。这让AI决策更稳，但也更耗计算。实际实现时，我通常会把所有可能的新方块位置采样出来，而不是全部枚举（比如只随机取5到8个格子），速度有明显提升，结果差别不大。
2.3 棋盘与移动逻辑的实现细节
AI底层一定是纯逻辑棋盘，不依赖图形界面。我来描述一下核心：
- 棋盘用4x4的二维数组，空位用0表示。
- 移动操作可以抽象成四个方向，但更优雅的做法是只写一个“向左移动”的通用函数，其他三个方向通过旋转矩阵复用。
- 合并逻辑要严格“先移动，再合并，再移动”，否则会出现不该有的连续合并。
我自己在写的时候吃过亏：如果合并后不补一次移动，像2 2 4 4向左就会变成4 8 0 0，这个没问题；但2 2 2 2向左如果只合并一次，会变成4 4 0 0，而正确结果是4 4 0 0，所以其实也还好。真正容易出问题的场景是4 4 8 8，如果不按标准三步走，你会得到8 4 4 8这种完全错误的结果。所以一定得按标准流程来。
建议写四个方向的单元测试，每个方向至少测5组用例，保证移动函数不是“看起来对”。
3. 实操过程与核心环节实现
3.1 一个能跑的AI核心代码骨架
下面是一个简化的Python实现，放在了命令行环境里，不依赖任何深度学习框架，跑起来就能看到AI在4x4棋盘上自我对弈。
import random import math from copy import deepcopy # 棋盘大小 SIZE = 4 # 左上角为 (0,0)，向右为x，向下为y def create_board(): board = [[0] * SIZE for _ in range(SIZE)] add_random_tile(board) add_random_tile(board) return board def add_random_tile(board): empty = [(x, y) for y in range(SIZE) for x in range(SIZE) if board[y][x] == 0] if not empty: return x, y = random.choice(empty) # 2 和 4 的概率比约为 9:1 board[y][x] = 2 if random.random() < 0.9 else 4 def compress(row): # 去掉0，补在后面 new_row = [v for v in row if v != 0] new_row += [0] * (SIZE - len(new_row)) return new_row def merge(row): # 合并相邻相同值，只合并一次 new_row = [] skip = False for i in range(SIZE): if skip: skip = False continue if i + 1 < SIZE and row[i] == row[i + 1]: new_row.append(row[i] * 2) skip = True else: new_row.append(row[i]) new_row += [0] * (SIZE - len(new_row)) return new_row def move_left(board): new_board = [] moved = False for row in board: compressed = compress(row) merged = merge(compressed) new_board.append(merged) if merged != row: moved = True return new_board, moved def rotate(board): # 顺时针旋转90度 return [list(row) for row in zip(*board[::-1])] def move(board, direction): # 统一处理四个方向：旋转到"向左"，移动，再旋转回来 b = deepcopy(board) for _ in range(direction): b = rotate(b) b, moved = move_left(b) for _ in range(4 - direction): b = rotate(b) return b, moved def empty_count(board): return sum(1 for row in board for v in row if v == 0) def smoothness(board): # 相邻格子差越小越平滑 score = 0 for y in range(SIZE): for x in range(SIZE): if x + 1 < SIZE: diff = abs(board[y][x] - board[y][x + 1]) if board[y][x] != 0 and board[y][x + 1] != 0: score -= diff if y + 1 < SIZE: diff = abs(board[y][x] - board[y + 1][x]) if board[y][x] != 0 and board[y + 1][x] != 0: score -= diff return score def monotonicity(board): # 分别检查行和列是否单调递增/递减，取较大值 total = 0 # 行 for row in board: inc = 0 dec = 0 for i in range(SIZE - 1): if row[i] != 0 and row[i + 1] != 0: if row[i] < row[i + 1]: inc += 1 elif row[i] > row[i + 1]: dec += 1 total += max(inc, dec) # 列 for x in range(SIZE): inc = 0 dec = 0 for y in range(SIZE - 1): if board[y][x] != 0 and board[y + 1][x] != 0: if board[y][x] < board[y + 1][x]: inc += 1 elif board[y][x] > board[y + 1][x]: dec += 1 total += max(inc, dec) return total def max_corner_bonus(board): # 最大值在角落时加分 max_val = max(max(row) for row in board) corners = [board[0][0], board[0][SIZE - 1], board[SIZE - 1][0], board[SIZE - 1][SIZE - 1]] if max_val in corners: return 20 return 0 def evaluate(board): # 组合各维度评分 empty = empty_count(board) * 60 smooth = smoothness(board) * 8 mono = monotonicity(board) * 25 corner = max_corner_bonus(board) * 20 return empty + smooth + mono + corner def expectimax(board, depth, is_ai_turn): if depth == 0: return evaluate(board) if is_ai_turn: best = -math.inf for d in range(4): new_board, moved = move(board, d) if not moved: continue score = expectimax(new_board, depth - 1, False) best = max(best, score) if best == -math.inf: return evaluate(board) return best else: # 玩家回合，随机方块出现，计算期望值 empty = [(x, y) for y in range(SIZE) for x in range(SIZE) if board[y][x] == 0] if not empty: return evaluate(board) # 采样部分空格，减少计算量 sample_size = min(6, len(empty)) sample = random.sample(empty, sample_size) total = 0 for x, y in sample: for val, prob in [(2, 0.9), (4, 0.1)]: new_board = deepcopy(board) new_board[y][x] = val total += prob * expectimax(new_board, depth - 1, True) return total / len(sample) def get_best_move(board, depth=3): best_score = -math.inf best_move = 0 for d in range(4): new_board, moved = move(board, d) if not moved: continue score = expectimax(new_board, depth, False) if score > best_score: best_score = score best_move = d return best_move这段代码里，expectimax里的随机节点用了采样，而不是枚举全部空格，主要是因为全枚举会让深度3的搜索在树莓派这种低性能设备上跑到秒级，采样到6个格子后，单步决策能压在150毫秒以内，棋盘表现几乎没区别。
3.2 如何让AI自动跑完整局
有了核心函数，跑完整局很简单。模拟一次对局，每次调用get_best_move得到方向，然后执行移动，再调用add_random_tile模拟新方块出现，直到无法移动为止。用下面这段驱动代码：
def run_game(depth=3): board = create_board() score = 0 max_tile = 0 while True: move_dir = get_best_move(board, depth) new_board, moved = move(board, move_dir) if not moved: break board = new_board add_random_tile(board) score += sum(sum(row) for row in board) # 简化计分 max_tile = max(max(row) for row in board) if max_tile >= 8192: print("达到8192！") break return max_tile, score for i in range(10): mt, sc = run_game(depth=3) print(f"第{i + 1}局：最高方块 {mt}，分数 {sc}")这是我最早期的版本，只关注能否稳定达到8192，计分逻辑也比较粗糙，只看最高方块。实际跑下来，深度3时8192的通过率大概在70%左右，深度4能到90%以上，但单步耗时会涨到约300毫秒。
如果你的目标是更高方块而不是分数，这个简化版已经足够参考。如果你想刷高分而不是只看最高值，就要把评估函数里的“分数收益”加进去，并在期望搜索里把每次合并产生的实际分数作为奖励项。
3.3 加速调试：命令行可视化
AI调试时最痛苦的是看不到棋盘状态。我的做法是加一个简单的终端打印：
def print_board(board): for row in board: print("\t".join(str(v) if v else "." for v in row)) print() # 在AI决策前调用 # print_board(board) # print("AI选择方向：", ["左", "下", "右", "上"][move_dir])这样就能实时看到AI是不是总在下同一个方向，或者哪个局部让AI陷入了“左右横跳”的循环。我经历过最典型的调试场景，是AI在某个状态反复左、右、左、右，分数不升但空格慢慢变少，问题几乎都出在平滑度权重太高，AI觉得左右两边一样好，没有长远规划。
4. 常见问题与排查技巧实录
4.1 卡在4096上不去
这是最常见的瓶颈。AI能稳定冲上2048或4096，但很难突破8192。我排查后发现，90%的原因是评估函数里没有让大数字固定在一个角落，尤其是最大值在中间时，AI下一步会非常迷茫，经常做出拆散大数字相邻结构的操作。
处理办法很简单：在评估函数里增加“最大值是否在角落”的强奖励，并且对“最大值旁边是否有同方向递增的数列”也加分。比如最大值在左上角，就希望第一行和第一列的数字沿远离方向递减。这样AI会主动把高数字往角落送。
4.2 搜索速度太慢
如果你发现AI单步决策超过1秒，先检查是不是随机节点枚举了所有空格。4x4棋盘前期空格可能只有10到15个，每个空格还有2种取值，深度3就变成10乘2乘4乘10乘2…直接爆炸。
解决方案我前面提过，就是采样。用随机采样替代全枚举后，速度可以提升5到10倍。另外，移动函数中复制棋盘开销很大，可以改成原地复制，或者在传入时直接操作再回滚。这种微观优化在深度4以上尤其重要。
4.3 无效方向导致死局
AI选出的方向有时候会“动都不动”，这种方向必须直接跳过，否则会让AI以为自己获得了新状态，实际棋盘没变化，白白浪费一个回合。这种情况在游戏后期特别致命，因为空格少，四个方向里会有两个方向完全动不了。我的建议是，在任何搜索和决策前，先过滤掉moved == False的方向。
4.4 随机性带来的心态问题
2048自带随机性，AI也不是100%稳赢。我做过一个压力测试：用同一套参数跑1000局，最高达到8192的比例大约是86%，剩下14%会在1024或4096附近翻车，原因往往是最开始连续几个4，或者AI在前几步没找到合适的角落策略。
如果你想让AI更稳，一个有效手段是做“开局热身”：前几步强制执行“往同一个方向推到底”，把大数字定在角落，然后再启动完整搜索。这个技巧听上去很土，但实测能把8192通过率提升三到五个百分点。
4.5 集成到浏览器游戏中的适配问题
很多同学想让AI直接操作网页版2048，这就需要做三件事：
- 读取棋盘数字：可以手动截图，也可以读DOM元素里的数值。
- 发送按键指令：用浏览器自动化脚本模拟键盘事件，或者用系统级按键模拟。
- 时钟同步：AI计算需要时间，要保证在游戏动画结束前给出下一步，否则操作会卡住。
我自己的做法是写了一个简单的浏览器辅助脚本，用JavaScript读取所有格子文本，转换成4x4数组，然后调用一个本地的AI服务接口，拿到方向后再用KeyboardEvent模拟按键。这里有个坑：2048游戏本身有动画，按键频率太快会漏掉输入。稳妥做法是每次按键后等待一个固定间隔，比如150毫秒，让动画完成再发下一个指令。
5. 从AI到辅助工具：脚本化与实战扩展
5.1 做一个2048辅助工具，而不是独立AI
很多人要的不是一个能玩的AI，而是一个“辅助工具”：AI给出建议方向，人自己操作。这比全自动脚本更有趣，也更适合直播或挑战视频。实现上很简单，把get_best_move的返回值映射成文字提示，叠加在游戏画面上，或者输出到终端即可。
我见过一些做得好的辅助工具，会把四个方向的推荐理由也显示出来，比如“向左：平滑度+8，空格+10”、“向下：大数字贴角+40”。这种透明度极高的提示，反而能帮玩家提高自己的操作水平。你甚至可以反向学习AI的决策，慢慢摆脱辅助。
如果你要做一个类似“2048游戏脚本”的东西，其实核心还是我前面讲的搜索和评估。脚本只是外壳，真正的灵魂在决策算法。
5.2 如何用AI做游戏测试
搜索热词里有“如何让AI测试游戏”，2048是个特别合适的测试对象。因为它的状态空间不算大，可以自动跑大量对局来验证规则、平衡性和难度曲线。
你可以把AI当成一个自动化测试器：
- 回归测试：每次修改评估函数后，自动跑500局，统计最高方块分布，确认没回退。
- 单元测试：每个方向都跑固定局面，检查移动和合并逻辑。
- 压力测试：把初始方块全部设成4，看AI能在多恶劣的环境下坚持多久。
- 数据收集：记录每步决策前的搜索深度、候选方向数量、期望分数，用来分析AI是否存在“左右手互搏”的行为。
我建议把跑分脚本整理成一个持续集成流程，每次代码改动后自动跑全套测试。这样你调参的时候才敢放开手改，而不是怕改坏了没法回头。
5.3 关于深度学习和更高级的路线
我开头就说了，想要稳定上8192，启发式搜索就够用。但如果你想做更炫酷的东西，或者想挑战16384、32768，那可以考虑训练一个神经网络策略模型。常见路线有：
- 强化学习：用一个深度网络直接预测每个方向的价值，通过自我博弈不断更新。
- 监督学习：先让期望搜索生成大量“状态-最优动作”数据，再用神经网络拟合。
- 蒙特卡洛树搜索加强化学习：经典AlphaZero风格，但2048的随机性比较大，需要做好概率建模。
不过说实话，这些方向复杂度会上一个台阶。我的建议是先把期望搜索做到极致，再去碰神经网络。因为深度学习的模型解释性差，排错困难，一旦分数上不去，你很难断定是网络结构问题、奖励设计问题还是数据问题。
一段额外的心得
写这个2048游戏AI的过程，给我的最大体会是：AI不一定要多复杂，关键是抓住问题的结构。2048最大的结构就是“随机性”和“合并潜力”，只要把这两点量化进搜索和评估里，普通笔记本跑一个纯Python脚本就能轻松达到8192。
最后再分享一个小技巧：当你调整评估函数权重时，千万不要只跑一两局就下结论。2048里面运气成分真不小，必须至少跑50局再对比通过率。我早期因为偷懒，把平滑度权重调得特别高，单看几局好像还行，跑了100局才发现8192通过率反而掉了12个百分点。这个教训我一直记着。
如果你也想复现这套方案，建议先从深度2开始，把整个流程跑通，再看AI下棋，等确信没有逻辑错误后再上深度3或4。别一上来就追求高深度，万一移动逻辑有bug，深度越高错得越离谱。祝你能顺利合成属于自己的8192。
