简介：这是一套基于Python开发的大富翁游戏设计源码，覆盖地产买卖、租金收取、随机事件、AI对手等经典玩法，适合Python初学者、游戏开发爱好者及课程设计人群，用于理解桌面游戏逻辑建模、面向对象设计与模块化开发。项目共计26个文件，其中20个py源文件构成核心逻辑，涵盖游戏初始化、玩家移动、地产交易、AI对手行为、事件触发、地图与界面交互等模块；2个JSON配置负责游戏规则、地图与道具参数；2个Excel工作簿用于玩家得分及历史数据管理；另有gitignore与Markdown说明文档，压缩包仅80KB，轻量便携。已有871人学习下载。资源附带完整测试用例（覆盖地图、地产、事件、玩家等模块）、文档说明与VS Code开发配置，可帮助读者快速跑通游戏流程，并参考其单测编写、状态更新与事件驱动思路；项目目录清晰区分源码、配置、文档和测试，便于二次开发与学习。对想用Python完成游戏项目或打磨课程设计作品的人而言，这是一份结构完整、可直接运行并易于扩展的实战范本。

1. 大富翁游戏设计源码：一张棋盘把 Python 的面向对象、事件循环和状态机串成一条线

基于 Python 开发的大富翁游戏设计源码，是课程设计和 Python 入门项目里出现频率极高的一套代码。它之所以被反复拿来练手，是因为大富翁的玩法刚好卡在“脚本写不动、工程又不大”的黄金区间：掷骰子走格子、买地交租、随机事件卡、AI 对手，每一个玩法都对应一个必须亲手处理的编程问题。网上能下载到的源码版本很多，但多数要么只有命令行外壳，要么图形界面漏洞百出。我会把落地路线拆成六步，从棋盘数据结构讲到 Pygame 渲染，再把交易逻辑、AI 和存档串起来。适合刚学完 Python 基础、想用完整项目验证自己水平的读者，也适合需要交课程设计作业的学生参考。

2. 先拆棋盘再写代码：大富翁的地图模型、玩家类与回合状态机

2.1 地图的数据结构：一维格子列表承载环形棋盘

大富翁的地图本质上是一个环形队列，玩家的位置只是一个整数下标。这是整个项目最先要定下来的数学模型。很多人拿到“设计源码”第一反应是先画界面，但界面背后的格子数据才是游戏能玩的前提。

我一般会直接用一个列表，每个元素是字典，把格子的名称、类型、价格、租金都塞进去：

# cell_data.py — 棋盘格子数据，下标即地图上的唯一编号 CELL_DATA = [ {"name": "起点", "type": "START", "price": 0, "rent": 0}, {"name": "北京胡同", "type": "PROPERTY", "price": 600, "rent": 120}, {"name": "机会", "type": "EVENT", "price": 0, "rent": 0}, {"name": "上海弄堂", "type": "PROPERTY", "price": 1000, "rent": 200}, {"name": "税", "type": "TAX", "price": 0, "rent": 150}, {"name": "广州骑楼", "type": "PROPERTY", "price": 1400, "rent": 280}, # ... 剩余格子按同样格式补齐，想加内容就加一行 ]

为什么用字典列表而不是定义一个 Cell 类？因为游戏里格子的差异集中在“类型、价格、租金”这几个字段上，字典在建图和写死数据时读起来最直观，新人照着加一行就能多一块地。等后期需要给不同格子加独有行为时，再给格子加一个 handler 字段，把行为函数挂进去，比一开始就设计抽象类更快落地。

顺带说一句，很多人一上来会想到用邻接矩阵表达棋盘，这在有岔路分支的地图里是合理的。但经典大富翁的走法是纯环形，玩家按下标加骰子数再对总格数取模就够了，用邻接矩阵反而是过度设计。这套线性结构也方便你后续做存档：玩家位置只存一个 int，加载时直接还原。

2.2 玩家类：资金、位置、房产与破产判定放在一起

玩家的状态用类来组织最合适。把和玩家相关的所有字段集中到一处，后续写 UI 时只需要访问 player.money、player.position，不用维护一堆平行列表。平行列表是新手最容易踩的第一个结构性问题——比如分别定义 player1_money、player2_money、player3_money，一旦要加新字段，改起来很痛苦。

