Cómo describir requisitos de minijuegos para la IA: escenas, nodos, componentes e interacciones

Le pides a la IA que «haga una función de salto» y te devuelve un montón de fragmentos de código que no funcionan. Quieres crear un nivel completo, pero no sabes cómo explicar la estructura del árbol de nodos; la IA genera una jerarquía caótica.

El problema no es la capacidad de la IA. Un prompt vago es como cocinar con una receta pero sin lista de ingredientes: la IA solo puede improvisar, y el resultado no se parece en nada a lo que tenías en mente.

Los requisitos de desarrollo de juegos se pueden estandarizar. Escena, nodo, componente e interacción: cada concepto central tiene su plantilla de descripción. En este artículo compartimos una metodología validada en la práctica: método de cuatro elementos para escenas, formato JSON de árbol de nodos, plantilla de descripción de componentes, fórmula de cinco elementos para interacciones, más 5 plantillas de prompt que puedes copiar y usar directamente.

Si usas Cocos Creator para minijuegos, quieres acelerar el trabajo con IA pero siempre acabas tropezando, aquí deberías encontrar lo que necesitas.

Por qué los requisitos de juego necesitan una descripción estandarizada

La descripción vaga de requisitos es el mayor enemigo del desarrollo de juegos con IA. Probé decir directamente «ayúdame a hacer una función de salto» y la IA devolvió código con player.y += 10: sin sistema físico, sin detección de colisiones, sin transición de animación. Al ejecutarlo, el personaje aparecía de golpe en el cielo.

Este tipo de problemas tiene tres síntomas típicos.

El primer problema: la IA no entiende la jerarquía de nodos. En Cocos Creator creas un nodo Player con un subnodo HealthBar para la barra de vida. Pero si solo dices «crea un jugador», la IA no sabrá que HealthBar debe ser un subnodo; puede colocarlo como nodo independiente en la raíz de la escena. Al ejecutar el código, la barra de vida no seguirá al jugador.

Mira la comparación:

❌ "Crea un jugador"
✅ "Crea nodo raíz Player con componente Sprite para mostrar el sprite del personaje, subnodo HealthBar para la barra de vida, posición relativa (0, 32)"

La segunda versión deja clara la relación padre-hijo; el código generado no mezclará la jerarquía.

El segundo problema: relaciones de componentes desordenadas. La arquitectura central de Cocos Creator es «nodo + componente»: el nodo es un contenedor vacío y los componentes le dan funcionalidad. Un nodo Player puede llevar Sprite (renderizado), RigidBody2D (cuerpo rígido), Collider (colisión) y PlayerScript (lógica personalizada). Si solo dices «haz que el personaje se mueva», la IA puede darte solo un script de movimiento, olvidando los componentes físicos; el personaje atraviesa paredes sin feedback de colisión.

La descripción correcta debe listar los componentes:

❌ "Haz que el personaje se mueva"
✅ "Nodo Player con RigidBody2D (type: dynamic), subnodo con Collider (tag: 'player'), más PlayerScript para entrada de teclado"

El tercer problema: lógica de interacción fragmentada. Dices «al pulsar el botón, salta» y la IA te da un listener de eventos táctiles, pero no define cuánto dura el salto, qué altura, si se puede saltar de nuevo en el aire ni cómo se restaura el estado. Al ejecutar, el personaje se mueve, pero la animación se traba, el estado queda bloqueado y los clics repetidos provocan bugs.

Una descripción completa de interacción debe incluir cinco elementos: condición de activación, tipo de evento, objeto objetivo, comportamiento de respuesta y cambio de estado. Más adelante lo desarrollamos; por ahora recuerda la fórmula:

Descripción de interacción = condición de activación + tipo de evento + objeto objetivo + comportamiento de respuesta + cambio de estado

La raíz de las descripciones vagas es la falta de pensamiento estructurado. La IA necesita contexto explícito, instrucciones concretas y condiciones límite claras. En ingeniería de prompts existe el marco CREATE, pensado originalmente para programación general y igualmente útil en desarrollo de juegos:

Campo	Aplicación en desarrollo de juegos
C - Context	Versión del motor (Cocos Creator 3.8), estructura del proyecto, estilo de código existente
R - Role	Definir a la IA como «experto en Cocos Creator»
E - Example	Ejemplo del formato JSON esperado para el árbol de nodos
A - Action	Qué hacer (crear nodos, montar componentes, escuchar eventos)
T - Tone	Estilo de código (TypeScript + API de Cocos Creator)
E - Edge	Restricciones (FPS ≥ 60, nodos ≤ 50)

