AI 外交：由大语言模型驱动的战略游戏

由 Alex Duffy @Alx-Ai 和 Tyler Marques @Tylermarques 创建

概述

此仓库在原始 Diplomacy 项目的基础上进行了扩展，引入了由大型语言模型（LLM）驱动的高级 AI 代理。游戏中每个大国均由一个自主代理控制，该代理能够维护自身状态、建立关系、开展谈判并作出战略决策。

核心特性

🤖 带状态的 AI 代理

每个大国由一个 DiplomacyAgent 表示，具备以下功能：

• 动态目标：根据游戏事件不断调整的战略目标
• 关系追踪：与其他大国保持敌对、不友好、中立、友好或同盟等关系
• 记忆系统：双层记忆结构，包括结构化的日记条目和整合机制
• 个性设定：基于大国特性的系统提示塑造每个代理的外交风格

💬 丰富的谈判机制

• 多轮消息交互（私密与全局）
• 关系感知的沟通策略
• 消息历史追踪与分析
• 能够检测被忽略的消息及无响应的大国

🎯 战略指令生成

• 使用广度优先搜索进行移动路径分析
• 结合上下文选择最近的威胁或机会对应的指令
• 提供后备逻辑以增强鲁棒性
• 支持多种 LLM 服务提供商（OpenAI、Claude、Gemini、DeepSeek、OpenRouter）

📊 高级游戏分析

• 自定义回合总结，按成功/失败分类
• 通过比较指令与谈判内容检测背叛行为
• 针对高层指令的战略规划阶段
• 全面记录所有 LLM 的交互过程

🧠 记忆管理

• 私人日记：按回合编号的结构化条目，用于提供给 LLM 的上下文
  • 包含关系更新的谈判摘要
  • 指令推理与战略理由
  • 反应背叛行为的回合结果分析
• 年度整合：自动汇总旧条目，防止上下文过载
• 智能上下文构建：仅向 LLM 提供相关的历史记录

AI 代理的工作原理

下图展示了每个 AI 代理的完整信息流与决策流程：

