@the-inclusionist/engine 9.0.0 → 11.0.0

package/dist-pkg/render/cenario-data.d.ts

@@ -1,127 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-/** Grama e flores de um tema `v3` (render/scene-sky.drawV3Grass). Cores em '#rrggbb'. */
-export interface Flora {
-    base: string;
-    top: string;
-    bLt: string;
-    bDk: string;
-    center: string;
-    petals: string[];
-}
-/**
- * Um cenário.
- *
- * O CAMPO `v3` FOI SEPARADO EM DOIS (2026-08-25), e o motivo é um pedido que ele não conseguia atender.
- * Ele significava três coisas ao mesmo tempo — "meu fundo é gerado das cores", "tenho céu vivo compartilhado"
- * e "tenho flora" — e isso funcionava enquanto só existiam dois tipos de tema: a Cidade (PNG, cena própria,
- * sem flora) e os quatro gerados (cores, céu vivo, flora).
- *
- * O Dev pediu FUNDO RASTER PARA A FLORESTA, mantendo a floresta como floresta. Isso é uma combinação nova —
- * PNG **com** flora e céu vivo — e ela não cabia num booleano só: virar `v3` para false teria tirado a grama,
- * as flores e as borboletas dela junto com o fundo gerado.
- *
- * Agora são duas perguntas independentes, e cada leitor faz a sua:
- *   · `fundo`     — de onde vêm as três camadas de parallax. Lido por render/parallax.
- *   · `decor`     — que decoração viva o céu recebe. Lido por render/scene-sky, pela PRESENÇA, não por rótulo.
- * A flora segue a mesma regra: quem tem entrada em THEME_FLORA tem flora, e ponto.
- */
-/**
- * UMA FAIXA DE PRÉDIOS de uma camada de parallax — o skyline da Cidade, como DADO (ADR-0042).
- *
- * TODO NÚMERO AQUI FOI MEDIDO nos três PNG que esta faixa substitui, não escolhido. O ADR-0042 registra por
- * que eles não podiam ser reproduzidos: os fundos precisam de 11.382 retângulos de cor uniforme (2.065 +
- * 2.899 + 6.418, cobertura gulosa 2D), duas a três ordens de grandeza acima do que a pipeline estimava,
- * porque 400×180 com 171 cores é arte desenhada à mão e não geometria.
- *
- * O que se salva medindo, então, não é o pixel — é a REGRA: onde a faixa fica sólida, quanto os topos
- * variam, quais são os dois tons do corpo e os dois da janela. Isso a torna RECOLORÍVEL, que é o que o
- * pilar 1 existe para comprar: o alto contraste repinta um dado e não repinta um PNG. E a Cidade é a maior
- * superfície da tela — sob PNG, era a única coisa que o modo de alto contraste jamais alcançava.
- */
-export interface FaixaDePredios {
-    /** y a partir do qual a faixa é SÓLIDA: abaixo desta linha é tudo prédio, sem buraco. */
-    base: number;
-    /**
-     * Os DOIS TONS DE PROFUNDIDADE, `[fundo, frente]`, desenhados nessa ordem.
-     *
-     * Cada camada de parallax tem duas fileiras no original, não uma — é o que dá o ar de cidade. A primeira
-     * versão deste gerador tinha só uma, e por isso a Cidade saiu chapada.
-     */
-    corpo: readonly [string, string];
-    /** Topos possíveis da fileira da FRENTE, `[mais alto, mais baixo]` — em y, o primeiro é o MENOR. */
-    topo: readonly [number, number];
-    /** Idem para a fileira do FUNDO, que é mais alta e mais simples. */
-    topoFundo: readonly [number, number];
-    /** As larguras possíveis de um prédio, em px. */
-    largura: readonly [number, number];
-    /**
-     * As cores da LUZ — janela ACESA, e só ela.
-     *
-     * ⚠️ NÃO EXISTE COR DE JANELA APAGADA, e essa foi a lição mais cara desta arte: a apagada é a parede. A
-     * primeira versão declarava um par "acesa/apagada" com dois tons quase idênticos, pintava TODA célula, e
-     * o resultado foi um quadriculado cinza. Pior: os dois tons que ela chamava de janela eram, na verdade, o
-     * segundo tom de MASSA — os prédios de trás.
-     *
-     * As luzes são QUENTES (R > B). Ausente = distante demais para acender.
-     */
-    luz?: readonly string[];
-    /** Fração média de janelas acesas. Varia por prédio em torno dela — uns quase escuros, outros cheios. */
-    aceso?: number;
-}
-/** O que todo tema tem, independentemente de como o fundo dele nasce. */
-interface TemaBase {
-    /** CHAVE i18n do nome exibido. Chave e não texto: tabela de módulo resolvida no import congelaria o idioma
-     *  no boot (ver a nota em input/devices). Quem exibe resolve com `t()`. */
-    nome: string;
-    /** Paradas do gradiente vertical do céu, do TOPO ao rodapé, distribuídas por igual. DUAS ou MAIS: com N
-     *  paradas, a de índice i cai em y = 180·i/(N-1) — é assim que se escolhe a ALTURA de uma cor. */
-    sky: readonly string[];
-    cloud?: [string, string];
-    /** Sol baixo com leque de raios, assado na textura do céu. Ausente = céu de puro gradiente. */
-    sol?: {
-        cor: string;
-        x: number;
-        y: number;
-    };
-    /** Este tema tem CHUVA (ciclo do clima em render/weather). Ausente = sempre seco. */
-    chuva?: true;
-    /** Quantos cúmulos na MANTA de tela, que fecha e abre com a chuva. Múltiplo de 3 (são 3 fileiras), e só a
-     *  de cima aparece no tempo bom. Ausente = as 3 lajes fixas da v3. */
-    nuvens?: number;
-    decor?: string[];
-}
-/** Fundo de MORROS: céu em gradiente + duas bandas de morro. Os quatro temas da v3. */
-export interface TemaMorros extends TemaBase {
-    fundo: 'morros';
-    /** As duas bandas de morro: `[fundo, frente]`. */
-    hills: readonly [string, string];
-}
-/** Fundo de PRÉDIOS: céu em gradiente + três faixas de skyline. A Cidade, e só ela por enquanto. */
-export interface TemaPredios extends TemaBase {
-    fundo: 'predios';
-    /** Uma faixa por camada de parallax, do mais distante ao mais próximo. */
-    predios: readonly [FaixaDePredios, FaixaDePredios, FaixaDePredios];
-}
-/**
- * O tema, e ele é uma UNIÃO DISCRIMINADA de propósito.
- *
- * Antes eram `fundo: 'gerado' | 'png'` com `sky?` e `hills?` opcionais, e o invariante de verdade — *quem é
- * gerado TEM céu e morros* — não morava em lugar nenhum: era uma frase num comentário e um `if` em
- * `render/parallax`. Quem lesse o tipo via quatro campos que podiam faltar; quem lesse o código via que
- * nunca faltavam. Agora o compilador cobra, e `render/scene-parallax` deixou de precisar redescrever isto
- * como `ParallaxTheme` — o que era o defeito do ADR-0039 outra vez, numa terceira vítima.
- */
-export type CenarioTema = TemaMorros | TemaPredios;
-/** O tema para o qual todo valor desconhecido cai. */
-export declare const CENARIO_PADRAO = "cidade";
-export declare const CENARIOS: Record<string, CenarioTema>;
-/** v3 exato — grama/flores por tema. SÓ dos temas `v3`: a Cidade não tem flora (por isso o `| undefined`). */
-export declare const THEME_FLORA: Record<string, Flora | undefined>;
-/** '#rrggbb' → 0xrrggbb, para o `beginFill` do PIXI. Verbatim do `hexN` do game.js. */
-export declare const hexN: (s: string) => number;
-/**
- * A validação de `setCenario`, sem o efeito: tema conhecido passa, o resto vira 'cidade'.
- * ⚠️ Cópia FIEL do monólito, herança do `Object.prototype` inclusive — ver o cabeçalho.
- */
-export declare function normalizarCenario(theme: string): string;
-export {};

