@the-inclusionist/engine 9.0.0 → 11.0.0

package/dist-pkg/render/player-anim.js

@@ -1,152 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/player-anim.ts — A ESCOLHA DO QUADRO do personagem: dado o estado do jogador, QUAL textura desenhar.
-// Extraída verbatim da segunda metade do `stepPlayer` do game.js (o trecho E15/E16/E17/E19/E20, de
-// `const COYOTE=5` até `pl._tx=tx`). Ela morava dentro da função de física por acidente histórico — mas não é
-// física: não move ninguém, não colide, não lê o mundo. É uma DECISÃO PURA a partir do estado já simulado,
-// e é por isso que ela é render e mora aqui, ao lado de render/sprites (quem cria as texturas) e de
-// render/viewports (quem as recolore por modo de visão).
-//
-// POR QUE A FRONTEIRA CAIU EXATAMENTE AQUI
-// O `stepPlayer` do monólito fazia quatro coisas em sequência: (1) física, (2) coleta de moeda/quiz,
-// (3) power-ups + chave/portão, (4) animação. A (1) já saiu para game/physics.ts (B1), que devolve
-// `{ran, dir}` — e `dir` existe justamente porque a animação lê a DIREÇÃO DO INPUT, não `vx` (a colisão zera
-// `vx` por quadros inteiros e isso reiniciava o ciclo de passos; só apareciam 2 dos 8 quadros). As (2) e (3)
-// são LÓGICA DE JOGO — dependem de `coins`, `powerups`, `gate`, do quiz e do HUD — e continuam no game.js;
-// não vieram junto de propósito, porque arrastá-las para cá traria de volta metade do monólito.
-// O corte começa em `const COYOTE=5` e termina em `pl._tx=tx`. A ÚLTIMA linha do original,
-// `if(pl.sprite) pl.sprite.texture=playerVizTex(tx, pl.viz)`, NÃO está aqui: ela toca um sprite do PIXI e o
-// recolor por modo de visão. Ela vive em render/draw.ts (`animatePlayer`), que é quem já lida com PIXI.
-// Assim este arquivo fica sem PIXI, sem DOM e sem estado de módulo — testável quadro a quadro no project
-// `node` do Vitest.
-//
-// O QUE É "PURO" AQUI (e o que não é)
-// A função é DETERMINÍSTICA dado `(pl, env)` e não faz I/O nenhum. Ela ESCREVE em `pl`, e isso é contrato,
-// não efeito colateral escondido: os relógios de animação (`anim`, `walkAnim`, `idleTime`, `flavorT`),
-// o quadro congelado da ventosa (`climbFrame`), o estado da gracinha (`flavor`) e as flags que o RESTO do
-// jogo lê (`walking`/`running`, que a bengala do modo cego consome em draw; `idleNow`; `_tx`, o quadro-base
-// em cor que o multi-tela recolore por viewport) moram no objeto do jogador desde o v3. Mover esses campos
-// para dentro do módulo criaria um segundo lugar de verdade sobre o jogador — o oposto do que a
-// modularização quer. O teste, por isso, sonda `pl` depois da chamada tanto quanto o valor de retorno.
-//
-// INJEÇÃO: `held` E `rnd` ENTRAM PELO `env`, NÃO POR IMPORT — e isso é um DESVIO CONSCIENTE do precedente de
-// game/physics.ts, que importa os dois. Lá a âncora de regressão são as 14 trajetórias-ouro, que exigem o
-// singleton de input e o RNG semeado reais; aqui não há trajetória-ouro nenhuma, e o valor da extração é
-// poder atravessar a cadeia de prioridade ramo a ramo. Com `held` injetado, um teste liga "Correr" sem
-// montar `keys`+`ctrl`+`padCur`; com `rnd` injetado, a gracinha sorteada é ESCOLHIDA em vez de descoberta.
-// O game.js passa exatamente os mesmos `held` (input/state) e `rnd` (core/rng), então a ordem de consumo da
-// semente — de que o attract-mode/replay depende — fica idêntica à do monólito.
-// As texturas também entram pelo `env` (`env.tex`): os `TEX_*` de render/sprites são bindings VIVOS que só
-// `initCharacterSprites()` preenche, e importá-los aqui amarraria o módulo ao boot do PIXI justamente na
-// parte que queremos testar sem ele. `ANIM` (as cadências) é constante pura → import normal.
-//
-// ARMADILHA DE ORDEM DE BOOT: nenhuma. O módulo não tem estado próprio nem toca nada no import.
-import { ANIM } from '../core/constants.js';
-/**
- * Coyote-time da ANIMAÇÃO (E16), em quadros. Existe para matar o flicker walk↔jump no pouso: `onGround`
- * pisca por 1 quadro ao repousar, e sem essa folga o personagem alternava entre andar e pular ao aterrissar.
- * É o coyote do RENDER e é independente do coyote da física (game/physics) — mudar um não muda o outro.
- */
-export const COYOTE = 5;
-/**
- * Escolhe o quadro do jogador para ESTE tick e adianta os relógios de animação.
- *
- * Cadeia de prioridade E17, do mais específico ao mais genérico — a ORDEM é a regra, não um detalhe:
- *   ventosa → escada → água → voo → aéreo(pulo) → andando → idle
- * Estar na água DENTRO de uma escada mostra escada; grudado na parede dentro d'água mostra ventosa.
- *
- * Também escreve em `pl` (ver AnimPlayer): `walking`/`running` (bengala), `idleNow`, os relógios e `_tx`.
- *
- * @returns o quadro escolhido (o mesmo valor que fica em `pl._tx`).
- */
-export function choosePlayerFrame(pl, env) {
-    const { dt, dir, tex, wheelchair } = env;
-    const held = env.held, rnd = env.rnd;
-    // E16: estado aéreo ESTÁVEL — subindo (vy<0) entra na hora; cair/sair de borda só após o coyote-time.
-    const grounded = pl.airTime <= COYOTE;
-    const airborne = !pl.clinging && ((pl.vy < 0 && !pl.onGround) || !grounded);
-    // 'moving' baseado no INPUT (direção segurada), NÃO em vx — a colisão zera vx por quadros e isso resetava
-    // o ciclo (só apareciam 2 dos 8 quadros). Assim os 8 quadros tocam contínuos.
-    const moving = (dir !== 0) && grounded && !pl.clinging;
-    pl.walking = moving && !pl.inWater && !pl.onLadder && !pl.flying; // p/ a bengala: só aparece andando
-    pl.running = pl.walking && held(pl, 'action1') && !!pl.runCane; // correndo: só com a bengala de corrida
-    pl.anim += dt; // idle (clock contínuo)
-    pl.walkAnim += dt; // clock do passo NUNCA reseta → ciclo de 8 sem reinício
-    const II = tex.idle;
-    const wcFreeze = wheelchair || !!pl.rmWalk; // cadeirante: pernas paradas — mesma via do movimento reduzido
-    let tx;
-    pl.idleNow = false;
-    if (pl.clinging) {
-        const ceil = (pl.clingN === 'U'); // E18f: teto e parede usam ciclos distintos
-        const CL = ceil ? tex.clingCeil : tex.clingWall;
-        if (!pl.rmWalk && (pl.vx !== 0 || pl.vy !== 0))
-            pl.climbFrame = (Math.floor(pl.walkAnim / ANIM.clingHold)) % CL.length; // só avança ao mover; parado MANTÉM o quadro
-        tx = CL[(pl.rmWalk ? 0 : (pl.climbFrame || 0)) % CL.length];
-    }
-    else if (pl.onLadder) {
-        const CB = tex.climb;
-        if (wheelchair) {
-            tx = II[0];
-        } // ELEVADOR cadeirante: pose PARADA (idle), não de escada
-        else {
-            const climbing = (pl.vy !== 0) && !pl.rmWalk;
-            tx = climbing ? CB[Math.floor(pl.walkAnim / ANIM.climbHold) % CB.length] : CB[0];
-        }
-    }
-    else if (pl.inWater) {
-        const stroking = ((dir !== 0) || held(pl, 'action2')) && !wcFreeze; // movendo = braçada; parado/congelado = pernas paradas
-        const SW = stroking ? tex.swim : tex.swimIdle;
-        tx = wcFreeze ? SW[0] : SW[Math.floor(pl.walkAnim / ANIM.swimHold) % SW.length];
-    }
-    else if (pl.flying) {
-        tx = tex.fly;
-    }
-    else if (airborne) {
-        if (wcFreeze)
-            tx = wheelchair ? II[0] : tex.jumpUp; // cadeirante caindo = pose neutra sentado; congelado = pulo num quadro
-        else
-            tx = pl.vy < 0 ? tex.jumpUp : tex.jumpDown; // subindo: pernas recolhidas / caindo: estendidas
-    }
-    else if (moving) {
-        if (wcFreeze) {
-            tx = II[0];
-        } // cadeirante/movimento reduzido: anda sem ciclo de passos
-        else {
-            const running = held(pl, 'action1'); // E19: correr ≠ andar — passada/cadência distintas
-            const M = running ? tex.run : tex.walk;
-            const hold = running ? ANIM.runHold : ANIM.walkHold;
-            tx = M[Math.floor(pl.walkAnim / hold) % M.length];
-        }
-    }
-    else {
-        pl.idleNow = true;
-        pl.idleTime += dt; // E20: parado → respira; após flavorDelay, uma gracinha
-        if (!pl.rmFlavor) { // gracinhas (toggle próprio — há quem se incomode)
-            if (pl.flavor < 0 && pl.idleTime > ANIM.flavorDelay) {
-                pl.flavor = Math.floor(rnd() * tex.flavors.length);
-                pl.flavorT = 0;
-            }
-            if (pl.flavor >= 0) {
-                const F = tex.flavors[pl.flavor];
-                const step = Math.floor(pl.flavorT / F.hold);
-                pl.flavorT += dt;
-                if (step >= F.seq.length) {
-                    pl.flavor = -1;
-                    pl.idleTime = 0;
-                }
-                else {
-                    tx = F.tex[F.seq[step]];
-                }
-            }
-        }
-        else
-            pl.flavor = -1;
-        if (pl.flavor < 0)
-            tx = pl.rmBreath ? II[0] : II[Math.floor(pl.anim / ANIM.idleHold) % II.length]; // respiração: congela ou cicla
-    }
-    if (!pl.idleNow) {
-        pl.idleTime = 0;
-        pl.flavor = -1;
-    } // saiu do idle → zera gracinha
-    pl._tx = tx; // quadro base (cor) p/ recolor por viewport
-    return tx;
-}

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

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import type { PixelPainter } from './canvas.js';
-export type Material = 'papel' | 'plastico' | 'metal' | 'vidro';
-export type Lixeira = 'azul' | 'vermelha' | 'amarela' | 'verde';
-/** Latinha de alumínio 6×9 — corpo prateado, tampa e base mais escuras, brilho de uma coluna. */
-export declare const paintLatinha: PixelPainter;
-/** Garrafa PET 6×11 — gargalo estreito, tampa, corpo translúcido esverdeado. */
-export declare const paintGarrafaPet: PixelPainter;
-/** Pote de vidro 8×9 — boca larga, tampa metálica, corpo azulado transparente. */
-export declare const paintPoteDeVidro: PixelPainter;
-/** Caixa de papelão 10×9 — papelão liso, aba superior e fita no meio. */
-export declare const paintCaixaDePapelao: PixelPainter;
-/** Catálogo dos objetos: tamanho do canvas + pintor. As chaves são os `Material` de `game/recycling`. */
-export declare const LIXO_ART: Readonly<Record<Material, {
-    w: number;
-    h: number;
-    paint: PixelPainter;
-}>>;
-export declare const LIXEIRA_W = 12, LIXEIRA_H = 15;
-/** A cor de cada lixeira, na CONAMA 275/2001. Corpo e um tom escuro para tampa, aro e sombra. */
-export declare const COR_DA_LIXEIRA: Readonly<Record<Lixeira, {
-    corpo: string;
-    escuro: string;
-}>>;
-/**
- * Uma lixeira 12×15 — corpo levemente cônico, tampa saliente, alça e o símbolo da reciclagem em três traços.
- *
- * ⚠️ O SÍMBOLO É CLARO SOBRE O CORPO, e não uma quinta cor: em alto contraste e nos filtros de daltonismo, o que
- * distingue as quatro lixeiras é a cor do corpo, e um símbolo colorido competiria com ela. Claro sobre escuro
- * sobrevive a qualquer um dos dezesseis modos de visão.
- */
-export declare const paintLixeira: (cor: Lixeira) => PixelPainter;
-export declare const PLACA_W = 20, PLACA_H = 28;
-/**
- * A placa 20×28: disco vermelho vazado, a pessoa jogando lixo em preto, a barra da proibição e o poste.
- *
- * Ela é o rosto de uma regra que o jogo NÃO pune (ver `game/recycling`): quem carrega lixo simplesmente não
- * passa daqui. A placa existe para que a criança saiba POR QUE não passou — sem ela, a barreira seria um bug
- * aos olhos de quem joga.
- */
-export declare const paintPlaca: PixelPainter;
-export interface RecyclingTextures {
-    lixo: Record<Material, unknown>;
-    lixeira: Record<Lixeira, unknown>;
-    placa: unknown;
-}
-/** Assa tudo uma vez. Chamada pela raiz de composição no boot — nunca no import (ver o cabeçalho). */
-export declare function createRecyclingTextures(): RecyclingTextures;

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

