34b - 游戏引擎工作流

# 1. 使用 Unity Hub 创建项目
# 选择 Unity 6.x LTS，模板选择 URP 3D 或 2D
# 项目名称遵循 PascalCase 规范
 
# 2. 初始化 Git 仓库
git init
echo "Library/
Temp/
Obj/
Build/
Builds/
Logs/
UserSettings/
MemoryCaptures/
*.csproj
*.sln
*.suo
*.tmp
*.user
*.userprefs
*.pidb
*.booproj
*.svd
*.pdb
*.mdb
*.opendb
*.VC.db" > .gitignore
 
# 3. 安装 Claude Code（如使用终端 Agent）
# 确保已安装 Claude Code CLI
claude --version
 
# 4. 配置 Cursor（如使用 AI IDE）
# 打开项目根目录，Cursor 自动识别 Unity 项目结构

# CLAUDE.md — Unity 游戏项目
 
## 项目概述
这是一个使用 Unity 6.x（URP）开发的 [游戏类型] 游戏。
目标平台：[PC / Mobile / Console]
 
## 技术栈
- 引擎：Unity 6.x LTS
- 渲染管线：URP（Universal Render Pipeline）
- 语言：C# 12+
- 输入系统：新版 Input System（com.unity.inputsystem）
- 物理：Unity Physics / Havok Physics
- UI：UI Toolkit 或 UGUI
 
## 项目结构

## 编码规范
- 公共成员：PascalCase（`public float MoveSpeed`）
- 私有成员：_camelCase（`private float _moveSpeed`）
- 序列化私有字段：`[SerializeField] private float _moveSpeed`
- 常量：UPPER_SNAKE_CASE（`const float MAX_SPEED = 10f`）
- 接口：I 前缀（`IDamageable`）
- 枚举：PascalCase（`enum GameState { Playing, Paused }`）

## 架构规范
- 使用 ScriptableObject 存储配置数据，不硬编码数值
- 使用事件系统（C# events 或 ScriptableObject 事件）解耦组件
- MonoBehaviour 仅用于 Unity 生命周期交互，业务逻辑放在纯 C# 类中
- 使用对象池管理频繁创建/销毁的对象（子弹、特效、敌人）
- 使用 Addressables 管理资产加载（非 Resources 文件夹）

## 性能约束
- 目标帧率：60 FPS（PC）/ 30 FPS（Mobile）
- Draw Call 预算：< 200（Mobile）/ < 500（PC）
- 内存预算：< 1GB（PC）/ < 512MB（Mobile）
- 禁止在 Update() 中分配堆内存（使用缓存、对象池）
- 禁止在 Update() 中使用 Find/GetComponent（在 Awake/Start 中缓存）
- 禁止使用 SendMessage()，使用直接引用或事件系统

## 禁止事项
- 不要使用 `GameObject.Find()` 或 `FindObjectOfType()` 在运行时查找对象
- 不要在 Update/FixedUpdate 中分配 new 对象
- 不要使用 Resources 文件夹加载资产（使用 Addressables）
- 不要忽略 null 检查，特别是序列化引用
- 不要使用旧版 Input Manager（使用新版 Input System）
- 不要在 MonoBehaviour 中写大量业务逻辑
- 不要硬编码字符串路径或魔法数字

# 使用 AI 生成项目初始化脚本
提示词：
"请为 Unity 6 URP 项目生成以下初始化配置：
1. 项目设置脚本（Editor 脚本，自动配置 Quality Settings、Physics Settings）
2. 基础 GameManager（单例，管理游戏状态）
3. 事件总线系统（基于 ScriptableObject）
4. 输入配置（新版 Input System，支持键鼠和手柄）
5. 基础场景层级结构模板

技术要求：
- Unity 6.x + URP
- 使用 [SerializeField] 暴露参数
- 包含 [Header] 和 [Tooltip] 属性
- 添加中文注释"

# 提示词模板 — Unity 场景结构
请为 [场景类型：主菜单/游戏关卡/Boss战/商店] 设计场景层级结构：

## 场景信息
- 游戏类型：[2D 平台跳跃 / 3D 动作 / 俯视角 RPG]
- 渲染管线：URP
- 目标平台：[PC / Mobile]

## 要求
1. 使用空 GameObject 作为组织容器（--- Environment ---、--- Gameplay ---）
2. 摄像机设置（Cinemachine 虚拟摄像机配置）
3. 光照设置（URP 光照参数）
4. UI Canvas 层级
5. 音频管理器
6. 对象池容器

## 输出
- 完整的场景层级树（缩进表示父子关系）
- 每个关键节点的组件配置说明
- 初始化脚本（如需要）

Scene Root
├── --- Managers ---
│   ├── GameManager
│   ├── AudioManager
│   ├── UIManager
│   └── ObjectPoolManager
├── --- Environment ---
│   ├── Terrain / Tilemap
│   ├── Props
│   ├── Lighting
│   │   ├── Directional Light
│   │   ├── Point Lights
│   │   └── Reflection Probes
│   └── VFX (环境粒子)
├── --- Gameplay ---
│   ├── Player
│   ├── Enemies
│   ├── Interactables
│   ├── Triggers
│   └── Spawn Points
├── --- Camera ---
│   ├── Main Camera
│   └── CM Virtual Cameras
├── --- UI ---
│   ├── HUD Canvas (Screen Space - Overlay)
│   ├── World Canvas (World Space)
│   └── Popup Canvas
└── --- Audio ---
    ├── BGM Source
    ├── SFX Source
    └── Ambient Source

# 提示词模板
请为 [游戏类型] 配置 Cinemachine 摄像机系统：

## 需求
- 主摄像机：跟随玩家，[2D 侧视 / 3D 第三人称 / 俯视角]
- 支持摄像机震动（受伤、爆炸）
- 支持区域限制（不超出关卡边界）
- 支持平滑过渡（进入 Boss 房间时切换摄像机）

## 技术要求
- 使用 Cinemachine 3.x（Unity 6 内置）
- CinemachineCamera 替代旧版 CinemachineVirtualCamera
- 使用 CinemachineImpulseSource 实现震动

# 提示词模板 — Unity C# 脚本生成（通用）
你是一个 Unity 6 游戏开发专家。请为我生成以下功能的 C# 脚本：

## 需求
[描述游戏功能需求]

## 技术约束
- Unity 版本：6.x（LTS）
- 渲染管线：URP
- 目标平台：[PC/Mobile/Console]
- 使用新版 Input System
- 遵循项目 CLAUDE.md 中的编码规范

## 架构要求
1. 使用 [SerializeField] 暴露可调参数，添加 [Header] 和 [Tooltip]
2. 在 OnDestroy 中清理所有事件订阅和协程
3. 使用 ScriptableObject 存储配置数据
4. 使用接口定义行为契约（IDamageable, IInteractable）
5. 包含必要的空值检查和错误处理
6. 添加中文注释说明关键逻辑
7. 不在 Update 中分配堆内存

## 输出格式
- 完整的 .cs 文件内容
- 必要的 ScriptableObject 定义
- 使用说明（如何挂载、配置参数）

# 具体示例提示词
请为 2D 平台跳跃游戏生成玩家控制器：

## 功能需求
1. 水平移动（加速/减速，非瞬时）
2. 跳跃（可变高度，按住跳更高）
3. 土狼时间（Coyote Time，离开平台后短暂可跳）
4. 跳跃缓冲（Jump Buffer，落地前按跳自动跳）
5. 墙壁滑行和蹬墙跳
6. 冲刺（带冷却）

## 技术要求
- 使用 Rigidbody2D（不用 CharacterController）
- 使用新版 Input System（InputAction）
- 地面检测使用 Physics2D.OverlapBox
- 所有参数通过 ScriptableObject 配置
- 使用状态机管理玩家状态

# 代码审查提示词
请审查以下 Unity C# 脚本，检查：

1. 性能问题（Update 中的分配、不必要的 GetComponent）
2. 内存泄漏（未取消的事件订阅、未停止的协程）
3. 空引用风险（未检查的序列化引用）
4. Unity 最佳实践违规
5. 代码可维护性和可读性

[粘贴代码]

请按严重程度排序，给出具体修改建议。

# 提示词模板 — Unity 资产导入配置
请为以下资产类型生成 Unity 导入配置脚本（AssetPostprocessor）：

## 资产类型和目标平台
- 纹理：[2D 精灵 / 3D 纹理 / UI 图片]
- 模型：[角色 / 环境 / 道具]
- 音频：[BGM / SFX / 语音]
- 目标平台：[PC / Mobile / Console]

## 优化要求
### 纹理
- 2D 精灵：Sprite 模式，Filter Point（像素风）或 Bilinear
- 3D 纹理：压缩格式 ASTC（Mobile）/ BC7（PC）
- UI 图片：Sprite Atlas 打包
- 最大尺寸限制：Mobile 1024，PC 2048

### 模型
- 导入时自动设置材质
- LOD 组自动配置
- 动画压缩设置

### 音频
- BGM：Streaming 加载，Vorbis 压缩
- SFX：Decompress On Load，ADPCM 压缩
- 语音：Compressed In Memory，Vorbis 压缩

# 提示词模板 — Addressables 配置
请为 Unity 项目配置 Addressables 资产管理系统：

## 需求
1. 按场景分组资产（每个关卡一个 Group）
2. 共享资产单独分组（UI、通用特效、音频）
3. 配置远程资产服务器（用于热更新）
4. 实现资产预加载管理器
5. 实现引用计数和自动卸载