package/dist-pkg/render/cenario-data.js

@@ -1,145 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/cenario-data — O CATÁLOGO DE CENÁRIOS: os quatro temas do jogo como DADO, e nada além disso.
-//
-// Este é o módulo-FOLHA da etapa D2-b: zero imports, zero PIXI, zero DOM, zero I/O. Ele responde a uma única
-// pergunta — "quais são os cenários, e de que cor é cada um?" — e é justamente por não responder a mais
-// nenhuma que ele pode ser lido, importado e testado por qualquer um dos seus consumidores sem arrastar meio
-// motor junto.
-//
-// ======================= POR QUE A FRONTEIRA CAIU AQUI =======================
-// `CENARIOS` e `THEME_FLORA` são as duas tabelas mais LIDAS e menos PROTEGIDAS do monólito. Antes desta
-// extração elas eram `const` no meio do `game.js` e chegavam aos módulos por INJEÇÃO — `render/scene-sky.ts`
-// as recebe inteiras no `SceneSkyCtx` (`CENARIOS`, `THEME_FLORA`), `game/attract.ts` recebe `CENARIOS` para
-// sortear o tema da demo, o splash recebe a lista reduzida a `{id,nome}`, e `setCenario` as consulta para
-// validar e para pintar. Cinco leitores, nenhum teste, e nenhum lugar onde a FORMA de um tema estivesse
-// escrita: cada leitor descobria por acidente que `T.cloud` só existe quando `T.v3` é verdadeiro, e que
-// `THEME_FLORA` não tem entrada para 'cidade'.
-//
-// Separar o dado da máquina que o consome é o corte mais barato e mais duradouro desta região: um tema novo
-// (uma estação, um bioma) passa a ser uma linha AQUI, e as invariantes que os leitores presumem viram
-// asserção em `tests/cenario-data.node.test.js` — em particular a mais silenciosa de todas, "todo tema `v3`
-// tem `sky`, `cloud`, `hills`, `decor` E uma entrada em `THEME_FLORA`". Quebrar essa correspondência não
-// derruba nada: `scene-sky` faz `const fl = THEME_FLORA[cenario]` e simplesmente não desenha grama. O tema
-// novo nasceria careca, e ninguém saberia dizer por quê.
-//
-// ======================= O QUE ESTÁ AQUI, E POR QUÊ ESTÁ JUNTO =======================
-//  · `CENARIOS`     — os quatro temas + a Cidade. `v3:false` (Cidade) significa "meu fundo vem de PNG e eu
-//                     tenho o céu/tráfego próprios de render/scene-city"; `v3:true` significa "meu fundo é
-//                     GERADO pelas fórmulas da v3.1.100 (render/scene-parallax) a partir destas cores".
-//                     Nenhum tema tem chuva — chuva é da Cidade, e é decisão de render/weather.
-//  · `THEME_FLORA`  — grama e flores por tema. Tabela IRMÃ da de cima e SÓ dos temas `v3`: a Cidade não tem
-//                     flora. Fica no mesmo arquivo porque as duas descrevem O MESMO tema por chaves iguais e
-//                     precisam ser editadas no mesmo gesto; separá-las convidaria exatamente a divergência
-//                     que o teste de correspondência existe para pegar.
-//  · `hexN`         — '#rrggbb' → número, o tradutor entre o dado (string, legível na tabela acima) e o PIXI
-//                     (`beginFill` quer inteiro). Ele vivia solto no meio do bloco de parallax do game.js e
-//                     tinha UM chamador: o `SceneSkyCtx`. É função da TABELA, não do parallax — todas as
-//                     cores que ele converte estão neste arquivo — e por isso veio para cá, e não para
-//                     render/parallax.
-//  · `normalizarCenario` — a validação de `setCenario` ("tema desconhecido → 'cidade'"), isolada do efeito.
-//
-// ======================= O QUE NÃO VEIO =======================
-//  · As FÓRMULAS que transformam estas cores em pixel (`themeSkyTexture`, `themeHillsTexture`,
-//    `parallaxPlaceholder`, `hillHeight`) já moram em render/scene-parallax.ts desde o Estágio 4. Este
-//    arquivo é a entrada delas, não a implementação.
-//  · O desenho da flora (`drawV3Grass`) e da decoração viva é de render/scene-sky.ts. Aqui só a paleta.
-//  · Os FATORES de profundidade das 3 camadas (`PARALLAX`) NÃO estão aqui, apesar de também serem dado: eles
-//    não variam por tema — descrevem a GEOMETRIA do fundo, e vivem ao lado da conta que os usa, em
-//    render/parallax.ts. Uma tabela de tema aqui, uma tabela de câmera lá.
-//
-// ======================= ⚠️ COMPORTAMENTO PRESERVADO: `normalizarCenario` ACEITA CHAVE HERDADA =======================
-// O monólito valida com `if(!CENARIOS[theme])theme='cidade'`. `CENARIOS` é um objeto literal, logo herda de
-// `Object.prototype`: `CENARIOS['toString']` é uma FUNÇÃO, e portanto truthy, e portanto 'toString' passa na
-// validação como se fosse um tema. O `setCenario` então persiste 'toString' em `incl_cenario`, tenta baixar
-// `assets/cenarios/toString/c4.png` e o jogo fica sem fundo. Só é alcançável por um valor forjado (chave de
-// localStorage adulterada; `window.__incl.setCenario('constructor')`), nunca pela UI — que monta o seletor a
-// partir de `Object.keys(CENARIOS)`.
-// ISTO É O COMPORTAMENTO ATUAL E FOI COPIADO TAL E QUAL, de propósito: esta etapa é uma EXTRAÇÃO, e trocar a
-// checagem por `hasOwnProperty` aqui seria consertar às escondidas, dentro de um movimento cuja garantia é
-// justamente "nada mudou". O teste PREGA a falha (`normalizarCenario('toString') === 'toString'`), para que o
-// conserto — quando vier — seja uma mudança visível de asserção e não uma surpresa.
-//
-// SEM I/O NO IMPORT: o corpo do módulo só declara literais. Não há `init`, não há factory, não há efeito —
-// e por isso não há armadilha de ordem de boot: importar este arquivo é sempre seguro, em qualquer ponto.
-// Ver docs/5-Refactoring/plano-modularizacao-mapa.md (D2-b).
-/** O tema para o qual todo valor desconhecido cai. */
-export const CENARIO_PADRAO = 'cidade';
-/* L6 (REFEITO — fiel à v3.1.100): os 4 temas usam EXATAMENTE o céu, as nuvens, as montanhas, a grama
-   e a decoração viva de lá (fórmulas copiadas). BLOCOS = Clarity SEM recolor (a v3 não recoloria tiles
-   por tema). A CHUVA deixou de ser privilégio da Cidade: é o campo `chuva` abaixo que a concede, e a
-   Floresta também a tem (decisão do Dev, 2026-08-25). */
-// ⚠️ TRÊS IDS MENTEM, e o rótulo é que está certo. `cemiterio` é "Amanhecer no Campo" e `espaco` é "Noite no
-// Campo" (ver `cen.*` nos dicionários): os temas mudaram, os ids ficaram. Com `campo` = "Dia no Campo", os três
-// são o MESMO lugar em três horas do dia, e é por isso que compartilham a silhueta em render/scene-parallax.
-// Renomear os ids é migração de dado persistido (`incl_cenario` e as gravações de demonstração os guardam),
-// então fica para uma rodada própria — e este aviso é a rede até lá. Quem ler só o id planta a arte errada;
-// foi o que quase aconteceu.
-//
-// SE UM DIA HOUVER TEMA DE ESPAÇO OU DE HALLOWEEN (decisão do Dev, 2026-08-25): no de espaço, os BLOCOS do
-// nível viram partes de estação espacial — não é só trocar o céu. E o de Halloween é uma FESTA de Halloween,
-// não um cemitério: abóboras, fantasias e doces, não túmulos.
-export const CENARIOS = {
-    // `chuva` estava ESCRITA NO CÓDIGO do clima, como `cenario === 'cidade'`. Era verdade e virou mentira no dia
-    // em que o Dev pediu chuva na Floresta — e o pior de uma condição dessas é que ela não avisa: quem lê
-    // `render/weather` não tem como saber que existe uma lista de temas, porque não existe lista, existe um `if`.
-    // Aqui a capacidade é DADO, e um tema novo declara a sua ao nascer.
-    // A CIDADE (ADR-0042), medida nos três PNG que ela substitui — e MEDIDA DE NOVO depois que a primeira
-    // versão saiu chapada na tela. O que a segunda medição corrigiu:
-    //
-    //   · as cores que eu tinha listado como "janela acesa/apagada" eram o SEGUNDO TOM DE MASSA (os prédios
-    //     de trás). Separando por temperatura, a luz é o que tem R > B — e ela é rara: 5,4% da área na
-    //     camada próxima, 0,28% na média, 0,04% na distante;
-    //   · cada camada tem DUAS fileiras de profundidade, não uma;
-    //   · as janelas são 2 px de largura por 3 a 5 de altura (263 na camada próxima), não pontos 2x2.
-    cidade: {
-        nome: 'cen.cidade', fundo: 'predios', chuva: true,
-        sky: ['#5d6f8e', '#5d6f8e', '#5d6f8e', '#374866'],
-        predios: [
-            // Camada 0 — a bruma. Duas profundidades quase iguais ao céu, e quase nenhuma luz.
-            { base: 144, topo: [96, 128], topoFundo: [71, 108], largura: [16, 40],
-                corpo: ['#4a5c7c', '#374866'], luz: ['#a5ac93', '#adb599'], aceso: 0.006 },
-            // Camada 1 — o meio. Os de trás são visivelmente mais claros (#6b7e98).
-            { base: 139, topo: [64, 122], topoFundo: [44, 100], largura: [14, 38],
-                corpo: ['#6b7e98', '#465164'], luz: ['#c2c0be', '#baada6', '#bfbdb9'], aceso: 0.022 },
-            // Camada 2 — a de perto, e a que carrega a cidade acesa. `base` 158 é a linha em que o original fica
-            // 100% sólido; acima dela a fileira da frente cobre ~70% das colunas e o resto é vão e fileira de trás.
-            { base: 158, topo: [88, 134], topoFundo: [66, 108], largura: [18, 44],
-                corpo: ['#637980', '#2b3e49'], luz: ['#c8c3b7', '#bdac8e', '#ccc4b5', '#d0ccc9'], aceso: 0.85 },
-        ],
-    },
-    campo: { nome: 'cen.campo', fundo: 'morros', sky: ['#86c5e8', '#cfeecb'], cloud: ['#ffffff', '#d4e6f5'], hills: ['#9fd47e', '#6fb84e'], decor: ['nuvens', 'passaros', 'borboletas'] },
-    cemiterio: { nome: 'cen.cemiterio', fundo: 'morros', sky: ['#2b2540', '#5a4f6b'], cloud: ['#d9c4dd', '#a98fb6'], hills: ['#4a5f55', '#33473d'], decor: ['nuvens', 'passaros', 'sparkles', 'minhocas', 'nevoa'] },
-    espaco: { nome: 'cen.espaco', fundo: 'morros', sky: ['#05030f', '#161033'], cloud: ['#3a3550', '#262238'], hills: ['#1e3030', '#142024'], decor: ['nuvens', 'sparkles', 'vagalumes'] },
-    // A FLORESTA É UM PÔR DO SOL, e antes era um céu VERDE (`#3f6b50`→`#8fbf73`) com nuvens verdes por cima.
-    // Verde no céu não é só feio: com os morros em `#2f5e35`, a silhueta das coníferas ficava a um passo da cor
-    // do fundo e sumia — plantei árvores que ninguém via, e só depois de ver na tela é que a causa apareceu.
-    //
-    // As sete paradas caem de 30 em 30 px (y = 180·i/6), e é por isso que são sete: é o que põe o AMARELO em
-    // y=60 e o VERMELHO em y=90, que é a linha do horizonte. O laranja entre eles não é declarado — ele nasce da
-    // interpolação, como o violeta nasce entre o índigo do topo e o rosa. As três últimas paradas ficam ATRÁS
-    // dos morros; existem para o degradê não terminar num corte seco na beira da tela.
-    floresta: { nome: 'cen.floresta', fundo: 'morros',
-        sky: ['#231a52', '#a34a6e', '#ffd166', '#e0392c', '#8e2320', '#5a1a1c', '#3a1418'],
-        sol: { cor: '#ffe9a8', x: 0.30, y: 0.46 },
-        cloud: ['#ffffff', '#e9a06a'], // corpo branco, sombra alaranjada: é a luz baixa batendo por baixo
-        chuva: true, nuvens: 27, // 3 fileiras de 9: a de cima sempre, as outras duas ao fechar o tempo
-        hills: ['#2f5e35', '#1f4226'], decor: ['nuvens', 'passaros', 'borboletas'] },
-};
-/** v3 exato — grama/flores por tema. SÓ dos temas `v3`: a Cidade não tem flora (por isso o `| undefined`). */
-export const THEME_FLORA = {
-    campo: { base: '#52933c', top: '#7cc35a', bLt: '#8fd968', bDk: '#46822f', center: '#ffe14d', petals: ['#ffe14d', '#ff7eb6', '#ffffff', '#ff6b6b'] },
-    cemiterio: { base: '#46624f', top: '#5e7d68', bLt: '#6f9079', bDk: '#3a5244', center: '#f0e6d0', petals: ['#c9b6e8', '#e7c9dd', '#b6c9e8'] },
-    espaco: { base: '#2d4650', top: '#40606a', bLt: '#557f88', bDk: '#26404a', center: '#fff6c0', petals: ['#d6ecff', '#ffffff', '#cfffe8'] },
-    floresta: { base: '#3a7a34', top: '#5fa84a', bLt: '#6fc255', bDk: '#2f6329', center: '#ffe14d', petals: ['#c98ce0', '#ffffff', '#ffd166', '#ff7eb6'] },
-};
-/** '#rrggbb' → 0xrrggbb, para o `beginFill` do PIXI. Verbatim do `hexN` do game.js. */
-export const hexN = (s) => parseInt(String(s).slice(1), 16);
-/**
- * A validação de `setCenario`, sem o efeito: tema conhecido passa, o resto vira 'cidade'.
- * ⚠️ Cópia FIEL do monólito, herança do `Object.prototype` inclusive — ver o cabeçalho.
- */
-export function normalizarCenario(theme) {
-    if (!CENARIOS[theme])
-        return CENARIO_PADRAO;
-    return theme;
-}