@@ -1,164 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/recycling-tex — a ARTE PROCEDURAL do lixo reciclável e das quatro lixeiras.
-//
-// Mesma técnica de `render/city-tex` (retângulos carimbados por `pixelCanvas`), e por isso mesmo um módulo à
-// parte e não um bloco lá dentro: `city-tex` é a arte DA RUA — bichos, pedestres, carros —, e o seu cabeçalho
-// diz com todas as letras que "props é decoração de QUALQUER cenário" e fica fora. Lixo e lixeira aparecem em
-// qualquer tema, então seguem a regra que aquele arquivo escreveu para si.
-//
-// SEM I/O NO IMPORT, pelo mesmo motivo que lá: `makeCanvas` toca `document`, e um módulo de `render/` é
-// importado pelo project `node` do Vitest. Não há constante pronta aqui — há `createRecyclingTextures()`, que a
-// raiz de composição chama uma vez no boot.
-//
-// ========================= POR QUE PROCEDURAL, E NÃO PNG =========================
-// O pilar diz "arte = dados: nenhum PNG embutido no jogo" (ADR-0010/0018). Quatro objetos e quatro lixeiras em
-// PNG seriam oito arquivos a versionar, precachear e recolorir à mão em cada modo de visão. Como retângulos,
-// eles são LIDOS pelo alto contraste e pelos filtros de daltonismo como o resto do mundo, sem exceção e sem
-// arquivo `_hc` paralelo — que é a dívida que o atlas de sprites do personagem ainda carrega.
-//
-// ========================= AS CORES SÃO CONTEÚDO =========================
-// As lixeiras seguem a Resolução CONAMA 275/2001, que é o padrão da rua brasileira: AZUL papel, VERMELHA
-// plástico, AMARELA metal, VERDE vidro. A criança que aprende a cor aqui reconhece a de fora — trocar uma por
-// gosto ensina errado. O gate compara este arquivo com `game/recycling`, que é quem decide o acerto, para que
-// as duas listas não possam divergir em silêncio.
-import { pixelTexture } from './canvas.js';
-/* ===================== os quatro objetos ===================== */
-// Miúdos de propósito: ficam no chão, ao lado de moedas, num mundo de 320×180. Grandes demais viram obstáculo
-// visual; pequenos demais somem para quem tem baixa visão — a faixa útil aqui é 6 a 11 px de largura.
-/** Latinha de alumínio 6×9 — corpo prateado, tampa e base mais escuras, brilho de uma coluna. */
-export const paintLatinha = (px) => {
-    px(1, 1, 4, 7, '#b9c2cc'); // corpo
-    px(1, 0, 4, 1, '#8b949e'); // tampa
-    px(1, 8, 4, 1, '#8b949e'); // base
-    px(2, 2, 1, 5, '#e6ecf2'); // brilho
-    px(0, 2, 1, 5, '#8b949e'); // sombra do lado
-};
-/** Garrafa PET 6×11 — gargalo estreito, tampa, corpo translúcido esverdeado. */
-export const paintGarrafaPet = (px) => {
-    px(2, 0, 2, 1, '#2f6fd0'); // tampa azul
-    px(2, 1, 2, 2, '#bfe6d8'); // gargalo
-    px(1, 3, 4, 7, '#a8dcc9'); // corpo
-    px(2, 4, 1, 5, '#dcf3ea'); // brilho
-    px(1, 10, 4, 1, '#7fbfa8'); // base
-};
-/** Pote de vidro 8×9 — boca larga, tampa metálica, corpo azulado transparente. */
-export const paintPoteDeVidro = (px) => {
-    px(1, 0, 6, 1, '#8b949e'); // tampa
-    px(1, 1, 6, 1, '#6f7883'); // aro
-    px(1, 2, 6, 6, '#a9cfe0'); // corpo
-    px(2, 3, 1, 4, '#e2f2f8'); // brilho
-    px(1, 8, 6, 1, '#7fa8ba'); // base
-};
-/** Caixa de papelão 10×9 — papelão liso, aba superior e fita no meio. */
-export const paintCaixaDePapelao = (px) => {
-    px(0, 1, 10, 8, '#c39a63'); // corpo
-    px(0, 0, 10, 1, '#a37f4f'); // aba de cima
-    px(4, 0, 2, 9, '#d9bb90'); // fita vertical
-    px(0, 4, 10, 1, '#a37f4f'); // vinco
-};
-/** Catálogo dos objetos: tamanho do canvas + pintor. As chaves são os `Material` de `game/recycling`. */
-export const LIXO_ART = Object.freeze({
-    metal: { w: 6, h: 9, paint: paintLatinha },
-    plastico: { w: 6, h: 11, paint: paintGarrafaPet },
-    vidro: { w: 8, h: 9, paint: paintPoteDeVidro },
-    papel: { w: 10, h: 9, paint: paintCaixaDePapelao },
-});
-/* ===================== as quatro lixeiras ===================== */
-export const LIXEIRA_W = 12, LIXEIRA_H = 15;
-/** A cor de cada lixeira, na CONAMA 275/2001. Corpo e um tom escuro para tampa, aro e sombra. */
-export const COR_DA_LIXEIRA = Object.freeze({
-    azul: { corpo: '#2f6fd0', escuro: '#1e4a8c' },
-    vermelha: { corpo: '#c8372d', escuro: '#8d251e' },
-    amarela: { corpo: '#e0b423', escuro: '#a07d13' },
-    verde: { corpo: '#2f9e52', escuro: '#1d6b36' },
-});
-/**
- * Uma lixeira 12×15 — corpo levemente cônico, tampa saliente, alça e o símbolo da reciclagem em três traços.
- *
- * ⚠️ O SÍMBOLO É CLARO SOBRE O CORPO, e não uma quinta cor: em alto contraste e nos filtros de daltonismo, o que
- * distingue as quatro lixeiras é a cor do corpo, e um símbolo colorido competiria com ela. Claro sobre escuro
- * sobrevive a qualquer um dos dezesseis modos de visão.
- */
-export const paintLixeira = (cor) => (px) => {
-    const { corpo, escuro } = COR_DA_LIXEIRA[cor];
-    px(1, 3, 10, 11, corpo); // corpo
-    px(0, 1, 12, 2, escuro); // tampa
-    px(5, 0, 2, 1, escuro); // alça
-    px(1, 14, 10, 1, escuro); // base
-    px(2, 4, 1, 9, escuro); // vinco esquerdo
-    px(9, 4, 1, 9, escuro); // vinco direito
-    px(4, 6, 4, 1, '#f2f5f7'); // símbolo: traço de cima
-    px(4, 8, 4, 1, '#f2f5f7'); // símbolo: traço do meio
-    px(4, 10, 4, 1, '#f2f5f7'); // símbolo: traço de baixo
-};
-/* ===================== a placa de proibido jogar lixo =====================
- *
- * ⚠️ SEGUNDA VERSÃO, e a primeira era pequena demais para dizer o que dizia. Tinha 11×16 e resolvia o disco
- * de proibição com quatro retângulos — na tela virava um quadradinho vermelho com um risco branco, que a
- * criança lê como "algum objeto", não como "aqui não". O Dev mandou a referência da placa de verdade (o
- * pictograma da pessoa jogando lixo dentro do círculo cortado) e pediu: "a placa deveria ser grande, com o
- * símbolo identificável da pessoa jogando coisas e o sinal de proibido."
- *
- * Agora são 20×28: prancha de 20×20 e poste de 8. O círculo vem de TABELA DE LINHAS, como a roda do carro —
- * é o mesmo problema, e pela mesma razão: numa arte de retângulos, o que o olho já sabe que é redondo
- * denuncia o desenho inteiro se sair quadrado.
- *
- * ⚠️ E A LEITURA É EM TRÊS CAMADAS, na ordem em que a criança precisa delas: a prancha clara separa a placa
- * do fundo; o pictograma PRETO sobre claro é o contraste mais alto que existe e sobrevive aos dezesseis
- * modos de visão; a barra vermelha vem por último, por cima de tudo, porque é ela que transforma "uma pessoa
- * jogando lixo" em "não jogue lixo". Trocar essa ordem inverte o sentido do desenho. */
-export const PLACA_W = 20, PLACA_H = 28;
-/** Disco Ø18: `[recuo, largura]` por linha. Mesma técnica da roda do carro. */
-const DISCO = [
-    [6, 6], [4, 10], [3, 12], [2, 14], [1, 16], [1, 16], [0, 18], [0, 18], [0, 18],
-    [0, 18], [0, 18], [0, 18], [1, 16], [1, 16], [2, 14], [3, 12], [4, 10], [6, 6],
-];
-/** Miolo Ø14, no mesmo formato — abre o vazio claro dentro do aro vermelho. */
-const MIOLO = [
-    [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],
-];
-const VERMELHO = '#d42a1e', CLARO = '#f2f5f7', PRETO = '#1a1d24', POSTE = '#6f7883';
-/**
- * A placa 20×28: disco vermelho vazado, a pessoa jogando lixo em preto, a barra da proibição e o poste.
- *
- * Ela é o rosto de uma regra que o jogo NÃO pune (ver `game/recycling`): quem carrega lixo simplesmente não
- * passa daqui. A placa existe para que a criança saiba POR QUE não passou — sem ela, a barreira seria um bug
- * aos olhos de quem joga.
- */
-export const paintPlaca = (px) => {
-    px(1, 0, 18, 20, CLARO); // prancha
-    px(0, 0, 20, 1, PRETO);
-    px(0, 19, 20, 1, PRETO); // moldura: topo e base
-    px(0, 1, 1, 18, PRETO);
-    px(19, 1, 1, 18, PRETO); // moldura: laterais
-    DISCO.forEach(([dx, w], i) => px(1 + dx, 1 + i, w, 1, VERMELHO));
-    MIOLO.forEach(([dx, w], i) => px(3 + dx, 3 + i, w, 1, CLARO));
-    // O pictograma, dentro do miolo (x 3..16, y 3..16): cabeça, tronco, braço estendido e as pernas.
-    px(7, 5, 3, 3, PRETO); // cabeça
-    px(7, 8, 3, 5, PRETO); // tronco
-    px(10, 9, 3, 1, PRETO); // braço que joga
-    px(7, 13, 1, 3, PRETO);
-    px(9, 13, 1, 3, PRETO); // pernas
-    px(13, 11, 1, 1, PRETO);
-    px(14, 13, 1, 1, PRETO);
-    px(12, 14, 1, 1, PRETO); // o lixo caindo
-    // A barra da proibição POR ÚLTIMO: é ela que faz o desenho dizer "não".
-    for (let k = 0; k < 12; k++)
-        px(4 + k, 4 + k, 3, 2, VERMELHO);
-    px(9, 20, 2, 7, POSTE);
-    px(7, 27, 6, 1, POSTE); // poste e pé
-};
-/** Assa tudo uma vez. Chamada pela raiz de composição no boot — nunca no import (ver o cabeçalho). */
-export function createRecyclingTextures() {
-    const lixo = {};
-    for (const m of Object.keys(LIXO_ART)) {
-        const a = LIXO_ART[m];
-        lixo[m] = pixelTexture(a.w, a.h, a.paint);
-    }
-    const lixeira = {};
-    for (const c of Object.keys(COR_DA_LIXEIRA)) {
-        lixeira[c] = pixelTexture(LIXEIRA_W, LIXEIRA_H, paintLixeira(c));
-    }
-    return { lixo, lixeira, placa: pixelTexture(PLACA_W, PLACA_H, paintPlaca) };
-}

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