## 输出
1. Addressables Group 配置方案
2. 资产加载管理器脚本
3. 场景加载工作流（带进度条）
4. 内存管理最佳实践

┌──────────────────────────────────────────────────────────────────┐
│              Unity AI 辅助完整开发工作流                           │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. 项目初始化                                                    │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ Unity Hub 创建项目 → 配置 CLAUDE.md → Git 初始化         │     │
│  │ → 安装必要 Package（Cinemachine, Input System, DOTween） │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  2. 核心系统开发（AI 辅助）                                       │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ Claude Code/Cursor 生成：                                │     │
│  │ • GameManager + 事件系统                                 │     │
│  │ • 玩家控制器 + 状态机                                    │     │
│  │ • 摄像机系统（Cinemachine）                              │     │
│  │ • 输入系统配置                                           │     │
│  │ → 人工测试手感 → 迭代调优                                │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  3. 游戏系统开发（AI 辅助 + Spec-Driven）                        │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ 每个系统独立 Spec：                                      │     │
│  │ • 战斗系统 → AI 生成 → 人工审查 → 测试                   │     │
│  │ • 库存系统 → AI 生成 → 人工审查 → 测试                   │     │
│  │ • 对话系统 → AI 生成 → 人工审查 → 测试                   │     │
│  │ • 存档系统 → AI 生成 → 人工审查 → 测试                   │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  4. 资产集成                                                     │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ AI 生成资产 → 人工质检 → 导入 Unity                      │     │
│  │ → AssetPostprocessor 自动配置                            │     │
│  │ → Addressables 分组 → Sprite Atlas 打包                  │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  5. 测试与优化                                                    │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ • Unity Test Framework（EditMode + PlayMode 测试）       │     │
│  │ • Profiler 性能分析 → AI 辅助优化建议                    │     │
│  │ • ML-Agents 自动化游玩测试                               │     │
│  │ • 多平台构建测试                                         │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  6. 构建与发布                                                    │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ Build Settings 配置 → Player Settings 优化               │     │
│  │ → Addressables Build → 平台构建                          │     │
│  │ → 测试构建包 → 提交商店                                  │     │
│  └─────────────────────────────────────────────────────────┘     │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

// Unity Sentis 使用示例 — 在游戏中运行 ONNX 模型
// 用途：NPC 行为预测、图像识别、自然语言处理
 
using Unity.Sentis;
using UnityEngine;
 
/// <summary>
/// Sentis AI 推理管理器
/// 在运行时加载和执行 ONNX 模型，无需外部服务器
/// </summary>
public class SentisInferenceManager : MonoBehaviour
{
    [Header("模型配置")]
    [SerializeField] private ModelAsset _modelAsset;
    [Tooltip("推理后端：GPU 性能更好，CPU 兼容性更好")]
    [SerializeField] private BackendType _backendType = BackendType.GPUCompute;
 
    private Worker _worker;
 
    private void Awake()
    {
        // 加载模型并创建推理 Worker
        var model = ModelLoader.Load(_modelAsset);
        _worker = new Worker(model, _backendType);
    }
 
    /// <summary>
    /// 执行推理
    /// </summary>
    public float[] Predict(float[] inputData, int[] inputShape)
    {
        // 创建输入张量
        using var inputTensor = new Tensor<float>(
            new TensorShape(inputShape), inputData);
 
        // 执行推理
        _worker.Schedule(inputTensor);
 
        // 获取输出
        var outputTensor = _worker.PeekOutput() as Tensor<float>;
        return outputTensor.ToReadOnlyArray();
    }
 
    private void OnDestroy()
    {
        _worker?.Dispose();
    }
}

# 提示词模板 — ML-Agents 配置
请为 [游戏场景] 配置 Unity ML-Agents 训练环境：

## 训练目标
[描述 AI 需要学习的行为，如"敌人学会追击和躲避玩家攻击"]

## 环境设置
1. Agent 脚本（观察空间、动作空间、奖励函数）
2. 训练配置 YAML（超参数）
3. 训练环境场景设置
4. 推理模式集成（训练完成后在游戏中使用）

## 约束
- 使用 ML-Agents 3.x
- 观察空间使用 Ray Perception Sensor
- 动作空间：[离散 / 连续]
- 训练时间预算：[1小时 / 4小时 / 过夜]

# 1. 使用 Godot 4.4+ 创建新项目
# 选择渲染器：Forward+（3D 高质量）/ Mobile（移动端）/ Compatibility（低端）
 
# 2. 初始化 Git
git init
echo ".godot/
*.import
export_presets.cfg
*.translation" > .gitignore
 
# 3. 安装 GDAI MCP 插件
# 方法 A：通过 Godot Asset Library
# 在 Godot 编辑器中：AssetLib → 搜索 "GDAI MCP" → 安装
 
# 方法 B：手动安装
# 下载 https://github.com/3ddelano/gdai-mcp-plugin-godot
# 将 addons/gdai_mcp/ 复制到项目的 addons/ 目录
 
# 4. 启用 GDAI MCP 插件
# Project → Project Settings → Plugins → 启用 GDAI MCP
 
# 5. 配置 AI 工具连接 MCP Server
# 在 Claude Code / Cursor 的 MCP 配置中添加 GDAI MCP Server

// .claude/mcp_servers.json（Claude Code MCP 配置）
{
  "gdai-mcp": {
    "command": "godot",
    "args": ["--headless", "--mcp"],
    "description": "Godot Engine MCP Server - 操控 Godot 编辑器"
  }
}

// Cursor MCP 配置（.cursor/mcp.json）
{
  "mcpServers": {
    "gdai-mcp": {
      "command": "godot",
      "args": ["--headless", "--mcp"],
      "description": "Godot Engine MCP Server"
    }
  }
}

# CLAUDE.md — Godot 游戏项目
 
## 项目概述
这是一个使用 Godot 4.4 开发的 [游戏类型] 游戏。
目标平台：[PC / Mobile / Web / Console]
 
## 技术栈
- 引擎：Godot 4.4+
- 语言：GDScript（主要）、C#（性能关键部分可选）
- 渲染器：Forward+（3D）/ Compatibility（2D/移动端）
- 物理：Jolt Physics（4.4+ 内置）/ Godot Physics
- UI：Control 节点系统
 
## 项目结构

## GDScript 编码规范（Godot 4.4+）
- 类名：PascalCase（`class_name PlayerController`）
- 变量/函数：snake_case（`var move_speed: float`）
- 常量：UPPER_SNAKE_CASE（`const MAX_SPEED: float = 10.0`）
- 信号：snake_case（`signal health_changed(new_health: int)`）
- 枚举：PascalCase 枚举名，UPPER_SNAKE_CASE 值
  ```gdscript
  enum State { IDLE, RUNNING, JUMPING, ATTACKING }

### 2.3 GDAI MCP Server 工作流详解

GDAI MCP 是 2025 年 Godot AI 生态最重要的突破。它让 AI Agent 可以直接操控 Godot 编辑器，实现真正的"Vibe Coding"游戏开发。

#### GDAI MCP 核心能力

#### 操作步骤 — GDAI MCP 完整工作流

**步骤 1：安装和配置 GDAI MCP**

```bash
# 安装 GDAI MCP 插件到 Godot 项目
# 方法 1：从 GitHub 下载
git clone https://github.com/3ddelano/gdai-mcp-plugin-godot.git
cp -r gdai-mcp-plugin-godot/addons/gdai_mcp your_project/addons/

# 方法 2：从 Godot Asset Library 安装
# 在 Godot 编辑器中：AssetLib → 搜索 "GDAI MCP" → Download → Install

# 启用插件
# Project → Project Settings → Plugins → 勾选 GDAI MCP → 重启编辑器

# 使用 Claude Code + GDAI MCP 的工作流示例

# 1. 让 AI 创建一个新场景
"请通过 GDAI MCP 在 Godot 中创建一个新的 2D 场景：
- 根节点：Node2D（命名为 Level1）
- 添加 TileMapLayer 子节点（用于地形）
- 添加 Camera2D 子节点（跟随玩家）
- 添加 CanvasLayer 子节点（用于 UI）
- 保存为 scenes/levels/level_1.tscn"

# 2. 让 AI 创建并附加脚本
"请为 Level1 场景创建关卡管理脚本：
- 创建 scripts/levels/level_1.gd
- 实现敌人生成逻辑
- 实现关卡完成检测
- 附加到 Level1 根节点"

# 3. 让 AI 读取和修复错误
"请检查 Godot 编辑器中的当前错误，分析原因并修复"

# 推荐的 GDAI MCP 工作流循环

开发者描述需求
    │
    ▼
Claude Code 分析需求
    │
    ├── 需要编辑器操作 → 通过 GDAI MCP 执行
    │   ├── 创建/修改场景
    │   ├── 添加/配置节点
    │   └── 设置信号连接
    │
    ├── 需要编写脚本 → 直接生成 .gd 文件
    │   ├── 创建新脚本
    │   ├── 修改现有脚本
    │   └── 附加到节点
    │
    └── 需要调试 → 读取编辑器状态
        ├── 获取错误列表
        ├── 分析场景树
        └── 检查节点属性
    │
    ▼
开发者在 Godot 编辑器中验证
    │
    ▼
运行游戏测试 → 反馈 → 迭代

# 提示词模板 — Godot 场景结构
请为 Godot 4.4 的 [场景类型] 设计场景树结构：

## 场景信息
- 游戏类型：[2D 平台跳跃 / 2D 俯视角 / 3D 第三人称]
- 渲染器：[Forward+ / Compatibility]

