Como descrever requisitos de jogos para IA: cenas, nós, componentes e interação

Você descreve para a IA: “crie uma função de pulo”, e ela devolve um monte de trechos de código que não rodam. Você quer criar uma fase completa, mas não sabe explicar a estrutura da árvore de nós; a hierarquia gerada pela IA vira uma bagunça.

O problema não está na capacidade da IA. Um prompt vago é como cozinhar com uma receita sem lista de ingredientes: a IA precisa improvisar, e o resultado fica bem diferente do que você imaginou.

Requisitos de desenvolvimento de jogos podem ser padronizados. Cena, nó, componente e interação são quatro conceitos centrais, cada um com um template de descrição. Este artigo apresenta uma metodologia testada na prática: o método dos quatro elementos de cena, o formato JSON para árvore de nós, o template de descrição de componentes, a fórmula dos cinco elementos de interação e 5 templates de prompt prontos para copiar.

Se você usa Cocos Creator para criar minijogos e quer ganhar eficiência com IA, mas vive tropeçando no resultado, a resposta provavelmente está aqui.

Por que requisitos de jogos precisam de descrição padronizada

Descrições vagas são o principal problema no desenvolvimento de jogos com IA. Eu já pedi diretamente: “me ajude a criar uma função de pulo”, e a IA me deu um trecho player.y += 10: sem sistema físico, sem detecção de colisão, sem transição de animação. Ao rodar, o personagem simplesmente se teletransportava para o céu.

Esse tipo de problema tem três sintomas típicos.

Primeiro problema: a IA não entende a hierarquia de nós. No Cocos Creator, você cria um nó Player e adiciona um nó filho HealthBar para mostrar a barra de vida. Mas, se você só diz “crie um jogador”, a IA não sabe que HealthBar deve existir como nó filho. Ela pode colocar HealthBar como um nó independente na raiz da cena. Quando o código roda, a barra de vida não acompanha o movimento do jogador.

Veja a diferença:

❌ "Crie um jogador"
✅ "Crie o nó raiz Player, monte um componente Sprite para exibir a textura do personagem e adicione o nó filho HealthBar para mostrar a barra de vida, com posição relativa (0, 32)"

A segunda versão deixa clara a relação pai-filho, então o código gerado pela IA não bagunça a hierarquia.

Segundo problema: a combinação de componentes fica confusa. A arquitetura central do Cocos Creator é “nó + componente”: o nó em si é uma casca vazia, e os componentes dão função a ele. Um nó Player pode ter quatro componentes: Sprite, para exibir a textura; RigidBody2D, para o corpo físico; Collider, para detecção de colisão; e PlayerScript, para a lógica personalizada. Se você só diz “faça o personagem se mover”, a IA pode entregar apenas um script de movimento, esquecer o componente físico, e o personagem atravessa paredes sem nenhum feedback de colisão.

A descrição correta deve listar os componentes:

❌ "Faça o personagem se mover"
✅ "No nó Player, monte o componente RigidBody2D (type: dynamic), um componente Collider no nó filho (tag: 'player') e adicione PlayerScript para processar entrada do teclado"

Terceiro problema: a lógica de interação fica fragmentada. Você diz “ao clicar no botão, faça o personagem pular”. A IA entrega um trecho de listener de toque, mas não trata quanto tempo o pulo dura, qual a altura, se pode pular de novo durante o pulo, nem como o estado volta ao normal depois. Ao rodar, o personagem realmente se move quando o botão é clicado, mas a animação engasga, o estado trava e cliques repetidos geram bugs.

Uma descrição completa de interação deve incluir cinco elementos: condição de disparo, tipo de evento, objeto-alvo, comportamento de resposta e mudança de estado. Vamos detalhar isso depois. Por enquanto, guarde a fórmula:

descrição da interação = condição de disparo + tipo de evento + objeto-alvo + comportamento de resposta + mudança de estado