# player.py — 玩家实体 class Player: def __init__(self, name, player_id, start_money=1500): self.name = name self.player_id = player_id self.money = start_money self.position = 0 # 当前位置，对应 CELL_DATA 下标 self.properties = [] # 持有的房产下标列表 self.in_jail = False # 是否坐牢 self.jail_rounds = 0 # 剩余坐牢轮数 self.bankrupt = False # 破产标记 def move(self, steps, total_cells): """沿环形地图前进，返回是否路过起点""" old_pos = self.position self.position = (old_pos + steps) % total_cells return self.position < old_pos def pay(self, amount): """扣款，余额不足则标记破产""" self.money -= amount if self.money < 0: self.money = 0 self.bankrupt = True

这里把 move 的返回值定义为“是否路过起点”，方便你在经过起点时发一次工资。pay 方法把负余额直接归零并标记破产，避免后续租金计算时出现负数账目。start_money 默认 1500，是因为经典版大富翁的初始资金设定；如果你想做高难度开局或者测试极端场景，构造时传一个更小的数字就能复现。

把这类小逻辑收敛进类的方法里，游戏主循环会清爽很多。比如破产后的资产清理，你只需要在回合切换处检查 player.bankrupt 再遍历其 properties 释放所有权，不必在每一处扣钱代码里重复判断。

2.3 回合状态机：五个状态把游戏流程定死

没有状态机的大富翁代码，通常会写成一坨 if-else 嵌套，最后谁也改不动。我的做法是定一个简单枚举，把一回合切成五段：开局准备、等待掷骰、移动动画、落地结算、回合收尾。每个状态只做一件事，出 bug 时看当前状态就能定位是渲染问题还是结算问题。

# game_state.py — 回合状态定义 class GameState: INIT = 0 # 开局准备 ROLL = 1 # 等待当前玩家掷骰子 MOVING = 2 # 玩家角色在地图上移动中 SETTLE = 3 # 落地结算：买地/交租/触发事件 END = 4 # 回合收尾，切换下一位玩家

主循环按状态分发任务，而不是在 while 里堆逻辑：

state = GameState.INIT while not game_over: if state == GameState.INIT: setup_players() state = GameState.ROLL elif state == GameState.ROLL: if wait_for_roll(): roll_value = roll_dice() state = GameState.MOVING elif state == GameState.MOVING: move_player_anim() if moving_done(): state = GameState.SETTLE elif state == GameState.SETTLE: settle_cell() state = GameState.END elif state == GameState.END: next_player() state = GameState.ROLL

这套状态机的核心价值是可控。后面加“暂停菜单”“存档界面”也只是往这个循环里插入新状态，不会把原有结构打乱。我见过不少开源项目的大富翁源码翻车，原因几乎都是没做状态机，主循环里塞了十几层条件，加一个功能就要改一大片。状态机虽然前期多写几行，但后期省下的调试时间远超成本。

3. 用 Pygame 把棋盘跑起来：窗口初始化、环形坐标映射与骰子渲染

3.1 环境准备：Python 环境与 Pygame 安装的关键点

先说环境。这个项目我推荐 Python 3.8 及以上版本，配 Pygame 2.x。Windows 用户在 Python 官网下载安装包时，记得勾选 Add Python to PATH，否则会出现“python 不是内部或外部命令”——这是新手第一道门槛。安装命令用 pip：

# 建议用 python -m pip，避免系统装了多版本 Python 时调错 pip python -m pip install pygame --user

验证安装是否可用，直接在命令行执行：

python -c "import pygame; print(pygame.version.ver)"

能打印出 2.x 版本号就说明环境没问题。我习惯加 --user 安装，避免污染系统级 site-packages。如果你电脑上同时存在 3.8 和 3.11 两套 Python，命令里一定要写清楚版本号（比如 py -3.11 -m pip），否则练到一半发现装错的库，回头排查会很折磨。

3.2 棋盘渲染：把一维格子映射到四方环形坐标

Pygame 的窗口是一个屏幕坐标系，左上角是原点，x 向右，y 向下。环形棋盘每边放几个格子没有定论，经典做法是每边 6 个普通格加 4 个角格，总共 28 格。窗口大小我取 760×760，单格 100 像素，视觉上比例合适。

# main.py — 窗口与棋盘常量 import pygame WIDTH, HEIGHT = 760, 760 GRID_SIZE = 100 # 单个格子边长 SIDE_CELLS = 6 # 每边普通格数量 CELL_COUNT = 28 # 总格子数 = 1 + 6 + 1 + 6 + 1 + 6 + 1 + 6