## 要求
1. 合理的节点层级（不超过 5 层深度）
2. 使用组合模式（场景嵌套）而非深层继承
3. 每个功能模块是独立的子场景（.tscn）
4. 包含碰撞层配置建议
5. 包含信号连接方案

## 输出
- 场景树结构（缩进表示父子关系）
- 每个节点的类型和关键属性
- 子场景拆分建议
- 信号连接图

Level（Node2D）
├── TileMapLayer          # 地形瓦片
├── Parallax              # 视差背景
│   ├── ParallaxBackground
│   └── ParallaxLayer
├── Entities              # 游戏实体容器
│   ├── Player.tscn       # 玩家子场景
│   ├── Enemies           # 敌人容器
│   └── Items             # 道具容器
├── Interactables         # 可交互对象
│   ├── Doors
│   ├── Chests
│   └── NPCs
├── Camera2D              # 摄像机
├── Navigation            # 导航
│   └── NavigationRegion2D
├── CanvasLayer           # UI 层
│   └── HUD.tscn          # HUD 子场景
└── AudioStreamPlayer     # 背景音乐

# 提示词模板 — 碰撞层配置
请为 [游戏类型] 设计 Godot 碰撞层（Physics Layers）配置：

## 游戏中的碰撞体类型
- 玩家
- 敌人
- 玩家子弹
- 敌人子弹
- 地形/墙壁
- 可交互对象
- 触发区域

## 输出
1. 碰撞层分配表（Layer 1-8）
2. 每种对象的 Layer 和 Mask 配置
3. 碰撞矩阵图

Layer 1: 地形/墙壁（Terrain）
Layer 2: 玩家（Player）
Layer 3: 敌人（Enemy）
Layer 4: 玩家子弹（PlayerProjectile）
Layer 5: 敌人子弹（EnemyProjectile）
Layer 6: 可拾取物品（Pickup）
Layer 7: 交互区域（Interaction）
Layer 8: 触发器（Trigger）

碰撞矩阵：
         地形  玩家  敌人  玩家弹  敌人弹  物品  交互  触发
地形      -    ✓    ✓     ✓      ✓     ✓    -    -
玩家      ✓    -    ✓     -      ✓     ✓    ✓    ✓
敌人      ✓    ✓    -     ✓      -     -    -    -
玩家弹    ✓    -    ✓     -      -     -    -    -
敌人弹    ✓    ✓    -     -      -     -    -    -
物品      ✓    ✓    -     -      -     -    -    -
交互      -    ✓    -     -      -     -    -    -
触发      -    ✓    -     -      -     -    -    -

# 在项目根目录创建 Skills 目录
mkdir -p .claude/skills/godot/
 
# 方法 1：从社区下载
# https://github.com/alexmeckes/godot-claude-skills
# 将 skills/ 目录内容复制到 .claude/skills/godot/
 
# 方法 2：手动创建核心 Skill 文件

# 提示词模板 — Godot GDScript 生成（通用）
你是一个 Godot 4.4+ 游戏开发专家。请生成以下功能的 GDScript：

## 需求
[描述游戏功能需求]

## 技术约束
- Godot 版本：4.4+
- 使用严格类型提示（var name: Type = value）
- 使用 @export 暴露编辑器参数
- 使用 await 替代 yield
- 信号使用 signal_name.connect() 语法
- 使用 Jolt Physics（如涉及 3D 物理）

## 代码规范
1. 类名使用 PascalCase，变量/函数使用 snake_case
2. 使用 @onready 延迟初始化节点引用
3. 使用 class_name 注册自定义类型
4. 资源管理使用 preload()（小资源）或 load()（大资源）
5. 状态机使用枚举 + match 语句
6. 使用类型化数组和字典（4.4+）
7. 添加中文注释说明关键逻辑

## 输出格式
- 完整的 .gd 文件内容
- 必要的 Resource 定义（.tres 或 .gd）
- 场景配置说明（需要哪些节点和属性）

# 具体示例提示词
请为 Godot 4.4 的 2D 平台跳跃游戏生成玩家控制器：

## 功能需求
1. 水平移动（加速/减速曲线）
2. 跳跃（可变高度，短按低跳长按高跳）
3. 土狼时间（Coyote Time）
4. 跳跃缓冲（Jump Buffer）
5. 墙壁滑行和蹬墙跳
6. 冲刺（带冷却和无敌帧）

## 技术要求
- 继承 CharacterBody2D
- 使用 Input.get_axis() 获取输入
- 地面检测使用 RayCast2D
- 所有参数通过 @export 或 Resource 配置
- 使用状态机管理玩家状态（枚举 + match）
- 使用 move_and_slide() 处理移动

## 场景结构
Player（CharacterBody2D）
├── CollisionShape2D
├── AnimatedSprite2D
├── GroundRayCast（RayCast2D）
├── WallRayCast（RayCast2D）
├── CoyoteTimer（Timer）
├── JumpBufferTimer（Timer）
└── DashCooldownTimer（Timer）

# scripts/core/event_bus.gd
# Godot 4.4 事件总线 — 全局信号中心
# 在 Project Settings → Autoload 中注册为 EventBus
 
class_name EventBusClass
extends Node
 
## 玩家相关信号
signal player_health_changed(current: int, max_health: int)
signal player_died
signal player_respawned(position: Vector2)
 
## 敌人相关信号
signal enemy_spawned(enemy: Node2D)
signal enemy_died(enemy: Node2D, position: Vector2)
signal all_enemies_cleared
 
## 游戏流程信号
signal level_started(level_id: int)
signal level_completed(level_id: int, time: float, score: int)
signal game_paused
signal game_resumed
signal game_over(final_score: int)
 
## 物品相关信号
signal item_collected(item_type: StringName, amount: int)
signal inventory_changed(item_type: StringName, new_count: int)
 
## UI 相关信号
signal show_dialog(dialog_data: Resource)
signal dialog_finished
signal show_notification(message: String, duration: float)

# resources/data/enemy_data.gd
# 使用 Resource 存储敌人配置数据
 
class_name EnemyData
extends Resource
 
@export_group("基础属性")
@export var enemy_name: StringName = &"Unknown"
@export var max_health: int = 100
@export var move_speed: float = 50.0
@export var damage: int = 10
 
@export_group("AI 行为")
@export var detection_range: float = 200.0
@export var attack_range: float = 50.0
@export var patrol_speed: float = 30.0
@export var chase_speed: float = 80.0
 
@export_group("掉落")
@export var drop_table: Array[DropEntry] = []
@export var experience_value: int = 10
 
@export_group("视觉")
@export var sprite_frames: SpriteFrames
@export var death_effect: PackedScene

# 提示词模板 — Godot 资产管线配置
请为 Godot 4.4 项目设计资产管理方案：

## 项目类型
[2D 像素风 / 2D 手绘 / 3D 低多边形 / 3D 写实]

## 需求
1. 资产导入配置（.import 文件设置）
2. 精灵表（Sprite Sheet）切割和动画配置
3. 音频导入和流式加载配置
4. 资源预加载策略
5. 场景切换时的资源管理

## 输出
1. 资产目录结构规范
2. 导入预设配置
3. ResourceLoader 异步加载管理器
4. 内存管理最佳实践

# scripts/core/resource_manager.gd
# 异步资源加载管理器
 
class_name ResourceManagerClass
extends Node
 
## 资源加载完成信号
signal resource_loaded(path: String, resource: Resource)
signal loading_progress(path: String, progress: float)
 
var _cache: Dictionary[String, Resource] = {}
var _loading_queue: Array[String] = []
 
## 同步加载（小资源）
func load_resource(path: String) -> Resource:
    if _cache.has(path):
        return _cache[path]
    var resource: Resource = load(path)
    if resource:
        _cache[path] = resource
    return resource
 
## 异步加载（大资源）
func load_resource_async(path: String) -> void:
    if _cache.has(path):
        resource_loaded.emit(path, _cache[path])
        return
    ResourceLoader.load_threaded_request(path)
    _loading_queue.append(path)
 
func _process(_delta: float) -> void:
    var completed: Array[String] = []
    for path: String in _loading_queue:
        var status: ResourceLoader.ThreadLoadStatus = \
            ResourceLoader.load_threaded_get_status(path)
        match status:
            ResourceLoader.THREAD_LOAD_LOADED:
                var resource: Resource = \
                    ResourceLoader.load_threaded_get(path)
                _cache[path] = resource
                resource_loaded.emit(path, resource)
                completed.append(path)
            ResourceLoader.THREAD_LOAD_IN_PROGRESS:
                var progress: Array = []
                ResourceLoader.load_threaded_get_status(path, progress)
                if progress.size() > 0:
                    loading_progress.emit(path, progress[0])
            ResourceLoader.THREAD_LOAD_FAILED:
                push_error("资源加载失败: %s" % path)
                completed.append(path)
    for path: String in completed:
        _loading_queue.erase(path)
 
## 释放缓存资源
func unload_resource(path: String) -> void:
    _cache.erase(path)
 
## 清空所有缓存
func clear_cache() -> void:
    _cache.clear()

