photoreal-game

Use ao construir um jogo 3D jogável e fotorrealista a partir de código (WebGL, WebGPU, Three.js, Unity, Unreal ou qualquer motor) — de qualquer gênero, não apenas FPS: transporte, reparo, furtividade, exploração, direção, gerenciamento. Abrange a aparência (luz, materiais, composição, formação de imagem), os sólidos (colisores, censo, âncoras de luz) e o ciclo (verbo, sistema, feedback, falha, playtest). Projetado para que um modelo de baixo custo possa gerar um jogo finalizado por meio de um harness de verificação executável — shaders, censo, colisão, luzes, playtest, produto, mobile, aparência. Origem: reproduzir a disciplina de produção do jogo FPS de arquivo único de 1,4 MB Saltline (feito com Claude Fable 5.2) em um modelo barato.

O que é photoreal-game?

Esta skill define uma disciplina de produção para transformar uma cena 3D gerada por código em um jogo curto e jogável que pareça fotográfico. O objetivo é um **jogo** completo, não uma imagem estática ou demonstração técnica: um jogador com um verbo, um sistema que responde, um modo de vencer e um modo de perder. A skill é agnóstica em relação a ferramentas e gêneros — o assunto determina o verbo e o mesmo procedimento se aplica a qualquer cenário, desde yardas de contêineres até oficinas de reparo. Ela funciona com qualquer agente de IA que possa editar arquivos, executar comandos e inspecionar imagens, sem dependência de motor ou versão específica. A motivação central da skill é reproduzir a disciplina de produção demonstrada pelo jogo Saltline (1.423.668 bytes, feito com Claude Fable 5.2) em modelos de baixo custo como DeepSeek V4.1 Flash. Para isso, a skill estrutura o trabalho em torno de portões executáveis (gates) que garantem qualidade: um harness Node.js/Python verifica automaticamente se a página possui contrato de renderização, census completo, colisões corretas, iluminação auditada e um loop de jogo funcional. O fluxo de trabalho prioriza "produto primeiro, depois aparência" — a camada de produto (título, configurações, pause, HUD) deve estar completa antes de qualquer refinamento visual. A skill é particularmente útil quando uma cena está geometricamente correta mas parece plana ou "gerada", quando o resultado final precisa corresponder a uma referência fotográfica, ou quando uma geração longa precisa manter coerência visual. Não deve ser usada para resultados estilizados intencionalmente (ex.: flat shading, cel shading) ou tarefas de precisão como CAD. O harness é opcional, mas recomendado, e requer Node.js 22+, Python 3.10+ com Pillow e um Chrome/Chromium. O texto da skill não possui dependências adicionais.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/NorwinYu/photoreal-game/tree/HEAD

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

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.

  1. 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.
  2. 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).
  3. 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.
  4. 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.
  5. 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.
  6. 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:

ArtefatoVerificação
um HTML autocontido, sem requisições de redecarregar 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 finalizadomenu, 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 censocobertura = 100%, zero falhas
auditoria de luztoda luz ancorada a uma luminária
relatório de colisãozero penetrações, zero fora dos limites, paridade de colisor 100%
playtestloop concluível, caminho de falha alcançável, reinício funciona
relatório mobilelayout 390×844, sem estouro horizontal, controles de toque presentes
relatório de caixa em 3–6 objetos do assuntocada métrica >= 0,8 da referência
pontuação do quadroreportada, 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.

ArtefatoMínimo
Telasmenu, jogando, pausado, configurações, perdido, ganho
Tela de títulovisível ao carregar; HUD oculto; título, premissa, iniciar, configurações/controles
Configuraçõessensibilidade, volume, FOV, inverter-Y, qualidade (ou um conjunto equivalente)
Persistênciauma chave sobrevive ao recarregar (melhor pontuação/progresso/configurações)
Entradateclado + 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)
HUDobjetivo+progresso, sobrevivência, arma/munição, prompt de contexto, bússola/marcadores, legendas
Áudiomudo + ≥6 eventos de mudança de estado
Câmerascâmera hero + câmeras de close-up estáticas em __PRODUCT.cameras
Desempenhoorçamentos declarados para chamadas/triângulos/luzes, medidos após o início
Mobile390×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.

ItemFatia verticalJogo pequeno finalizado
Objetivos1 cadeia, 3 momentos1–3 cadeias, 5–8 momentos
Papéis de inimigo/interagível23–5 + um clímax
Armas/ferramentas2 (primária + secundária)3–5
Verbos do jogadormover, mirar, atirar, recarregar+ agachar/saltar/interagir/habilidade
Mundoum local, 3 camadas de profundidade2–3 espaços conectados
Shelltítulo, pausa, configurações, fim+ salvar, qualidade, toque
Sessão3–8 min10–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.

  1. Luz — uma única fonte dominante com direção, cor e elevação definidas, mais um ambiente para reflexões e preenchimento.
  2. Materiais — variação em rugosidade, normal e sujeira, em vez de cor sozinha.
  3. Composição e densidade — objetos em várias escalas e profundidades, com um ponto focal claro e dicas de escala legíveis.
  4. Formação da imagem — anti-aliasing, mapeamento de tons, bloom, granulação, vinheta.
  5. 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ãoConteúdo
Assuntosobre o que é o quadro, em que escala
Hora e climadetermina névoa, força de reflexão, contraste
Luz chavedireção, elevação, temperatura de cor, intensidade
Céu e ambientecor do preenchimento de sombra
Família de materiaisquais superfícies existem, quão ásperas, quão molhadas
Ponto focalonde o olho deve pousar primeiro
Restriçõeso 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árioChavePreenchimento / IBLArMaterial característico
Noturno industrialchave fria média-baixa, práticasenv do céu, poças mornasexponencial, cor do céuchão molhado, luminárias emissivas
Dia nubladochave ampla do céu, 35–60°IBL forteperspectiva aérea finaconcreto fosco, poças
Hora dourada / contraluzchave quente baixa atrás do assuntopreenchimento frio do céunévoa longa, bordaasfalto molhado, vidro, metal
Meio-dia clarochave alta, sombras duraspreenchimento do céu + reflexomínimaareia, pedra, tinta
Interiores com luz práticajanela + poucas fontes mornasenv da janela/céufeixes de luz, poeiramadeira, tecido, metal
Subterrâneo / luz artificialpráticas + emissivasambiente baixovolumétricoconcreto 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.

CampoConteúdo
Layout do mundograde de piso, paredes, pilares, cobertura (se interna)
Peças do kitcaixa, cilindro, esfera, plano, escada, rampa, viga — cada uma com dimensões
Decalquestexturas repetíveis para piso, parede, teto, detalhes
Materiaisalbedo, 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.

Habilidades Relacionadas