给 AI 写小游戏开发需求：场景、节点、组件、交互怎么描述

你向 AI 描述「做个跳跃功能」，它给了你一堆无法运行的碎片代码。你想创建一个完整的游戏关卡，但不知道怎么把节点树结构讲清楚，AI 生成的层级乱成一团。

问题不在 AI 的能力。模糊的 Prompt 就像拿着菜谱做菜却没有配料表——AI 只能自由发挥，结果和你想的完全不一样。

游戏开发的需求其实可以标准化。场景、节点、组件、交互，这四个核心概念都有对应的描述模板。这篇文章分享一套实战验证过的方法论：场景四要素法、节点树 JSON 格式、组件描述模板、交互五要素公式，外加 5 个可以直接复制使用的 Prompt 模板。

如果你在用 Cocos Creator 做小游戏，想靠 AI 提效率但又总是翻车，这里应该有你需要的答案。

为什么游戏需求需要标准化描述

模糊的需求描述是 AI 游戏开发的头号杀手。我试过直接说「帮我做个跳跃功能」，AI 给了一段 player.y += 10 的代码——没有物理系统、没有碰撞检测、没有动画过渡，跑起来角色直接瞬移到天上去了。

这类问题有三个典型症状。

第一个问题：AI 无法理解节点层级。你在 Cocos Creator 里创建一个 Player 节点，下面挂了 HealthBar 子节点显示血条。但如果你只说「创建一个玩家」，AI 不会知道 HealthBar 要作为子节点存在，它可能会把 HealthBar 当成独立节点放在场景根目录里。代码跑起来，血条不会跟随玩家移动。

看一眼对比：

❌ "创建一个玩家"
✅ "创建 Player 根节点，挂载 Sprite 组件显示角色贴图，子节点 HealthBar 显示血条，相对位置 (0, 32)"

第二个版本把父子关系讲清楚了，AI 生成的代码就不会层级混乱。

第二个问题：组件组合关系混乱。Cocos Creator 的核心架构是「节点 + 组件」——节点本身是空壳，组件赋予功能。一个 Player 节点可能挂载 Sprite（显示贴图）、RigidBody2D（物理刚体）、Collider（碰撞检测）、PlayerScript（自定义逻辑）四个组件。如果你只说「让角色能移动」，AI 可能只给你一个移动脚本，忘了挂物理组件，角色穿墙而过，毫无碰撞反馈。

正确的描述应该把组件清单列出来：

❌ "让角色能移动"
✅ "Player 节点挂载 RigidBody2D 组件（type: dynamic），子节点 Collider 组件（tag: 'player'），再加 PlayerScript 处理键盘输入"

第三个问题：交互逻辑碎片化。你说「点击按钮跳一下」，AI 给你一段触摸事件监听代码，但跳多久、跳多高、跳的时候能不能再跳、跳完之后状态怎么恢复，这些细节都没处理。代码跑起来，点击按钮角色确实动了，但动画卡顿、状态锁定、连续点击会出 bug。

完整的交互描述应该包含五个要素：触发条件、事件类型、目标对象、响应行为、状态变化。这一点后面会展开讲，先记住公式：

交互描述 = 触发条件 + 事件类型 + 目标对象 + 响应行为 + 状态变化

模糊描述的根源是缺少结构化思维。AI 需要明确的上下文、具体的指令、清晰的边界条件。Prompt 工程里有个 CREATE 框架，原本是通用编程的最佳实践，用在游戏开发上同样有效：

字段	游戏开发应用
C - Context	提供引擎版本（Cocos Creator 3.8）、项目结构、现有代码风格
R - Role	明确 AI 是「Cocos Creator 开发专家」
E - Example	给出期望的节点树 JSON 格式示例
A - Action	明确要做什么（创建节点、挂载组件、监听事件）
T - Tone	指定代码风格（TypeScript + Cocos Creator API）
E - Edge	说明约束条件（FPS ≥ 60、节点数 ≤ 50）

这套框架的核心逻辑是：把「做什么」拆解成「在什么条件下」「用什么工具」「达成什么标准」。下面四个章节会围绕场景、节点、组件、交互四个维度，把 CREATE 框架落地成可复制的模板。