┌──────────────────────────────────────────────────────────────────┐
│              Godot AI 辅助完整开发工作流                           │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. 项目初始化                                                    │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ Godot 4.4 创建项目 → 安装 GDAI MCP 插件                 │     │
│  │ → 配置 CLAUDE.md → 安装 Godot Skills → Git 初始化       │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  2. 核心系统开发（GDAI MCP + Claude Code）                       │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ AI Agent 通过 MCP 操控编辑器：                           │     │
│  │ • 创建场景结构 → 添加节点 → 配置属性                     │     │
│  │ • 生成 GDScript → 附加到节点 → 连接信号                  │     │
│  │ • 创建 Autoload（GameManager, EventBus）                 │     │
│  │ → 开发者在编辑器中验证 → 运行测试                        │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  3. 游戏系统开发（迭代循环）                                      │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ 每个系统：                                               │     │
│  │ 描述需求 → AI 生成脚本 + 场景 → 人工审查                 │     │
│  │ → 编辑器中测试 → 反馈 → AI 修改 → 验证通过              │     │
│  │                                                         │     │
│  │ 系统列表：玩家控制 → 敌人 AI → 战斗 → 关卡生成          │     │
│  │ → 物品/库存 → 存档 → UI → 音频                          │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  4. 资产集成                                                     │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ AI 生成资产 → 导入 Godot → 配置 .import 设置            │     │
│  │ → 创建 SpriteFrames 动画 → 配置 AudioStream             │     │
│  │ → 创建材质和 Shader                                     │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  5. 测试与优化                                                    │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ • GUT（Godot Unit Test）框架测试                         │     │
│  │ • 内置 Profiler 性能分析                                 │     │
│  │ • AI 辅助 Bug 修复（读取编辑器错误）                     │     │
│  │ • 多平台导出测试                                         │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  6. 导出与发布                                                    │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ Export Presets 配置 → 平台模板下载                        │     │
│  │ → 导出 PC（Windows/Linux/macOS）                         │     │
│  │ → 导出 Web（HTML5）→ 导出 Mobile（Android/iOS）          │     │
│  │ → 测试导出包 → 提交商店                                  │     │
│  └─────────────────────────────────────────────────────────┘     │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────┐
│           Unreal Engine AI 辅助的挑战与解决方案                 │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  挑战 1：Blueprints 是可视化节点图，LLM 无法直接生成           │
│  ┌────────────────────────────────────────────────────┐      │
│  │ 解决方案：                                          │      │
│  │ A. 用 C++ 写逻辑，暴露给 Blueprints 调用            │      │
│  │ B. 用 MCP Server 操控编辑器创建 Blueprint 节点       │      │
│  │ C. 让 AI 描述 Blueprint 步骤，人工在编辑器中实现     │      │
│  │ D. 使用 UnrealGenAISupport 自动生成 Blueprint       │      │
│  └────────────────────────────────────────────────────┘      │
│                                                              │
│  挑战 2：C++ 代码复杂度高，UE 宏系统独特                      │
│  ┌────────────────────────────────────────────────────┐      │
│  │ 解决方案：                                          │      │
│  │ A. 在 CLAUDE.md 中详细定义 UE 编码规范和宏用法       │      │
│  │ B. 提供 .h/.cpp 模板作为参考                         │      │
│  │ C. 使用 Gameplay Framework 标准模式                  │      │
│  │ D. 分离引擎交互层和纯逻辑层                          │      │
│  └────────────────────────────────────────────────────┘      │
│                                                              │
│  挑战 3：项目结构复杂，编译时间长                              │
│  ┌────────────────────────────────────────────────────┐      │
│  │ 解决方案：                                          │      │
│  │ A. 使用模块化项目结构                                │      │
│  │ B. 热重载（Live Coding）减少编译等待                  │      │
│  │ C. 核心逻辑用 C++，快速迭代用 Blueprints             │      │
│  │ D. 使用 UnrealBuildTool 增量编译优化                  │      │
│  └────────────────────────────────────────────────────┘      │
│                                                              │
│  挑战 4：上下文窗口限制（UE 项目代码量巨大）                   │
│  ┌────────────────────────────────────────────────────┐      │
│  │ 解决方案：                                          │      │
│  │ A. 使用 Gemini 2.5 Pro（1M+ token 上下文）          │      │
│  │ B. 精心选择相关文件提供给 AI                         │      │
│  │ C. 使用 MCP 让 AI 按需读取项目文件                   │      │
│  │ D. 模块化开发，每次只关注一个模块                    │      │
│  └────────────────────────────────────────────────────┘      │
│                                                              │
└──────────────────────────────────────────────────────────────┘

# 1. 使用 Epic Games Launcher 创建 UE5.4+ 项目
# 选择模板：Third Person / Top Down / Blank
# 选择语言：C++（推荐，AI 可直接生成）
# 启用 Starter Content（可选）
 
# 2. 初始化 Git
git init
echo "Binaries/
DerivedDataCache/
Intermediate/
Saved/
Build/
.vs/
*.sln
*.VC.db
*.opensdf
*.opendb
*.sdf
*.suo
*.xcodeproj
*.xcworkspace" > .gitignore
 
# 3. 安装 Unreal MCP 插件
# 方法 A：UnrealGenAISupport
# 从 GitHub 下载：https://github.com/prajwalshettydev/UnrealGenAISupport
# 将插件复制到 Plugins/ 目录
 
# 方法 B：VibeUE
# 从 https://vibeue.com/ 下载安装
 
# 4. 配置 MCP 连接
# 在 Claude Code / Cursor 中配置 Unreal MCP Server

# CLAUDE.md — Unreal Engine 游戏项目
 
## 项目概述
这是一个使用 Unreal Engine 5.4+ 开发的 [游戏类型] 游戏。
目标平台：[PC / Console / Mobile]
 
## 技术栈
- 引擎：Unreal Engine 5.4+
- 语言：C++（核心逻辑）+ Blueprints（快速迭代/设计师工具）
- 渲染：Nanite + Lumen（PC/Console）/ Forward Shading（Mobile）
- 输入：Enhanced Input System
- AI：Behavior Tree + EQS（Environment Query System）
- 动画：Control Rig + IK
- UI：UMG（Unreal Motion Graphics）
 
## 项目结构

## C++ 编码规范（Unreal 风格）
- 类前缀：U（UObject）、A（AActor）、F（结构体）、E（枚举）、I（接口）、T（模板）
- 成员变量：PascalCase，无前缀（`float MoveSpeed`）
- 函数：PascalCase（`void TakeDamage(float Amount)`）
- 布尔变量：b 前缀（`bool bIsAlive`）
- 指针：使用 TObjectPtr<>（UE5 推荐）
- 智能指针：TSharedPtr、TWeakPtr、TUniquePtr

## UE 宏使用规范
```cpp
// 类声明
UCLASS(Blueprintable, BlueprintType)
class PROJECTNAME_API AMyActor : public AActor

// 属性
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Combat")
float MaxHealth = 100.0f;

UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "State")
bool bIsAlive = true;

// 函数
UFUNCTION(BlueprintCallable, Category = "Combat")
void TakeDamage(float Amount);

UFUNCTION(BlueprintImplementableEvent, Category = "Combat")
void OnDeath();

// 委托
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnHealthChanged, float, NewHealth);
UPROPERTY(BlueprintAssignable, Category = "Events")
FOnHealthChanged OnHealthChanged;

### 3.4 Unreal MCP Server 工作流

#### UnrealGenAISupport — 自动 Blueprint 和场景生成

UnrealGenAISupport 是目前功能最全面的 Unreal MCP 实现，支持：

#### 操作步骤 — Unreal MCP 工作流

**步骤 1：安装 UnrealGenAISupport**

```bash
# 1. 克隆插件仓库
git clone https://github.com/prajwalshettydev/UnrealGenAISupport.git

# 2. 将插件复制到 UE 项目
cp -r UnrealGenAISupport/Plugins/UnrealGenAISupport \
  YourProject/Plugins/

# 3. 重新生成项目文件
# Windows: 右键 .uproject → Generate Visual Studio project files
# macOS: 右键 .uproject → Generate Xcode project

# 4. 编译项目（插件会自动编译）

# 5. 在编辑器中启用插件
# Edit → Plugins → 搜索 "UnrealGenAISupport" → 启用 → 重启

# 6. 配置 MCP 连接
# 插件启动后会在本地运行 MCP Server
# 在 Claude Code / Cursor 中配置连接

# 使用 Claude Code + Unreal MCP 的工作流示例

# 1. 让 AI 创建关卡布局
"请通过 Unreal MCP 在当前关卡中创建以下布局：
- 在 (0, 0, 0) 放置一个 Floor（Static Mesh: Plane，缩放 10x10）
- 在四周放置墙壁（Box Collision + Static Mesh）
- 添加 4 个 Point Light（暖色调，强度 5000）
- 添加 Player Start 在 (0, 0, 100)
- 添加 3 个敌人生成点（NavMesh 可达区域）"

# 2. 让 AI 生成 C++ 组件
"请生成一个 UHealthComponent（ActorComponent）：
- MaxHealth、CurrentHealth 属性（BlueprintReadWrite）
- TakeDamage 函数（BlueprintCallable）
- Heal 函数（BlueprintCallable）
- OnHealthChanged 委托（BlueprintAssignable）
- OnDeath 委托（BlueprintAssignable）
- 包含 .h 和 .cpp 文件"

# 3. 让 AI 描述 Blueprint 操作步骤
"请描述如何在 Blueprint 中实现以下功能：
- 玩家按 E 键与 NPC 交互
- 显示对话 UI
- 对话选项影响任务状态
请给出详细的节点连接步骤。"

# 提示词模板 — Unreal C++ 生成（通用）
你是一个 Unreal Engine 5.4+ 游戏开发专家。请生成以下功能的 C++ 代码：

## 需求
[描述游戏功能需求]

## 技术约束
- UE 版本：5.4+
- 使用 UCLASS、UPROPERTY、UFUNCTION 宏
- 遵循 Unreal 命名规范（F/U/A/E/I/T 前缀）
- 使用 Enhanced Input System
- 使用 Gameplay Ability System（如涉及技能）

