@the-inclusionist/engine 9.0.0 → 10.0.0

package/dist-pkg/render/parallax.js

@@ -1,158 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/parallax — AS TRÊS CAMADAS DE FUNDO: onde cada uma fica, e de que tema ela é feita.
-//
-// Camada 1 do jogo é o tileset + o personagem. Atrás dele vêm três `TilingSprite`, e é isso que este módulo
-// governa: quanto cada uma se desloca quando a câmera anda (`updateParallax`), e qual textura cada uma veste
-// quando o cenário muda (`aplicarTemaParallax`). Nada mais — o tileset do mundo, o céu vivo da v3, o clima e a
-// Cidade têm cada um o seu módulo, e nenhum deles passa por aqui.
-//
-// ======================= A ENTREGA: A CONTA SAIU DE DENTRO DO EFEITO =======================
-// `updateParallax` era MATEMÁTICA PURA DISFARÇADA DE EFEITO. Dado (camX, camY) e os fatores de profundidade,
-// existe UMA posição determinada para cada camada — mas no monólito essa posição só existia como o lado
-// esquerdo de quatro atribuições dentro de um `for`, e a única forma de conferi-la era subir o jogo inteiro e
-// olhar. Aqui a conta é `posicoesParallax(camX, camY, camadas, reduzido)`, uma função pura que devolve
-// `{x, y, tileX, tileY}` por camada, e o `updateParallax` virou o carimbo dela nos sprites.
-//
-// O que essa separação torna verificável — e o que quebraria em SILÊNCIO sem ela:
-//  1. A CONTRA-POSIÇÃO. Os três sprites vivem DENTRO do container `camera` (têm de viver: é assim que também
-//     aparecem nas render-textures do multi-tela). O `camera` anda `-camX` a cada quadro; cada camada é posta
-//     em `+camX` para cancelar exatamente esse movimento e ficar PARADA na tela. É o cancelamento que faz o
-//     fundo parecer fundo. Inverta o sinal e o céu passa a correr com o dobro da velocidade do mundo, na
-//     direção errada — o jogo continua rodando, os testes de física continuam verdes, e só quem olhar percebe.
-//  2. A PROPORCIONALIDADE. O `tilePosition` de cada camada rola por `-camX * fator`. Camada mais distante
-//     (fator menor) se mexe MENOS. Ignorar o fator (ou trocá-lo entre duas camadas) achata a profundidade sem
-//     erro nenhum em lugar nenhum.
-//  3. O MOVIMENTO REDUZIDO. Com `rm.parallax` ligado (acessibilidade: gatilho vestibular), o `tilePosition`
-//     trava em zero — o fundo vira papel de parede — MAS a contra-posição continua valendo. Trocar essa ordem
-//     (travar `x`/`y` em vez do `tilePosition`) grudaria o fundo no mundo e produziria exatamente o
-//     deslizamento que a opção existe para eliminar, para a pessoa que pediu para não ver deslizamento.
-//
-// ======================= POR QUE A FRONTEIRA CAIU AQUI, E NÃO ANTES NEM DEPOIS =======================
-// ANTES (o dado dos temas) saiu para render/cenario-data.ts: as cores não são geometria de câmera, e são
-// lidas por scene-sky e pelo attract, que não têm nada a ver com rolagem. `PARALLAX` FICOU aqui, e não lá,
-// porque os fatores não variam por tema — são a definição de "o que é fundo" — e porque a conta que os
-// consome é a deste arquivo.
-// DEPOIS (a orquestração da troca de cenário) ficou em render/set-cenario.ts. `setCenario` faz TRÊS coisas:
-// repinta o fundo, RECONSTRÓI A TEXTURA DO MUNDO a partir dos PNG de tile do tema, e avisa a vida ambiente e
-// o alto contraste. Só a primeira é parallax. Trazer as outras duas para cá daria a este módulo a textura do
-// tileset — que não é fundo, é a Camada 1 — e o ciclo de vida do alto contraste. Por isso `aplicarTemaParallax`
-// mora aqui e é CHAMADO de lá: este módulo sabe vestir as três camadas e não sabe por quê.
-//
-// ======================= A PARTE IMPURA, E O QUE ELA GUARDA =======================
-// `aplicarTemaParallax` tem duas metades assimétricas, e a assimetria é o ponto:
-//  · Tema `v3` (Campo/Amanhecer/Noite/Floresta): as texturas são GERADAS na hora (render/scene-parallax), de
-//    forma síncrona. Não há espera, logo não há corrida.
-//  · Cidade (`v3:false`): as três texturas são PNG baixados, e chegam quando chegarem. Entre o pedido e a
-//    chegada a pessoa pode ter trocado de cenário de novo — por isso cada callback abre com
-//    `if (getCenario() !== theme) return`. Sem essa guarda, um PNG atrasado da Cidade sobrescreveria o céu do
-//    tema recém-escolhido. É a corrida mais fácil de introduzir e a mais difícil de reproduzir de mão, e é
-//    por ela, mais do que por qualquer outra coisa, que esta metade também entrou num módulo testável.
-// Nos dois caminhos a ordem é a mesma e importa: grava em `texNormal` → invalida o cache de recolor
-// (`clearParallaxTexCache`) → e SÓ pinta o sprite se o modo de visão for 'normal'. Nos modos acessíveis quem
-// pinta é render/viz-setters, lendo a textura crua que acabamos de gravar; pintar aqui atropelaria o recolor.
-//
-// ======================= INJEÇÃO, INTERFACE ESTRUTURAL E ORDEM DE BOOT =======================
-// Nada de `import * as PIXI`: declaramos só o que tocamos — um `TilingSprite` é, aqui, quatro campos
-// (`x`, `y`, `texture`, `tilePosition`) e um construtor de três argumentos. É o precedente de
-// render/scene-sky e render/viewports, e é o que deixa o módulo (e a factory INTEIRA, não só a parte pura)
-// rodar no project `node`, com sprites de mentira e um `Image` falso.
-// Pela mesma razão os três geradores de textura (`placeholderTex`/`skyTex`/`hillsTex`) entram INJETADOS em vez
-// de importados de render/scene-parallax: eles chamam `makeCanvas`, e importá-los aqui obrigaria todo teste da
-// factory a ter um `document`.
-//  · `rm` entra por VALOR: é `const` no game.js, mutado in place pelo painel de movimento reduzido (mesma
-//    decisão de render/draw.ts). Ler `rm.parallax` a cada quadro já vê o valor novo.
-//  · `getCenario`/`getVizMode` entram por GETTER: são as mega-variáveis de core/state.js, REATRIBUÍDAS.
-//  · `getDecorDeTela` é GETTER porque `starsG`/`skyDecoG`/`fogG` são declarados MUITO depois no game.js — o
-//    monólito protegia isso com `typeof starsG!=='undefined'`. Aqui o game.js passa `() => [starsG, skyDecoG,
-//    fogG]` (são `var`, logo içados) e a guarda por elemento fica deste lado.
-//  · `createParallax` DEVOLVE `layers` e `texNormal` em vez de recebê-los: o game.js os mantém como `const`
-//    desestruturados do retorno, e `texNormal` continua sendo o MESMO array que `initViewports` recebe por
-//    VALOR — `aplicarTemaParallax` troca os ELEMENTOS in place, nunca o array.
-//
-// ⚠️ ORDEM DE BOOT: `createParallax` tem de rodar logo depois de `camera` existir e ANTES de qualquer coisa que
-// dependa de `parallaxLayers` — o `camera.addChildAt(ts, i)` dá a ordem-z do fundo, e `starsG` é inserido
-// relativamente a `parallaxLayers[1]`. E tem de rodar ANTES do `setCenario` do boot, que é quem veste as
-// camadas com o tema salvo.
-//
-// SEM I/O NO IMPORT: o corpo do módulo declara `PARALLAX` e funções. Nenhum sprite é criado, nenhuma textura é
-// gerada e nenhuma imagem é pedida até `createParallax`/`aplicarTemaParallax` serem chamados.
-// Ver docs/5-Refactoring/plano-modularizacao-mapa.md (D2-b).
-import { LOGICAL_W, LOGICAL_H } from '../core/constants.js';
-/* Parallax: 3 camadas de FUNDO atrás do tileset (Camada 1 = tileset+personagem).
-   Camada 4 (fator 0.10) é a mais distante e "quase não se mexe" — receberá a maior imagem possível do
-   PixelLab. Vivem DENTRO do camera (contra-posicionadas p/ ficarem fixas na tela) para também aparecerem nas
-   render-textures do multiplayer. tilePosition faz o scroll fracionado → ilusão de profundidade.
-   A ORDEM do array é a ordem-z: índice 0 no fundo. */
-export const PARALLAX = [
-    { key: 'sky', factor: 0.10, fy: 0 }, // Camada 4 — mais distante (céu/horizonte), maior imagem
-    { key: 'far', factor: 0.28, fy: 0 }, // Camada 3
-    { key: 'near', factor: 0.52, fy: 0 }, // Camada 2 — mais próxima do tileset
-];
-/** Índice da camada → número do arquivo PNG da Cidade (`c4.png`, `c3.png`, `c2.png`). */
-export const ARQUIVO_POR_CAMADA = [4, 3, 2];
-/**
- * A matemática do parallax, sem sprite nenhum.
- *
- * `x`/`y` = `camX`/`camY` porque o container `camera` está em `-camX`/`-camY`: a soma dá ZERO, e a camada
- * fica parada na tela. É esse cancelamento que faz o fundo parecer fundo.
- * `tileX`/`tileY` = `-cam * fator`: quanto MENOR o fator, menos a textura rola, mais distante a camada parece.
- * Com `reduzido` (movimento reduzido — `rm.parallax`), a rolagem trava em zero e o fundo vira papel de
- * parede; a contra-posição CONTINUA valendo, senão o fundo passaria a deslizar junto com o mundo — o oposto
- * exato do que a opção existe para dar.
- */
-export function posicoesParallax(camX, camY, camadas = PARALLAX, reduzido = false) {
-    return camadas.map((p) => ({
-        x: camX,
-        y: camY,
-        tileX: reduzido ? 0 : -camX * p.factor,
-        tileY: reduzido ? 0 : -camY * p.fy,
-    }));
-}
-/* ===================== a montagem + o carimbo (impuro) ===================== */
-/** Cria as 3 camadas dentro do `camera` e devolve a API que as move e as veste. */
-export function createParallax(ctx) {
-    const layers = PARALLAX.map((_p, i) => {
-        const ts = ctx.criarAzulejo(ctx.placeholderTex(i), LOGICAL_W, LOGICAL_H);
-        ctx.camera.addChildAt(ts, i); // i=0 (sky) fica no fundo; depois far, near; tileset entra por cima
-        return ts;
-    });
-    // texturas normais (recoloridas p/ o fundo no alto contraste). Array `const` no game.js: os ELEMENTOS mudam.
-    const texNormal = layers.map((ts) => ts.texture);
-    function updateParallax(camX, camY) {
-        const pos = posicoesParallax(camX, camY, PARALLAX, !!ctx.rm.parallax);
-        for (let i = 0; i < layers.length; i++) {
-            const ts = layers[i], q = pos[i];
-            ts.x = q.x;
-            ts.y = q.y; // anula o camera → fixa na tela
-            ts.tilePosition.set(q.tileX, q.tileY); // rolagem fracionada → profundidade (0,0 no movimento reduzido)
-        }
-        // L6: decor de TELA da v3 (estrelas atrás dos morros · nuvens/pássaros à frente · névoa na frente de tudo).
-        // Guarda por elemento: no boot elas ainda não existem (eram o `typeof starsG!=='undefined'` do monólito).
-        for (const g of ctx.getDecorDeTela()) {
-            if (g)
-                g.position.set(camX, camY);
-        }
-    }
-    /** Grava a textura crua da camada `i`, invalida o recolor e — só no modo 'normal' — pinta o sprite. */
-    function vestir(i, t) {
-        texNormal[i] = t;
-        ctx.clearParallaxTexCache();
-        if (ctx.getVizMode() === 'normal')
-            layers[i].texture = t; // nos modos acessíveis quem pinta é viz-setters
-    }
-    /**
-     * TODA TROCA DE TEMA É SÍNCRONA AGORA (ADR-0042), e isso é mais que uma simplificação.
-     *
-     * Enquanto a Cidade vinha de PNG, este caminho era assíncrono e carregava a corrida junto: três `Image`
-     * baixando, e cada `onload` tendo de perguntar `getCenario() !== theme` antes de pintar, porque a criança
-     * podia ter trocado de cenário no meio. Isso sumiu com os arquivos — não há mais o que baixar, e portanto
-     * não há mais corrida que possa perder.
-     */
-    function aplicarTemaParallax(theme, T) {
-        const texs = T.fundo === 'predios'
-            ? [ctx.citySkyTex(T), ctx.skylineTex(T.predios[1], 977), ctx.skylineTex(T.predios[2], 131)]
-            : [ctx.skyTex(T), ctx.hillsTex(T, false, theme), ctx.hillsTex(T, true, theme)];
-        layers.forEach((_ts, i) => vestir(i, texs[i]));
-    }
-    return { layers, texNormal, updateParallax, aplicarTemaParallax };
-}