这里的关键是写一个预计算坐标表的函数，把格子下标映射到窗口坐标。预计算而不是实时推导的好处是：地图固定不变，查表一次生成、到处复用，也方便后续手工微调某个角格的视觉位置。

# layout.py — 预生成 28 个格子的左上角坐标 def build_cell_positions(width, height, cell_size): positions = [] # 右下角起点 positions.append((width - cell_size, height - cell_size)) # 下边普通格，从右往左 for i in range(1, SIDE_CELLS + 1): positions.append((width - (i + 1) * cell_size, height - cell_size)) # 左下角 positions.append((0, height - cell_size)) # 左边普通格，从下往上 for i in range(1, SIDE_CELLS + 1): positions.append((0, height - (i + 1) * cell_size)) # 左上角 positions.append((0, 0)) # 上边普通格，从左往右 for i in range(1, SIDE_CELLS + 1): positions.append((i * cell_size, 0)) # 右上角 positions.append((width - cell_size, 0)) # 右边普通格，从上往下 for i in range(1, SIDE_CELLS + 1): positions.append((width - cell_size, i * cell_size)) return positions

这套布局是“右下角起点、逆时针前进”。绘制时遍历 CELL_DATA，按下标查坐标，用不同颜色区分格子类型：地产格我习惯用浅绿色，事件卡橙色，税灰色，起点和监狱用特殊颜色。边框用黑色 2 像素描边，防止同色格子连成一片看不出边界。

绘制函数只需要一个 for 循环：

# 绘制整个棋盘 positions = build_cell_positions(WIDTH, HEIGHT, GRID_SIZE) for idx, pos in enumerate(positions): color = get_cell_color(CELL_DATA[idx]["type"]) pygame.draw.rect(screen, color, (pos[0], pos[1], GRID_SIZE, GRID_SIZE)) pygame.draw.rect(screen, (0, 0, 0), (pos[0], pos[1], GRID_SIZE, GRID_SIZE), 2)

get_cell_color 是一个类型到颜色的映射函数，直接返回 RGB 元组。这里有个容易踩的细节：每次主循环都要重绘画布，所以这个 for 循环必须放在游戏循环内，而不是只画一次——窗口被切换或者被其他窗口遮挡后再回来，内容会全部丢失。

3.3 骰子动画与回合控制：事件循环里最容易被 sleep 拖死的部分

骰子绘制本身很简单：一个圆角矩形加几个圆点。麻烦的是动画手感。很多教程让你用 time.sleep(1) 模拟骰子滚动，但这一睡会把整个事件循环卡死，窗口直接变成“未响应”。正确的做法是记录一个倒计时帧数，每帧更新骰子点数，倒计时结束后才结算移动。

def draw_dice(screen, value, x, y, size=80): """绘制骰子：value 为 1~6 的点数""" pygame.draw.rect(screen, (245, 245, 245), (x, y, size, size), border_radius=10) pygame.draw.rect(screen, (0, 0, 0), (x, y, size, size), 2) # 每个点数对应的圆点相对位置（坐标比例） dot_map = { 1: [(0.5, 0.5)], 2: [(0.25, 0.25), (0.75, 0.75)], 3: [(0.25, 0.25), (0.5, 0.5), (0.75, 0.75)], 4: [(0.25, 0.25), (0.25, 0.75), (0.75, 0.25), (0.75, 0.75)], 5: [(0.25, 0.25), (0.25, 0.75), (0.5, 0.5), (0.75, 0.25), (0.75, 0.75)], 6: [(0.25, 0.25), (0.25, 0.75), (0.5, 0.25), (0.5, 0.75), (0.75, 0.25), (0.75, 0.75)], } for rx, ry in dot_map[value]: cx = x + int(rx * size) cy = y + int(ry * size) pygame.draw.circle(screen, (0, 0, 0), (cx, cy), size // 10)

配合主循环帧数控制：

clock = pygame.time.Clock() running = True roll_countdown = 0 # 骰子动画剩余帧数 while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # 玩家点击骰子区域，且当前处于 ROLL 状态 if event.type == pygame.MOUSEBUTTONDOWN and state == GameState.ROLL: roll_countdown = 20 # 20 帧动画 state = GameState.MOVING if roll_countdown > 0: roll_countdown -= 1 dice_value = random.randint(1, 6) if roll_countdown == 0: step_count = dice_value current_player.move(step_count, CELL_COUNT) # 其余渲染逻辑... pygame.display.flip() clock.tick(30)