## 架构要求
1. .h 和 .cpp 分离
2. UPROPERTY 使用适当的说明符
   - EditAnywhere：编辑器可编辑
   - BlueprintReadWrite：蓝图可读写
   - VisibleAnywhere：编辑器只读
   - Replicated：网络同步
3. UFUNCTION(BlueprintCallable) 暴露给蓝图
4. 使用 TObjectPtr<> 替代裸指针
5. 正确管理内存（UPROPERTY 标记或智能指针）
6. 包含必要的 #include 和前向声明
7. 添加中文注释说明关键逻辑

## 输出格式
- .h 头文件（完整）
- .cpp 实现文件（完整）
- 使用说明（如何在编辑器中配置）
- Blueprint 暴露接口说明

// 提示词：请生成 UE5 的生命值组件
 
// HealthComponent.h
#pragma once
 
#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "HealthComponent.generated.h"
 
/// 生命值变化委托
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
    FOnHealthChanged, float, CurrentHealth, float, MaxHealth);
 
/// 死亡委托
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnDeath);
 
/**
 * 生命值组件
 * 管理 Actor 的生命值、伤害和治疗
 * 可附加到任何 Actor（玩家、敌人、可破坏物）
 */
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class PROJECTNAME_API UHealthComponent : public UActorComponent
{
    GENERATED_BODY()
 
public:
    UHealthComponent();
 
    /// 生命值变化事件（蓝图可绑定）
    UPROPERTY(BlueprintAssignable, Category = "Health|Events")
    FOnHealthChanged OnHealthChanged;
 
    /// 死亡事件（蓝图可绑定）
    UPROPERTY(BlueprintAssignable, Category = "Health|Events")
    FOnDeath OnDeath;
 
    /// 受到伤害
    UFUNCTION(BlueprintCallable, Category = "Health")
    void TakeDamage(float DamageAmount, AActor* DamageCauser = nullptr);
 
    /// 治疗
    UFUNCTION(BlueprintCallable, Category = "Health")
    void Heal(float HealAmount);
 
    /// 获取当前生命值百分比（0-1）
    UFUNCTION(BlueprintPure, Category = "Health")
    float GetHealthPercent() const;
 
    /// 是否存活
    UFUNCTION(BlueprintPure, Category = "Health")
    bool IsAlive() const;
 
protected:
    virtual void BeginPlay() override;
 
    /// 最大生命值
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Health",
        meta = (ClampMin = "1.0"))
    float MaxHealth = 100.0f;
 
    /// 当前生命值
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Health")
    float CurrentHealth;
 
    /// 是否有无敌帧
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Health")
    bool bHasInvincibility = false;
 
    /// 无敌帧持续时间（秒）
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Health",
        meta = (EditCondition = "bHasInvincibility", ClampMin = "0.0"))
    float InvincibilityDuration = 0.5f;
 
private:
    /// 当前是否处于无敌状态
    bool bIsInvincible = false;
 
    /// 无敌帧计时器句柄
    FTimerHandle InvincibilityTimerHandle;
 
    /// 无敌帧结束回调
    void OnInvincibilityEnd();
};

# 提示词模板 — Blueprint 操作指导
请描述如何在 UE5 Blueprint 中实现以下功能：

## 功能需求
[描述需要在 Blueprint 中实现的功能]

## 输出格式
请按以下格式描述每个步骤：
1. 在哪个 Blueprint 中操作
2. 添加什么节点（精确的节点名称）
3. 节点的输入/输出引脚连接
4. 需要设置的属性值
5. 如果涉及变量，说明变量类型和默认值

## 示例格式
步骤 1：打开 BP_PlayerCharacter
步骤 2：在 Event Graph 中，从 Event BeginPlay 拖出
步骤 3：添加 "Create Widget" 节点
  - Class: WBP_HUD
  - Owning Player: Get Player Controller (Index 0)
步骤 4：从 Create Widget 的 Return Value 拖出
步骤 5：添加 "Add to Viewport" 节点
...

# 提示词模板 — Nanite 资产配置
请为 UE5 项目配置 Nanite 资产管线：

## 需求
1. 哪些资产应该启用 Nanite（高多边形静态网格）
2. 哪些资产不应该使用 Nanite（透明物体、变形网格）
3. Nanite 导入设置最佳实践
4. LOD 与 Nanite 的关系
5. 性能监控指标

## 项目类型
[开放世界 / 线性关卡 / 室内场景]
目标平台：[PC / Console]（Nanite 不支持移动端）

# 提示词模板 — Lumen 光照配置
请为 UE5 场景配置 Lumen 全局光照：

## 场景类型
[室外开放世界 / 室内场景 / 混合场景]

## 需求
1. Lumen 全局光照设置（Software/Hardware Ray Tracing）
2. Lumen 反射设置
3. 光源配置最佳实践
4. 性能优化（Lumen Scene Detail、Final Gather Quality）
5. 烘焙 vs 实时的选择标准

## 性能目标
- 目标帧率：[60 / 30] FPS
- 目标分辨率：[1080p / 1440p / 4K]
- GPU：[RTX 3060 / RTX 4070 / Console]

# 提示词模板 — MetaHuman 集成
请为 UE5 项目集成 MetaHuman 角色：

## 需求
1. MetaHuman Creator 创建角色的工作流
2. 导入 UE5 项目的步骤
3. 动画系统配置（Control Rig、IK）
4. NVIDIA ACE 集成（AI 面部动画）
5. 性能优化（LOD、材质复杂度）

## 用途
[主角 / NPC / 过场动画角色]

MetaHuman Creator（Web）
    │
    ├── 创建/自定义角色外观
    ├── 调整面部特征、发型、服装
    └── 导出到 UE5 项目
        │
        ▼
UE5 项目集成
    │
    ├── Quixel Bridge 下载 MetaHuman 资产
    ├── 配置 Animation Blueprint
    ├── 设置 Control Rig（面部/身体）
    ├── 配置 LOD（近/中/远距离）
    └── 集成 NVIDIA ACE（可选）
        │
        ├── Audio2Face-3D 插件
        ├── AI 驱动嘴型同步
        └── 实时面部表情生成

┌──────────────────────────────────────────────────────────────────┐
│           Unreal Engine AI 辅助完整开发工作流                      │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. 项目初始化                                                    │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ UE5 创建 C++ 项目 → 安装 MCP 插件                       │     │
│  │ → 配置 CLAUDE.md → 模块化项目结构 → Git 初始化          │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  2. C++ 核心框架（AI 辅助生成）                                   │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ Claude Code / Cursor 生成：                              │     │
│  │ • GameMode / GameState / GameInstance                    │     │
│  │ • 基础 Character 类（玩家/敌人基类）                     │     │
│  │ • 核心 Component（Health, Combat, Inventory）            │     │
│  │ • Enhanced Input 配置                                    │     │
│  │ → 编译 → 在编辑器中验证                                  │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  3. Blueprint 扩展（AI 指导 + 人工操作）                          │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ AI 描述 Blueprint 步骤 → 人工在编辑器中实现              │     │
│  │ 或 MCP 自动生成 Blueprint → 人工验证                     │     │
│  │ • 玩家 BP（继承 C++ 基类）                               │     │
│  │ • 敌人 BP（行为树 + AI Controller）                      │     │
│  │ • UI Widget BP                                           │     │
│  │ • 关卡 BP                                                │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  4. 资产管线                                                     │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ 3D 模型 → Nanite 启用 → 材质配置                        │     │
│  │ MetaHuman → 导入 → 动画配置                              │     │
│  │ 环境 → Lumen 光照 → World Partition                      │     │
│  │ 音频 → MetaSounds 配置                                   │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  5. 测试与优化                                                    │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ • Automation Testing Framework                           │     │
│  │ • Unreal Insights 性能分析                               │     │
│  │ • GPU Profiler（Nanite/Lumen 优化）                      │     │
│  │ • AI 辅助 Bug 分析和修复                                 │     │
│  └─────────────────────────────────────────────────────────┘     │
│       │                                                          │
│       ▼                                                          │
│  6. 打包与发布                                                    │
│  ┌─────────────────────────────────────────────────────────┐     │
│  │ Project Settings 优化 → Packaging Settings               │     │
│  │ → Cook Content → 平台打包                                │     │
│  │ → 测试打包版本 → 提交商店                                │     │
│  └─────────────────────────────────────────────────────────┘     │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

你要做什么类型的游戏？
│
├── 2D 游戏
│   ├── 独立开发者 / 小团队 → Godot 4（最佳性价比）
│   ├── 需要丰富插件生态 → Unity（Asset Store）
│   └── 像素风 / 快速原型 → Godot 4
│
├── 3D 游戏（中小规模）
│   ├── 移动端 → Unity（跨平台最佳）
│   ├── PC 独立游戏 → Unity 或 Godot 4
│   └── 快速原型 → Godot 4
│
├── 3D 游戏（大规模/高画质）
│   ├── AAA 品质 → Unreal Engine
│   ├── 开放世界 → Unreal Engine（World Partition）
│   └── 高保真角色 → Unreal Engine（MetaHuman + Nanite）
│
└── AI 辅助开发优先
    ├── 最佳 AI 代码生成 → Unity（C# 训练数据最多）
    ├── 最佳 MCP 集成 → Godot（GDAI MCP 最成熟）
    ├── 最佳内置 AI → Unity（Unity AI 6.2+）
    └── 最低成本 → Godot（完全免费）