场景描述的四要素法

场景是游戏开发的顶层概念。一个完整的场景描述包含四个要素：类型、风格、元素、交互点。把这四项填清楚，AI 就能生成一个骨架完整的关卡。

先看四要素的定义：

要素	定义	描述方法
场景类型	游戏关卡 / 界面 / 菜单	「一个 {类型} 场景，包含 {元素}」
视觉风格	2D / 3D、像素 / 写实	「采用 {风格} 美术风格，参考 {游戏名}」
核心元素	玩家、敌人、道具、UI	「包含 {数量} 个 {类型} 对象，位置 {坐标}」
交互点	可点击 / 可碰撞区域	「定义 {数量} 个交互区域，触发 {事件}」

这套方法的核心是：先确定场景的「骨架」（类型 + 风格），再填充「内容」（元素 + 交互点）。就像盖房子，先画蓝图，再往里面摆家具。

举个实战案例。你要做一个推箱子游戏关卡，描述怎么写？

【场景描述】

场景类型：一个推箱子游戏关卡场景
视觉风格：采用简约几何风格，背景为纯色，网格尺寸 64x64

核心元素：
  - 1 个 Player 节点（位置：第 1 行第 1 列）
  - 3 个 Box 节点（位置：第 2 行第 2 列、第 3 行第 4 列、第 5 行第 2 列）
  - 3 个 Target 节点（目标位置，显示为凹陷方格）
  - 墙壁节点（围绕场景边界）

交互点：
  - Player 可推动 Box，碰撞检测触发位移
  - Box 到达 Target 时触发胜利检测
  - 场景边界碰撞触发阻挡

【技术约束】

引擎：Cocos Creator 3.8
语言：TypeScript
性能：FPS ≥ 60，节点数 ≤ 50

这段描述把四要素都覆盖了。类型是「推箱子关卡」，风格是「简约几何」，元素列出了 Player、Box、Target、墙壁四个对象的具体位置，交互点定义了推箱子、胜利检测、边界阻挡三个核心逻辑。技术约束单独列出来，保证 AI 生成的代码符合性能要求。

这里有个细节：核心元素的位置用「第 N 行第 N 列」描述，而不是直接写像素坐标。这样做的好处是：AI 会根据网格尺寸（64x64）自动换算成像素坐标（第 1 行第 1 列 = (64, 64)），代码更灵活，改网格尺寸时不用手动调所有坐标。

再来一个模板，可以直接复制使用：

## 场景描述模板

【基本信息】

- 场景名称：{sceneName}
- 场景类型：{类型：战斗场景 / 菜单场景 / 结算场景}
- 视觉风格：{风格描述}

【核心元素清单】

1. {节点名}：{数量} 个，初始位置 ({x}, {y})
2. {节点名}：{数量} 个，功能描述
3. ...

【交互点定义】

- {交互点名称}：触发条件 {条件}，响应行为 {行为}
- {交互点名称}：...

【技术要求】

- 引擎版本：{version}
- 语言：{TypeScript / JavaScript}
- 性能指标：{FPS / 节点数 / 内存}

这套模板适合大多数 2D 小游戏场景。填完四要素，AI 就能生成一个结构完整的关卡骨架。第三章会讲怎么把「核心元素清单」展开成节点树的 JSON 格式，让 AI 理解层级关系。

节点树的标准描述格式

节点树是 Cocos Creator 场景的核心数据结构。每个节点可以有子节点，子节点继承父节点的位置（相对坐标），形成一棵树。向 AI 描述节点树，最清晰的方式是用 JSON 格式。

为什么选 JSON？因为它是结构化的、可解析的、AI 能直接理解。你给一段 JSON，AI 就知道根节点是谁、子节点有哪些、每个节点挂什么组件、属性是什么。代码生成时，AI 会按照 JSON 的层级关系逐层创建节点，不会搞乱父子关系。

先看一个标准的节点树 JSON 结构：