A raiz da descrição vaga é a falta de pensamento estruturado. A IA precisa de contexto claro, instruções concretas e condições de contorno bem definidas. Em engenharia de prompts existe o framework CREATE, originalmente usado como boa prática geral de programação; em desenvolvimento de jogos, ele funciona do mesmo jeito:

Campo	Aplicação em desenvolvimento de jogos
C - Context	Fornecer a versão do engine (Cocos Creator 3.8), a estrutura do projeto e o estilo do código existente
R - Role	Definir a IA como “especialista em Cocos Creator”
E - Example	Dar um exemplo do formato JSON esperado para a árvore de nós
A - Action	Explicar o que deve ser feito: criar nós, montar componentes, escutar eventos
T - Tone	Especificar o estilo do código: TypeScript + API do Cocos Creator
E - Edge	Declarar restrições: FPS ≥ 60, número de nós ≤ 50

A lógica central desse framework é quebrar “o que fazer” em “em quais condições”, “com quais ferramentas” e “com qual padrão de qualidade”. As próximas quatro seções transformam o CREATE em templates copiáveis para cena, nó, componente e interação.

Método dos quatro elementos para descrever cenas

A cena é o conceito de nível mais alto no desenvolvimento de jogos. Uma descrição completa de cena contém quatro elementos: tipo, estilo, elementos e pontos de interação. Quando esses quatro itens estão claros, a IA consegue gerar uma fase com esqueleto completo.

Veja primeiro a definição dos quatro elementos:

Elemento	Definição	Como descrever
Tipo de cena	Fase do jogo / interface / menu	”Uma cena de {tipo}, contendo {elementos}“
Estilo visual	2D / 3D, pixel art / realista	”Usa estilo visual {estilo}, com referência em {nome do jogo}“
Elementos principais	Jogador, inimigos, itens, UI	”Contém {quantidade} objetos do tipo {tipo}, na posição {coordenadas}“
Pontos de interação	Áreas clicáveis / áreas de colisão	”Define {quantidade} áreas de interação, disparando {evento}”

O núcleo desse método é: primeiro definir o “esqueleto” da cena, ou seja, tipo + estilo; depois preencher o “conteúdo”, ou seja, elementos + pontos de interação. É como construir uma casa: você desenha a planta antes de colocar os móveis.

Vamos a um caso prático. Você quer criar uma fase de Sokoban. Como escrever a descrição?

[Descrição da cena]

Tipo de cena: uma fase de jogo Sokoban
Estilo visual: estilo geométrico minimalista, fundo em cor sólida, grade de 64x64

Elementos principais:
  - 1 nó Player (posição: linha 1, coluna 1)
  - 3 nós Box (posições: linha 2 coluna 2, linha 3 coluna 4, linha 5 coluna 2)
  - 3 nós Target (posições de destino, exibidas como casas rebaixadas)
  - nós Wall (ao redor dos limites da cena)

Pontos de interação:
  - Player pode empurrar Box; a detecção de colisão dispara o deslocamento
  - Quando Box chega a Target, dispara a verificação de vitória
  - Colisão com os limites da cena dispara bloqueio

[Restrições técnicas]

Engine: Cocos Creator 3.8
Linguagem: TypeScript
Desempenho: FPS ≥ 60, número de nós ≤ 50

Essa descrição cobre os quatro elementos. O tipo é “fase de Sokoban”; o estilo é “geométrico minimalista”; os elementos listam Player, Box, Target e Wall com posições concretas; os pontos de interação definem empurrar caixas, verificar vitória e bloquear limites. As restrições técnicas ficam separadas para garantir que o código gerado pela IA siga os requisitos de desempenho.

Há um detalhe importante aqui: as posições dos elementos principais usam “linha N, coluna N” em vez de coordenadas em pixels. A vantagem é que a IA pode converter automaticamente de acordo com o tamanho da grade, por exemplo, linha 1 coluna 1 = (64, 64). O código fica mais flexível; ao mudar o tamanho da grade, você não precisa ajustar manualmente todas as coordenadas.