## 关键规则（Unity 专用）
- 使用新版 Input System，不要使用 Input.GetKey()
- 使用 [SerializeField] 而非 public 字段
- 使用 ScriptableObject 存储数据配置
- 使用 Addressables 而非 Resources 文件夹
- MonoBehaviour 仅用于 Unity 生命周期，业务逻辑用纯 C# 类
- 使用对象池管理频繁创建/销毁的对象
- 在 OnDestroy 中清理事件订阅

## 关键规则（Godot 4.4+ 专用）
- 使用 @export 替代 export（Godot 3 语法）
- 使用 await 替代 yield（Godot 3 语法）
- 使用 signal.connect() 替代 connect() 字符串形式
- 所有变量必须有类型提示
- 使用 @onready 缓存节点引用
- 使用 class_name 注册自定义类型
- 使用 Resource（.tres）存储数据配置
- 使用场景组合而非深层继承

## 关键规则（UE5.4+ 专用）
- 所有 UObject 成员必须标记 UPROPERTY（防止 GC 回收）
- 使用 TObjectPtr<> 替代裸指针
- 使用 Enhanced Input System，不要使用旧版 Input
- C++ 写核心逻辑，暴露 BlueprintCallable 给蓝图
- 使用 UFUNCTION(BlueprintImplementableEvent) 让蓝图扩展
- 使用 DataAsset / DataTable 存储配置数据
- 使用 ActorComponent 实现组件化
- 不要在构造函数中访问其他 Actor

# 通用提示词模板 — 适用于任何引擎
请为 [引擎名称] 实现一个 [系统名称] 系统：

## 系统需求
[详细描述系统功能]

## 设计约束
- 必须支持 [热重载 / 存档序列化 / 网络同步]
- 性能预算：[每帧 < 1ms / 支持 100+ 实体]
- 需要与 [其他系统] 交互

## 架构要求
1. 使用 [设计模式：状态机 / 观察者 / 命令 / ECS]
2. 数据驱动，配置与逻辑分离
3. 提供清晰的公共 API
4. 包含使用示例

## 引擎特定要求
### Unity
- 使用 ScriptableObject 存储配置
- 使用 C# events 或 UnityEvent 通信
- 遵循 Unity 编码规范

### Godot
- 使用 Resource 存储配置
- 使用 Signal 通信
- 遵循 GDScript 编码规范

### Unreal
- 使用 DataAsset / DataTable 存储配置
- 使用 Delegate 通信
- 遵循 Unreal 编码规范
- 提供 .h 和 .cpp 分离的代码

请为 Unity 6 生成一个自定义编辑器工具：

## 工具功能
[描述编辑器工具的功能]

## 技术要求
- 使用 Editor Window 或 Custom Inspector
- 使用 UIElements / UI Toolkit（不用 IMGUI）
- 放在 Editor/ 文件夹下
- 使用 SerializedProperty 操作数据
- 支持 Undo/Redo
- 包含工具栏按钮或菜单项入口

请通过 GDAI MCP 执行以下 Godot 编辑器操作：

## 操作列表
1. [创建/修改/删除] [场景/节点/脚本/资源]
2. [具体操作描述]

## 约束
- 使用 Godot 4.4+ API
- 操作完成后验证结果
- 如果操作失败，报告错误并建议修复方案

请描述如何在 UE5 Blueprint 中实现以下功能：

## 功能需求
[描述功能]

## 输出要求
1. 使用哪个 Blueprint（新建还是修改现有）
2. 逐步的节点添加和连接说明
3. 每个节点的精确名称（可在编辑器中搜索到的）
4. 需要创建的变量（名称、类型、默认值）
5. 需要的事件节点（Event BeginPlay, Event Tick 等）
6. 截图描述（如果节点图复杂）

# 1. 创建 Godot 4.4 项目
# 2. 安装 GDAI MCP 插件
# 3. 编写 CLAUDE.md（Godot 4.4 专用规范）
# 4. 安装 Claude Code Godot Skills
 
# 使用 Claude Code 生成核心架构：
claude "请为 Godot 4.4 的 2D 动作游戏创建核心架构：
- GameManager（Autoload，管理游戏状态）
- EventBus（Autoload，全局信号中心）
- StateMachine（通用状态机组件）
- ObjectPool（对象池管理器）
请遵循项目 CLAUDE.md 中的规范。"

shadow_blade/
├── scenes/
│   ├── player/
│   │   └── player.tscn
│   ├── enemies/
│   │   ├── slime.tscn
│   │   └── ninja.tscn
│   ├── levels/
│   │   ├── level_1.tscn
│   │   └── level_2.tscn
│   ├── ui/
│   │   ├── hud.tscn
│   │   └── pause_menu.tscn
│   └── effects/
│       ├── shadow_clone.tscn
│       └── teleport_effect.tscn
├── scripts/
│   ├── core/
│   │   ├── game_manager.gd      # Autoload
│   │   ├── event_bus.gd          # Autoload
│   │   ├── state_machine.gd      # 通用状态机
│   │   └── object_pool.gd        # 对象池
│   ├── player/
│   │   ├── player_controller.gd  # 玩家控制
│   │   ├── shadow_system.gd      # 影子分身系统
│   │   └── player_states.gd      # 玩家状态定义
│   ├── enemies/
│   │   ├── enemy_base.gd         # 敌人基类
│   │   └── enemy_ai.gd           # 敌人 AI
│   └── systems/
│       ├── combat_system.gd      # 战斗系统
│       └── level_manager.gd      # 关卡管理
├── resources/
│   ├── data/
│   │   ├── player_data.tres       # 玩家配置
│   │   └── enemy_data/            # 敌人配置
│   └── themes/
│       └── game_theme.tres        # UI 主题
├── assets/
│   ├── sprites/
│   ├── audio/
│   └── fonts/
├── addons/
│   └── gdai_mcp/
└── CLAUDE.md

# 通过 GDAI MCP 创建玩家场景
claude "请通过 GDAI MCP 创建玩家场景 scenes/player/player.tscn：
- 根节点：CharacterBody2D（命名 Player）
- 子节点：CollisionShape2D（胶囊形状）
- 子节点：AnimatedSprite2D
- 子节点：RayCast2D（地面检测，向下）
- 子节点：Area2D + CollisionShape2D（攻击范围）
- 子节点：Timer（影子冷却，3秒）
- 子节点：Marker2D（影子生成位置标记）
配置碰撞层：Layer 2（Player），Mask 1,3,6,7"

# 生成影子分身系统脚本
claude "请生成影子分身系统 scripts/player/shadow_system.gd：
功能：
1. 按 Shift 在当前位置留下影子分身
2. 影子分身是半透明的玩家幽灵
3. 再次按 Shift 瞬移到影子位置
4. 瞬移有 3 秒冷却
5. 瞬移路径上的敌人受到伤害
6. 影子存在时间最长 10 秒，超时自动消失
7. 同时只能存在 1 个影子

技术要求：
- 使用信号通知其他系统
- 瞬移使用 Tween 实现视觉效果
- 影子使用 Sprite2D + 半透明 Shader
- 路径伤害使用 RayCast2D 检测"

# 生成敌人 AI
claude "请为《影刃》生成两种敌人 AI：

1. 史莱姆（Slime）：
   - 在平台上来回巡逻
   - 发现玩家后加速追击
   - 接触玩家造成伤害
   - 使用状态机：PATROL → CHASE → STUNNED

2. 忍者（Ninja）：
   - 站在固定位置
   - 发现玩家后投掷手里剑
   - 玩家靠近时后跳保持距离
   - 使用状态机：IDLE → ATTACK → RETREAT → IDLE

两种敌人都使用 enemy_base.gd 基类，
配置数据使用 EnemyData Resource。"

# 通过 GDAI MCP 搭建关卡
claude "请通过 GDAI MCP 创建第一关 scenes/levels/level_1.tscn：
- 使用 TileMapLayer 创建地形
- 放置 3 个史莱姆和 2 个忍者
- 添加入口和出口标记
- 添加背景视差层
- 添加 Camera2D（跟随玩家，有边界限制）
- 添加 CanvasLayer + HUD

关卡设计：
- 教学区域（只有史莱姆，教玩家基础操作）
- 挑战区域（忍者 + 史莱姆组合）
- Boss 前区域（需要使用影子瞬移通过陷阱）"

# Leonardo.AI 生成角色精灵
# 提示词：
"pixel art game character, ninja with dark cape, 
32x32 sprite sheet, 4-direction idle and run animation,
dark action game style, transparent background"

# Suno 生成 BGM
# 提示词：
"dark electronic action game music, fast-paced, 
130 BPM, synthesizer and bass, loopable,
ninja stealth game soundtrack"

# AI 辅助 Bug 修复
claude "请检查 Godot 编辑器中的错误列表，
分析以下已知 Bug 并提供修复：
1. 影子瞬移后玩家偶尔卡在墙里
2. 忍者手里剑穿过地形
3. 死亡后重生位置不正确"

# CLAUDE.md — Unity 游戏项目完整模板
 
## 项目概述
这是一个使用 Unity 6.x（URP）开发的 [游戏类型] 游戏。
- 目标平台：[PC / Mobile / Console]
- 开发团队：[独立开发者 / 小团队 N 人]
- 预计开发周期：[N 个月]
 
## 技术栈
- 引擎：Unity 6.x LTS
- 渲染管线：URP（Universal Render Pipeline）
- 语言：C# 12+
- 输入系统：新版 Input System（com.unity.inputsystem）
- 物理：Unity Physics
- UI：UI Toolkit
- 动画：Animator + Cinemachine 3.x
- 音频：Unity Audio + FMOD/Wwise（可选）
- 网络：Netcode for GameObjects（如多人游戏）
- 版本控制：Git + Git LFS
 