这段代码的核心思路是“动画归动画、逻辑归逻辑”：骰子点数在倒计时内不断变化，给玩家肉眼可见的随机感；倒计时归零才真正调用 move，避免动画中途逻辑抢跑。clock.tick(30) 把帧率锁在 30fps，也就是每帧约 33ms，20 帧动画差不多 0.67 秒，手感刚好。

角色移动也走同样的思路。我给 Player 对象加一个 prev_position 记录上一格坐标，移动动画用一个 progress 值从 0 渐变到 1，玩家圆点沿着两格中心点做线性插值。真正的核心数据只有 position 这一个整数，动画只是视觉层，这样调试时你打印玩家位置永远是真值。

4. 让玩法闭环：买地收租、事件卡机制与 AI 对手的决策逻辑

4.1 买地、租金与破产结算：资金流的三段式处理

玩家走完动画落地，SETTLE 状态会根据格子类型分发处理。这块分发函数是全游戏最核心的逻辑，我建议单独放一个文件，避免和渲染代码混在一起。

# settle.py — 落地结算 def settle_cell(game): p = game.current_player cell = CELL_DATA[p.position] if cell["type"] == "PROPERTY": owner_id = game.ownership[p.position] if owner_id is None: # 无主地块，资金足够就自动购买 if cell["price"] <= p.money: buy_property(game, p, p.position) else: log(f"{p.name} 资金不足，放弃购买 {cell['name']}") elif owner_id != p.player_id: # 支付租金给地主 owner = game.players[owner_id] p.pay(cell["rent"]) owner.money += cell["rent"] log(f"{p.name} 向 {owner.name} 支付租金 {cell['rent']}") elif cell["type"] == "TAX": p.pay(cell["rent"]) # 税款直接用 rent 字段存 elif cell["type"] == "EVENT": card = draw_event_card() apply_event(game, card)

这里有个细节值得注意：租金结算是先扣款、再给收款方加钱。如果先给地主加钱再扣租客，租客破产时这笔钱就凭空消失了。顺序问题在后面对账时非常难看。

逻辑顺序：付租金 → 判破产 → 清理遗产。清理遗产的代码放在 END 状态里执行：

# 回合收尾时检查破产玩家 def next_player(game): p = game.current_player if p.bankrupt: for idx in p.properties: game.ownership[idx] = None # 释放房产 p.properties.clear() log(f"{p.name} 破产，房产已释放") game.turn_index = (game.turn_index + 1) % len(game.players)

释放房产必须遍历 properties 并把 ownership 对应位置置空，否则后续玩家查 owner_id 时会查到一堆“幽灵地主”——这是欠债破产后最容易出现的逻辑漏洞。ownership 数组我用[None] * len(CELL_DATA)初始化，每个下标存玩家索引或 None，比在 Player 里互相找要直白得多。

4.2 事件卡机制：随机但不失控，注意二次落地规则

事件卡是大富翁变数最大的部分。实现上不需要做花哨的插件化，用一个列表加一个分发函数就够了。卡的字段统一成 name、action、value 三个键，后续加新卡只加列表行，分发函数不用改。

# event.py — 事件卡定义与执行 EVENT_CARDS = [ {"name": "前进三格", "action": "move", "value": 3}, {"name": "倒退两格", "action": "move", "value": -2}, {"name": "银行发放红利", "action": "money", "value": 200}, {"name": "交通罚单", "action": "money", "value": -100}, {"name": "进监狱", "action": "jail", "value": 0}, # ... 更多卡片 ] def apply_event(game, card): p = game.current_player if card["action"] == "money": if card["value"] > 0: p.money += card["value"] else: p.pay(-card["value"]) # pay 只接受正数 elif card["action"] == "move": p.move(card["value"], len(CELL_DATA)) # 事件卡的移动不触发落地结算 elif card["action"] == "jail": p.in_jail = True p.jail_rounds = 2

事件卡触发的移动有一个玩家经常忽略的规则：它不算“落地”，不触发买地或交租。这是为了避免连锁反应导致一场游戏 10 分钟内靠事件卡反复买地，局面失控。代码上你只需要在 apply_event 里直接调用 p.move，不经过 settle_cell，就天然隔离了这条规则。