@@ -1,77 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import type { Desenho, Visivel } from './port.js';
-type Gfx = Desenho & Visivel;
-type VisibleLayer = Visivel;
-interface DarkRegion {
-    set: Set<string>;
-}
-interface Pl {
-    x: number;
-    y: number;
-    quit?: boolean;
-}
-export interface SceneCityCtx {
-    cityDecoG: Gfx;
-    abandonG: Gfx;
-    lavaFxG: Gfx;
-    waterFxG: Gfx;
-    skyLayer: VisibleLayer;
-    darkRegions: DarkRegion[];
-    solidAt: (x: number, y: number) => boolean;
-    tileAt: (x: number, y: number) => number;
-    lifeSurfaceAt: (tx: number) => number;
-    WORLD_W: number;
-    WORLD_H: number;
-    TILE: number;
-    WORLD_PX_W: number;
-    WORLD_PX_H: number;
-    LOGICAL_W: number;
-    LOGICAL_H: number;
-    BOX: {
-        h: number;
-    };
-    DIRECT_CFG: Record<string, unknown>;
-    getCenario: () => string;
-    getVizMode: () => string;
-    getPlayers: () => Pl[];
-    getFxClock: () => number;
-    getRm: () => {
-        decor?: boolean;
-    };
-    onCenarioChange?: (city: boolean) => void;
-}
-export interface SceneCity {
-    buildCityDeco: () => void;
-    applyCenarioVida: () => void;
-    stepTileFx: () => void;
-}
-/** Coluna com poste de luz na fachada (a cada 11 tiles). */
-export declare function isStreetlampColumn(tx: number): boolean;
-/** Coluna com letreiro na fachada (a cada 9 tiles, exige parede 3 tiles acima — checado pelo chamador). */
-export declare function isSignageColumn(tx: number): boolean;
-export declare const SIGNAGE_COLORS: readonly [3656096, 16747610, 6598911, 16765503];
-/** Cor do letreiro daquela coluna (4 variações, cíclicas por tx). */
-export declare function signageColor(tx: number): number;
-/** Tipo de decoração da célula abandonada (entulho/viga/pichação/vazio) — hash determinístico em tx,ty. */
-export declare function abandonedDecorKind(tx: number, ty: number): number;
-export declare const GRAFFITI_COLORS: readonly [13193174, 5232250, 14076239];
-/** Cor da pichação daquela coluna (3 variações, cíclicas por tx). */
-export declare function graffitiColor(tx: number): number;
-/** Deriva horizontal (0..3) dos tracinhos de lava — avança 1 tile a cada 8 ticks do fxClock. */
-export declare function lavaStreakOffset(fxClock: number, worldX: number): number;
-/** Hash determinístico por coluna, usado p/ escolher o "leito" da água (coral/algas/vazio). */
-export declare function waterBedHash(tx: number): number;
-/** Tipo de leito da coluna: 0=coral, 1=algas, 2=vazio. */
-export declare function waterBedKind(tx: number): number;
-export declare const CORAL_COLORS: readonly [15234107, 15909198, 9187129];
-/** Cor do coral daquela coluna (3 variações, derivadas do mesmo hash do leito). */
-export declare function coralColor(tx: number): number;
-/** Hash determinístico por célula, usado p/ decidir se há peixe nadando ali (água aberta). */
-export declare function fishHash(tx: number, ty: number): number;
-/** ~1/7 das células de água aberta recebe um peixe. */
-export declare function fishSpawnsAt(tx: number, ty: number): boolean;
-export declare const FISH_COLORS: readonly [15026253, 3829413, 4763754];
-/** Cor do peixe daquela célula (3 variações, derivadas do hash de peixe). */
-export declare function fishColor(tx: number, ty: number): number;
-export declare function initSceneCity(ctx: SceneCityCtx): SceneCity;
-export {};

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