## 核心依赖包
- com.unity.cinemachine（摄像机系统）
- com.unity.inputsystem（输入系统）
- com.unity.addressables（资产管理）
- com.unity.textmeshpro（文本渲染）
- com.unity.sentis（AI 推理，可选）
 
## 编码规范
### 命名
- 命名空间：PascalCase（`namespace ShadowBlade.Combat`）
- 类/接口：PascalCase（`class PlayerController`、`interface IDamageable`）
- 公共方法/属性：PascalCase（`public void TakeDamage()`）
- 私有字段：_camelCase（`private float _moveSpeed`）
- 参数/局部变量：camelCase（`float damageAmount`）
- 常量：UPPER_SNAKE_CASE（`const float MAX_SPEED = 10f`）
- 枚举值：PascalCase（`enum GameState { Playing, Paused }`）
 
### 代码组织
- 每个 MonoBehaviour 一个文件
- 文件名与类名一致
- 使用 #region 组织大文件
- 字段顺序：序列化字段 → 公共属性 → 私有字段 → Unity 回调 → 公共方法 → 私有方法
 
### 必须遵循的模式
```csharp
// ✅ 正确：使用 SerializeField + 私有字段
[Header("移动参数")]
[SerializeField, Tooltip("移动速度")] 
private float _moveSpeed = 5f;
 
// ❌ 错误：使用 public 字段
public float moveSpeed = 5f;
 
// ✅ 正确：缓存组件引用
private Rigidbody2D _rb;
private void Awake() => _rb = GetComponent<Rigidbody2D>();
 
// ❌ 错误：每帧获取组件
private void Update() => GetComponent<Rigidbody2D>().velocity = ...;
 
// ✅ 正确：使用事件解耦
public event Action<float> OnHealthChanged;
 
// ❌ 错误：直接引用其他组件
private void Update() => FindObjectOfType<UIManager>().UpdateHP();

### 6.2 Godot CLAUDE.md 完整模板

```markdown
# CLAUDE.md — Godot 游戏项目完整模板

## 项目概述
这是一个使用 Godot 4.4+ 开发的 [游戏类型] 游戏。
- 目标平台：[PC / Mobile / Web / Console]
- 开发团队：[独立开发者 / 小团队 N 人]
- 预计开发周期：[N 个月]

## 技术栈
- 引擎：Godot 4.4+
- 语言：GDScript（主要）
- 渲染器：[Forward+ / Mobile / Compatibility]
- 物理：[Jolt Physics / Godot Physics]
- UI：Control 节点 + Theme 系统
- 音频：AudioStreamPlayer + AudioBus
- 版本控制：Git

## Autoload 单例
- GameManager：游戏状态管理
- EventBus：全局信号中心
- AudioManager：音频管理
- SaveManager：存档管理

## GDScript 编码规范（Godot 4.4+ 严格模式）

### 命名规范
- 类名：PascalCase（`class_name PlayerController`）
- 文件名：snake_case（`player_controller.gd`）
- 变量/函数：snake_case（`var move_speed: float`）
- 常量：UPPER_SNAKE_CASE（`const MAX_SPEED: float = 10.0`）
- 信号：snake_case（`signal health_changed(value: int)`）
- 枚举名：PascalCase，值：UPPER_SNAKE_CASE
- 私有成员：_ 前缀（`var _internal_state: int`）

### 必须使用的语法（Godot 4.4+）
```gdscript
# ✅ 正确：严格类型提示
var speed: float = 5.0
var enemies: Array[Enemy] = []
var scores: Dictionary[String, int] = {}  # 4.4+ 类型化字典
func move(direction: Vector2) -> void:

# ❌ 错误：无类型提示
var speed = 5.0
var enemies = []
func move(direction):

# ✅ 正确：@export 和 @onready
@export var max_health: int = 100
@onready var sprite: AnimatedSprite2D = $AnimatedSprite2D

# ❌ 错误：Godot 3 语法
export var max_health = 100
onready var sprite = $AnimatedSprite2D

# ✅ 正确：信号连接
health_changed.connect(_on_health_changed)
await get_tree().create_timer(1.0).timeout

# ❌ 错误：Godot 3 语法
connect("health_changed", self, "_on_health_changed")
yield(get_tree().create_timer(1.0), "timeout")

# ✅ 正确：super 调用
func _ready() -> void:
    super._ready()

# ❌ 错误：Godot 3 语法
func _ready():
    ._ready()

class_name MyClass
extends Node2D
 
## 文档注释
 
# 信号
signal my_signal(value: int)
 
# 枚举
enum State { IDLE, RUNNING }
 
# 常量
const MAX_VALUE: int = 100
 
# @export 变量
@export var my_param: float = 1.0
 
# @onready 变量
@onready var my_node: Sprite2D = $Sprite2D
 
# 普通变量
var _state: State = State.IDLE
 
# 生命周期函数
func _ready() -> void: pass
func _process(delta: float) -> void: pass
func _physics_process(delta: float) -> void: pass
func _input(event: InputEvent) -> void: pass
 
# 公共函数
func do_something() -> void: pass
 
# 私有函数
func _internal_logic() -> void: pass
 
# 信号回调
func _on_button_pressed() -> void: pass

### 6.3 Unreal CLAUDE.md 完整模板

```markdown
# CLAUDE.md — Unreal Engine 游戏项目完整模板

## 项目概述
这是一个使用 Unreal Engine 5.4+ 开发的 [游戏类型] 游戏。
- 目标平台：[PC / Console / Mobile]
- 开发团队：[独立开发者 / 小团队 / 中型团队]
- 预计开发周期：[N 个月]

## 技术栈
- 引擎：Unreal Engine 5.4+
- 语言：C++（核心）+ Blueprints（扩展/快速迭代）
- 渲染：Nanite + Lumen（PC/Console）
- 输入：Enhanced Input System
- AI：Behavior Tree + EQS + Mass AI
- 动画：Animation Blueprint + Control Rig
- UI：UMG（Unreal Motion Graphics）
- 音频：MetaSounds
- 网络：Unreal Replication System（如多人游戏）

## C++ 编码规范

### 命名规范
- 类前缀：U（UObject）、A（AActor）、F（结构体/非UObject类）
  E（枚举）、I（接口）、T（模板）、S（Slate Widget）
- 成员变量：PascalCase（`float MaxHealth`）
- 布尔变量：b 前缀（`bool bIsAlive`）
- 函数：PascalCase（`void TakeDamage(float Amount)`）
- 参数：PascalCase（`void SetHealth(float NewHealth)`）
- 指针：使用 TObjectPtr<>（`TObjectPtr<UHealthComponent> HealthComp`）