抽卡函数也简单：

import random def draw_event_card(): """随机抽一张，不做放回，简化实现""" return random.choice(EVENT_CARDS)

真要做复杂，可以抽完不放回、洗牌重发，但经典大富翁用随机选取完全够玩。事件卡的执行顺序要和棋盘格子的类型一一对应：只有落入 type 为 EVENT 的格子才抽卡，避免玩家在普通地产格上莫名其妙被罚款。

4.3 AI 对手：用“资金健康线”做决策，别写成全买或全不买

AI 的决策逻辑决定了游戏的可玩性。最烂的写法是永远不买、永远只等收租，那样游戏变成纯掷骰子比运气；另一种全买策略则会让 AI 快到后期稳稳碾压玩家。我给 AI 用一个“资金健康线”策略：现金大于地块价格一定倍数才买，再叠加一点随机观望，让每局走势有差异。

# ai.py — AI 购买决策 import random def decide_buy(player, cell_index): """AI 购买决策：资金充裕才买，留足抗风险现金流""" cell = CELL_DATA[cell_index] if cell["type"] != "PROPERTY": return False if player.money < cell["price"] * 1.5: return False # 30% 概率观望，避免每局都雷同 if random.random() < 0.3: return False return True

这段代码里最值得调的是倍数 1.5 和概率 0.3。倍数调高，AI 会变得保守，手里攥一堆现金不消费，后期地皮被玩家垄断；倍数调低到 1.2 左右，AI 容易在早期破产。0.3 的观望概率是为了打破“资金足够必买”的确定性，否则 AI 的可预测性会让玩家很快找到节奏。AI 的具体行动不需要新线程，它只是在轮到它时调用同一个 decide_buy 并返回决策，流程上仍是同步的。

AI 的移动、结算、交易全部复用玩家同一条逻辑链，唯一区别是决策函数从“鼠标点击”换成“decide_buy 返回值”。这其实就是大富翁项目最优雅的一点：玩法规则层和交互层完全解耦，换个人机接口不需要动任何结算代码。

5. 大富翁项目常见问题与避坑：环境、中文与循环最劝退新人

5.1 python 命令找不到，pip 装到了另一个环境

现象：在命令行输入 python 提示“不是内部或外部命令”，或者 python -m pip install pygame 装完后 import 仍然报 ModuleNotFoundError。

原因：Windows 上安装 Python 时没有勾选 Add Python to PATH；或者电脑里有多个 Python 版本，pip 装进了一个 python，代码用另一个 python 跑。

解决：去 Python 官网重新运行安装包，在第一个界面勾选“Add Python to PATH”，安装完成后重开命令行。多版本场景下，显式用版本号命令，例如py -3.11 -m pip install pygame，再用py -3.11 -c "import pygame; print(pygame.version.ver)"验证。不要依赖裸 pip，它指向哪个解释器完全看 PATH 顺序。

5.2 窗口里中文全部显示成方块

现象：游戏界面上的卡牌名称、玩家昵称、提示文字全部变成一串小方块。

原因：pygame.font.Font 默认字体不包含中文字形。Win 系统下 SysFont 自动选择机制偶尔会失效，尤其用 font.SysFont(None, 20) 的时候。

解决：显式指定中文字体名：

font = pygame.font.SysFont("microsoftyahei", 20)

如果字体名记不准，用pygame.font.get_fonts()打印系统所有字体列表，找包含 msh 或 yahei 的条目。Mac 上换"pingfang"或"songti"。这个坑不大，但碰上就是一整片黑块，很容易让新手误判成自己代码写错了。

5.3 点击骰子后窗口卡死，标题栏显示“未响应”

现象：游戏刚启动时一切正常，点了一下骰子区域，窗口立刻转圈，动画也不走了。

原因：在事件循环里写了time.sleep(1)来模拟骰子晃动或角色走路停顿。sleep 会阻塞整个 pygame 主循环，期间既无法渲染也无法接收鼠标键盘事件，系统判定窗口未响应。

解决：把 sleep 换成帧计数。就是我在前面第 3.3 节写的 roll_countdown 模式：每帧减 1，减到 0 才执行结算。角色移动动画同样用 progress 插值，不要用 sleep。这是整个项目里最容易让新手束手无策的坑，也是最值得记住的一条：pygame 主循环里永远不要长眠。