graph TB
    %% 游戏状态来源
    subgraph "游戏状态信息"
        GS[游戏状态<br/>- 单位位置<br/>- 补给中心<br/>- 各国状态]
        GH[游戏历史<br/>- 历史指令<br/>- 历史消息<br/>- 回合结果]
        PS[回合总结<br/>- 成功行动<br/>- 失败行动<br/>- 棋盘变化]
    end
    
    %% 代理内部状态
    subgraph "代理状态 (DiplomacyAgent)"
        GOALS[动态目标<br/>- 扩张目标<br/>- 联盟优先级<br/>- 防御需求]
        REL[关系<br/>从敌对到同盟的等级]
        
        subgraph "记忆系统"
            DIARY[私人日记<br/>按回合编号的条目]
            
            ND[谈判日记<br/>- 消息分析<br/>- 信任评估<br/>- 关系变化]
            OD[指令日记<br/>- 战略推理<br/>- 风险收益分析]
            PRD[回合结果日记<br/>- 结果分析<br/>- 背叛检测<br/>- 成功评价]
            
            CONS[日记整合<br/>每年使用 Gemini Flash 生成摘要]
        end
        
        JOURNAL[私人日志<br/>仅用于调试]
    end
    
    %% 上下文构建
    subgraph "上下文构建"
        POC[Possible Order Context<br/>- BFS 路径搜索<br/>- 最近的敌人<br/>- 未控制的补给中心<br/>- 相邻领土]
        
        BCP[build_context_prompt<br/>整合所有信息]
        
        RECENT[近期上下文<br/>- 最近 40 条日记条目<br/>- 当前关系<br/>- 当前目标]
    end
    
    %% LLM 决策点
    subgraph "LLM 决策点"
        INIT_LLM[初始化<br/>设定初始目标与关系]
        
        NEG_LLM[谈判<br/>生成消息<br/>更新关系]
        
        PLAN_LLM[规划<br/>制定战略指令]
        
        ORD_LLM[指令生成<br/>选择具体行动]
        
        STATE_LLM[状态更新<br/>调整目标与关系]
    end
    
    %% 提示模板
    subgraph "提示模板"
        PROMPTS[大国专属提示<br/>+ 指令模板<br/>+ 上下文模板]
    end
    
    %% 信息流动
    GS --> BCP
    GH --> BCP
    PS --> STATE_LLM
    
    GOALS --> BCP
    REL --> BCP
    DIARY --> RECENT
    RECENT --> BCP
    
    POC --> BCP
    BCP --> NEG_LLM
    BCP --> ORD_LLM
    BCP --> PLAN_LLM
    
    PROMPTS --> INIT_LLM
    PROMPTS --> NEG_LLM
    PROMPTS --> PLAN_LLM
    PROMPTS --> ORD_LLM
    PROMPTS --> STATE_LLM
    
    %% 日记更新
    NEG_LLM --> ND
    ORD_LLM --> OD
    PS --> PRD
    
    ND --> DIARY
    OD --> DIARY
    PRD --> DIARY
    
    %% 状态更新
    INIT_LLM --> GOALS
    INIT_LLM --> REL
    NEG_LLM --> REL
    STATE_LLM --> GOALS
    STATE_LLM --> REL
    
    %% 整合
    DIARY -->|每两年一次| CONS
    CONS -->|汇总后| DIARY
    
    %% 样式
    classDef gameState fill:#e74c3c,stroke:#333,stroke-width:2px,color:#fff
    classDef agentState fill:#3498db,stroke:#333,stroke-width:2px,color:#fff
    classDef context fill:#2ecc71,stroke:#333,stroke-width:2px,color:#fff
    classDef llm fill:#f39c12,stroke:#333,stroke-width:2px,color:#fff
    classDef memory fill:#9b59b6,stroke:#333,stroke-width:2px,color:#fff
    
    class GS,GH,PS gameState
    class GOALS,REL,JOURNAL agentState
    class POC,BCP,RECENT context
    class INIT_LLM,NEG_LLM,PLAN_LLM,ORD_LLM,STATE_LLM llm
    class DIARY,ND,OD,PRD,CONS memory

关键组件详解

1. 信息来源

   • 游戏状态：当前棋盘布局、单位位置及补给中心归属
   • 游戏历史：过去的所有指令、消息及结果记录
   • 回合总结：对每回合成功与失败情况的分类分析

2. 代理记忆架构

   • 私人日记：主要的记忆系统，按回合进行结构化记录
   • 日记类型：三种专门的日记类型分别记录游戏的不同方面
   • 整合机制：每年自动汇总日记内容，防止上下文过载
   • 日志：非结构化的调试日志（不用于 LLM）

3. 上下文构建

   • 战略分析：利用广度优先搜索识别潜在的威胁与机遇
   • 关系上下文：当前的外交关系影响所有决策
   • 历史上下文：近期的日记条目为决策提供连续性

4. LLM 决策点

   • 初始化：设定初始性格特征与目标
   • 谈判：基于关系生成符合情境的消息
   • 规划：制定高层次的战略指令
   • 指令：结合全面的战略上下文选择具体行动
   • 状态更新：根据游戏结果调整目标与关系

实现细节

核心文件

1. lm_game.py - 主游戏调度器

   • 管理智能体的生命周期和游戏阶段
   • 协调异步LLM调用以实现最大性能
   • 处理错误跟踪与恢复
   • 保存包含阶段摘要和智能体关系的游戏状态

2. ai_diplomacy/agent.py - 带状态的智能体实现

   • DiplomacyAgent类，包含目标、关系和记忆
   • 强健的JSON解析功能，适用于多种LLM响应格式
   • 每次游戏事件生成日记条目
   • 基于游戏结果的状态更新逻辑

3. ai_diplomacy/clients.py - LLM抽象层

   • BaseModelClient接口，用于所有LLM提供商
   • 提供OpenAI、Claude、Gemini、DeepSeek、OpenRouter等实现
   • 构建提示并解析响应
   • 具备重试逻辑和错误处理机制

