Prompts de IA para um jogo de plataforma com rebobinamento temporal: das regras ao plano de criação

Escreva prompts de IA para um jogo de plataforma com rebobinamento temporal que conectem a reversão do movimento e do estado do mundo à jogabilidade. Avance do briefing inicial até um protótipo jogável.

Seele Editorial TeamAtualizado 17 de novembro de 2026

Um jogo de plataforma com rebobinamento temporal precisa responder claramente a uma pergunta: o que o jogo restaura? Rebobinar apenas o jogador enquanto os perigos continuam se movendo cria um tipo de quebra-cabeça. Restaurar o jogador e os objetos do mundo cria outro. Se o prompt não especificar essa diferença, o build pode parecer correto e ainda assim implementar uma regra de jogo diferente.

Este exemplo registra um jogador e um bloco em queda em snapshots periódicos. Ele rebobina a fase por um segundo e mantém consumida a carga usada. Os números são valores fictícios de design para permitir um rastreamento de estado reproduzível. Os prompts não foram executados e este pacote não inclui um resultado jogável nem evidências de teste.

Um herói de plataforma está em uma saliência enquanto um bloco de pedra em queda parece subir por um rastro azul do tempo.
Arte conceitual original de rebobinamento temporal, não uma captura de tela.

Defina o que é rebobinado

Comece com uma saliência segura, uma plataforma inferior e um bloco de pedra em queda. O jogador corre para a direita a 2 unidades de design por segundo. O bloco começa na altura y=4 e cai a 1 unidade por segundo. Salve um snapshot a cada 0.25 segundo para que um rebobinamento de um segundo atravesse quatro intervalos armazenados.

Cada snapshot inclui a posição e a velocidade do jogador, a posição e a velocidade do bloco e o relógio da fase. Ao rebobinar, esses valores voltam juntos. O bloco não continua caindo enquanto o jogador se move para trás no tempo. Essa escolha cria um estado de mundo coerente para inspecionar.

A carga de rebobinamento é diferente. Ela é um meta-recurso que fica fora da linha do tempo. Defina o máximo e o valor inicial em 2 segundos e gaste 1 segundo de carga para cada segundo rebobinado. Se o jogador voltar de t=2 para t=1, o mundo retorna ao snapshot anterior, mas a carga continua consumida. Restaurar a carga também permitiria que o jogador recarregasse a ferramenta rebobinando repetidamente.

EstadoÉ salvo no snapshot?Motivo
Posição e velocidade do jogadorSimO movimento volta ao quadro anterior.
Posição e velocidade do bloco em quedaSimO movimento do mundo é rebobinado junto com o jogador.
Relógio da faseSimO tempo do mundo corresponde aos objetos restaurados.
Carga de rebobinamentoNãoUsar a mecânica ainda consome um recurso persistente.
Snapshots posteriores ao tempo restauradoDescartadosA próxima ação cria uma nova ramificação da linha do tempo.

Decida o que acontece com os snapshots futuros que deixam de ser usados quando o rebobinamento termina. Neste exemplo, eles são descartados. Caso contrário, uma nova ação de movimento poderia entrar em conflito com um estado futuro obsoleto, que já não corresponde às ações do jogador. Essa regra de ramificação é tão importante quanto o efeito visual do rebobinamento.

Acompanhe um rebobinamento de um segundo

Em t=0, o jogador começa em x=0 e o bloco em y=4. Depois de um segundo, o jogador se moveu 2 unidades e o bloco caiu 1 unidade. Portanto, o estado salvo em t=1 é jogador x=2 e bloco y=3. Em t=2, o mesmo movimento deixa o jogador em x=4 e o bloco em y=2.

Agora mantenha o comando de rebobinar pressionado por um segundo. O jogo volta por quatro snapshots de 0.25 segundo, de t=2 a t=1. O estado restaurado é jogador x=2, bloco y=3 e relógio da fase t=1. O medidor de rebobinamento cai de 2 segundos para 1. Ao soltar o comando, os estados de t=1.25 até t=2 são descartados; a nova partida continua a partir do ponto restaurado.

Tempo da faseJogador xBloco yCarga de rebobinamentoEvento
t=0042.0sEstado inicial.
t=1.0s232.0sSnapshot anterior.
t=2.0s422.0sEstado atual antes do rebobinamento.
Restaurado: t=1.0s231.0sQuatro snapshots restaurados; ramificação futura descartada.

A aritmética é simples de propósito: o movimento horizontal é de 2 unidades por segundo, e o bloco cai a 1 unidade por segundo. O estado em t=1 não é um quadro observado do jogo; é o resultado esperado dessas regras fictícias. Um build jogável deve exibir as mesmas variáveis durante os testes para que a pessoa revisora compare o ponto de restauração real com a tabela.

O jogador e um objeto do mundo são rebobinados juntos.
Ilustração conceitual do jogador e de um objeto do mundo rebobinando juntos.