{
  "rootNode": "Scene",
  "tree": {
    "Player": {
      "components": ["Sprite", "RigidBody2D", "PlayerScript"],
      "position": {"x": 100, "y": 200},
      "properties": {
        "size": {"width": 64, "height": 64},
        "anchor": {"x": 0.5, "y": 0.5}
      },
      "children": {
        "HealthBar": {
          "components": ["ProgressBar"],
          "position": {"x": 0, "y": 32}
        },
        "Weapon": {
          "components": ["Sprite"],
          "position": {"x": 48, "y": 0}
        }
      }
    },
    "Enemies": {
      "components": [],
      "children": {
        "Enemy1": {
          "components": ["Sprite", "EnemyScript"],
          "position": {"x": 300, "y": 150}
        },
        "Enemy2": {
          "components": ["Sprite", "EnemyScript"],
          "position": {"x": 400, "y": 250}
        }
      }
    },
    "UI": {
      "components": [],
      "children": {
        "ScoreLabel": {
          "components": ["Label"],
          "content": "Score: 0"
        },
        "PauseButton": {
          "components": ["Button"],
          "onClick": "pauseGame()"
        }
      }
    }
  }
}

这段 JSON 描述了一个简单的战斗场景。根节点是 Scene，下面有三个顶层节点：Player（玩家）、Enemies（敌人容器）、UI（界面）。Player 下面又挂了 HealthBar 和 Weapon 两个子节点。AI 读到这段 JSON，就知道 HealthBar 要作为 Player 的子节点创建，位置是相对 Player 的 (0, 32)。

节点树描述有三个关键点需要记住。

第一个关键点：父子关系必须明确。子节点的 position 是相对父节点的偏移量。比如 HealthBar 的 position 是 (0, 32)，意思是它在 Player 正上方 32 像素的位置。如果 Player 移动到 (200, 300)，HealthBar 会自动跟随到 (200, 332)。这个机制保证了血条始终跟着玩家走。

如果你把 HealthBar 放在场景根节点而不是 Player 的子节点，血条就不会跟随玩家。我踩过这个坑：AI 生成的代码把 UI 元素都放在根节点，跑起来发现血条和玩家分离，玩家移动时血条原地不动。后来改用 JSON 格式描述节点树，AI 生成的代码层级关系就对了。

第二个关键点：组件组合而非继承。Cocos Creator 的设计理念是「节点是实体，组件赋予功能」。一个节点本身没有任何行为，挂了 Sprite 组件才能显示图片，挂了 RigidBody2D 才有物理属性，挂了 Script 才有自定义逻辑。这种组合式设计比继承式设计更灵活——你可以给 Player 挂 Sprite + RigidBody + Script，给 Enemy 挂 Sprite + RigidBody + EnemyScript，两个节点共享部分组件，但各自有独立的脚本。

JSON 里用 components 数组描述组件清单。AI 会按照数组顺序逐个挂载组件，每个组件的属性可以在 properties 里补充。

第三个关键点：节点命名要规范。遵循驼峰命名（Player、Enemy、HealthBar），功能性节点可以用下划线（bg_sprite、ui_canvas）。命名清晰的好处是：AI 生成的代码变量名一致，你后续维护代码时一眼就能看出节点用途。

再来一个实战案例：射击游戏的节点树。这段 JSON 可以直接发给 AI，让它生成完整的场景代码：

{
  "rootNode": "GameScene",
  "tree": {
    "Player": {
      "components": [
        "Sprite(贴图路径: assets/player.png)",
        "RigidBody2D(type: dynamic, gravityScale: 0)",
        "Collider(tag: 'player')",
        "PlayerScript"
      ],
      "position": {"x": 200, "y": 400},
      "properties": {"size": {"width": 64, "height": 64}},
      "children": {
        "BulletSpawnPoint": {"position": {"x": 32, "y": 0}}
      }
    },
    "Enemies": {
      "children": [
        {
          "Enemy1": {
            "components": ["Sprite", "Collider(tag: 'enemy')"],
            "position": {"x": 600, "y": 200}
          }
        },
        {
          "Enemy2": {
            "components": ["Sprite", "Collider(tag: 'enemy')"],
            "position": {"x": 700, "y": 300}
          }
        }
      ]
    },
    "Bullets": {
      "components": [],
      "description": "子弹池容器，动态创建 Bullet 节点"
    },
    "UI": {
      "children": {
        "ScoreLabel": {"components": ["Label"], "content": "Score: 0"},
        "RestartButton": {"components": ["Button"], "onClick": "restartGame()"}
      }
    }
  }
}