Aqui vai um template que você pode copiar diretamente:

## Template de descrição de cena

[Informações básicas]

- Nome da cena: {sceneName}
- Tipo de cena: {tipo: cena de combate / cena de menu / cena de resultado}
- Estilo visual: {descrição do estilo}

[Lista de elementos principais]

1. {nome do nó}: {quantidade} unidades, posição inicial ({x}, {y})
2. {nome do nó}: {quantidade} unidades, descrição da função
3. ...

[Definição dos pontos de interação]

- {nome do ponto de interação}: condição de disparo {condição}, comportamento de resposta {comportamento}
- {nome do ponto de interação}: ...

[Requisitos técnicos]

- Versão do engine: {version}
- Linguagem: {TypeScript / JavaScript}
- Métricas de desempenho: {FPS / número de nós / memória}

Esse template funciona para a maioria das cenas de minijogos 2D. Depois de preencher os quatro elementos, a IA consegue gerar um esqueleto de fase bem estruturado. A próxima seção mostra como expandir a “lista de elementos principais” para um formato JSON de árvore de nós, ajudando a IA a entender as relações hierárquicas.

Formato padrão para descrever a árvore de nós

A árvore de nós é a estrutura de dados central de uma cena no Cocos Creator. Cada nó pode ter nós filhos, e os filhos herdam a posição do pai em coordenadas relativas, formando uma árvore. Para descrever essa árvore para a IA, o jeito mais claro é usar JSON.

Por que JSON? Porque ele é estruturado, analisável e a IA entende diretamente. Ao fornecer um JSON, a IA sabe quem é o nó raiz, quais são os filhos, quais componentes cada nó recebe e quais propriedades cada um tem. Na geração de código, ela cria os nós camada por camada seguindo a hierarquia do JSON, sem bagunçar relações pai-filho.

Veja uma estrutura JSON padrão de árvore de nós:

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

Esse JSON descreve uma cena de combate simples. O nó raiz é Scene, com três nós de primeiro nível: Player, Enemies e UI. Dentro de Player existem dois nós filhos, HealthBar e Weapon. Ao ler esse JSON, a IA entende que HealthBar deve ser criado como filho de Player, com posição relativa (0, 32).

Há três pontos essenciais na descrição de árvores de nós.

Primeiro ponto: a relação pai-filho precisa estar explícita. A posição de um nó filho é um deslocamento relativo ao pai. Por exemplo, HealthBar em (0, 32) significa que ele fica 32 pixels acima de Player. Se Player se mover para (200, 300), HealthBar acompanha automaticamente para (200, 332). Esse mecanismo garante que a barra de vida sempre siga o jogador.

Se você coloca HealthBar na raiz da cena, em vez de colocá-lo como filho de Player, a barra não acompanha o jogador. Eu já caí nessa armadilha: a IA gerou código colocando todos os elementos de UI na raiz; ao rodar, a barra de vida ficava separada do jogador e permanecia parada quando ele se movia. Depois que passei a descrever a árvore em JSON, a hierarquia gerada pela IA ficou correta.

Segundo ponto: composição de componentes, não herança. A filosofia do Cocos Creator é: “o nó é a entidade, componentes dão funcionalidade”. Um nó não tem comportamento por si só. Ele só exibe imagem ao receber Sprite, ganha propriedades físicas ao receber RigidBody2D e passa a ter lógica personalizada ao receber Script. Esse design por composição é mais flexível que herança: você pode montar Sprite + RigidBody + Script em Player, Sprite + RigidBody + EnemyScript em Enemy, e os dois nós compartilham alguns componentes enquanto mantêm scripts próprios.

No JSON, o array components descreve a lista de componentes. A IA monta os componentes na ordem do array, e as propriedades de cada um podem ser complementadas em properties.

