Jogos 3D fotorrealistas a partir de código
Um procedimento para transformar uma cena 3D gerada por código em um jogo curto e jogável que pareça fotográfico. O alvo é um jogo, não uma imagem estática, uma demonstração técnica ou um walkthrough: um jogador com um verbo, um sistema que responde, um modo de vencer e um modo de perder.
Nada aqui pressupõe um gênero. O assunto decide o verbo — um pátio de contêineres sugere transportar uma carga antes do fim do turno; uma oficina sugere reparar uma máquina; uma escadaria sugere sair sem ser visto. Jogos de tiro são uma instanciação entre muitas, e o mesmo procedimento os produz apenas quando o assunto pede um.
O procedimento é agnóstico em relação a ferramentas. Ele pressupõe um agente que possa editar arquivos, executar comandos e inspecionar imagens. Nada abaixo depende de um motor, versão de biblioteca ou produto de fornecedor específico.
Origem e significado. Esta skill existe para responder a uma pergunta feita por Saltline — um jogo de tiro para navegador de 1.423.668 bytes em arquivo único, sem ativos externos, feito com Claude Fable 5.2. A parte interessante não era o tamanho; era que o modelo escreveu o gerador. Esta skill empacota essa disciplina de produção em portões executáveis, para que um modelo de baixo custo (como DeepSeek V4.1 Flash) possa ser submetido ao mesmo padrão. O resultado não é o mesmo jogo; é a mesma disciplina — e a evidência está registrada nos estudos de caso do repositório.
O harness incluído é opcional, mas recomendado: ele torna os portões executáveis
em vez de aspiracionais. Ele precisa de Node.js 22+, Python 3.10+ com Pillow e um
binário Chrome/Chromium (CHROME_PATH se não estiver em um local padrão). O
texto da skill em si não tem dependências.
Como executar isso com um modelo de baixo custo
A skill é escrita para que um modelo fraco possa executá-la: todo julgamento importante é delegado a uma verificação, e o trabalho do modelo é preencher tabelas e aplicar a correção de maior prioridade. Siga estas regras literalmente.
- Não projete arquitetura. Comece a partir de um esqueleto que já tenha:
o harness de renderização, o contrato da página (
__READY,__STATS,__SCENE,__AUDIT,__COLLIDERS,__BOUNDS,__TESTMOVE,__TEST,__PRODUCT), a cadeia de pós-processamento, um shell de jogo finalizado (título, configurações, pausa, salvar, toque, marcadores de HUD) e uma tabela de kit vazia. Copie-o e depois preencha as tabelas. Arquitetura inventada a cada execução é onde modelos fracos falham. - Preencha, não invente. Os produtos de trabalho são seis tabelas: produto (shell + conteúdo), direção de arte, kit (dimensões + peças + decalques), superfícies (albedo/rugosidade/normal), luzes (posição + luminária) e o loop (verbo/sistema/feedback/falha/teste).
- Produto primeiro, depois aparência.
produto → censo → luzes → colisão → playtest → mobile → aparência. Um quadro que é bonito mas não tem configurações, nem segundo papel de inimigo, nem marcadores de objetivo ou caminho de toque não é uma rodada finalizada. - Uma alteração por rodada, depois execute todos os portões. Uma rodada só é válida se nenhum portão regredir. Um ganho visual que quebra o produto ou o loop é revertido.
- Nunca autoavalie. Se um portão discordar da sua opinião, o portão vence. Se um portão estiver errado, corrija o portão com um contra-exemplo — nunca o ignore.
- Pare no orçamento ou no platô, o que ocorrer primeiro, e reporte a pior câmera e a lista de portões com falha.
Um modelo que seguir essas seis regras produzirá resultados comparáveis a uma fração do custo; um modelo que pular a regra 5 produzirá regressões de aparência plausível.
Contrato de entrega
Uma execução só está completa quando estes itens existirem e todos os portões estiverem verdes:
| Artefato | Verificação |
|---|---|
| um HTML autocontido, sem requisições de rede | carregar com a rede desabilitada |
contrato da página exposto (__READY, __STATS, __SCENE, __AUDIT, __COLLIDERS, __BOUNDS, __TESTMOVE, __TEST, __GAME, __PRODUCT) | harness os lê |
| shell de jogo finalizado | menu, configurações, pausa, salvar, toque, hierarquia de HUD, fim/reiniciar |
| amplitude de conteúdo | ≥2 papéis de inimigo/interagível, ≥2 ferramentas, ≥1 cadeia de objetivos, ≥3 momentos |
| relatório de censo | cobertura = 100%, zero falhas |
| auditoria de luz | toda luz ancorada a uma luminária |
| relatório de colisão | zero penetrações, zero fora dos limites, paridade de colisor 100% |
| playtest | loop concluível, caminho de falha alcançável, reinício funciona |
| relatório mobile | layout 390×844, sem estouro horizontal, controles de toque presentes |
| relatório de caixa em 3–6 objetos do assunto | cada métrica >= 0,8 da referência |
| pontuação do quadro | reportada, mas nunca usada para substituir um portão |
Contrato de produto finalizado
Um quadro jogável não é um jogo finalizado. Os portões do loop protegem o comportamento; os
portões do produto protegem o shell, a amplitude de conteúdo e a primeira impressão. Declare o
seguinte na página para que harness/product.mjs possa verificar sem ler a
mente do modelo.
| Artefato | Mínimo |
|---|---|
| Telas | menu, jogando, pausado, configurações, perdido, ganho |
| Tela de título | visível ao carregar; HUD oculto; título, premissa, iniciar, configurações/controles |
| Configurações | sensibilidade, volume, FOV, inverter-Y, qualidade (ou um conjunto equivalente) |
| Persistência | uma chave sobrevive ao recarregar (melhor pontuação/progresso/configurações) |
| Entrada | teclado + mouse + toque; mira alternativa quando o bloqueio de ponteiro falha |
| Objetivos | ≥1 cadeia com ≥3 momentos e marcadores/bússola no mundo |
| Papéis | ≥2 papéis de inimigo/obstáculo/interagível, não apenas um recolorido |
| Ferramentas | ≥2: um verbo primário e um secundário (arma/ferramenta/habilidade) |
| HUD | objetivo+progresso, sobrevivência, arma/munição, prompt de contexto, bússola/marcadores, legendas |
| Áudio | mudo + ≥6 eventos de mudança de estado |
| Câmeras | câmera hero + câmeras de close-up estáticas em __PRODUCT.cameras |
| Desempenho | orçamentos declarados para chamadas/triângulos/luzes, medidos após o início |
| Mobile | 390×844 sem estouro horizontal; controles de toque alcançáveis |
Orçamento de conteúdo para uma fatia vertical
Preencha isso antes de qualquer passada de arte. Uma fatia vertical é uma sessão de 3–8 minutos com uma cadeia de objetivos completa, dois papéis, um sistema característico e um shell projetado. É menor que um demo reel e maior que uma demonstração técnica.
| Item | Fatia vertical | Jogo pequeno finalizado |
|---|---|---|
| Objetivos | 1 cadeia, 3 momentos | 1–3 cadeias, 5–8 momentos |
| Papéis de inimigo/interagível | 2 | 3–5 + um clímax |
| Armas/ferramentas | 2 (primária + secundária) | 3–5 |
| Verbos do jogador | mover, mirar, atirar, recarregar | + agachar/saltar/interagir/habilidade |
| Mundo | um local, 3 camadas de profundidade | 2–3 espaços conectados |
| Shell | título, pausa, configurações, fim | + salvar, qualidade, toque |
| Sessão | 3–8 min | 10–30 min |
O manifesto é uma declaração; os portões verificam o comportamento do DOM e as contagens declaradas. Não declare o que a página não faz.
window.__PRODUCT = {
title: { name: 'Game title', start: '#start', hud: '#hud', hudHiddenOnTitle: true },
screens: ['menu', 'playing', 'paused', 'settings', 'lost', 'won'],
ui: { start: '#start', hud: '#hud', pause: '#pause', settings: '#settings', end: '#end', touch: '#touch' },
settings: ['sensitivity', 'volume', 'fov', 'invertY', 'quality'],
persistence: ['game.best'],
input: { keyboard: true, mouse: true, touch: true },
content: {
objectives: [{ id: 'objective-1', title: 'Objective', steps: 3 }],
roles: ['role-a', 'role-b'],
tools: ['tool-a', 'tool-b'],
beats: ['intro', 'contact', 'mid', 'climax', 'win'],
},
hud: ['objective', 'compass', 'health', 'ammo', 'prompt', 'subtitles'],
audio: { events: 10, mute: true },
perf: { maxCalls: 700, maxTris: 400000, maxLights: 14 },
cameras: [
{ name: 'hero', cam: [0.5, 1.7, 10, -2.6, 1.3, -10] },
{ name: 'close', cam: [-6.4, 1.4, 5.2, -9.9, 1.0, 2.2] },
],
test: { start: 'start', pause: 'pause', resume: 'resume', settings: 'openSettings', save: 'save' },
};
Ações __TEST padrão (ações extras permitidas): start, pause, resume,
openSettings, closeSettings, save, state. Elas devem funcionar sem bloqueio de ponteiro
e retornar um instantâneo compatível com JSON. A tela de título deve ocultar o HUD;
iniciar deve revelá-lo; as telas de configurações, pausa e fim devem ser inspecionáveis pelo DOM.
Quando usar
- Uma cena está geometricamente correta, mas parece plana, plástica ou "gerada".
- Um render deve corresponder a uma fotografia de referência, conceito ou direção de arte.
- Iluminação, materiais ou composição precisam ser melhorados de forma controlada.
- Uma geração longa precisa permanecer coerente em muitas iterações.
Quando não usar
- Resultado deliberadamente estilizado (shading flat, cel, diagramático, semelhante a UI). Eles precisam de abstração consistente, não plausibilidade física. O procedimento se transfere, mas substitua o perfil fotorrealista e o portão de aparência por um consistente com o estilo; uma cena estilizada medida contra um perfil fotográfico perde por construção, não por qualidade.
- Tarefas de precisão (CAD, desenhos de engenharia) onde legibilidade supera realismo.
- Cenas sem câmera: visualização de dados, grafos de nós, UI.
Modelo do problema
O realismo percebido vem de cinco alavancas. Aplique-as nesta ordem; o retorno sobre o esforço cai drasticamente conforme você desce na lista.
- Luz — uma única fonte dominante com direção, cor e elevação definidas, mais um ambiente para reflexões e preenchimento.
- Materiais — variação em rugosidade, normal e sujeira, em vez de cor sozinha.
- Composição e densidade — objetos em várias escalas e profundidades, com um ponto focal claro e dicas de escala legíveis.
- Formação da imagem — anti-aliasing, mapeamento de tons, bloom, granulação, vinheta.
- Detalhe geométrico — o último recurso, e apenas onde ele sobrevive a vários pixels na tela.
Duas consequências que valem a pena declarar explicitamente:
- Detalhes menores que aproximadamente dois pixels são removidos pelo anti-aliasing e não contribuem para a imagem. Adicionar contagem de polígonos nessa escala é desperdício.
- Uma cena pode ter exposição correta e ainda parecer vazia. Vazio é um problema de densidade, não de gradação.
Mais três consequências para um jogo finalizado:
- Um quadro é necessário, mas não suficiente. A camada de produto — arte-chave do título, configurações, pausa, salvar, toque, marcadores de objetivo, rádio/legendas, amplitude de conteúdo — é julgada antes que o jogador perceba a iluminação.
- As cinco alavancas são independentes do assunto. Elas se aplicam a um porto diurno, um interior claro, um campo nevado ou uma arena estilizada. Noite/chuva/neblina são um cenário, não o padrão.
- A pontuação do quadro é uma bússola para uma aparência de referência. Ela não pode distinguir um jogo finalizado de uma demo bonita.
Fluxo de trabalho
Cada etapa tem uma saída. Não comece a próxima etapa sem ela.
Etapa 1 — Torne o render observável (recomendado antes de qualquer trabalho na cena)
Produza uma maneira reproduzível de capturar um quadro e inspecioná-lo.
Saída: um comando que retorna uma imagem e, idealmente, alguns números.
Se seu ambiente já tiver uma ferramenta de captura de tela, use-a. Caso contrário, construa a menor que funcione:
- Inicie um navegador headless contra um servidor estático local.
- Aguarde um sinal de prontidão da página (veja o contrato abaixo) e então capture.
- Opcionalmente, calcule estatísticas da imagem: histograma de exposição, recorte, contagem de cores, densidade de bordas.
Contrato da página que mantém as capturas determinísticas:
window.__READY = true; // definido após alguns quadros renderizados
window.__STATS = { calls, triangles }; // contadores opcionais do renderizador
// parâmetros de consulta opcionais
// ?shot=1 ocultar UI
// ?cam=x,y,z,tx,ty,tz câmera fixa
// ?seed=N semente aleatória fixa
Regras:
- Câmera fixa, semente fixa, viewport fixo para toda comparação.
- Armazene cada captura sob um nome versionado; nunca sobrescreva a anterior.
- Se nenhuma métrica estiver disponível, mantenha as imagens e compare-as lado a lado. A comparação visual é suficiente; métricas apenas tornam a atribuição mais rápida.
Etapa 2 — Escreva um resumo de direção de arte
Saída: uma tabela curta. Toda linha deve ser concreta o suficiente para ser implementada.
| Decisão | Conteúdo |
|---|---|
| Assunto | sobre o que é o quadro, em que escala |
| Hora e clima | determina névoa, força de reflexão, contraste |
| Luz chave | direção, elevação, temperatura de cor, intensidade |
| Céu e ambiente | cor do preenchimento de sombra |
| Família de materiais | quais superfícies existem, quão ásperas, quão molhadas |
| Ponto focal | onde o olho deve pousar primeiro |
| Restrições | o que não deve aparecer (ex.: branco puro, chão plano, céu limpo) |
Orientação:
- Escolha uma história de luz dominante. Fontes adicionais são preenchimento, reflexo, ou práticas, e devem ser subordinadas.
- Restrinja o assunto antes de adicionar detalhes. Condições que reduzem a complexidade visível — noite, chuva, névoa, poeira, contraluz, cenários industriais ou de interiores — são escolhas legítimas e eficazes, não atalhos.
- Escolha uma elevação chave deliberadamente. O comprimento da sombra escala como
altura / tan(elevação): uma chave baixa produz sombras longas que podem colocar todo o primeiro plano na sombra, o que parece "sem sombras". Elevações médias (aproximadamente 20–30°) geralmente dão forma e uma área iluminada para contrastar. - Escolha o cenário de iluminação antes do kit. Não recorra a noite, chuva ou interiores industriais porque eles escondem detalhes ausentes. Noite é uma opção; um amanhecer com contraluz ou um interior claro é mais difícil e frequentemente mais convincente.
| Cenário | Chave | Preenchimento / IBL | Ar | Material característico |
|---|---|---|---|---|
| Noturno industrial | chave fria média-baixa, práticas | env do céu, poças mornas | exponencial, cor do céu | chão molhado, luminárias emissivas |
| Dia nublado | chave ampla do céu, 35–60° | IBL forte | perspectiva aérea fina | concreto fosco, poças |
| Hora dourada / contraluz | chave quente baixa atrás do assunto | preenchimento frio do céu | névoa longa, borda | asfalto molhado, vidro, metal |
| Meio-dia claro | chave alta, sombras duras | preenchimento do céu + reflexo | mínima | areia, pedra, tinta |
| Interiores com luz prática | janela + poucas fontes mornas | env da janela/céu | feixes de luz, poeira | madeira, tecido, metal |
| Subterrâneo / luz artificial | práticas + emissivas | ambiente baixo | volumétrico | concreto molhado, placas |
Uma cena com contraluz não é "mais fácil": ela expõe realces recortados, projeções de cor e silhuetas fracas. Corrija a exposição e a suavização de realces antes de adicionar detalhes.
Etapa 3 — Construa o kit
Saída: uma tabela de dimensões, peças e decalques que o renderizador pode ler para produzir a cena.
| Campo | Conteúdo |
|---|---|
| Layout do mundo | grade de piso, paredes, pilares, cobertura (se interna) |
| Peças do kit | caixa, cilindro, esfera, plano, escada, rampa, viga — cada uma com dimensões |
| Decalques | texturas repetíveis para piso, parede, teto, detalhes |
| Materiais | albedo, rugosidade, metalicidade, normal (valores ou caminhos de textura) |
O kit deve ser montável a partir de um número pequeno de primitivas. Uma variedade aparente vem de combinação e escala, não de uma biblioteca de peças. Se você tiver mais de 20 linhas de peças, provavelmente está superespecificando.
Etapa 4 — Censo de sólidos
Saída: uma contagem de cada objeto, seu estado (renderizado, colidido, iluminado) e quebra de paridade.
Cada objeto na cena deve:
- Existir no DOM (ou na árvore de cena, se não-DOM).
- Ter um colisor que corresponda à sua geometria visível.
- Estar iluminado por pelo menos uma luz.
O censo detecta objetos órfãos: visíveis mas sem colisor, colididos mas não renderizados, iluminados mas ausentes. A paridade deve ser 100%.
window.__SCENE = {
objects: [
{ id: 'wall-1', type: 'box', visible: true, collider: true, lit: true },
{ id: 'floor-1', type: 'plane', visible: true, collider: true, lit: true },
],
coverage: 100, // percentual de objetos com colisor e iluminação
failures: [], // lista de IDs com paridade quebrada
};
Etapa 5 — Auditoria de luz
Saída: uma tabela de cada luz, sua âncora de luminária e cobertura.
Cada luz deve ser ancorada a uma peça visível — uma lâmpada, janela ou painel emissivo — para que a fonte pareça vir de um objeto no mundo. Luzes órfãs produzem iluminação sem origem, que quebra a plausibilidade.
window.__AUDIT = {
lights: [
{ id: 'light-1', fixture: 'lamp-1', type: 'point', intensity: 150, color: '#ffeedd' },
],
anchored: 100, // percentual de luzes ancoradas
};
Etapa 6 — Colisão
Saída: relatório de penetrações e limites.
O agente deve testar pares de colisores em busca de penetração e verificar se nenhum objeto saiu dos limites do mundo. Um objeto que passa por uma parede ou está fora das bordas do chão é um erro de colisão.
window.__COLLIDERS = {
penetrations: [], // lista de pares { a, b, depth }
outOfBounds: [], // lista de IDs de objetos
parity: 100, // percentual de objetos com colisor
};
Etapa 7 — Playtest
Saída: um loop jogável verificado.
O playtest deve confirmar que:
- O jogo pode ser iniciado (da tela de título).
- O jogador pode executar o verbo primário e o secundário.
- Um caminho de falha existe (ex.: perder toda a vida) e leva a uma tela de fim.
- O reinício funciona.
- Pausa e retomada funcionam.
- Configurações podem ser abertas e alteradas.
window.__TEST = {
start: () => { /* inicia o jogo */ },
pause: () => { /* pausa */ },
resume: () => { /* retoma */ },
openSettings: () => { /* abre configurações */ },
closeSettings: () => { /* fecha configurações */ },
save: () => { /* salva */ },
state: () => { /* retorna estado atual */ },
};
Etapa 8 — Mobile
Saída: layout 390×844 verificado sem estouro horizontal.
A página deve renderizar em uma viewport de 390×844 sem barras de rolagem horizontais. Controles de toque devem estar presentes e alcançáveis.
Etapa 9 — Aparência
Saída: relatório de comparação de caixa em 3–6 objetos do assunto.
Compare a cena renderizada com a referência (fotografia, conceito ou geração anterior) usando métricas de histograma, nitidez e cor. Cada métrica deve ser
= 0,8 da referência.
Etapa 10 — Produto
Saída: verificação do shell de produto finalizado.
O harness harness/product.mjs verifica que:
- As telas existem (menu, jogando, pausado, configurações, perdido, ganho).
- A tela de título é visível no carregamento.
- As configurações contêm sensibilidade, volume, FOV, inverter-Y, qualidade.
- A persistência salva pelo menos uma chave.
- A entrada aceita teclado, mouse e toque.
- Os objetivos têm pelo menos 1 cadeia com 3 momentos.
- Os papéis incluem pelo menos 2 papéis distintos.
- As ferramentas incluem pelo menos 2 (primária e secundária).
- O HUD contém objetivo, bússola, saúde, munição, prompt, legendas.
- O áudio tem pelo menos 6 eventos de mudança de estado.
- As câmeras incluem hero e close-up.
- O desempenho declara orçamentos para chamadas, triângulos e luzes.
Referências
- Saltline: jogo FPS de arquivo único, 1.423.668 bytes, feito com Claude Fable 5.2.
- Estudos de caso: repositório contém exemplos de aplicação da disciplina.
- Harness:
harness/contém verificações executáveis para cada portão.