这段 JSON 有几个细节值得注意：

Player 下面有个 BulletSpawnPoint 子节点，位置是 (32, 0)，这个节点是子弹发射点，相对玩家偏移 32 像素
Enemies 是一个容器节点，下面用数组形式列出多个 Enemy 子节点
Bullets 是子弹池容器，description 字段说明它是动态创建 Bullet 节点的父节点
UI 下面的 RestartButton 有 onClick 属性，直接绑定回调函数名

发给 AI 时，加上技术约束：

请根据以上节点树 JSON 创建 Cocos Creator 场景。

要求：
1. 使用 Cocos Creator 3.8 API
2. TypeScript 代码，包含类型注解
3. 脚本组件使用 @ccclass 装饰器
4. 事件监听使用 node.on() 方法

AI 会按照 JSON 的层级关系生成完整的场景创建代码，包含节点创建、组件挂载、属性设置三个步骤。你拿到代码后，只需要补充脚本组件的具体逻辑，场景骨架就完成了。

组件描述模板

组件是节点功能的载体。向 AI 描述组件，核心是讲清楚四个字段：功能、属性、依赖、示例配置。这套模板适合所有 Cocos Creator 内置组件和自定义脚本组件。

先看四字段定义：

字段	必填性	描述
功能	必填	组件做什么（一句话）
属性	必填	配置参数（类型 + 描述）
依赖	可选	需要节点具备什么属性 / 其他组件
示例配置	推荐	典型配置值

这套模板的逻辑是：先告诉 AI 组件的用途（功能），再列出可调参数（属性），最后说明前置条件（依赖）。AI 会按照这个结构生成组件挂载代码，属性值按示例配置填写。

举个实战案例：Sprite 组件描述。

## 组件名称：Sprite

**功能**：显示图片贴图，2D 游戏最常用的渲染组件

**属性**：

- spriteFrame：SpriteFrame - 图片资源 | 默认值：null
- sizeMode：SizeMode - 尺寸模式（CUSTOM / RAW / TRIMMED） | 默认值：TRIMMED
- type：SpriteType - 渲染类型（SIMPLE / SLICED / TILED / FILLED） | 默认值：SIMPLE

**依赖**：

- 需要节点具备：size 属性（当 sizeMode = CUSTOM 时）

**示例配置**：

spriteFrame: assets/player.png
sizeMode: RAW

这段描述把 Sprite 组件的核心属性都列出来了。AI 读到这段，会生成类似这样的代码：

const sprite = node.addComponent(Sprite);
sprite.spriteFrame = assets.player;
sprite.sizeMode = SizeMode.RAW;

再来一个物理组件案例：RigidBody2D。

## 组件名称：RigidBody2D

**功能**：2D 物理刚体，赋予节点物理属性（重力、碰撞）

**属性**：

- type：RigidBodyType - 刚体类型（STATIC / DYNAMIC / KINEMATIC） | 默认值：STATIC
- gravityScale：number - 重力系数 | 默认值：1.0
- linearVelocity：Vec2 - 线速度 | 默认值：(0, 0)

**依赖**：

- 需要其他组件：Collider2D（碰撞检测）

**示例配置**：

type: DYNAMIC
gravityScale: 0.5
linearVelocity: (100, 0)

这里有个依赖字段：RigidBody2D 需要配合 Collider2D 才能做碰撞检测。AI 读到这个依赖，会提醒你在同一个节点上挂 Collider2D 组件，或者自动帮你加上。

这里讲一个常见的坑。我之前向 AI 描述「让角色有物理属性」，AI 只给我挂了 RigidBody2D，没挂 Collider。代码跑起来，角色确实受重力影响往下掉，但碰到地面直接穿过去了——没有碰撞检测。后来改用组件描述模板，把依赖字段加进去，AI 生成的代码就同时挂了 RigidBody2D + Collider2D。

总结一下组件描述模板的标准格式：

## 组件名称：{ComponentType}