package/dist-pkg/render/city-tex.d.ts

@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import { tex, type PixelPainter } from './canvas.js';
-type Tex = ReturnType<typeof tex>;
-/** O par de quadros do ciclo de 2 tempos que TODA figura da rua usa. */
-export type TexPair = [Tex, Tex];
-/** Índice do quadro: 0 e 1, os dois tempos do ciclo. */
-export type Frame = 0 | 1;
-/** Pombo no chão 7×6 — corpo cinza, bico laranja, pés. f alterna cabeça alta ↔ bicando. */
-export declare const paintPombo: (f: Frame) => PixelPainter;
-/** Pombo em revoada 8×7 — mesmo corpo, asa batendo. */
-export declare const paintPomboFly: (f: Frame) => PixelPainter;
-/** Gato 12×8 — corpo/cabeça/orelhas/rabo escuros, olho verde; f alterna as patas. */
-export declare const paintGato: (f: Frame) => PixelPainter;
-/** Cão 13×9 — corpo marrom, focinho escuro, orelha; f alterna as patas. */
-export declare const paintCao: (f: Frame) => PixelPainter;
-/** Catálogo dos bichos: tamanho do canvas + painter por quadro. Fonte única que `createCityTextures` percorre
- *  e que o teste de regressão de arte itera — as chaves são as MESMAS que `game/life` lê em `LifeTexAtlas`. */
-export declare const CREATURE_ART: {
-    readonly pombo: {
-        readonly w: 7;
-        readonly h: 6;
-        readonly paint: (f: Frame) => PixelPainter;
-    };
-    readonly pomboFly: {
-        readonly w: 8;
-        readonly h: 7;
-        readonly paint: (f: Frame) => PixelPainter;
-    };
-    readonly gato: {
-        readonly w: 12;
-        readonly h: 8;
-        readonly paint: (f: Frame) => PixelPainter;
-    };
-    readonly cao: {
-        readonly w: 13;
-        readonly h: 9;
-        readonly paint: (f: Frame) => PixelPainter;
-    };
-};
-export type CreatureKey = keyof typeof CREATURE_ART;
-/** Tamanho da silhueta — casado com o do personagem jogável (render/sprites). */
-export declare const ADULT_W = 16, ADULT_H = 32;
-/** Cor única de toda silhueta (era o `const col` fora do `mk` no main.js). */
-export declare const ADULT_COL = "#262b38";
-/** As 6 silhuetas — 3 masculinas + 3 femininas, todas 16×32. A ordem é a do original (M1, M2, M3, F1, F2, F3);
- *  `game/life` sorteia por índice, então reordenar troca qual silhueta cada sorteio produz. */
-export declare const ADULT_SHAPES: ((f: Frame) => PixelPainter)[];
-/** Tamanho do carro — 3× NATIVO (detalhado, sem upscale); `game/traffic` conta com os 78px de largura. */
-export declare const CAR_W = 78, CAR_H = 36;
-/** As 4 pinturas de fábrica: `[lataria, sombra, teto]`. */
-export declare const CAR_PALETTES: readonly (readonly [string, string, string])[];
-/** Um carro 78×36 na paleta dada. Vidros, brilhos, farol e lanterna são fixos (não seguem a lataria). */
-export declare const paintCar: (body: string, dark: string, top: string) => PixelPainter;
-/** O que o main.js injeta em `game/life` e `game/traffic` — nomes iguais aos campos dos respectivos `Ctx`. */
-export interface CityTextures {
-    lifeTex: Record<CreatureKey, TexPair>;
-    adultTex: TexPair[];
-    carTex: Tex[];
-}
-/** Assa TODA a arte da rua de uma vez. TOCA `document` — chame só no boot do navegador, nunca no import.
- *  Não memoiza de propósito: é chamada uma vez pelo main.js; um cache aqui só esconderia uma segunda chamada. */
-export declare function createCityTextures(): CityTextures;
-export {};