package/dist-pkg/render/player-anim.d.ts

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import type { ControlledPlayer } from '../core/entity.js';
-/** Uma textura de quadro. Opaca de propósito: este módulo ESCOLHE quadros, nunca os desenha. */
-export type Frame = unknown;
-/** Uma "gracinha" de descanso (render/sprites.FLAVORS): `seq` indexa `tex`, `hold` é o nº de ticks por passo. */
-export interface FlavorLike {
-    seq: readonly number[];
-    hold: number;
-    tex: readonly Frame[];
-}
-/** O conjunto COMPLETO de quadros do personagem. Espelha os `TEX_*` de render/sprites, com nomes curtos. */
-export interface PlayerTextures {
-    idle: readonly Frame[];
-    walk: readonly Frame[];
-    run: readonly Frame[];
-    jumpUp: Frame;
-    jumpDown: Frame;
-    climb: readonly Frame[];
-    fly: Frame;
-    clingWall: readonly Frame[];
-    clingCeil: readonly Frame[];
-    swim: readonly Frame[];
-    swimIdle: readonly Frame[];
-    flavors: readonly FlavorLike[];
-}
-/** Os campos do jogador que a ANIMAÇÃO lê ou escreve. O objeto real (game/player.makePlayer) é superconjunto. */
-/**
- * O jogador visto pela ANIMAÇÃO — derivado de core/entity. O que cada campo significa está documentado lá,
- * uma vez; o que importa registrar AQUI é o que este módulo faz com eles:
- *
- *  · LÊ o que a física produziu: `vx`/`vy`, os três contatos, `clinging`/`clingN`/`flying` e `airTime`
- *    (quadros desde que saiu do chão — a base do coyote-time). `runCane` decide se `running` pode ligar.
- *  · LÊ as preferências de Movimento Reduzido: `rmWalk` congela TODA a locomoção num quadro único,
- *    `rmBreath` congela a respiração do idle, `rmFlavor` desliga as gracinhas.
- *  · ESCREVE os relógios: `anim` (respiração), `walkAnim` (o passo — NUNCA reseta, senão o ciclo de 8
- *    reinicia), `climbFrame` (quadro CONGELADO da ventosa), `idleNow`/`idleTime`, `flavor`/`flavorT`,
- *    `walking`/`running` (lidos pelo desenho da bengala em render/draw) e `_tx`, o quadro-base EM COR a
- *    partir do qual o multi-tela recolore, por viewport.
- *  · `ctrl`/`pad` entram só porque `held` precisa deles. `ControlledPlayer`: a animação roda em partida.
- *
- * `clingN` era `string | null` aqui e `ClingSide | null` na física — a mesma face da ventosa, uma tipada e
- * a outra não. Derivar fecha isso sem discussão.
- */
-export type AnimPlayer = Pick<ControlledPlayer, 'vx' | 'vy' | 'onGround' | 'onLadder' | 'inWater' | 'clinging' | 'clingN' | 'flying' | 'airTime' | 'runCane' | 'rmWalk' | 'rmBreath' | 'rmFlavor' | 'anim' | 'walkAnim' | 'climbFrame' | 'idleNow' | 'idleTime' | 'flavor' | 'flavorT' | 'walking' | 'running' | '_tx' | 'ctrl' | 'pad'>;
-/** Tudo que a escolha do quadro precisa e que não mora no jogador. */
-export interface PlayerAnimEnv {
-    dt: number;
-    dir: number;
-    wheelchair: boolean;
-    held(pl: AnimPlayer, act: string): boolean;
-    rnd(): number;
-    tex: PlayerTextures;
-}
-/**
- * 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 declare 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 declare function choosePlayerFrame(pl: AnimPlayer, env: PlayerAnimEnv): Frame;

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) };
-}