**功能**：{一句话描述组件功能}

**属性**：

- {属性名}：{类型} - {描述} | 默认值：{default}
- {属性名}：{类型} - {描述} | 默认值：{default}

**依赖**：

- 需要节点具备：{Node 属性}（如：size、anchor）
- 需要其他组件：{Component 名}（如：RigidBody2D）

**示例配置**：

{property}: {value}
{property}: {value}

**代码示例**：

```typescript
// 获取组件
const sprite = this.node.getComponent(Sprite);
sprite.spriteFrame = newSpriteFrame;

这套模板适合 Cocos Creator 的所有内置组件（Sprite、Label、Button、RigidBody2D、Collider2D 等），也适合自定义脚本组件。如果你要创建一个 PlayerScript 组件，用同样的模板描述：

## 组件名称：PlayerScript

**功能**：处理玩家移动、跳跃、碰撞响应的自定义逻辑

**属性**：

- moveSpeed：number - 移动速度 | 默认值：200
- jumpHeight：number - 跳跃高度 | 默认值：100
- health：number - 当前生命值 | 默认值：100

**依赖**：

- 需要节点具备：RigidBody2D 组件（用于物理移动）
- 需要节点具备：Collider2D 组件（用于碰撞检测）

**示例配置**：

moveSpeed: 300
jumpHeight: 150
health: 100

AI 读到这段描述，会生成一个完整的 PlayerScript TypeScript 类，包含 @property 装饰器定义的属性、onLoad / start / update 生命周期方法、move / jump / takeDamage 等自定义方法。你拿到代码后，只需要填充具体逻辑，骨架已经完成了。

交互描述公式

交互是游戏逻辑的核心。玩家点击按钮、角色碰撞敌人、子弹击中目标，这些都是交互。向 AI 描述交互，最清晰的方式是用五要素公式：

交互描述 = 触发条件 + 事件类型 + 目标对象 + 响应行为 + 状态变化

五个要素的含义：

触发条件：什么情况下触发（碰撞、点击、键盘输入）
事件类型：具体事件名（TOUCH_START、onCollisionEnter）
目标对象：哪个节点 / 组件响应事件
响应行为：执行什么方法 / 函数
状态变化：数据 / 视觉如何变化

这套公式保证交互描述是完整的闭环。少了任何一个要素，AI 生成的代码都会有 bug。

举个例子。你说「点击按钮跳一下」，AI 只给你触摸事件监听代码，但没有说明跳多高、跳多久、跳完之后状态怎么恢复。代码跑起来，点击按钮角色确实动了，但动画卡顿、状态锁定、连续点击会出问题。

正确的描述应该把五个要素都写清楚：

## 交互名称：点击跳跃

【触发条件】

- 触发方式：触摸点击
- 触发对象：JumpButton 节点
- 触发时机：TOUCH_END（手指离开屏幕）

【事件监听】

- 监听节点：JumpButton
- 事件类型：Node.EventType.TOUCH_END
- 回调函数：onJumpButtonClicked

【响应行为】

- 执行方法：PlayerScript.jump()
- 参数传递：height = 100, duration = 0.3

【状态变化】

- 数据变化：Player.position.y += 100
- 视觉变化：Player 节点播放 jump 动画（scale: 1.0 → 1.2 → 1.0）
- 状态变化：Player.isJumping = true（持续 0.3 秒）

【代码实现】

```typescript
jumpButton.on(Node.EventType.TOUCH_END, (event) => {
  const playerScript = player.getComponent(PlayerScript);
  playerScript.jump({ height: 100, duration: 0.3 });
}, this);


这段描述把五个要素都覆盖了。AI 读到这段，会生成完整的触摸事件监听代码，包含回调函数、参数传递、状态管理。你拿到代码后，只需要补充 jump() 方法的具体实现逻辑。

再来一个碰撞交互案例：