5.4 某玩家落地后无限买地，回合永远推不下去

现象：游戏进行到中后期，日志里看到同一个玩家反复买地，钱扣成了负数但还继续操作，回合不切换。

原因：破产判定只在扣款的某个分支里做了，但 SETTLE 状态处理完后状态机没有正常推进到 END，或者 next_player 里没有过滤破产玩家，导致它的回合被跳过逻辑写漏。

解决：在 END 状态统一检查破产并清理房产，然后无条件推进 turn_index。再加一道全局保险：超过 200 回合强制结束游戏，按资金余额排名判胜负。这道保险不是正规玩法，但能防止 AI 决策写坏时游戏永不终止，调试期全靠它兜底。

5.5 pygame 窗口一闪而过，程序直接退出

现象：运行主文件后窗口闪了一下就没了，控制台也没有报错。

原因：主循环 while running 的条件在初始化阶段就变成了 False，或者 pygame.init() 写在了 while 循环内部，第一次迭代结束就被回收。

解决：把pygame.init()和screen = pygame.display.set_mode(...)放到 while 之前，窗口关闭事件的处理里只置running = False，不调用pygame.quit()。框架写对后，这类问题基本灭绝。还有一个小细节：pygame.display.flip()要放在每帧渲染的最后，而不是渲染之前，否则你会看到一帧黑屏。

6. 源码的进阶可选技巧：把 JSON 存档和开局日志加进游戏，让调试不再从头跑

如果你的大富翁源码已经能完整跑完一局，下一步最值得投入的是存档系统。没有存档的版本，每次调试 AI 都要从头掷骰子几十回合才能复现问题，非常消耗耐心。JSON 序列化是这里最合适的选择：Python 标准库直接支持、文件人可读、Git 对比友好，不需要引入 sqlite 之类的额外依赖。

# save.py — 存档与读档 import json import time def save_game(game, filename=None): """将一局游戏的状态写入 JSON 文件""" if filename is None: filename = f"save_{int(time.time())}.json" # 时间戳区分存档 data = { "turn": game.turn_index, "ownership": game.ownership, "players": [ { "name": p.name, "money": p.money, "position": p.position, "properties": p.properties, "in_jail": p.in_jail, "jail_rounds": p.jail_rounds, "bankrupt": p.bankrupt, } for p in game.players ], } with open(filename, "w", encoding="utf-8") as f: json.dump(data, f, ensure_ascii=False, indent=2) print(f"已保存到 {filename}") def load_game(game, filename): """从 JSON 文件恢复游戏状态，覆盖当前内存对象""" with open(filename, "r", encoding="utf-8") as f: data = json.load(f) game.turn_index = data["turn"] game.ownership = data["ownership"] for p, pd in zip(game.players, data["players"]): p.money = pd["money"] p.position = pd["position"] p.properties = pd["properties"] p.in_jail = pd["in_jail"] p.jail_rounds = pd["jail_rounds"] p.bankrupt = pd["bankrupt"]

save_game 里有个容易忽略的点：所有字段必须是 JSON 可序列化的基本类型。Player 对象不能直接 json.dump，所以手动拆成字典；ownership 列表本身就是 int 和 None，原样保存即可。load_game 的入参 game 是已经初始化好的游戏对象，读档只覆盖状态字段，不重新创建玩家，避免外部引用的引用断层。

配合存档，我再推荐一个习惯：开局日志。每回合落一条日志，记录玩家、骰子点数、落地格子、资金变动：

import datetime def log(message): ts = datetime.datetime.now().strftime("%H:%M:%S") print(f"[{ts}] {message}")

有了这两样，调试节奏会完全改变。以前 AI 决策出错，你要从第一回合开始重新打；现在从可疑存档恢复，再配合日志就能反推决策函数在什么资金条件下做了错误选择。我早期写大富翁版本时没有存档，每次微调 AI 参数都必须整局重跑，一天下来大半时间耗在掷骰子上；后来花了半小时补上 JSON 存档，才发现所谓“AI 太傻”很多时候不是决策逻辑的问题，而是破产清理顺序错了导致幽灵地主收租。这种定位效率，是源码能否持续改下去的关键分水岭。希望这些经验帮你在自己的大富翁项目里少走弯路，把每一局调试都用在该用的地方。

本文还有配套的精品资源，点击获取