La lógica central del marco es descomponer «qué hacer» en «bajo qué condiciones», «con qué herramientas» y «con qué estándar». Las cuatro secciones siguientes aplican CREATE a escena, nodo, componente e interacción con plantillas reutilizables.

Método de cuatro elementos para describir escenas

La escena es el concepto de nivel superior en desarrollo de juegos. Una descripción completa incluye cuatro elementos: tipo, estilo, elementos y puntos de interacción. Con esos cuatro campos claros, la IA puede generar un nivel con estructura sólida.

Definición de los cuatro elementos:

Elemento	Definición	Método de descripción
Tipo de escena	Nivel / interfaz / menú	«Una escena de {tipo} que incluye {elementos}»
Estilo visual	2D / 3D, pixel / realista	«Estilo artístico {estilo}, referencia {nombre del juego}»
Elementos centrales	Jugador, enemigos, objetos, UI	«{cantidad} objetos de tipo {tipo}, posición {coordenadas}»
Puntos de interacción	Zonas clicables / colisionables	«{cantidad} zonas de interacción que disparan {evento}»

La idea central: primero el «esqueleto» de la escena (tipo + estilo), luego el «contenido» (elementos + interacción). Como construir una casa: primero el plano, luego los muebles.

Ejemplo práctico: un nivel de Sokoban. ¿Cómo redactarlo?

【Descripción de escena】

Tipo de escena: nivel de juego Sokoban
Estilo visual: geométrico minimalista, fondo de color sólido, cuadrícula 64x64

Elementos centrales:
  - 1 nodo Player (posición: fila 1, columna 1)
  - 3 nodos Box (posición: fila 2 col 2, fila 3 col 4, fila 5 col 2)
  - 3 nodos Target (posiciones objetivo, casillas hundidas)
  - Nodos de pared (perímetro de la escena)

Puntos de interacción:
  - Player puede empujar Box; colisión provoca desplazamiento
  - Box en Target activa detección de victoria
  - Colisión con borde de escena bloquea el movimiento

【Restricciones técnicas】

Motor: Cocos Creator 3.8
Lenguaje: TypeScript
Rendimiento: FPS ≥ 60, nodos ≤ 50

Esta descripción cubre los cuatro elementos. Tipo: nivel Sokoban. Estilo: geométrico minimalista. Elementos: Player, Box, Target y paredes con posiciones concretas. Interacción: empujar, victoria y bloqueo en bordes. Las restricciones técnicas garantizan código acorde al rendimiento.

Detalle útil: las posiciones se describen como «fila N, columna N» en lugar de píxeles. La IA convierte según la cuadrícula (64x64): fila 1 col 1 = (64, 64). El código es más flexible; al cambiar el tamaño de celda no hay que retocar todas las coordenadas.

Plantilla reutilizable:

## Plantilla de descripción de escena

【Información básica】

- Nombre de escena: {sceneName}
- Tipo: {combate / menú / resultados}
- Estilo visual: {descripción del estilo}

【Lista de elementos centrales】

1. {nombreNodo}: {cantidad}, posición inicial ({x}, {y})
2. {nombreNodo}: {cantidad}, descripción de función
3. ...

【Definición de puntos de interacción】

- {nombrePunto}: condición {condición}, respuesta {comportamiento}
- {nombrePunto}: ...

【Requisitos técnicos】

- Versión del motor: {version}
- Lenguaje: {TypeScript / JavaScript}
- Métricas: {FPS / nodos / memoria}

Esta plantilla encaja con la mayoría de escenas 2D. Con los cuatro elementos completos, la IA genera un esqueleto de nivel coherente. En la siguiente sección veremos cómo expandir la lista de elementos a JSON de árbol de nodos para que la IA entienda la jerarquía.

Formato estándar para describir el árbol de nodos

El árbol de nodos es la estructura central de una escena en Cocos Creator. Cada nodo puede tener hijos que heredan posición relativa al padre. La forma más clara de describirlo a la IA es JSON.