```markdown
## 交互名称：碰撞伤害检测

【触发条件】

- 触发方式：碰撞检测
- 触发对象：Player 节点 Collider + Enemy 节点 Collider
- 触发时机：onCollisionEnter（碰撞开始）

【事件监听】

- 监听组件：Player 节点的 Collider 组件
- 事件类型：Collider2D.onCollisionEnter
- 回调函数：onPlayerHitEnemy

【响应行为】

- 执行方法：PlayerScript.takeDamage(amount)
- 参数传递：damage = 10

【状态变化】

- 数据变化：Player.health -= 10
- 视觉变化：Player 节点播放闪白动画（0.1 秒）
- 状态变化：Player.isHurt = true（持续 0.2 秒）

【代码实现】

```typescript
onCollisionEnter(self: Collider2D, other: Collider2D) {
  if (other.tag === 'enemy') {
    const playerScript = this.node.getComponent(PlayerScript);
    playerScript.takeDamage(10);
    this.flashWhite(0.1);
  }
}


这里有个细节：触发对象是两个节点的 Collider 组件，触发时机是 onCollisionEnter。AI 读到这段，会知道要在 Player 的 Collider 组件上监听碰撞事件，判断碰撞对象的 tag 是 'enemy' 后执行伤害逻辑。

交互描述有一个常见坑：状态变化没有讲清楚。我之前向 AI 描述「碰撞敌人扣血」，AI 给了一段 `health -= 10` 的代码，但没有加视觉反馈（闪白动画）和状态锁定（isHurt）。代码跑起来，玩家撞敌人确实扣血，但没有任何视觉提示，玩家不知道自己受伤了，连续碰撞会瞬间扣完血。

后来改用五要素公式，把状态变化补进去，AI 生成的代码就包含闪白动画和状态锁定，交互体验完整了。

这里给一个标准交互描述模板：

```markdown
## 交互名称：{交互描述}

【触发条件】

- 触发方式：{触摸 / 键盘 / 碰撞}
- 触发对象：{节点名}
- 触发时机：{TOUCH_START / TOUCH_END / onCollisionEnter}

【事件监听】

- 监听节点：{节点名}
- 事件类型：Node.EventType.{事件类型}
- 回调函数：{函数名}

【响应行为】

- 执行方法：{脚本名}.{方法名}
- 参数传递：{参数列表}

【状态变化】

- 数据变化：{变量名} = {新值}
- 视觉变化：{动画 / 颜色 / 位置变化}

这套模板适合触摸交互（点击按钮、滑动屏幕）、碰撞交互（角色撞敌人、子弹击目标）、键盘交互（方向键移动、空格键跳跃）。填完五个要素，AI 就能生成完整的事件监听代码。

Cocos Creator 的触摸事件有四种类型，这里列出来供参考：

事件类型	触发时机
TOUCH_START	手指按下屏幕
TOUCH_MOVE	手指在屏幕上滑动
TOUCH_END	手指离开屏幕
TOUCH_CANCEL	触摸被系统取消（如来电打断）

监听方式是 node.on(Node.EventType.{事件类型}, callback, target)。销毁时用 node.off() 取消监听，避免内存泄漏。这些细节在模板里都有体现，AI 会按照规范生成代码。

5个实战Prompt模板

前面讲了场景四要素、节点树 JSON、组件描述模板、交互五要素公式。这四个方法论落地到 Prompt，需要一套标准格式。这里提供 5 个可以直接复制使用的模板，覆盖创建场景、创建节点、实现交互、创建脚本、优化性能五个场景。

模板 1：创建完整场景

【角色】你是 Cocos Creator 开发专家，精通 TypeScript 和节点组件架构。

【任务】创建以下游戏场景的完整代码。

【场景描述】

场景类型：{类型}
视觉风格：{风格}
核心元素：{节点列表}
交互点：{交互列表}

【节点树结构】

```json
{节点树 JSON}

【技术要求】

引擎：Cocos Creator 3.8
语言：TypeScript，使用 @ccclass 装饰器
API：使用 Cocos Creator 官方 API（node.getComponent、node.on 等）

【输出要求】

场景代码（完整的节点创建逻辑）
脚本代码（包含类型注解和注释）
事件监听代码（交互逻辑）


### 模板 2：创建节点并挂载组件

【角色】Cocos Creator TypeScript 开发者

【任务】创建 {节点名} 节点并挂载 {组件列表} 组件

【节点属性】