4. ai_diplomacy/possible_order_context.py - 战略分析

   • 在游戏地图上进行广度优先搜索路径规划
   • 识别最近的威胁或机会
   • 分析相邻领土
   • 为指令生成丰富的XML上下文

5. ai_diplomacy/prompt_constructor.py - 集中式提示构建

   • 整合游戏状态、智能体状态和战略上下文
   • 格式化不同LLM任务的提示
   • 与模板系统集成

6. ai_diplomacy/game_history.py - 游戏各阶段追踪

   • 存储消息、指令及结果
   • 为智能体提供历史背景
   • 跟踪被忽略的消息，用于关系分析

提示模板

ai_diplomacy/prompts/目录下包含可定制的模板：

• 针对各强国的系统提示（如france_system_prompt.txt）
• 针对特定任务的指令（order_instructions.txt、conversation_instructions.txt）
• 针对不同游戏事件的日记生成提示
• 状态更新与规划模板

运行AI游戏

# 基本谈判游戏
python lm_game.py --max_year 1910 --num_negotiation_rounds 3

# 包含战略规划阶段
python lm_game.py --max_year 1910 --planning_phase --num_negotiation_rounds 2

# 自定义模型分配（顺序：奥地利、英格兰、法国、德国、意大利、俄罗斯、土耳其）
python lm_game.py --models "claude-3-5-sonnet-20241022,gpt-4o,claude-3-5-sonnet-20241022,gpt-4o,claude-3-5-sonnet-20241022,gpt-4o,claude-3-5-sonnet-20241022"

# 直到游戏结束或特定年份
python lm_game.py --num_negotiation_rounds 2 --planning_phase

# 将所有数据输出到指定目录（若目录已存在则自动续跑）
python lm_game.py --run_dir results/game_run_001

# 从特定阶段恢复中断的游戏
python lm_game.py --run_dir results/game_run_001 --resume_from_phase S1902M

# 关键状态分析：从现有运行中恢复，但将新结果保存到其他位置
python lm_game.py \
  --run_dir results/game_run_001 \
  --critical_state_analysis_dir results/critical_analysis_001 \
  --resume_from_phase F1903M

# 在特定阶段后结束模拟，无论剩余年份多少
python lm_game.py --run_dir results/game_run_002 --end_at_phase F1905M

# 设置全局最大token生成限制
python lm_game.py --run_dir results/game_run_003 --max_tokens 8000

# 按模型设置token限制（AU,EN,FR,GE,IT,RU,TR）
python lm_game.py --run_dir results/game_run_004 \
  --max_tokens_per_model "8000,8000,16000,8000,8000,16000,8000"

# 使用自定义提示目录
python lm_game.py --run_dir results/game_run_005 --prompts_dir ./prompts/my_variants

设置--models（快速指南）

• 请按固定顺序传递一个由最多七个模型ID组成的逗号分隔列表：奥地利、英格兰、法国、德国、意大利、俄罗斯、土耳其。