Um caso extremo é pedir um rebobinamento entre snapshots salvos. O prompt deve especificar se o jogo restaura o snapshot anterior mais próximo, interpola entre dois snapshots ou registra o histórico em intervalos menores. Neste exemplo, o jogo sempre restaura o snapshot mais próximo no horário solicitado ou antes dele, e informa o horário realmente restaurado. Assim, o comportamento é determinístico e o traçado esperado fica fácil de auditar.

À medida que o protótipo cresce, amplie o snapshot como uma unidade. Se uma porta depende de um interruptor, salve os estados dos dois; se um projétil puder causar dano, decida também se sua posição e seu dono são restaurados. Omitir um valor relacionado pode criar uma combinação que nunca existiu em nenhuma das duas linhas do tempo. Mantenha uma lista curta dos campos de jogo que podem ser rebobinados ao lado do metarrecurso persistente para que prompts futuros não alterem o contrato sem avisar.

Organize os prompts por etapas

O primeiro prompt cria a sala, a saliência, os controles do jogador e o bloco em queda, sem rebobinamento. Mantenha o movimento determinístico e mostre o relógio da fase. Isso confirma que o estado inicial é compreensível antes de adicionar um buffer temporal.

O segundo prompt salva snapshots a cada 0.25 segundo. Especifique exatamente quais campos do jogador e dos objetos entram em cada um. Um snapshot que salva apenas a posição pode restaurar visualmente o bloco, mas manter a velocidade posterior; inclua a velocidade se o objeto continuar se movendo depois do rebobinamento.

O terceiro prompt adiciona a duração do rebobinamento e a carga. Peça um rebobinamento de um segundo a partir de t=2, que deve restaurar x=2 e y=3. A carga tem limite de 2 segundos e fica fora do snapshot; depois desse rebobinamento, resta 1 segundo. Informe se os comandos ficam desativados durante a restauração e como a linha do tempo se ramifica depois.

O quarto prompt adiciona um rastro temporal discreto e a reinicialização. Ao reiniciar, o jogador e o bloco devem voltar às posições iniciais, o relógio da fase deve zerar, o histórico salvo deve ser apagado e a carga de rebobinamento deve voltar a 2. Mantenha fixos o conteúdo dos snapshots e as regras dos recursos enquanto ajusta o feedback visual.

Verificações para um futuro build jogável

  • Registre o estado do jogador e do bloco em t=1 e t=2 antes de rebobinar.
  • Rebobine exatamente um segundo e compare os valores restaurados com o snapshot de t=1.
  • Confirme que a carga de rebobinamento diminui de 2 para 1 e não é restaurada.
  • Faça um novo movimento após rebobinar e verifique se os snapshots futuros da ramificação descartada desapareceram.
  • Peça um rebobinamento entre snapshots salvos e registre qual horário o jogo seleciona.
  • Reinicie e confira posição, velocidade, relógio, buffer do histórico e carga.

Essas são verificações de aceitação planejadas, não testes concluídos. O tema original pede prompts executados e um resultado jogável. Este pacote não atende a esse requisito: os prompts não foram executados e não há build do jogo nem evidências de teste de jogo.

Ilustração fictícia de um estado restaurado, não uma captura de um jogo real.
Arte conceitual fictícia de um estado restaurado, não uma imagem capturada durante o jogo.

A página do AI Game Maker da SEELE descreve como começar com um prompt de texto, testar um primeiro jogo jogável no navegador e aprimorá-lo com prompts seguintes. Isso é contexto geral do produto; a página não valida este modelo de rebobinamento nem afirma que exista um recurso de retorno no tempo.

Perguntas frequentes

O que um prompt de jogo de plataforma com rebobinamento temporal deve definir primeiro?

Defina o intervalo dos snapshots, a duração do rebobinamento, o estado do jogador, os objetos do mundo incluídos nos snapshots e qualquer recurso que persista fora da linha do tempo. Em seguida, teste um intervalo de rebobinamento.

Inimigos e plataformas móveis também devem ser rebobinados?

Escolha explicitamente. Restaurá-los junto com o jogador cria um snapshot coerente do mundo; deixá-los no presente cria outra mecânica. Neste exemplo, a posição do jogador e a de um bloco em queda são rebobinadas juntas.

A energia de rebobinamento deve voltar junto com o resto do mundo?

Em geral, o design deve decidir se ela é um meta-recurso persistente. Neste exemplo, a carga de rebobinamento fica fora dos snapshots para que o uso da mecânica não restaure a carga consumida.

Com que frequência um jogo de plataforma deve salvar snapshots de rebobinamento?

Escolha um intervalo que permita movimentos suficientemente fluidos e que seja fácil de inspecionar. Este exemplo fictício salva o estado a cada 0.25 segundo e restaura um estado de um segundo atrás.

Esses prompts de rebobinamento ou estados do jogo foram testados em um build jogável?

Não. Os prompts são rascunhos não executados e os valores de estado vêm de cálculos fictícios. Não alegamos que exista um build gerado, um rebobinamento observado ou um resultado de teste de jogo.

SEELE AI

Transforme este guia em um projeto jogável.

Comece com um briefing claro e evolua sua ideia no Workspace da Seele AI.

Começar a criar