### UPROPERTY 说明符速查
```cpp
// 编辑器可编辑，蓝图可读写
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")

// 编辑器只读，蓝图只读
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "State")

// 仅蓝图可读（不在编辑器显示）
UPROPERTY(BlueprintReadOnly, Category = "Internal")

// 网络同步
UPROPERTY(Replicated, EditAnywhere, Category = "Network")

// 条件编辑
UPROPERTY(EditAnywhere, meta = (EditCondition = "bUseCustomValue"))

// 范围限制
UPROPERTY(EditAnywhere, meta = (ClampMin = "0.0", ClampMax = "100.0"))

// 蓝图可调用
UFUNCTION(BlueprintCallable, Category = "Combat")
 
// 蓝图可实现（C++ 声明，蓝图实现）
UFUNCTION(BlueprintImplementableEvent, Category = "Events")
 
// 蓝图可覆盖（C++ 有默认实现）
UFUNCTION(BlueprintNativeEvent, Category = "Events")
 
// 纯函数（无副作用）
UFUNCTION(BlueprintPure, Category = "Utils")
 
// 服务器 RPC
UFUNCTION(Server, Reliable, WithValidation)
 
// 客户端 RPC
UFUNCTION(Client, Reliable)

C++ 负责：
├── 核心游戏逻辑（伤害计算、状态管理）
├── 性能关键代码（物理、AI 决策）
├── 网络同步逻辑
├── 数据结构和算法
└── 基类定义（暴露接口给 Blueprint）

Blueprint 负责：
├── 视觉效果配置（粒子、材质参数）
├── UI 布局和交互
├── 快速原型和迭代
├── 设计师可调参数
├── 动画蓝图（Animation Blueprint）
└── 关卡特定逻辑

---

## 7. MCP Server 对比与选择

### 7.1 游戏引擎 MCP Server 全景

| MCP Server | 引擎 | 核心能力 | 成熟度 | 维护状态 | 推荐度 |
|-----------|------|---------|--------|---------|--------|
| **GDAI MCP** | Godot 4.2+ | 场景/脚本/资源/调试全覆盖 | ⭐⭐⭐⭐⭐ | 活跃 | 🥇 |
| **Godot MCP（ee0pdt）** | Godot 4.x | 节点创建/编辑/场景管理 | ⭐⭐⭐⭐ | 活跃 | 🥈 |
| **Coding-Solo Godot MCP** | Godot 4.x | 启动编辑器/运行项目/调试输出 | ⭐⭐⭐ | 活跃 | 🥉 |
| **UnrealGenAISupport** | UE5 | Blueprint/场景/Python 脚本 | ⭐⭐⭐⭐ | 活跃 | 🥇 |
| **VibeUE** | UE5 | 对话式开发/Blueprint 理解 | ⭐⭐⭐⭐ | 活跃 | 🥈 |
| **Unreal MCP（FastMCP）** | UE5.5+ | Actor/Blueprint/Widget/视口 | ⭐⭐⭐⭐ | 活跃 | 🥈 |
| **Unreal-MCPython** | UE5 | Python 脚本/Blueprint 解释 | ⭐⭐⭐ | 活跃 | 🥉 |
| **Unity MCP（社区）** | Unity 6 | 基础编辑器操作 | ⭐⭐ | 早期 | ⭐⭐ |

### 7.2 MCP Server 选择建议

---

## 避坑指南

### ❌ 常见错误

1. **AI 生成 Godot 3 语法而非 Godot 4**
   - 问题：AI 训练数据中 Godot 3 代码远多于 Godot 4，经常生成 `yield`、`export`、`connect("signal", target, "method")` 等过时语法，导致运行时错误
   - 正确做法：在 CLAUDE.md 中明确列出所有 Godot 3 → 4 的语法变更，使用 Claude Code Godot Skills 强制现代语法，每次生成后检查是否包含旧语法关键词

2. **Unity 项目中 AI 使用旧版 Input Manager**
   - 问题：AI 经常生成 `Input.GetKey()`、`Input.GetAxis()` 等旧版 Input Manager 代码，而非新版 Input System 的 `InputAction`
   - 正确做法：在 CLAUDE.md 中明确禁止旧版 Input API，提供新版 Input System 的代码模板作为参考，在项目设置中禁用旧版 Input Manager

3. **Unreal 项目中 AI 忽略 UPROPERTY 标记**
   - 问题：AI 生成的 C++ 代码中，UObject 指针成员变量缺少 UPROPERTY 标记，导致垃圾回收器回收对象后出现悬空指针崩溃
   - 正确做法：在 CLAUDE.md 中强调"所有 UObject 成员必须标记 UPROPERTY"，使用 TObjectPtr<> 替代裸指针，代码审查时重点检查指针成员

4. **期望 AI 直接生成 Unreal Blueprints**
   - 问题：开发者期望 AI 像生成代码一样直接生成 Blueprint 节点图，但 Blueprint 是二进制/JSON 格式的可视化脚本，LLM 无法直接输出
   - 正确做法：使用 UnrealGenAISupport MCP 自动生成 Blueprint；或让 AI 生成 C++ 代码暴露给 Blueprint 调用；或让 AI 描述 Blueprint 节点连接步骤由人工实现

5. **AI 在 Update/Process 中分配内存**
   - 问题：AI 生成的游戏逻辑经常在每帧更新函数中创建新对象（`new Vector3()`、`Array.new()`、`FString::Printf()`），导致频繁 GC 和帧率波动
   - 正确做法：在 Steering 规则中明确禁止在更新函数中分配内存，要求使用对象池、预分配缓冲区、缓存计算结果

6. **不同引擎的 AI 代码生成质量差异巨大**
   - 问题：AI 对 C#（Unity）的代码生成质量最高（训练数据最多），GDScript 次之，UE C++ 最差（宏系统复杂、训练数据相对少）
   - 正确做法：Unity 项目可以更多依赖 AI 生成；Godot 项目使用 Skills 提升质量；Unreal 项目需要更多人工审查，核心逻辑建议人工编写后让 AI 扩展

7. **MCP 操作未验证就继续开发**
   - 问题：通过 MCP 让 AI 操控编辑器创建场景/节点后，不在编辑器中验证就继续下一步，导致错误累积
   - 正确做法：每次 MCP 操作后在编辑器中验证结果，特别是节点属性、信号连接、碰撞层配置等容易出错的地方

8. **忽略引擎版本特定的 API 变化**
   - 问题：Unity 6 vs Unity 2022、Godot 4.4 vs 4.3、UE 5.4 vs 5.3 之间存在 API 差异，AI 可能混用不同版本的 API
   - 正确做法：在 CLAUDE.md 中精确指定引擎版本号，提供版本特定的 API 变更列表，使用引擎内置的 API 文档验证

### ✅ 最佳实践

1. **为每个引擎编写详细的 CLAUDE.md**：这是 AI 辅助游戏开发中 ROI 最高的投入，一份好的 Steering 规则可以避免 80% 的常见错误
2. **使用 MCP Server 实现编辑器自动化**：GDAI MCP（Godot）和 UnrealGenAISupport（Unreal）可以让 AI Agent 直接操控编辑器，比手动操作快 3-5 倍
3. **C++ 写核心，Blueprint/GDScript 做扩展**：在 Unreal 中，让 AI 生成 C++ 基类并暴露接口给 Blueprint；在 Godot 中，核心系统用 GDScript，配置用 Resource
4. **每个系统独立开发和测试**：不要让 AI 一次性生成整个游戏，分系统开发（玩家→敌人→战斗→关卡→UI），每个系统完成后测试验证
5. **资产管线标准化**：建立从 AI 生成到引擎导入的标准化管线，包括命名规范、格式要求、导入设置模板
6. **频繁 Git 提交**：AI 辅助开发时更需要频繁提交，因为 AI 可能意外破坏已有功能，Git 回滚是最后的安全网
7. **人工测试游戏手感**：AI 可以生成功能正确的代码，但游戏的"手感"（跳跃弧度、攻击反馈、摄像机跟随）只有人类才能评判和调优

---

## 相关资源与延伸阅读

### MCP Server 与 AI 集成

1. **[GDAI MCP Server](https://gdaimcp.com/)** — Godot 引擎最全面的 MCP 服务器，支持场景、脚本、资源、调试全流程操控
2. **[UnrealGenAISupport](https://github.com/prajwalshettydev/UnrealGenAISupport)** — Unreal Engine 的 AI 自动化插件，支持 Blueprint 和场景自动生成
3. **[VibeUE](https://vibeue.com/)** — Unreal Engine 的对话式 AI 开发 MCP Server
4. **[Godot MCP（ee0pdt）](https://github.com/ee0pdt/Godot-MCP)** — 社区 Godot MCP 实现，支持节点创建和场景管理

### Claude Code Skills

5. **[Godot Claude Skills](https://github.com/alexmeckes/godot-claude-skills)** — Claude Code 的 Godot 4 代码生成 Skill，强制现代 GDScript 语法
6. **[GDScript Patterns Skill](https://www.mcpmarket.com/tools/skills/godot-gdscript-patterns-1)** — Godot 游戏架构模式 Skill（状态机、事件总线、对象池）

### 引擎官方资源

7. **[Unity AI 官方页面](https://unity.com/ai/faq)** — Unity AI 工具套件官方文档，包含 Generators、Assistants、Automation
8. **[Godot 4.4 发布说明](https://godotengine.org/releases/4.4/)** — Godot 4.4 新特性详解，包含 Jolt Physics、类型化字典等
9. **[Unreal Engine MetaHuman](https://www.unrealengine.com/en-US/metahuman)** — MetaHuman 官方文档，高保真数字人创建框架
10. **[Unity ML-Agents](https://github.com/Unity-Technologies/ml-agents)** — Unity 官方机器学习 Agent 工具包

---

## 参考来源

- [GDAI MCP — Introducing GDAI MCP](https://gdaimcp.com/blog/introducing-gdai-mcp)（2025 年 6 月）— GDAI MCP Server 发布，Godot 4.2+ AI Agent 集成
- [Unity 6.2 Launches Unity AI](https://completeaitraining.com/news/unity-62-launches-unity-ai-suite-with-generative-tools-new/)（2025 年 8 月）— Unity AI Beta 发布，编辑器内生成式 AI 工具
- [Unity AI Will Let You Build Entire Games with Words](https://gradientgroup.com/unity-ai-will-let-you-build-entire-games-with-just-words/)（2026 年 2 月）— Unity CEO 宣布升级版 Unity AI 支持自然语言生成完整游戏
- [Unity Says Its AI Tech Will Soon Eliminate the Need for Coding](https://www.gamedeveloper.com/programming/unity-says-its-ai-tech-will-soon-be-able-to-prompt-full-casual-games-into-existence-)（2026 年 2 月）— Unity AI 民主化游戏开发
- [Unreal Engine MCP: FastMCP AI Automation](https://mcplane.com/mcp_servers/unreal)（2025 年 7 月）— UE5.5+ MCP 自动化工具
- [UnrealGenAISupport — Automatic Blueprint Generation](https://github.com/prajwalshettydev/UnrealGenAISupport)（2025 年）— Unreal AI Blueprint 自动生成插件
- [Godot 4.4 Release Notes](https://godotengine.org/releases/4.4/)（2025 年 3 月）— Godot 4.4 新特性：Jolt Physics、类型化字典、性能优化
- [Godot Claude Skills](https://www.claudepluginhub.com/skills/alexmeckes-godot-claude-skills/skills/godot-code-gen)（2025 年）— Claude Code Godot 4 代码生成 Skill
- [NVIDIA ACE + MetaHuman](https://developer.nvidia.com/blog/simplify-and-scale-ai-powered-metahuman-deployment-with-nvidia-ace-and-unreal-engine-5/)（2024 年 11 月）— NVIDIA ACE 与 UE5 MetaHuman AI 面部动画集成
- [Godot MCP（ee0pdt）](https://deepwiki.com/ee0pdt/Godot-MCP)（2025 年）— Godot MCP 系统架构解析

---

> 📖 返回 [总览与导航](../00-总览与导航.md) | 上一节：[AI辅助游戏开发概览](./34a-AI辅助游戏开发概览.md) | 下一节：[AI辅助游戏逻辑](./34c-AI辅助游戏逻辑.md)