• 模型ID语法

  <客户端前缀>:模型[@base_url][#api_key]
  

  • 前缀: – 指定客户端（openai、openai-requests、openai-responses、anthropic、gemini、deepseek、openrouter、together）。
  • @base_url – 使用代理或备用端点。
  • #api_key – 内联密钥（覆盖环境变量）。

  # 所有势力都使用OpenRouter上的gpt-4o：
  --models "openrouter:gpt-4o"
  # 仅奥地利使用自定义URL+密钥：
  --models "openai:llama-3.2-3b@http://localhost:8000#myapikey,openai:gpt-4o,openai:gpt-4o,openai:gpt-4o,openai:gpt-4o,openai:gpt-4o,openai:gpt-4o"
  

使用experiment_runner.py运行批量实验

experiment_runner.py是一个轻量级调度器：它会并行启动多个lm_game.py实例，在同一个实验目录下收集它们的成果，并执行您指定的分析模块。所有属于lm_game.py的参数标志都可以直接传递；调度器会验证这些参数并原封不动地转发给每个游戏实例。

---

示例

# 并行运行10个独立游戏（迭代），使用自定义提示目录，
# 并且所有七股势力都采用同一模型（GPT-4o）。
python3 experiment_runner.py \
    --experiment_dir "results/exp001" \
    --iterations 10 \
    --parallel 10 \
    --max_year 1905 \
    --num_negotiation_rounds 0 \
    --prompts_dir "ai_diplomacy/prompts" \
    --models "gpt-4o,gpt-4o,gpt-4o,gpt-4o,gpt-4o,gpt-4o,gpt-4o"


# 关键状态分析：从W1901A阶段恢复每个运行（基于现有基础运行），并在S1902M阶段停止。将执行两个分析模块：
#  • summary         → 汇总结果与评分

#  • critical_state  → 关键阶段前后快照
python3 experiment_runner.py \
    --experiment_dir "results/exp002" \
    --iterations 10 \
    --parallel 10 \
    --resume_from_phase W1901A \
    --end_at_phase S1902M \
    --num_negotiation_rounds 0 \
    --critical_state_base_run "results/test1" \
    --prompts_dir "ai_diplomacy/prompts" \
    --analysis_modules "summary,critical_state" \
    --models "gpt-4o,gpt-4o,gpt-4o,gpt-4o,gpt-4o,gpt-4o,gpt-4o"

(任何其他 lm_game.py 标志——如 --planning_phase、--max_tokens 等——都可以像在单局游戏中使用它们那样直接添加。)

---

实验运行器专用参数

标志	类型 / 默认值	描述
--experiment_dir (必填)	Path	实验的根目录；子文件夹 runs/ 和 analysis/ 会自动管理。使用同一目录重新运行将恢复现有运行并重新生成分析结果。
--iterations	int, 默认 1	本次实验要启动的独立游戏数量。
--parallel	int, 默认 1	同时执行的最大游戏数量（使用进程池）。
--analysis_modules	str, 默认 "summary"	游戏全部结束后要运行的分析模块列表，用逗号分隔。模块从 experiment_runner.analysis.<name> 中导入，必须提供 run(experiment_dir, ctx) 方法。
--critical_state_base_run	Path, 可选	指向先前 lm_game 运行产生的现有 run_dir 的路径。每次迭代都从该快照恢复；新生成的产物会写入当前的 experiment_dir 下。
--seed_base	int, 默认 42	基础随机种子。第 ɪ 次运行的种子为 seed_base + ɪ，从而实现可重复的批次运行。

(所有其他命令行标志均属于 lm_game.py，并将原样传递给它。)

环境设置

创建一个包含 API 密钥的 .env 文件：

OPENAI_API_KEY=your_key_here
ANTHROPIC_API_KEY=your_key_here
GEMINI_API_KEY=your_key_here
DEEPSEEK_API_KEY=your_key_here
OPENROUTER_API_KEY=your_key_here

模型配置

可以在 ai_diplomacy/utils.py 中为各势力分配模型：

def assign_models_to_powers() -> Dict[str, str]:
    return {
        "AUSTRIA": "o3",
        "ENGLAND": "claude-sonnet-4-20250514",
        "FRANCE": "gpt-4.1",
        "GERMANY": "gemini-2.5-pro-preview-05-06",
        "ITALY": "openrouter-meta-llama/llama-4-maverick",
        "RUSSIA": "claude-opus-4-20250514",
        "TURKEY": "openrouter-google/gemini-2.5-flash-preview-05-20",
    }

支持的模型包括：

• OpenAI: gpt-4o, gpt-4.1, o3, o4-mini
• Anthropic: claude-3-5-sonnet-20241022, claude-opus-4-20250514
• Google: gemini-2.0-flash, gemini-2.5-pro-preview
• OpenRouter: 包括 Llama、Qwen、DeepSeek 等多种模型

游戏输出与分析

游戏会按时间戳保存到 results/ 目录下。每个游戏文件夹包含：

• lmvsgame.json - 包含阶段摘要和代理关系的完整游戏数据
• overview.jsonl - 错误统计和模型分配信息
• game_manifesto.txt - 来自规划阶段的战略指令
• general_game.log - 详细的游戏执行日志
• llm_responses.csv - 所有 LLM 交互的完整日志

游戏 JSON 中包含用于 AI 分析的特殊字段：

• phase_summaries - 每个阶段的分类行动结果
• agent_relationships - 每个阶段的外交态势
• final_agent_states - 游戏结束时的目标和关系

数据处理与 RL 分析流程

为了详细分析 LLM 交互及订单成功率，采用两步流程：

1. 将 CSV 转换为 RL JSON： csv_to_rl_json.py 脚本会处理通常位于以“FULL_GAME”结尾的游戏特定子目录中的 llm_responses.csv 文件（例如 results/20250524_..._FULL_GAME/）。它会将这些原始交互数据转换为适合强化学习（RL）分析的 JSON 格式。

   要批量处理所有相关 CSV 文件：

   python csv_to_rl_json.py --scan_dir results/
   

   该命令会扫描 results/ 目录下的“FULL_GAME”子文件夹，将其中的 llm_responses.csv 文件转换为 JSON，并将所有生成的 *_rl.json 文件输出到 results/json/ 目录中。

2. 分析 RL JSON 文件： analyze_rl_json.py 脚本会分析上一步生成的 JSON 文件。它会按模型汇总成功和失败的护航及支援订单统计数据。

   要运行分析：

   python analyze_rl_json.py results/json/
   

   该命令会处理 results/json/ 目录下的所有 *_rl.json 文件，并在项目根目录下生成两份报告：

   • analysis_summary.txt: 订单统计的简洁摘要。
   • analysis_summary_debug.txt: 包含唯一“success”字段值及其他调试信息的详细报告。

此流程能够全面了解 LLM 在生成有效且成功的游戏订单方面的表现。

赛后分析工具

战略时刻分析

分析游戏中的关键战略时刻，包括背叛、合作以及精彩策略：

# 分析已完成的游戏
python analyze_game_moments.py results/20250522_210700_o3vclaudes_o3win

# 限制分析范围至特定阶段
python analyze_game_moments.py results/game_folder --max-phases 20

# 使用不同的分析模型
python analyze_game_moments.py results/game_folder --model claude-3-5-sonnet-20241022

分析会识别以下内容：

• 背叛行为：当各势力明确承诺某种行动，却采取了相矛盾的行动时
• 合作行为：各势力之间成功协调一致的行动
• 两面派行为：各势力对不同方做出相互矛盾的承诺
• 精彩战略：执行得极为出色的策略性操作
• 战略失误：严重削弱自身局势的重大错误

分析输出包括：

• Markdown 报告（game_moments/[game]_report_[timestamp].md）
  • AI 自动生成的整局游戏叙述
  • 总结性统计数据（背叛、合作等）
  • 各模型的无效走法次数
  • 谎言分析，区分故意与无意谎言
  • 最重要的战略时刻，附完整背景及日记条目
• JSON 数据（game_moments/[game]_data_[timestamp].json）
  • 所有检测到的事件的完整结构化数据
  • 包含得分、类别和关系等元数据
  • 原始谎言检测数据，供进一步分析使用

示例输出片段如下：

## 各势力使用的模型
- **土耳其**：o3
- **英格兰**：claude-sonnet-4-20250514
- **俄罗斯**：claude-opus-4-20250514

## 各模型的无效走法数量
- **o3**：91 次无效走法
- **claude-sonnet-4**：67 次无效走法

## 谎言分析
### 各模型的谎言情况
- **o3**：共 195 次谎言（71 次故意，124 次无意）
- **claude-opus-4**：共 96 次谎言（0 次故意，96 次无意）

外交谎言检测

分析系统通过比较以下三方面来检测谎言：

1. 消息内容：各势力彼此之间的承诺
2. 私人日记：各势力私下计划的内容（来自谈判日记条目）
3. 实际命令：各势力真正执行的行动

谎言被分为两类：

• 故意谎言：日记中显示出有计划的欺骗意图（例如“误导他们”、“实际上……”）
• 无意谎言：没有证据表明存在计划中的欺骗行为（很可能是误解）

动画与可视化

使用交互式 3D 动画系统可视化游戏：

# 启动动画服务器
cd ai_animation
npm install
npm run dev

# 在浏览器中打开 http://localhost:5173
# 加载一个游戏 JSON 文件即可观看动画回放

功能特点：

• 3D 地图展示部队移动与战斗
• 分阶段播放控制
• 聊天窗口显示外交消息
• 排行榜实时追踪补给中心数量
• 配备音效与视觉特效

游戏统计与模式

对数百场 AI 对弈的分析揭示了一些有趣的规律：

各模型的表现特征

• 无效走法率：某些模型（如 o3）会产生较多无效走法，但打法较为激进
• 欺骗模式：各模型在诚实度方面差异巨大（故意谎言比例从 0% 到 100% 不等）
• 战略风格：从防守型/诚实型到进攻型/欺骗型不等

常见的战略模式

• 开局战术：RT 重锤（俄土组合）、西线三强联盟、勒班多阵型
• 中盘动态：背后捅刀时机、联盟转换、运输船队运作
• 收官挑战：僵持线、被迫和棋、关键玩家决定胜负

未来探索方向

• 自适应谈判：根据对话流程动态调整回合数
• 联盟检测：识别并跟踪多方联盟
• 个性演化：让智能体能够调整其外交风格
• 锦标赛模式：自动进行多局比赛，并计算 ELO 等级分
• 人机混合：允许人类玩家与 AI 智能体同场竞技
• 实时解说：为观众生成现场解说文字
• 欺骗训练：专门训练模型以检测或实施谎言
• 元策略学习：让智能体能够从过往对局中学习经验

---

文档说明

完整的文档可在 diplomacy.readthedocs.io 查阅。

可用的分析脚本

1. 战略时刻分析（analyze_game_moments.py）

全面分析游戏动态：

python analyze_game_moments.py results/game_folder [选项]

选项：
  --model MODEL         使用的分析模型（默认：gemini-2.5-flash）
  --max-phases N        只分析前 N 个阶段
  --max-concurrent N    并发 API 调用数量（默认：5）
  --report PATH         输出报告路径（未指定时自动生成）
  --json PATH           输出 JSON 文件路径（未指定时自动生成）

2. 集中式谎言检测（analyze_lies_focused.py）

详细分析外交欺骗行为：

python analyze_lies_focused.py results/game_folder [--output report.md]

3. 游戏结果统计（analyze_game_results.py）

汇总所有已完成游戏的胜负统计数据：

python analyze_game_results.py
# 生成 model_power_statistics.csv

该脚本会分析所有 *_FULL_GAME 文件夹，统计每个模型作为各个势力出战并获胜的次数。

4. 游戏可视化（ai_animation/）

交互式 3D 游戏可视化工具：

cd ai_animation
npm install
npm run dev
# 打开 http://localhost:5173 并加载一个游戏 JSON 文件

快速入门

安装步骤

该项目使用 uv 进行 Python 依赖管理。

设置项目依赖

# 克隆仓库
git clone https://github.com/your-repo/AI_Diplomacy.git
cd AI_Diplomacy

# 安装依赖并创建虚拟环境
uv sync

# 激活虚拟环境
source .venv/bin/activate  # Unix/macOS 系统
# 或
.venv\Scripts\activate     # Windows 系统

运行一局游戏

以下脚本会在本地随机提交有效指令，直到游戏结束：

import random
from diplomacy import Game
from diplomacy.utils.export import to_saved_game_format

# 创建一局游戏
# 也可以通过参数指定地图名称，例如：Game(map_name='pure')
game = Game()
while not game.is_game_done:

    # 获取所有地点的可能指令列表
    possible_orders = game.get_all_possible_orders()

    # 随机为每个势力选取一条有效指令
    for power_name, power in game.powers.items():
        power_orders = [random.choice(possible_orders[loc]) for loc in game.get_orderable_locations(power_name)
                        if possible_orders[loc]]
        game.set_orders(power_name, power_orders)

    # 可以通过 game.add_message 在本地发送消息
    # 例如：game.add_message(Message(sender='FRANCE',
    #                               recipient='ENGLAND',
    #                               message='这是一条消息',
    #                               phase=self.get_current_phase(),
    #                               time_sent=int(time.time())))

    # 处理游戏进入下一阶段
    game.process()

# 将游戏导出到磁盘以便可视化（游戏会被追加到文件中）

# 或者，我们也可以这样做 >> file.write(json.dumps(to_saved_game_format(game)))
to_saved_game_format(game, output_path='game.json')

网页界面

还可以使用 React 安装一个网页界面，以便与机器人和/或其他人对战，并可视化游戏过程。

可以通过以下步骤安装网页界面：

# 安装 NVM
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash

# 克隆仓库
git clone https://github.com/diplomacy/diplomacy.git

# 在本地安装依赖
# 建议在 conda 或 virtualenv 环境中安装
cd diplomacy/
pip install -r requirements_dev.txt

# 构建 Node 模块
cd diplomacy/web
npm install .
npm install . --only=dev

# 在一个终端窗口或标签页中启动 React 服务器
npm start

# 在另一个终端窗口或标签页中启动 Diplomacy 服务器
python -m diplomacy.server.run

网页界面将可通过 http://localhost:3000 访问。

用户可以使用 admin/password 或 username/password 登录。如果输入的用户名在数据库中不存在，系统会自动创建新用户。

可视化游戏

可以通过网页界面右上角的“从磁盘加载游戏”菜单来可视化游戏。

网络对战

可以通过 WebSocket 远程加入网络对战。下面的脚本演示了如何进行网络对战。

注意：为了使脚本正常运行，必须使用 python -m diplomacy.server.run 启动服务器。

import asyncio
import random
from diplomacy.client.connection import connect
from diplomacy.utils import exceptions

POWERS = ['AUSTRIA', 'ENGLAND', 'FRANCE', 'GERMANY', 'ITALY', 'RUSSIA', 'TURKEY']

async def create_game(game_id, hostname='localhost', port=8432):
    """ 在服务器上创建一场游戏 """
    connection = await connect(hostname, port)
    channel = await connection.authenticate('random_user', 'password')
    await channel.create_game(game_id=game_id, rules={'REAL_TIME', 'NO_DEADLINE', 'POWER_CHOICE'})

async def play(game_id, power_name, hostname='localhost', port=8432):
    """ 以指定势力身份进行游戏 """
    connection = await connect(hostname, port)
    channel = await connection.authenticate('user_' + power_name, 'password')

    # 等待游戏开始并加入
    while not (await channel.list_games(game_id=game_id)):
        await asyncio.sleep(1.)
    game = await channel.join_game(game_id=game_id, power_name=power_name)

    # 开始游戏
    while not game.is_game_done:
        current_phase = game.get_current_phase()

        # 提交指令
        if game.get_orderable_locations(power_name):
            possible_orders = game.get_all_possible_orders()
            orders = [random.choice(possible_orders[loc]) for loc in game.get_orderable_locations(power_name)
                      if possible_orders[loc]]
            print('[%s/%s] - 提交了: %s' % (power_name, game.get_current_phase(), orders))
            await game.set_orders(power_name=power_name, orders=orders, wait=False)

        # 可以通过 game.send_message 发送消息
        # await game.send_game_message(message=game.new_power_message('FRANCE', '这是消息'))

        # 等待游戏处理完成
        while current_phase == game.get_current_phase():
            await asyncio.sleep(0.1)

    # 可以使用 to_saved_game_format 保存游戏的本地副本
    # 若要下载包含所有势力消息的游戏副本，需要以管理员身份导出游戏，即使用 'admin' / 'password' 登录

async def launch(game_id):
    """ 创建并进行一场网络对战 """
    await create_game(game_id)
    await asyncio.gather(*[play(game_id, power_name) for power_name in POWERS])

if __name__ == '__main__':
    asyncio.run(launch(game_id=str(random.randint(1, 1000))))

许可证

版权所有 © 2025 Good Start Labs

更多详情请参阅 LICENSE 文件。

AI_Diplomacy 快速上手指南

AI_Diplomacy 是一个基于大语言模型（LLM）的策略游戏 AI 框架，扩展了经典的《外交》（Diplomacy）游戏。它能让每个国家由具备记忆、关系追踪和战略决策能力的自主 AI 代理控制。

环境准备

系统要求

• Python: 3.10 或更高版本
• 操作系统: Linux, macOS, 或 Windows (推荐 Linux/macOS 以获得最佳异步性能)
• API 密钥: 至少需要一个支持的 LLM 提供商密钥 (OpenAI, Anthropic/Claude, Google/Gemini, DeepSeek, OpenRouter 等)

前置依赖

确保已安装 git 和 pip。本项目主要依赖 Python 标准库及常见的 AI 客户端库（安装步骤中会自动处理）。

安装步骤

1. 克隆仓库

   git clone https://github.com/diplomacy/diplomacy.git
   cd diplomacy
   # 注意：AI_Diplomacy 是作为扩展模块存在的，请确保你位于包含 ai_diplomacy 目录的项目根目录下
   

   (注：如果该项目是独立仓库，请直接克隆对应的 AI_Diplomacy 仓库地址)

2. 创建虚拟环境（推荐）

   python -m venv venv
   source venv/bin/activate  # Windows 用户请使用: venv\Scripts\activate
   

3. 安装依赖

   pip install -r requirements.txt
   

   如果没有 requirements.txt，请根据项目实际依赖安装核心库，通常包括：

   pip install openai anthropic google-generativeai httpx asyncio
   

4. 配置 API 密钥 在终端导出你的 LLM 提供商密钥（以 OpenAI 和 Anthropic 为例）：

   export OPENAI_API_KEY="your-openai-key"
   export ANTHROPIC_API_KEY="your-anthropic-key"
   # 其他提供商同理，或在运行命令中通过 #api_key 语法直接指定
   

基本使用

1. 运行一场基础游戏

启动一个由 AI 控制的完整游戏，设置最大年份为 1910 年，每回合进行 3 轮谈判：

python lm_game.py --max_year 1910 --num_negotiation_rounds 3

2. 指定不同的 AI 模型

你可以为七个国家（奥地利、英国、法国、德国、意大利、俄罗斯、土耳其）分配不同的模型。以下示例交替使用 Claude 3.5 Sonnet 和 GPT-4o：

python lm_game.py --max_year 1910 --models "claude-3-5-sonnet-20241022,gpt-4o,claude-3-5-sonnet-20241022,gpt-4o,claude-3-5-sonnet-20241022,gpt-4o,claude-3-5-sonnet-20241022"

模型指定语法说明： 格式为 <客户端前缀>:模型名[@基础 URL][#API 密钥]。

• 单模型通用：所有国家使用 OpenRouter 上的 GPT-4o

  python lm_game.py --models "openrouter:gpt-4o"
  

• 自定义地址/密钥：仅为奥地利指定本地部署的模型，其余使用默认环境变量

  python lm_game.py --models "openai:llama-3.2-3b@http://localhost:8000#myapikey,openai:gpt-4o,openai:gpt-4o,openai:gpt-4o,openai:gpt-4o,openai:gpt-4o,openai:gpt-4o"
  

3. 保存结果与断点续跑

将游戏日志和状态保存到指定目录，并支持从中断的阶段恢复：

# 首次运行并保存结果
python lm_game.py --run_dir results/game_run_001 --num_negotiation_rounds 2

# 从特定阶段（如 1902 年春季移动阶段）恢复运行
python lm_game.py --run_dir results/game_run_001 --resume_from_phase S1902M

4. 批量实验（进阶）

使用 experiment_runner.py 并行运行多场游戏以进行对比分析：

python3 experiment_runner.py \
    --experiment_dir "results/exp001" \
    --iterations 10 \
    --parallel 10 \
    --max_year 1905 \
    --models "gpt-4o"

核心功能提示

• 记忆系统：AI 会自动维护“私人日记”，记录谈判、订单推理和背叛检测，并每年进行总结以防上下文溢出。
• 战略规划：添加 --planning_phase 参数可启用高层战略指令生成阶段，使 AI 决策更具长远性。
• 日志分析：所有 LLM 交互、关系变化和订单生成逻辑均会被详细记录在 run_dir 指定的文件夹中。