package/dist-pkg/render/city-tex.js

@@ -1,228 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/city-tex — a ARTE PROCEDURAL DA RUA: os bichos, os pedestres e os carros do cenário Cidade.
-//
-// Três blocos que viviam soltos no main.js (`LIFE_TEX`, `ADULT_TEX`, `CAR_TEX`) e que são a MESMA coisa vista
-// de três ângulos: retângulos coloridos carimbados num canvas offscreen que vira PIXI.Texture. Por isso caem
-// juntos aqui, e não em três módulos: o que os une não é o assunto (bicho ≠ carro), é a TÉCNICA e o CONSUMIDOR
-// — quem os pede é a Cidade, e só ela. `render/props` (moeda, árvore) e `render/world-tex` (o nível inteiro)
-// ficam onde estão: props é decoração de QUALQUER cenário, world-tex é o mapa, não a rua.
-//
-// A DUPLICAÇÃO QUE ESTA EXTRAÇÃO CUROU: cada um dos três blocos declarava o SEU `mk` e o SEU `px`, com
-// assinaturas que não conversavam — `mk(w,h,paint)` com `px(x,y,w,h,cor)`; `mk(paint)` de 16×32 fixo com
-// `px(x,y,w,h)` e a cor presa numa `const` de fora; `mk(body,dark,top)` de 78×36 fixo com `px(x,y,w,h,cl)`.
-// Três grafias para "pinte um retângulo". Agora existe uma só, `pixelCanvas`/`pixelTexture` em render/canvas.
-// EFEITO COLATERAL ACEITO: as silhuetas de adulto passaram a receber a cor em CADA chamada (`ADULT_COL`) em vez
-// de um `fillStyle` único antes do laço. O bitmap resultante é idêntico ao byte — só o número de atribuições de
-// `fillStyle` muda —, e em troca some a última assinatura divergente.
-//
-// SEM I/O NO IMPORT — este é o ponto mais importante do arquivo. As texturas de origem nasciam em IIFE no corpo
-// do main.js, o que funciona lá porque o main.js só roda no navegador; um módulo em `render/` é importado pelo
-// project `node` do Vitest, onde `makeCanvas` toca `document` e explode. Por isso NÃO há constante pronta aqui:
-// há `createCityTextures()`, chamada uma vez pelo main.js no boot. Mesmo precedente de `render/textures`
-// (caches preenchidos por `initTextures`) e `render/viewports` (`initViewports`).
-//
-// A FRONTEIRA COM O JOGO NÃO SE MEXE: `game/life` e `game/traffic` continuam recebendo as texturas por INJEÇÃO
-// (`initLife({ lifeTex, adultTex, … })`, `initTraffic({ CAR_TEX, … })`) — eles nunca importaram este módulo e
-// continuam sem importar, para seguirem testáveis em `node` com texturas de mentira. O main.js é que passou a
-// buscar aqui o que antes fabricava em casa. Quem cria as CAMADAS (`lifeLayer`, `carLayer`) e solda o z-order
-// segue sendo o main.js: z-order é composição de cena, não arte.
-//
-// ARMADILHAS AO MEXER NA ARTE:
-//  · Os comentários de arte (`// cabeça alta / bicando`, `// M2: magro, de boné`, `// coluna B + retrovisor`)
-//    são a ÚNICA documentação de qual retângulo é qual parte da figura. Não os apague ao editar coordenadas.
-//  · A silhueta F2 NÃO chama `arms` — é verbatim do original, não esquecimento: os dois retângulos altos do
-//    cabelo longo (`2,4,3,13` e `11,4,3,13`) ocupam exatamente onde os braços iriam. Se um dia isso for
-//    "consertado", a F2 muda de forma no jogo.
-//  · Os carros são 3× NATIVOS (78×36 desenhados, sem upscale) porque a rua fica na camada da frente, perto da
-//    câmera; os bichos são 1× (7×6 … 13×9). Não normalize as escalas: `game/traffic` conta com os 78px.
-//  · Dois quadros por figura, sempre na ordem `[f0, f1]`: `game/life` alterna por índice (`f = f ? 0 : 1`).
-//    Inverter o par não quebra nenhum tipo — quebra a animação, em silêncio.
-import { pixelTexture } from './canvas.js';
-/* ===================== bichos: pombo, pombo voando, gato, cão ===================== */
-/** Pombo no chão 7×6 — corpo cinza, bico laranja, pés. f alterna cabeça alta ↔ bicando. */
-export const paintPombo = (f) => (px) => {
-    px(1, 2, 4, 2, '#9aa3b2');
-    px(0, 3, 2, 1, '#7d8695');
-    if (f === 0) {
-        px(4, 1, 2, 2, '#b9c2d0');
-        px(6, 2, 1, 1, '#e0a23c');
-    }
-    else {
-        px(4, 3, 2, 2, '#b9c2d0');
-        px(6, 4, 1, 1, '#e0a23c');
-    } // cabeça alta / bicando
-    px(2, 5, 1, 1, '#c96a2e');
-    px(4, 5, 1, 1, '#c96a2e');
-};
-/** Pombo em revoada 8×7 — mesmo corpo, asa batendo. */
-export const paintPomboFly = (f) => (px) => {
-    px(2, 3, 4, 2, '#9aa3b2');
-    px(6, 2, 2, 2, '#b9c2d0');
-    px(7, 3, 1, 1, '#e0a23c');
-    if (f === 0)
-        px(1, 0, 4, 2, '#c8d0dc');
-    else
-        px(1, 5, 4, 2, '#c8d0dc'); // asa cima/baixo
-};
-/** Gato 12×8 — corpo/cabeça/orelhas/rabo escuros, olho verde; f alterna as patas. */
-export const paintGato = (f) => (px) => {
-    px(1, 3, 8, 3, '#454b58');
-    px(8, 1, 3, 3, '#454b58');
-    px(8, 0, 1, 1, '#454b58');
-    px(10, 0, 1, 1, '#454b58');
-    px(0, 2, 1, 3, '#454b58');
-    px(9, 2, 1, 1, '#9fe07a');
-    if (f === 0) {
-        px(2, 6, 1, 2, '#454b58');
-        px(7, 6, 1, 2, '#454b58');
-    }
-    else {
-        px(3, 6, 1, 2, '#454b58');
-        px(6, 6, 1, 2, '#454b58');
-    }
-};
-/** Cão 13×9 — corpo marrom, focinho escuro, orelha; f alterna as patas. */
-export const paintCao = (f) => (px) => {
-    px(1, 3, 9, 4, '#8a6a44');
-    px(9, 1, 4, 4, '#8a6a44');
-    px(12, 2, 1, 2, '#3a2d1c');
-    px(9, 0, 2, 2, '#6d5334');
-    px(0, 2, 1, 3, '#8a6a44');
-    if (f === 0) {
-        px(2, 7, 1, 2, '#6d5334');
-        px(8, 7, 1, 2, '#6d5334');
-    }
-    else {
-        px(3, 7, 1, 2, '#6d5334');
-        px(7, 7, 1, 2, '#6d5334');
-    }
-};
-/** Catálogo dos bichos: tamanho do canvas + painter por quadro. Fonte única que `createCityTextures` percorre
- *  e que o teste de regressão de arte itera — as chaves são as MESMAS que `game/life` lê em `LifeTexAtlas`. */
-export const CREATURE_ART = {
-    pombo: { w: 7, h: 6, paint: paintPombo },
-    pomboFly: { w: 8, h: 7, paint: paintPomboFly },
-    gato: { w: 12, h: 8, paint: paintGato },
-    cao: { w: 13, h: 9, paint: paintCao },
-};
-/* ===================== adultos: 6 silhuetas 16×32 ===================== */
-// Adultos = SILHUETAS 16×32 (mesma proporção/tamanho do personagem), formatos distintos M/F (pedido do José)
-/** Tamanho da silhueta — casado com o do personagem jogável (render/sprites). */
-export const ADULT_W = 16, ADULT_H = 32;
-/** Cor única de toda silhueta (era o `const col` fora do `mk` no main.js). */
-export const ADULT_COL = '#262b38';
-/** Pernas: calça (duas colunas alternando o passo) ou saia + pernas curtas. */
-const legs = (px, f, skirt) => {
-    if (skirt) {
-        px(4, 20, 8, 6, ADULT_COL);
-        if (f === 0) {
-            px(5, 26, 2, 6, ADULT_COL);
-            px(9, 26, 2, 6, ADULT_COL);
-        }
-        else {
-            px(4, 26, 2, 6, ADULT_COL);
-            px(10, 26, 2, 6, ADULT_COL);
-        }
-    }
-    else {
-        if (f === 0) {
-            px(5, 20, 3, 12, ADULT_COL);
-            px(9, 20, 3, 11, ADULT_COL);
-        }
-        else {
-            px(4, 20, 3, 11, ADULT_COL);
-            px(10, 20, 3, 12, ADULT_COL);
-        }
-    }
-};
-/** Braços pendentes, defasados entre os quadros (dá o balanço da caminhada). */
-const arms = (px, f) => {
-    if (f === 0) {
-        px(2, 10, 2, 8, ADULT_COL);
-        px(12, 10, 2, 8, ADULT_COL);
-    }
-    else {
-        px(2, 11, 2, 7, ADULT_COL);
-        px(12, 9, 2, 8, ADULT_COL);
-    }
-};
-/** As 6 silhuetas — 3 masculinas + 3 femininas, todas 16×32. A ordem é a do original (M1, M2, M3, F1, F2, F3);
- *  `game/life` sorteia por índice, então reordenar troca qual silhueta cada sorteio produz. */
-export const ADULT_SHAPES = [
-    (f) => (px) => { px(4, 0, 8, 6, ADULT_COL); px(3, 6, 10, 14, ADULT_COL); arms(px, f); legs(px, f, false); }, // M1: ombros largos
-    (f) => (px) => { px(5, 0, 6, 5, ADULT_COL); px(3, 1, 10, 2, ADULT_COL); px(5, 5, 6, 15, ADULT_COL); arms(px, f); legs(px, f, false); }, // M2: magro, de boné
-    (f) => (px) => { px(4, 1, 8, 5, ADULT_COL); px(2, 6, 12, 14, ADULT_COL); arms(px, f); legs(px, f, false); }, // M3: troncudo
-    (f) => (px) => { px(4, 0, 8, 6, ADULT_COL); px(11, 3, 3, 10, ADULT_COL); px(4, 6, 8, 10, ADULT_COL); px(3, 16, 10, 5, ADULT_COL); arms(px, f); legs(px, f, true); }, // F1: rabo de cavalo + saia
-    (f) => (px) => { px(3, 0, 10, 6, ADULT_COL); px(2, 4, 3, 13, ADULT_COL); px(11, 4, 3, 13, ADULT_COL); px(5, 6, 6, 10, ADULT_COL); px(4, 16, 8, 5, ADULT_COL); legs(px, f, true); }, // F2: cabelo longo + vestido (sem `arms` — ver o cabeçalho)
-    (f) => (px) => { px(3, 0, 10, 7, ADULT_COL); px(4, 7, 8, 9, ADULT_COL); px(3, 16, 10, 5, ADULT_COL); arms(px, f); legs(px, f, true); }, // F3: chanel + saia
-];
-/* ===================== carros: 4 cores, 78×36 (3× nativo) ===================== */
-/** Tamanho do carro — 3× NATIVO (detalhado, sem upscale); `game/traffic` conta com os 78px de largura. */
-export const CAR_W = 78, CAR_H = 36;
-/** As 4 pinturas de fábrica: `[lataria, sombra, teto]`. */
-export const CAR_PALETTES = [
-    ['#c8452e', '#7d2717', '#a03a24'], // vermelho
-    ['#2e6fc8', '#193f7d', '#2757a0'], // azul
-    ['#3aa15b', '#1f6336', '#2f8a4c'], // verde
-    ['#c8a12e', '#7d641a', '#a8862a'], // amarelo
-];
-/* ===================== A RODA É REDONDA, E ISSO PRECISOU SER DITO =====================
- * A primeira versão do carro (portada verbatim do monólito) fazia o pneu com UM retângulo de 14×11. Numa
- * arte de retângulos carimbados, a roda é o único elemento que o olho sabe de cor que é redondo — e é o
- * primeiro que denuncia o desenho inteiro. O Dev, olhando a rua: "melhore os carros, estão muito feios com
- * as rodas quadradas."
- *
- * O jeito de ter círculo aqui é o de sempre em pixel art: uma TABELA de linhas, cada uma com o recuo e a
- * largura daquela altura. Não é aproximação de matemática em tempo de execução — é o desenho, escrito. */
-/** Pneu Ø14: `[recuo, largura]` por linha, de cima para baixo. */
-const PNEU = [
-    [5, 4], [3, 8], [2, 10], [1, 12], [1, 12], [0, 14], [0, 14],
-    [0, 14], [0, 14], [1, 12], [1, 12], [2, 10], [3, 8], [5, 4],
-];
-/** Aro Ø8, no mesmo formato — desenhado dentro do pneu. */
-const ARO = [
-    [2, 4], [1, 6], [0, 8], [0, 8], [0, 8], [0, 8], [1, 6], [2, 4],
-];
-/** Um carro 78×36 na paleta dada. Vidros, brilhos, farol e lanterna são fixos (não seguem a lataria). */
-export const paintCar = (body, dark, top) => (px) => {
-    px(3, 14, 72, 13, body);
-    px(3, 25, 72, 2, dark); // corpo + saia escura
-    px(1, 16, 2, 8, dark);
-    px(75, 16, 2, 8, dark); // para-choques
-    // Cabine com o teto AFUNILADO: eram 40px de bloco reto, e teto reto num carro de perfil lê como caixa.
-    px(17, 4, 36, 2, top);
-    px(15, 6, 40, 9, top);
-    px(17, 6, 36, 9, body);
-    px(19, 7, 14, 7, '#bcd6ee');
-    px(37, 7, 14, 7, '#bcd6ee'); // vidros
-    px(20, 8, 4, 2, '#eef6ff');
-    px(38, 8, 4, 2, '#eef6ff'); // brilho dos vidros
-    px(34, 7, 3, 7, top);
-    px(53, 10, 4, 4, dark); // coluna B + retrovisor
-    px(3, 14, 72, 1, 'rgba(255,255,255,.28)'); // realce superior da lataria
-    px(35, 15, 1, 10, dark); // frisa entre as duas portas
-    px(0, 17, 3, 5, '#ffd9a0');
-    px(75, 17, 3, 5, '#ff6a5a'); // farol / lanterna
-    const wheel = (wx) => {
-        px(wx + 1, 20, 12, 2, dark);
-        px(wx - 1, 21, 16, 1, dark); // caixa de roda, em arco
-        PNEU.forEach(([dx, w], i) => px(wx + dx, 22 + i, w, 1, '#10131a')); // pneu
-        ARO.forEach(([dx, w], i) => px(wx + 3 + dx, 25 + i, w, 1, '#2b3140')); // aro
-        px(wx + 6, 28, 2, 2, '#8a93a8'); // cubo
-    };
-    wheel(11);
-    wheel(53);
-};
-/** Assa TODA a arte da rua de uma vez. TOCA `document` — chame só no boot do navegador, nunca no import.
- *  Não memoiza de propósito: é chamada uma vez pelo main.js; um cache aqui só esconderia uma segunda chamada. */
-export function createCityTextures() {
-    const pair = (w, h, paint) => [pixelTexture(w, h, paint(0)), pixelTexture(w, h, paint(1))]; // ordem [f0, f1] — game/life alterna por índice
-    const lifeTex = {};
-    for (const k of Object.keys(CREATURE_ART)) {
-        const a = CREATURE_ART[k];
-        lifeTex[k] = pair(a.w, a.h, a.paint);
-    }
-    const adultTex = ADULT_SHAPES.map((v) => pair(ADULT_W, ADULT_H, v));
-    const carTex = CAR_PALETTES.map(([body, dark, top]) => pixelTexture(CAR_W, CAR_H, paintCar(body, dark, top)));
-    return { lifeTex, adultTex, carTex };
-}

package/dist-pkg/render/city-tiles.d.ts

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import { type PixelPainter } from './canvas.js';
-/** O TILE do miolo da parede: alvenaria em fiada alternada. 51 retângulos, 9 cores, fiel ao pixel. */
-export declare const paintTileFill: PixelPainter;
-/** O TILE do TOPO da plataforma: mesma alvenaria com a borda superior iluminada. 62 retângulos, 23 cores. */
-export declare const paintTileSurface: PixelPainter;
-/** Os dois tiles como canvas 16×16 — a forma que `worldCanvas` consumia das imagens carregadas. */
-export declare function cityTiles(): {
-    fill: HTMLCanvasElement;
-    surface: HTMLCanvasElement;
-};