Terceiro ponto: os nomes dos nós devem seguir um padrão. Use camel case para nomes como Player, Enemy e HealthBar; nós funcionais podem usar sublinhado, como bg_sprite e ui_canvas. Nomes claros ajudam porque as variáveis geradas pela IA ficam consistentes, e você entende a finalidade de cada nó de imediato ao manter o código depois.

Agora um caso prático: a árvore de nós de um jogo de tiro. Este JSON pode ser enviado diretamente para a IA para gerar o código completo da cena:

{
  "rootNode": "GameScene",
  "tree": {
    "Player": {
      "components": [
        "Sprite(texture path: 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": "Contêiner do pool de balas; cria nós Bullet dinamicamente"
    },
    "UI": {
      "children": {
        "ScoreLabel": {"components": ["Label"], "content": "Score: 0"},
        "RestartButton": {"components": ["Button"], "onClick": "restartGame()"}
      }
    }
  }
}

Alguns detalhes desse JSON merecem atenção:

• Player tem um nó filho BulletSpawnPoint, na posição (32, 0). Esse nó é o ponto de disparo da bala, deslocado 32 pixels em relação ao jogador.
• Enemies é um nó contêiner, e os vários inimigos são listados em array abaixo dele.
• Bullets é o contêiner do pool de balas. O campo description explica que ele é o nó pai dos nós Bullet criados dinamicamente.
• Em UI, RestartButton tem a propriedade onClick, vinculada diretamente ao nome da função de callback.

Ao enviar isso para a IA, acrescente as restrições técnicas:

Crie uma cena do Cocos Creator com base na árvore de nós JSON acima.

Requisitos:
1. Use a API do Cocos Creator 3.8
2. Código em TypeScript, com anotações de tipo
3. Componentes de script devem usar o decorador @ccclass
4. Listeners de evento devem usar o método node.on()

A IA gera o código completo de criação da cena seguindo a hierarquia do JSON, incluindo criação de nós, montagem de componentes e configuração de propriedades. Depois, você só precisa completar a lógica concreta dos componentes de script; o esqueleto da cena já está pronto.

Template de descrição de componentes

Componentes são o veículo das funções de um nó. Ao descrever componentes para a IA, o ponto central é explicar quatro campos: função, propriedades, dependências e configuração de exemplo. Esse template funciona tanto para componentes internos do Cocos Creator quanto para componentes de script personalizados.

Veja a definição dos quatro campos:

Campo	Obrigatório?	Descrição
Função	Obrigatório	O que o componente faz, em uma frase
Propriedades	Obrigatório	Parâmetros de configuração: tipo + descrição
Dependências	Opcional	Quais propriedades do nó ou outros componentes são necessários
Configuração de exemplo	Recomendado	Valores típicos de configuração

A lógica do template é: primeiro diga à IA para que o componente serve; depois liste os parâmetros ajustáveis; por fim, explique os pré-requisitos. A IA usa essa estrutura para gerar o código de montagem do componente e preencher propriedades com base nos exemplos.

Um caso prático: descrição do componente Sprite.

## Nome do componente: Sprite

**Função**: exibir uma textura de imagem; componente de renderização mais comum em jogos 2D

**Propriedades**:

- spriteFrame: SpriteFrame - recurso de imagem | valor padrão: null
- sizeMode: SizeMode - modo de tamanho (CUSTOM / RAW / TRIMMED) | valor padrão: TRIMMED
- type: SpriteType - tipo de renderização (SIMPLE / SLICED / TILED / FILLED) | valor padrão: SIMPLE

**Dependências**:

- O nó precisa ter: propriedade size (quando sizeMode = CUSTOM)

**Configuração de exemplo**:

spriteFrame: assets/player.png
sizeMode: RAW

Essa descrição lista as propriedades centrais do Sprite. Ao lê-la, a IA costuma gerar algo assim:

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

Agora um caso de componente físico: RigidBody2D.

## Nome do componente: RigidBody2D

**Função**: corpo rígido 2D; dá propriedades físicas ao nó, como gravidade e colisão

**Propriedades**:

- type: RigidBodyType - tipo de corpo rígido (STATIC / DYNAMIC / KINEMATIC) | valor padrão: STATIC
- gravityScale: number - coeficiente de gravidade | valor padrão: 1.0
- linearVelocity: Vec2 - velocidade linear | valor padrão: (0, 0)

**Dependências**:

- Requer outro componente: Collider2D (detecção de colisão)

**Configuração de exemplo**:

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

Aqui existe um campo de dependência: RigidBody2D precisa trabalhar junto com Collider2D para detectar colisões. Ao ler essa dependência, a IA lembra você de montar Collider2D no mesmo nó, ou adiciona automaticamente.

Este é um erro comum. Antes, quando eu descrevia para a IA “dê propriedades físicas ao personagem”, ela só montava RigidBody2D e esquecia Collider. Ao rodar, o personagem realmente caía sob efeito da gravidade, mas atravessava o chão porque não havia detecção de colisão. Depois que passei a usar o template de componentes e incluir o campo de dependências, o código gerado passou a montar RigidBody2D + Collider2D ao mesmo tempo.

Resumindo, o formato padrão do template de descrição de componentes é:

## Nome do componente: {ComponentType}

**Função**: {descrição da função do componente em uma frase}

**Propriedades**:

- {nomeDaPropriedade}: {tipo} - {descrição} | valor padrão: {default}
- {nomeDaPropriedade}: {tipo} - {descrição} | valor padrão: {default}

**Dependências**:

- O nó precisa ter: {propriedade do Node} (por exemplo: size, anchor)
- Requer outro componente: {nome do Component} (por exemplo: RigidBody2D)

**Configuração de exemplo**:

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

**Exemplo de código**:

```typescript
// Obtém o componente
const sprite = this.node.getComponent(Sprite);
sprite.spriteFrame = newSpriteFrame;
```

Esse template serve para todos os componentes internos do Cocos Creator, como Sprite, Label, Button, RigidBody2D e Collider2D, e também para componentes de script personalizados. Se você quer criar um componente PlayerScript, use o mesmo formato:

## Nome do componente: PlayerScript

**Função**: processar movimento, pulo e resposta a colisões do jogador

**Propriedades**:

- moveSpeed: number - velocidade de movimento | valor padrão: 200
- jumpHeight: number - altura do pulo | valor padrão: 100
- health: number - vida atual | valor padrão: 100

**Dependências**:

- O nó precisa ter: componente RigidBody2D (para movimento físico)
- O nó precisa ter: componente Collider2D (para detecção de colisão)

**Configuração de exemplo**:

moveSpeed: 300
jumpHeight: 150
health: 100

Ao ler essa descrição, a IA gera uma classe TypeScript PlayerScript completa, com propriedades definidas por decorador @property, métodos de ciclo de vida como onLoad / start / update e métodos personalizados como move / jump / takeDamage. Depois, você só precisa preencher a lógica concreta; o esqueleto já está montado.

Fórmula de descrição de interação

Interação é o centro da lógica de jogo. Jogador clicar em botão, personagem colidir com inimigo, bala atingir alvo: tudo isso é interação. A forma mais clara de descrever interação para a IA é usar a fórmula dos cinco elementos:

descrição da interação = condição de disparo + tipo de evento + objeto-alvo + comportamento de resposta + mudança de estado

O significado dos cinco elementos:

• Condição de disparo: em que situação a interação acontece, como colisão, clique ou entrada de teclado
• Tipo de evento: nome concreto do evento, como TOUCH_START ou onCollisionEnter
• Objeto-alvo: qual nó ou componente responde ao evento
• Comportamento de resposta: qual método ou função é executado
• Mudança de estado: como dados ou visual mudam

Essa fórmula garante que a descrição da interação tenha um ciclo completo. Se faltar qualquer elemento, o código gerado pela IA tende a ter bug.

Um exemplo: você diz “ao clicar no botão, pule”. A IA só entrega código de listener de toque, mas não sabe a altura, a duração, nem como o estado volta depois. Ao rodar, o personagem até se move, mas a animação engasga, o estado trava e cliques repetidos causam problemas.

A descrição correta deve explicitar os cinco elementos:

## Nome da interação: pulo ao clicar

[Condição de disparo]

- Forma de disparo: toque/clique
- Objeto que dispara: nó JumpButton
- Momento de disparo: TOUCH_END (quando o dedo sai da tela)

[Listener de evento]

- Nó escutado: JumpButton
- Tipo de evento: Node.EventType.TOUCH_END
- Função de callback: onJumpButtonClicked

[Comportamento de resposta]

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

[Mudança de estado]

- Mudança de dados: Player.position.y += 100
- Mudança visual: nó Player toca a animação jump (scale: 1.0 → 1.2 → 1.0)
- Mudança de estado: Player.isJumping = true (dura 0,3 segundo)

[Implementação em código]

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

Essa descrição cobre os cinco elementos. Ao lê-la, a IA gera o código completo de listener de toque, incluindo callback, passagem de parâmetros e gestão de estado. Depois, você só precisa completar a lógica concreta do método jump().

Agora um exemplo de interação por colisão:

## Nome da interação: detecção de dano por colisão

[Condição de disparo]

- Forma de disparo: detecção de colisão
- Objetos que disparam: Collider do nó Player + Collider do nó Enemy
- Momento de disparo: onCollisionEnter (início da colisão)

[Listener de evento]

- Componente escutado: componente Collider do nó Player
- Tipo de evento: Collider2D.onCollisionEnter
- Função de callback: onPlayerHitEnemy

[Comportamento de resposta]

- Método executado: PlayerScript.takeDamage(amount)
- Parâmetro: damage = 10

[Mudança de estado]

- Mudança de dados: Player.health -= 10
- Mudança visual: nó Player toca animação de flash branco (0,1 segundo)
- Mudança de estado: Player.isHurt = true (dura 0,2 segundo)

[Implementação em código]

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

O detalhe aqui é que os objetos de disparo são os componentes Collider dos dois nós, e o momento é onCollisionEnter. Ao ler isso, a IA entende que deve escutar o evento de colisão no Collider de Player, verificar se o tag do objeto colidido é ‘enemy’ e então executar a lógica de dano.

Um erro comum em descrições de interação é não explicar a mudança de estado. Eu já pedi para a IA “tirar vida ao colidir com inimigo”, e ela gerou apenas health -= 10, sem feedback visual, como flash branco, e sem bloqueio de estado, como isHurt. Ao rodar, o jogador realmente perdia vida ao bater no inimigo, mas não havia indicação visual; além disso, colisões contínuas podiam zerar a vida instantaneamente.

Depois que passei a usar a fórmula dos cinco elementos e incluir a mudança de estado, o código gerado passou a ter flash branco e bloqueio temporário, deixando a experiência de interação completa.

Aqui está um template padrão de descrição de interação:

## Nome da interação: {descrição da interação}

[Condição de disparo]

- Forma de disparo: {toque / teclado / colisão}
- Objeto que dispara: {nome do nó}
- Momento de disparo: {TOUCH_START / TOUCH_END / onCollisionEnter}

[Listener de evento]

- Nó escutado: {nome do nó}
- Tipo de evento: Node.EventType.{tipo de evento}
- Função de callback: {nome da função}

[Comportamento de resposta]

- Método executado: {nomeDoScript}.{nomeDoMétodo}
- Parâmetros: {lista de parâmetros}

[Mudança de estado]

- Mudança de dados: {nomeDaVariável} = {novo valor}
- Mudança visual: {animação / cor / mudança de posição}

Esse template funciona para interações por toque, como clicar em botão ou deslizar na tela; por colisão, como personagem bater em inimigo ou bala atingir alvo; e por teclado, como setas para mover ou espaço para pular. Depois de preencher os cinco elementos, a IA consegue gerar código completo de escuta de eventos.

No Cocos Creator, eventos de toque têm quatro tipos principais:

Tipo de evento	Momento de disparo
TOUCH_START	O dedo toca a tela
TOUCH_MOVE	O dedo desliza na tela
TOUCH_END	O dedo sai da tela
TOUCH_CANCEL	O toque é cancelado pelo sistema, por exemplo, por uma chamada telefônica

A forma de escutar é node.on(Node.EventType.{tipo de evento}, callback, target). Na destruição, use node.off() para cancelar o listener e evitar vazamento de memória. Esses detalhes aparecem no template, então a IA tende a gerar o código conforme a norma.

5 templates práticos de prompt

Até aqui, falamos do método dos quatro elementos de cena, da árvore de nós em JSON, do template de descrição de componentes e da fórmula dos cinco elementos de interação. Para transformar essa metodologia em prompts, vale usar um formato padrão. Abaixo estão 5 templates prontos para copiar, cobrindo criação de cena, criação de nó, implementação de interação, criação de script e otimização de desempenho.

Template 1: criar uma cena completa

[Papel] Você é especialista em desenvolvimento com Cocos Creator, TypeScript e arquitetura de nós/componentes.

[Tarefa] Crie o código completo da seguinte cena de jogo.

[Descrição da cena]

Tipo de cena: {tipo}
Estilo visual: {estilo}
Elementos principais: {lista de nós}
Pontos de interação: {lista de interações}

[Estrutura da árvore de nós]

```json
{JSON da árvore de nós}
```

[Requisitos técnicos]

- Engine: Cocos Creator 3.8
- Linguagem: TypeScript, usando o decorador @ccclass
- API: usar a API oficial do Cocos Creator, como node.getComponent e node.on

[Requisitos de saída]

1. Código da cena, com lógica completa de criação dos nós
2. Código dos scripts, com anotações de tipo e comentários
3. Código de listener de eventos, com a lógica de interação

Template 2: criar nó e montar componentes

[Papel] Desenvolvedor TypeScript de Cocos Creator

[Tarefa] Crie o nó {nome do nó} e monte os componentes {lista de componentes}

[Propriedades do nó]

- Nome: {nodeName}
- Posição: ({x}, {y})
- Tamanho: {width}x{height}
- Âncora: ({anchorX}, {anchorY})

[Configuração dos componentes]

1. {nome do componente}:
   - {propriedade}: {valor}
2. {nome do componente}:
   - {propriedade}: {valor}

[Requisitos de saída]

- Código TypeScript, com anotações de tipo
- Usar a API do Cocos Creator 3.8
- Adicionar comentários em português explicando cada linha

Template 3: implementar lógica de interação

[Papel] Especialista no sistema de eventos do Cocos Creator

[Tarefa] Implemente a seguinte lógica de interação

[Descrição da interação]

Condição de disparo: {condição de disparo}
Tipo de evento: {tipo de evento}
Objeto-alvo: {nome do nó}
Comportamento de resposta: {nome do método}
Mudança de estado: {descrição da mudança}

[Restrições técnicas]

- Usar node.on para escutar eventos
- Usar Node.EventType para o tipo de evento
- A função de callback deve conter o parâmetro event
- Ao destruir, usar node.off para cancelar o listener

[Requisitos de saída]

- Código TypeScript
- Incluir lógica completa de listener, callback e destruição
- Adicionar tratamento de erro para nó inexistente e componente ausente

Template 4: criar componente de script

[Papel] Especialista em scripts do Cocos Creator

[Tarefa] Crie o componente de script {nome do script}

[Função do script]

{descrição da função}

[Definição de propriedades]

@property({tipo})
{nomeDaPropriedade}: {tipo} = {valor padrão}

[Lista de métodos]

1. {nomeDoMétodo}({parâmetros}): {tipo de retorno}
   - Função: {descrição}
2. {nomeDoMétodo}({parâmetros}): {tipo de retorno}
   - Função: {descrição}

[Ciclo de vida]

- onLoad: {lógica de inicialização}
- start: {lógica de início}
- update(dt): {lógica atualizada a cada frame}

[Requisitos de saída]

- Código TypeScript, usando decoradores @ccclass e @property
- Incluir métodos completos de ciclo de vida
- Adicionar anotações de tipo e comentários em português

Template 5: otimizar desempenho da árvore de nós

[Papel] Especialista em otimização de desempenho no Cocos Creator

[Tarefa] Otimize o desempenho da seguinte estrutura de árvore de nós

[Árvore de nós atual]

```json
{JSON da árvore de nós}
```

[Problemas de desempenho]

- Muitos nós: {quantidade}
- DrawCall alto: {vezes}
- Uso alto de memória: {tamanho}

[Metas de otimização]

- FPS: ≥ 60
- DrawCall: ≤ 20
- Memória: ≤ 100MB

[Estratégias de otimização]

1. Mesclar nós: {plano de mesclagem}
2. Usar pool de nós: {plano de reutilização}
3. Otimizar componentes: {plano de otimização dos componentes}

[Requisitos de saída]

- JSON da árvore de nós otimizada
- Código TypeScript de otimização
- Dados comparativos de desempenho: antes vs depois

Esses cinco templates cobrem o fluxo completo de desenvolvimento de jogos com IA: da criação da cena à montagem de nós, da implementação de interações à escrita de scripts e, por fim, à otimização de desempenho. Cada template segue o framework CREATE: Context, com definição de papel; Action, com descrição da tarefa; Edge, com restrições técnicas e métricas de desempenho; e Example, com exemplo de JSON da árvore de nós.

Na prática, copie o template e substitua o conteúdo dentro de {}. Por exemplo, no template 2, se você quer criar um nó Player, troque {nodeName} por Player, {lista de componentes} por Sprite, RigidBody2D, PlayerScript e preencha as propriedades conforme sua necessidade. A IA gera o código completo seguindo o template, poupando o tempo de escrever o prompt do zero.

Conclusão

Este artigo apresentou quatro metodologias e cinco templates práticos. Vamos recapitular os pontos principais:

Quatro elementos da descrição de cena: tipo, estilo, elementos e pontos de interação. Primeiro defina o esqueleto da cena, depois preencha o conteúdo, para que a IA gere uma fase bem estruturada.

Formato JSON da árvore de nós: nó raiz → nós filhos → componentes → propriedades → posição. Use um formato estruturado para descrever hierarquias; assim, a IA cria os nós camada por camada e não confunde relações pai-filho.

Quatro campos da descrição de componentes: função, propriedades, dependências e configuração de exemplo. Primeiro explique o uso, depois liste parâmetros e, por fim, declare pré-requisitos; a IA segue essa estrutura para gerar código de montagem de componentes.

Cinco elementos da descrição de interação: condição de disparo, tipo de evento, objeto-alvo, comportamento de resposta e mudança de estado. Juntos, eles formam um ciclo completo, evitando lacunas no código gerado.

Essas quatro metodologias entram nos prompts por meio de cinco templates práticos: criar cena, criar nó, implementar interação, criar script e otimizar desempenho. Os templates seguem o framework CREATE; basta copiar e substituir o conteúdo entre {} para usar.

Na próxima vez que você descrever requisitos de jogo para uma IA, experimente usar JSON para a árvore de nós e a fórmula dos cinco elementos para a lógica de interação. Compare o antes e depois: descrições vagas geram código fragmentado, hierarquias confusas e interações incompletas; descrições padronizadas geram código mais estruturado, hierarquia mais clara e interações fechadas. O ganho de eficiência é bem concreto.