名称：{nodeName}
位置：({x}, {y})
尺寸：{width}x{height}
锚点：({anchorX}, {anchorY})

【组件配置】

{组件名}：
- {属性}：{值}
{组件名}：
- {属性}：{值}

【输出要求】

TypeScript 代码，包含类型注解
使用 Cocos Creator 3.8 API
添加中文注释解释每行代码


### 模板 3：实现交互逻辑

【角色】Cocos Creator 事件系统专家

【任务】实现以下交互逻辑

【交互描述】

触发条件：{触发条件}
事件类型：{事件类型}
目标对象：{节点名}
响应行为：{方法名}
状态变化：{变化描述}

【技术约束】

使用 node.on 监听事件
事件类型使用 Node.EventType 枚举
回调函数包含 event 参数
销毁时使用 node.off 取消监听

【输出要求】

TypeScript 代码
包含完整的监听、回调、销毁逻辑
添加错误处理（节点不存在、组件缺失）


### 模板 4：创建脚本组件

【角色】Cocos Creator 脚本开发专家

【任务】创建 {脚本名} 脚本组件

【脚本功能】

{功能描述}

【属性定义】

@property({类型})
{属性名}：{类型} = {默认值}

【方法清单】

{方法名}({参数})：{返回类型}
- 功能：{描述}
{方法名}({参数})：{返回类型}
- 功能：{描述}

【生命周期】

onLoad：{初始化逻辑}
start：{启动逻辑}
update(dt)：{每帧更新逻辑}

【输出要求】

TypeScript 代码，使用 @ccclass 和 @property 装饰器
包含完整的生命周期方法
添加类型注解和中文注释


### 模板 5：优化节点树性能

【角色】Cocos Creator 性能优化专家

【任务】优化以下节点树结构的性能

【当前节点树】

{节点树 JSON}

【性能问题】

节点数量过多：{数量}
DrawCall 过高：{次数}
内存占用过大：{大小}

【优化目标】

FPS：≥ 60
DrawCall：≤ 20
内存：≤ 100MB

【优化策略】

合并节点：{合并方案}
使用节点池：{复用方案}
优化组件：{组件优化方案}

【输出要求】

优化后的节点树 JSON
TypeScript 优化代码
性能对比数据（优化前 vs 优化后）


这五个模板覆盖了 AI 游戏开发的完整流程：从场景创建到节点挂载，从交互实现到脚本编写，最后到性能优化。每个模板都遵循 CREATE 框架：Context（角色设定）、Action（任务描述）、Edge（技术约束、性能指标）、Example（节点树 JSON 示例）。

使用时，直接复制模板，替换 `{}` 里的内容。比如模板 2，你要创建一个 Player 节点，就把 `{nodeName}` 改成 `Player`，`{组件列表}` 改成 `Sprite, RigidBody2D, PlayerScript`，属性按实际需求填写。AI 会按照模板生成完整的代码，省去你从头写 Prompt 的时间。

## 总结

这篇文章讲了四套方法论和五个实战模板。回顾一下核心要点：

**场景描述四要素**：类型、风格、元素、交互点。先确定场景骨架，再填充内容，AI 生成一个结构完整的关卡。

**节点树 JSON 格式**：根节点 → 子节点 → 组件 → 属性 → 位置。用结构化格式描述层级关系，AI 按照树状结构逐层创建节点，不会搞乱父子关系。

**组件描述四字段**：功能、属性、依赖、示例配置。先讲用途，再列参数，最后说前置条件，AI 按照这个结构生成组件挂载代码。

**交互描述五要素**：触发条件、事件类型、目标对象、响应行为、状态变化。五个要素形成完整闭环，AI 生成的代码不会有遗漏。

这四套方法论落地到 Prompt，用五个实战模板承载：创建场景、创建节点、实现交互、创建脚本、优化性能。模板遵循 CREATE 框架，直接复制替换 `{}` 内容就能用。

下次向 AI 描述游戏需求时，试试用 JSON 格式描述节点树，用五要素公式描述交互逻辑。对比一下前后效果：模糊描述生成的代码碎片化、层级混乱、交互缺失；标准化描述生成的代码结构完整、层级清晰、交互闭环。效率的提升是实实在在的。