@@ -1,181 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/scene-city — city scenario decoration: sidewalk/streetlamp/signage facade band, water-tank walls,
-// abandoned-interior clutter (darkRegions, drawn under the darkness layer), and the live water/lava tile fx
-// (waves/coral/algae/fish, lava streaks). Extracted from game.js. The layers (cityDecoG/abandonG/lavaFxG/
-// waterFxG/skyLayer) are CREATED in game.js — z-order stays soldered there — and INJECTED here; we move only
-// the LOGIC. Formulas copied verbatim. `applyCenarioVida` is the thin scenario-toggle orchestrator: it flips
-// only this module's own layers and calls an injected hook so the coordinator can wire game/life and
-// game/traffic's own scenario reactions (see the module boundary note in the extraction report).
-// ---- Seleção de tile/decoração por posição (lógica pura, determinística — hash em tx/ty, sem PIXI) ----
-/** Coluna com poste de luz na fachada (a cada 11 tiles). */
-export function isStreetlampColumn(tx) { return tx % 11 === 4; }
-/** Coluna com letreiro na fachada (a cada 9 tiles, exige parede 3 tiles acima — checado pelo chamador). */
-export function isSignageColumn(tx) { return tx % 9 === 2; }
-export const SIGNAGE_COLORS = [0x37c9a0, 0xff8c5a, 0x64b0ff, 0xffd23f];
-/** Cor do letreiro daquela coluna (4 variações, cíclicas por tx). */
-export function signageColor(tx) { return SIGNAGE_COLORS[tx % 4]; }
-/** Tipo de decoração da célula abandonada (entulho/viga/pichação/vazio) — hash determinístico em tx,ty. */
-export function abandonedDecorKind(tx, ty) { return (tx * 13 + ty * 7) % 10; }
-export const GRAFFITI_COLORS = [0xc94fd6, 0x4fd67a, 0xd6c94f];
-/** Cor da pichação daquela coluna (3 variações, cíclicas por tx). */
-export function graffitiColor(tx) { return GRAFFITI_COLORS[tx % 3]; }
-/** Deriva horizontal (0..3) dos tracinhos de lava — avança 1 tile a cada 8 ticks do fxClock. */
-export function lavaStreakOffset(fxClock, worldX) { return (Math.floor(fxClock / 8) + worldX) % 4; }
-/** Hash determinístico por coluna, usado p/ escolher o "leito" da água (coral/algas/vazio). */
-export function waterBedHash(tx) { return (tx * 2654435761) >>> 0; }
-/** Tipo de leito da coluna: 0=coral, 1=algas, 2=vazio. */
-export function waterBedKind(tx) { return waterBedHash(tx) % 3; }
-export const CORAL_COLORS = [0xe8743b, 0xf2c14e, 0x8c2f39];
-/** Cor do coral daquela coluna (3 variações, derivadas do mesmo hash do leito). */
-export function coralColor(tx) { return CORAL_COLORS[(waterBedHash(tx) >>> 3) % 3]; }
-/** Hash determinístico por célula, usado p/ decidir se há peixe nadando ali (água aberta). */
-export function fishHash(tx, ty) { return (tx * 40503 + ty * 12289) >>> 0; }
-/** ~1/7 das células de água aberta recebe um peixe. */
-export function fishSpawnsAt(tx, ty) { return fishHash(tx, ty) % 7 === 0; }
-export const FISH_COLORS = [0xe5484d, 0x3a6ea5, 0x48b06a];
-/** Cor do peixe daquela célula (3 variações, derivadas do hash de peixe). */
-export function fishColor(tx, ty) { return FISH_COLORS[fishHash(tx, ty) % 3]; }
-export function initSceneCity(ctx) {
-    // buildCityDeco v3: desenhado UMA vez (mapa é estático) — calçada+postes+letreiros na fachada mais baixa,
-    // paredes/linha d'água da caixa d'água (bounding box dos tiles de água, tipo 3), e entulho/viga/pichação
-    // sob a escuridão das áreas secretas (abandonG, camada abaixo de darkLayer no game.js).
-    function buildCityDeco() {
-        const g = ctx.cityDecoG;
-        g.clear();
-        const a = ctx.abandonG;
-        a.clear();
-        const TILE = ctx.TILE;
-        // ---- FACHADA (banda mais baixa, por onde o personagem anda): calçada + postes + letreiros.
-        // Placas de PARE ficam na rua da frente (game/traffic), junto dos carros.
-        const BASE_TY = ctx.WORLD_H - 9;
-        for (let tx = 1; tx < ctx.WORLD_W - 1; tx++) {
-            const ty = ctx.lifeSurfaceAt(tx);
-            if (ty < BASE_TY)
-                continue;
-            const X = tx * TILE, y = ty * TILE;
-            g.beginFill(0x9aa0ad, 0.9).drawRect(X, y, TILE, 2).endFill(); // calçada clara
-            g.beginFill(0x565e70, 1).drawRect(X, y + 2, TILE, 1).endFill(); // meio-fio
-            if (isStreetlampColumn(tx)) {
-                g.beginFill(0x3a4152).drawRect(X + 7, y - 30, 2, 30).endFill();
-                g.beginFill(0x3a4152).drawRect(X + 7, y - 30, 8, 2).endFill(); // poste + braço
-                g.beginFill(0xffe9a8, 1).drawRect(X + 13, y - 29, 3, 3).endFill();
-                g.beginFill(0xffe9a8, 0.18).drawRect(X + 9, y - 31, 11, 8).endFill(); // lâmpada + halo FIXO (sem piscar)
-            }
-            if (isSignageColumn(tx) && ctx.solidAt(tx, ty - 3)) {
-                const c = signageColor(tx); // letreiro na fachada
-                g.beginFill(0x141824).drawRect(X + 2, y - 3.5 * TILE, 12, 6).endFill();
-                g.beginFill(c, 1).drawRect(X + 3, y - 3.5 * TILE + 1, 10, 4).endFill();
-                g.beginFill(c, 0.15).drawRect(X, y - 3.5 * TILE - 2, 16, 10).endFill(); // brilho estável
-            }
-        }
-        // ---- CAIXA D'ÁGUA: paredes metálicas nas bordas do corpo d'água (tile 3) + linha d'água no topo
-        let wx0 = 1e9, wx1 = -1, wy0 = 1e9, wy1 = -1;
-        for (let ty = 0; ty < ctx.WORLD_H; ty++)
-            for (let tx = 0; tx < ctx.WORLD_W; tx++) {
-                if (ctx.tileAt(tx, ty) === 3) {
-                    wx0 = Math.min(wx0, tx);
-                    wx1 = Math.max(wx1, tx);
-                    wy0 = Math.min(wy0, ty);
-                    wy1 = Math.max(wy1, ty);
-                }
-            }
-        if (wx1 >= 0) {
-            const X0 = wx0 * TILE, X1 = (wx1 + 1) * TILE, Y0 = wy0 * TILE, Y1 = (wy1 + 1) * TILE;
-            g.beginFill(0x6a7486, 0.85).drawRect(X0 - 3, Y0 - 6, 3, Y1 - Y0 + 6).drawRect(X1, Y0 - 6, 3, Y1 - Y0 + 6).endFill(); // paredes do tanque
-            for (let ry = Y0; ry < Y1; ry += 12) {
-                g.beginFill(0x49515f).drawRect(X0 - 3, ry, 3, 2).drawRect(X1, ry, 3, 2).endFill();
-            } // rebites
-            g.beginFill(0xbfe6ff, 0.5).drawRect(X0, Y0, X1 - X0, 1.5).endFill(); // linha d'água
-        }
-        // ---- ABANDONADO (darkRegions): entulho, viga e pichação — desenhado sob a escuridão
-        for (const reg of ctx.darkRegions) {
-            for (const key of reg.set) {
-                const [tx, ty] = key.split(',').map(Number);
-                const X = tx * TILE, Y = ty * TILE, h = abandonedDecorKind(tx, ty);
-                if (ctx.solidAt(tx, ty + 1) && h < 3) {
-                    a.beginFill(0x555b66).drawRect(X + 2, Y + TILE - 5, 7, 5).endFill();
-                    a.beginFill(0x434955).drawRect(X + 7, Y + TILE - 3, 6, 3).endFill();
-                } // entulho
-                else if (h === 4) {
-                    a.beginFill(0x6b4e2e, 0.9).drawRect(X, Y + 3, TILE, 3).endFill();
-                } // viga exposta
-                else if (h === 7) {
-                    const c = graffitiColor(tx);
-                    a.beginFill(c, 0.55).drawRect(X + 3, Y + 6, 9, 2).drawRect(X + 5, Y + 9, 6, 2).endFill();
-                } // pichação
-            }
-        }
-    }
-    // applyCenarioVida: orquestrador FINO do troca-de-cenário. Só liga/desliga as camadas que este módulo possui
-    // (deco da cidade + o céu procedural da cidade); trânsito (carLayer + cars) e vida (criaturas) são de outros
-    // dois módulos e reagem via onCenarioChange — nunca tocados diretamente daqui.
-    function applyCenarioVida() {
-        const city = ctx.getCenario() === 'cidade';
-        ctx.cityDecoG.visible = city;
-        ctx.skyLayer.visible = city; // deco/céu da cidade SÓ na Cidade
-        ctx.onCenarioChange?.(city);
-    }
-    // stepTileFx v3: água (ondas de superfície + leito coral/algas + peixes esparsos) e lava (tracinhos claros à
-    // deriva) — só perto de cada jogador (câmera), com dedupe por célula entre jogadores em tela dividida.
-    function stepTileFx() {
-        ctx.lavaFxG.clear();
-        ctx.waterFxG.clear();
-        if (ctx.DIRECT_CFG[ctx.getVizMode()] || ctx.getRm().decor)
-            return; // HC repinta o mundo; viewDecor off na v3 = só a base estática
-        const TILE = ctx.TILE, t = ctx.getFxClock(), seen = new Set();
-        for (const pl of ctx.getPlayers()) {
-            if (pl.quit)
-                continue;
-            const camX = Math.max(0, Math.min(pl.x - ctx.LOGICAL_W / 2, ctx.WORLD_PX_W - ctx.LOGICAL_W));
-            const camY = Math.max(0, Math.min((pl.y - ctx.BOX.h / 2) - ctx.LOGICAL_H / 2, ctx.WORLD_PX_H - ctx.LOGICAL_H));
-            const tx0 = Math.max(0, Math.floor(camX / TILE) - 1), tx1 = Math.min(ctx.WORLD_W - 1, Math.floor((camX + ctx.LOGICAL_W) / TILE) + 1);
-            const ty0 = Math.max(0, Math.floor(camY / TILE) - 1), ty1 = Math.min(ctx.WORLD_H - 1, Math.floor((camY + ctx.LOGICAL_H) / TILE) + 1);
-            for (let ty = ty0; ty <= ty1; ty++)
-                for (let tx = tx0; tx <= tx1; tx++) {
-                    const tt = ctx.tileAt(tx, ty);
-                    if (tt !== 3 && tt !== 9)
-                        continue; // só água(3)/lava(9)
-                    const k = tx + ',' + ty;
-                    if (seen.has(k))
-                        continue;
-                    seen.add(k);
-                    const X = tx * TILE, Y = ty * TILE;
-                    if (tt === 9) {
-                        const off = lavaStreakOffset(t, X); // lava v3: tracinhos claros que derivam
-                        ctx.lavaFxG.beginFill(0xff7755).drawRect(X + off, Y + 3, 3, 1).drawRect(X + ((off + 6) % TILE), Y + 8, 3, 1).endFill();
-                        continue;
-                    }
-                    // ÁGUA v3: ondulação verde sutil que deriva
-                    ctx.waterFxG.beginFill(0x46a078, 0.12).drawRect(X, Y + 7 + Math.round(2 * Math.sin(tx * 1.3 + t * 0.04)), TILE, 2).endFill();
-                    if (ctx.tileAt(tx, ty - 1) !== 3) {
-                        const off = Math.sin(t * 0.05 + X * 0.1) > 0 ? 1 : 0; // linha de superfície SÓ na borda de cima
-                        ctx.waterFxG.beginFill(0xffffff, 0.35).drawRect(X + off, Y + 1, TILE - off, 1).endFill();
-                    }
-                    if (ctx.solidAt(tx, ty + 1)) {
-                        const kind = waterBedKind(tx); // leito: coral / algas (determinísticos por coluna)
-                        if (kind === 0) {
-                            ctx.waterFxG.beginFill(coralColor(tx))
-                                .drawRect(X + 6, Y + 9, 2, 7).drawRect(X + 4, Y + 10, 2, 4).drawRect(X + 9, Y + 8, 2, 5).drawRect(X + 3, Y + 12, 1, 2).drawRect(X + 11, Y + 11, 1, 2).endFill();
-                        }
-                        else if (kind === 1) {
-                            ctx.waterFxG.beginFill(0x3fae6a);
-                            const sway = 2 * Math.sin(t * 0.06 + tx); // algas balançando
-                            for (let a2 = 0; a2 < 9; a2++) {
-                                ctx.waterFxG.drawRect(X + 7 + Math.round(sway * (a2 / 9)), Y + 15 - a2, 1, 1);
-                                if (a2 % 2 === 0)
-                                    ctx.waterFxG.drawRect(X + 9 + Math.round(sway * (a2 / 9)), Y + 15 - a2, 1, 1);
-                            }
-                            ctx.waterFxG.endFill();
-                        }
-                    }
-                    else if (fishSpawnsAt(tx, ty)) { // água aberta: peixinho esparso nadando (com olho!)
-                        const fx2 = X + 6 + Math.round(5 * Math.sin(t * 0.04 + tx + ty)), fy2 = Y + 7 + Math.round(2 * Math.sin(t * 0.07 + ty));
-                        const dir = Math.cos(t * 0.04 + tx + ty) >= 0 ? 1 : -1;
-                        ctx.waterFxG.beginFill(fishColor(tx, ty)).drawRect(fx2, fy2, 3, 2).drawRect(fx2 - dir, fy2, 1, 2).endFill();
-                        ctx.waterFxG.beginFill(0xffffff, 1).drawRect(fx2 + (dir > 0 ? 2 : 0), fy2, 1, 1).endFill();
-                    }
-                }
-        }
-    }
-    return { buildCityDeco, applyCenarioVida, stepTileFx };
-}