¿Por qué JSON? Es estructurado, parseable y la IA lo entiende directamente. Con un JSON sabe cuál es la raíz, qué hijos hay, qué componentes lleva cada nodo y qué propiedades tiene. Al generar código, crea nodos capa por capa según la jerarquía, sin mezclar relaciones padre-hijo.

Estructura JSON estándar:

{
  "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()"
        }
      }
    }
  }
}

Este JSON describe una escena de combate simple. Raíz Scene; tres nodos de primer nivel: Player, Enemies (contenedor) y UI. Player tiene HealthBar y Weapon como hijos. La IA sabe que HealthBar debe crearse como hijo de Player en posición relativa (0, 32).

Tres puntos clave al describir el árbol de nodos.

Primero: la relación padre-hijo debe ser explícita. La posición del hijo es offset respecto al padre. HealthBar en (0, 32) queda 32 píxeles sobre Player. Si Player se mueve a (200, 300), HealthBar va a (200, 332). Así la barra de vida sigue al jugador.

Si HealthBar está en la raíz en lugar de bajo Player, no lo seguirá. Me pasó: la IA puso elementos UI en la raíz; al moverse el jugador, la barra quedaba fija. Con JSON de árbol de nodos, la jerarquía salió correcta.

Segundo: composición de componentes, no herencia. En Cocos Creator, «el nodo es entidad, el componente da función». Sin Sprite no hay imagen; sin RigidBody2D no hay física; sin Script no hay lógica propia. Puedes combinar Sprite + RigidBody + Script en Player y Sprite + RigidBody + EnemyScript en Enemy: componentes compartidos, scripts distintos.

En JSON, el array components lista los componentes. La IA los monta en orden; propiedades extra van en properties.

Tercero: nombres de nodos consistentes. CamelCase (Player, Enemy, HealthBar); nodos funcionales pueden usar guion bajo (bg_sprite, ui_canvas). Nombres claros alinean variables en el código generado y facilitan el mantenimiento.

Ejemplo de árbol para un shooter; puedes enviarlo tal cual a la IA:

{
  "rootNode": "GameScene",
  "tree": {
    "Player": {
      "components": [
        "Sprite(ruta textura: 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": "Contenedor de pool de balas; crea nodos Bullet dinámicamente"
    },
    "UI": {
      "children": {
        "ScoreLabel": {"components": ["Label"], "content": "Score: 0"},
        "RestartButton": {"components": ["Button"], "onClick": "restartGame()"}
      }
    }
  }
}

Detalles a notar:

• BulletSpawnPoint bajo Player en (32, 0): punto de disparo, 32 píxeles a la derecha del jugador
• Enemies es contenedor; hijos listados como array
• Bullets es pool; description indica creación dinámica de nodos Bullet
• RestartButton en UI con onClick enlazado al nombre de callback

Al enviar a la IA, añade restricciones técnicas:

Crea la escena de Cocos Creator según el JSON del árbol de nodos anterior.

Requisitos:
1. API de Cocos Creator 3.8
2. Código TypeScript con anotaciones de tipo
3. Componentes script con decorador @ccclass
4. Eventos con node.on()

La IA generará código de creación de escena completo: nodos, componentes y propiedades. Solo tendrás que completar la lógica de los scripts; el esqueleto de escena quedará hecho.

Plantilla de descripción de componentes

Los componentes portan la funcionalidad del nodo. Al describirlos a la IA, lo esencial son cuatro campos: función, propiedades, dependencias y configuración de ejemplo. Sirve para componentes integrados y scripts personalizados de Cocos Creator.

Definición de los cuatro campos:

Campo	Obligatorio	Descripción
Función	Sí	Qué hace el componente (una frase)
Propiedades	Sí	Parámetros (tipo + descripción)
Dependencias	Opcional	Qué debe tener el nodo / otros componentes
Configuración de ejemplo	Recomendado	Valores típicos

La lógica: propósito (función), parámetros (propiedades), prerrequisitos (dependencias). La IA genera código de montaje con valores según el ejemplo.

Ejemplo: componente Sprite.

## Nombre del componente: Sprite

**Función**: Muestra texturas de imagen; componente de renderizado 2D más usado

**Propiedades**:

- spriteFrame: SpriteFrame - recurso de imagen | valor por defecto: null
- sizeMode: SizeMode - modo de tamaño (CUSTOM / RAW / TRIMMED) | por defecto: TRIMMED
- type: SpriteType - tipo de render (SIMPLE / SLICED / TILED / FILLED) | por defecto: SIMPLE

**Dependencias**:

- El nodo necesita: propiedad size (cuando sizeMode = CUSTOM)

**Configuración de ejemplo**:

spriteFrame: assets/player.png
sizeMode: RAW

Con esta descripción, la IA puede generar código como:

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

Otro ejemplo: RigidBody2D.

## Nombre del componente: RigidBody2D

**Función**: Cuerpo rígido 2D; gravedad y colisiones físicas

**Propiedades**:

- type: RigidBodyType - tipo (STATIC / DYNAMIC / KINEMATIC) | por defecto: STATIC
- gravityScale: number - escala de gravedad | por defecto: 1.0
- linearVelocity: Vec2 - velocidad lineal | por defecto: (0, 0)

**Dependencias**:

- Requiere: Collider2D (detección de colisiones)

**Configuración de ejemplo**:

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

RigidBody2D necesita Collider2D para colisiones reales. La IA, al leer la dependencia, avisará o añadirá Collider2D en el mismo nodo.

Trampa habitual: pedí «física para el personaje» y la IA solo montó RigidBody2D, sin Collider. El personaje caía pero atravesaba el suelo. Con la plantilla y el campo de dependencias, el código incluyó RigidBody2D + Collider2D.

Formato estándar de la plantilla:

## Nombre del componente: {ComponentType}

**Función**: {descripción en una frase}

**Propiedades**:

- {nombre}: {tipo} - {descripción} | por defecto: {default}
- {nombre}: {tipo} - {descripción} | por defecto: {default}

**Dependencias**:

- El nodo necesita: {propiedad del nodo} (p. ej. size, anchor)
- Requiere componente: {nombre} (p. ej. RigidBody2D)

**Configuración de ejemplo**:

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

**Ejemplo de código**:

```typescript
// Obtener componente
const sprite = this.node.getComponent(Sprite);
sprite.spriteFrame = newSpriteFrame;

La plantilla vale para Sprite, Label, Button, RigidBody2D, Collider2D y scripts propios. Para PlayerScript:

## Nombre del componente: PlayerScript

**Función**: Lógica de movimiento, salto y respuesta a colisiones del jugador

**Propiedades**:

- moveSpeed: number - velocidad de movimiento | por defecto: 200
- jumpHeight: number - altura de salto | por defecto: 100
- health: number - vida actual | por defecto: 100

**Dependencias**:

- Requiere: RigidBody2D (movimiento físico)
- Requiere: Collider2D (detección de colisiones)

**Configuración de ejemplo**:

moveSpeed: 300
jumpHeight: 150
health: 100

La IA puede generar una clase PlayerScript completa: @property, onLoad / start / update, move / jump / takeDamage. Solo completas la lógica concreta; el esqueleto ya está.

Fórmula para describir interacciones

La interacción es el núcleo de la lógica de juego: pulsar botones, colisiones jugador-enemigo, impacto de balas. La forma más clara de describirla a la IA es la fórmula de cinco elementos:

Descripción de interacción = condición de activación + tipo de evento + objeto objetivo + comportamiento de respuesta + cambio de estado

Significado de los cinco elementos:

• Condición de activación: cuándo ocurre (colisión, clic, teclado)
• Tipo de evento: nombre concreto (TOUCH_START, onCollisionEnter)
• Objeto objetivo: qué nodo / componente responde
• Comportamiento de respuesta: qué método / función ejecutar
• Cambio de estado: cómo cambian datos y aspecto visual

La fórmula cierra el ciclo. Falta un elemento y el código tendrá bugs.

Ejemplo: «al pulsar el botón, salta». La IA solo da el listener táctil, sin altura, duración ni recuperación de estado. El personaje se mueve, pero la animación se traba, el estado se bloquea y los clics repetidos fallan.

La descripción correcta incluye los cinco elementos:

## Nombre de interacción: Salto al pulsar

【Condición de activación】

- Forma: toque en pantalla
- Objeto: nodo JumpButton
- Momento: TOUCH_END (dedo levantado)

【Escucha de eventos】

- Nodo: JumpButton
- Tipo: Node.EventType.TOUCH_END
- Callback: onJumpButtonClicked

【Comportamiento de respuesta】

- Método: PlayerScript.jump()
- Parámetros: height = 100, duration = 0.3

【Cambio de estado】

- Datos: Player.position.y += 100
- Visual: animación jump en Player (scale: 1.0 → 1.2 → 1.0)
- Estado: Player.isJumping = true (duración 0.3 s)

【Implementación】

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

Con los cinco elementos, la IA genera el listener completo con callback, parámetros y gestión de estado. Solo implementas la lógica interna de jump().

Ejemplo de colisión:

```markdown
## Nombre de interacción: Daño por colisión

【Condición de activación】

- Forma: detección de colisión
- Objetos: Collider de Player + Collider de Enemy
- Momento: onCollisionEnter (inicio de colisión)

【Escucha de eventos】

- Componente: Collider del nodo Player
- Tipo: Collider2D.onCollisionEnter
- Callback: onPlayerHitEnemy

【Comportamiento de respuesta】

- Método: PlayerScript.takeDamage(amount)
- Parámetros: damage = 10

【Cambio de estado】

- Datos: Player.health -= 10
- Visual: flash blanco en Player (0.1 s)
- Estado: Player.isHurt = true (duración 0.2 s)

【Implementación】

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

Detalle: dos Colliders, momento onCollisionEnter. La IA escuchará en el Collider de Player, comprobará tag 'enemy' y aplicará daño.

Trampa habitual: «colisión con enemigo resta vida» sin describir cambio de estado. La IA devolvió `health -= 10` sin feedback visual ni bloqueo isHurt. Sin aviso al jugador, colisiones seguidas vacían la vida al instante. Con la fórmula de cinco elementos, el código incluyó flash y bloqueo temporal.

Plantilla estándar:

```markdown
## Nombre de interacción: {descripción}

【Condición de activación】

- Forma: {toque / teclado / colisión}
- Objeto: {nombre del nodo}
- Momento: {TOUCH_START / TOUCH_END / onCollisionEnter}

【Escucha de eventos】

- Nodo: {nombre}
- Tipo: Node.EventType.{tipo}
- Callback: {nombreFunción}

【Comportamiento de respuesta】

- Método: {script}.{método}
- Parámetros: {lista}

【Cambio de estado】

- Datos: {variable} = {nuevo valor}
- Visual: {animación / color / posición}

Sirve para toque (botones, deslizar), colisión (jugador-enemigo, bala-objetivo) y teclado (flechas, espacio). Con los cinco elementos, la IA genera listeners completos.

Cocos Creator define cuatro tipos de evento táctil:

Tipo de evento	Momento
TOUCH_START	Dedo presiona la pantalla
TOUCH_MOVE	Dedo se desliza
TOUCH_END	Dedo se levanta
TOUCH_CANCEL	Toque cancelado por el sistema (p. ej. llamada entrante)

Escucha: node.on(Node.EventType.{tipo}, callback, target). Al destruir, node.off() para evitar fugas de memoria. La IA seguirá estas convenciones en el código generado.

5 plantillas de prompt listas para usar

Hemos visto escena (cuatro elementos), árbol JSON, componentes e interacción (cinco elementos). Para llevarlo al prompt hace falta un formato estándar. Aquí van 5 plantillas copiables: crear escena, crear nodo, implementar interacción, crear script y optimizar rendimiento.

Plantilla 1: Crear escena completa

【Rol】Eres experto en Cocos Creator, TypeScript y arquitectura nodo-componente.

【Tarea】Genera el código completo de la siguiente escena de juego.

【Descripción de escena】

Tipo: {tipo}
Estilo visual: {estilo}
Elementos centrales: {lista de nodos}
Puntos de interacción: {lista de interacciones}

【Estructura del árbol de nodos】

```json
{JSON del árbol}

【Requisitos técnicos】

• Motor: Cocos Creator 3.8
• Lenguaje: TypeScript con decorador @ccclass
• API: oficial de Cocos Creator (node.getComponent, node.on, etc.)

【Salida esperada】

1. Código de escena (creación completa de nodos)
2. Scripts (con tipos y comentarios)
3. Código de eventos (lógica de interacción)

### Plantilla 2: Crear nodo y montar componentes

【Rol】Desarrollador TypeScript en Cocos Creator

【Tarea】Crear nodo {nombreNodo} y montar componentes {listaComponentes}

【Propiedades del nodo】

• Nombre: {nodeName}
• Posición: ({x}, {y})
• Tamaño: {width}x{height}
• Ancla: ({anchorX}, {anchorY})

【Configuración de componentes】

1. {nombreComponente}:
   • {propiedad}: {valor}
2. {nombreComponente}:
   • {propiedad}: {valor}

【Salida esperada】

• Código TypeScript con anotaciones de tipo
• API Cocos Creator 3.8
• Comentarios explicando cada línea

### Plantilla 3: Implementar lógica de interacción

【Rol】Experto en sistema de eventos de Cocos Creator

【Tarea】Implementar la siguiente interacción

【Descripción de interacción】

Condición de activación: {condición}
Tipo de evento: {tipo}
Objeto objetivo: {nombreNodo}
Comportamiento: {nombreMétodo}
Cambio de estado: {descripción}

【Restricciones técnicas】

• Escuchar con node.on
• Tipos Node.EventType
• Callback con parámetro event
• node.off al destruir

【Salida esperada】

• Código TypeScript
• Escucha, callback y limpieza completos
• Manejo de errores (nodo inexistente, componente faltante)

### Plantilla 4: Crear componente script

【Rol】Experto en scripts de Cocos Creator

【Tarea】Crear componente script {nombreScript}

【Función del script】

{descripción de función}

【Definición de propiedades】

@property({tipo})
{nombrePropiedad}: {tipo} = {valorPorDefecto}

【Lista de métodos】

1. {nombreMétodo}({parámetros}): {tipoRetorno}
   • Función: {descripción}
2. {nombreMétodo}({parámetros}): {tipoRetorno}
   • Función: {descripción}

【Ciclo de vida】

• onLoad: {inicialización}
• start: {arranque}
• update(dt): {actualización por frame}

【Salida esperada】

• TypeScript con @ccclass y @property
• Métodos de ciclo de vida completos
• Tipos y comentarios explicativos

### Plantilla 5: Optimizar rendimiento del árbol de nodos

【Rol】Experto en optimización de rendimiento en Cocos Creator

【Tarea】Optimizar el rendimiento de la siguiente estructura de nodos

【Árbol actual】

{JSON del árbol}

【Problemas de rendimiento】

• Demasiados nodos: {cantidad}
• DrawCall alto: {valor}
• Memoria excesiva: {tamaño}

【Objetivos】

• FPS: ≥ 60
• DrawCall: ≤ 20
• Memoria: ≤ 100MB

【Estrategias】

1. Fusionar nodos: {plan}
2. Pool de nodos: {plan de reutilización}
3. Optimizar componentes: {plan}

【Salida esperada】

• JSON del árbol optimizado
• Código TypeScript de optimización
• Datos comparativos (antes vs después)

Estas cinco plantillas cubren el flujo completo: escena, nodos, interacción, scripts y rendimiento. Cada una sigue CREATE: Context (rol), Action (tarea), Edge (restricciones), Example (JSON de nodos).

Copia la plantilla y sustituye `{}`. En la plantilla 2, para Player: `{nodeName}` → `Player`, `{listaComponentes}` → `Sprite, RigidBody2D, PlayerScript`, y ajusta propiedades. La IA generará código completo y ahorrarás redactar prompts desde cero.

## Resumen

Cuatro metodologías y cinco plantillas prácticas. Puntos clave:

**Cuatro elementos de escena**: tipo, estilo, elementos, puntos de interacción. Primero el esqueleto, luego el contenido; la IA genera un nivel estructurado.

**JSON de árbol de nodos**: raíz → hijos → componentes → propiedades → posición. Formato estructurado para que la IA cree capas sin romper la jerarquía.

**Cuatro campos de componente**: función, propiedades, dependencias, ejemplo. Propósito, parámetros y prerrequisitos antes del código de montaje.

**Cinco elementos de interacción**: activación, evento, objetivo, respuesta, cambio de estado. Ciclo cerrado sin huecos en el código.

Las cinco plantillas (escena, nodo, interacción, script, rendimiento) aplican CREATE: copia, reemplaza `{}` y usa.

La próxima vez que describas requisitos de juego a la IA, prueba JSON para el árbol y la fórmula de cinco elementos para interacciones. Compara: prompts vagos dan código fragmentado, jerarquías rotas e interacciones incompletas; descripciones estandarizadas dan estructura clara y bucles de interacción cerrados. La mejora de eficiencia es real.