@the-inclusionist/engine 9.0.0 → 11.0.0

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

@@ -1,140 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/city-tiles.ts — OS DOIS TILES DA CIDADE, como DADOS e não como PNG (pilar "arte = dados", ADR-0010).
-//
-// `tile_fill` e `tile_surface` eram dois PNG de 16×16 baixados por `carregarTilesDoTema`. Aqui eles voltam como
-// `PixelPainter` — a mesma forma que `render/city-tex` já usa para os pombos, os gatos e as silhuetas: uma
-// lista de retângulos `px(x, y, w, h, cor)`.
-//
-// POR QUE RETÂNGULOS E NÃO UMA REGRA DE ALVENARIA. A primeira tentativa foi inferir a regra (tijolo 7×6, junta
-// de 1 px, fiada alternada, bisel) e gerá-la. Deu 66% de acerto exato: a arte tem variação FEITA À MÃO — o
-// bisel muda de tijolo para tijolo, e nenhuma regra curta a alcança. A decomposição em retângulos custa 51 e
-// 62 chamadas e acerta 100%. Entre uma regra elegante que erra um quinto dos pixels e uma lista que acerta
-// todos, num tile de 16×16 desenhado à mão, a lista é a resposta honesta.
-//
-// O QUE ISSO COMPRA, além de tirar dois PNG do pacote: o desenho passa a ser recolorível (o alto contraste e
-// as paletas seguras para daltonismo mexem em cores, não em bitmaps), some o carregamento assíncrono — e com
-// ele a guarda de corrida de `set-cenario` e os 404 de boot dos temas que não têm arte própria.
-import { pixelCanvas } from './canvas.js';
-/** O TILE do miolo da parede: alvenaria em fiada alternada. 51 retângulos, 9 cores, fiel ao pixel. */
-export const paintTileFill = (px) => {
-    px(0, 0, 1, 1, '#403b48');
-    px(1, 0, 3, 1, '#b8b6c1');
-    px(4, 0, 2, 1, '#bcbdc9');
-    px(6, 0, 2, 1, '#828291');
-    px(8, 0, 1, 1, '#403b48');
-    px(9, 0, 1, 1, '#b1b0bc');
-    px(10, 0, 4, 1, '#b8b6c1');
-    px(14, 0, 2, 1, '#403b48');
-    px(0, 1, 1, 1, '#b1b0bc');
-    px(1, 1, 6, 5, '#828291');
-    px(7, 1, 1, 4, '#403b48');
-    px(8, 1, 1, 5, '#b8b6c1');
-    px(9, 1, 6, 5, '#828291');
-    px(15, 1, 1, 5, '#393543');
-    px(0, 2, 1, 3, '#b8b6c1');
-    px(0, 5, 1, 1, '#b1b0bc');
-    px(7, 5, 1, 1, '#3e2e3f');
-    px(0, 6, 1, 3, '#403b48');
-    px(1, 6, 1, 1, '#777485');
-    px(2, 6, 4, 1, '#828291');
-    px(6, 6, 3, 3, '#403b48');
-    px(9, 6, 5, 1, '#828291');
-    px(14, 6, 2, 2, '#403b48');
-    px(1, 7, 5, 1, '#403b48');
-    px(9, 7, 5, 1, '#403b48');
-    px(1, 8, 1, 1, '#b1b0bc');
-    px(2, 8, 2, 1, '#b8b6c1');
-    px(4, 8, 1, 1, '#bcbdc9');
-    px(5, 8, 1, 1, '#b1b0bc');
-    px(9, 8, 1, 1, '#b1b0bc');
-    px(10, 8, 2, 1, '#b8b6c1');
-    px(12, 8, 1, 1, '#bcbdc9');
-    px(13, 8, 1, 1, '#b1b0bc');
-    px(14, 8, 1, 1, '#403b48');
-    px(15, 8, 1, 1, '#393543');
-    px(0, 9, 1, 5, '#b1b0bc');
-    px(1, 9, 6, 5, '#828291');
-    px(7, 9, 1, 3, '#403b48');
-    px(8, 9, 1, 5, '#b8b6c1');
-    px(9, 9, 6, 5, '#828291');
-    px(15, 9, 1, 2, '#403b48');
-    px(15, 11, 1, 3, '#393543');
-    px(7, 12, 1, 2, '#393543');
-    px(0, 14, 1, 2, '#403b48');
-    px(1, 14, 5, 1, '#828291');
-    px(6, 14, 3, 2, '#403b48');
-    px(9, 14, 5, 1, '#828291');
-    px(14, 14, 2, 2, '#403b48');
-    px(1, 15, 1, 1, '#444653');
-    px(2, 15, 4, 1, '#403b48');
-    px(9, 15, 5, 1, '#403b48');
-};
-/** O TILE do TOPO da plataforma: mesma alvenaria com a borda superior iluminada. 62 retângulos, 23 cores. */
-export const paintTileSurface = (px) => {
-    px(0, 0, 1, 1, '#8b8994');
-    px(1, 0, 3, 1, '#bbbac5');
-    px(4, 0, 2, 1, '#bdbdc8');
-    px(6, 0, 2, 1, '#a6a5b2');
-    px(8, 0, 1, 1, '#8b8994');
-    px(9, 0, 1, 1, '#b8b7c3');
-    px(10, 0, 4, 1, '#bbbac5');
-    px(14, 0, 2, 1, '#8b8994');
-    px(0, 1, 1, 1, '#b6b5c1');
-    px(1, 1, 6, 1, '#9b9aa8');
-    px(7, 1, 1, 1, '#74717d');
-    px(8, 1, 1, 1, '#bab8c3');
-    px(9, 1, 6, 1, '#9b9aa8');
-    px(15, 1, 1, 1, '#706e7a');
-    px(0, 2, 1, 1, '#b9b7c2');
-    px(1, 2, 6, 1, '#90909e');
-    px(7, 2, 1, 1, '#5e5a66');
-    px(8, 2, 1, 1, '#b9b7c2');
-    px(9, 2, 6, 1, '#90909e');
-    px(15, 2, 1, 1, '#585562');
-    px(0, 3, 1, 2, '#b8b6c1');
-    px(1, 3, 6, 3, '#828291');
-    px(7, 3, 1, 2, '#403b48');
-    px(8, 3, 1, 3, '#b8b6c1');
-    px(9, 3, 6, 3, '#828291');
-    px(15, 3, 1, 3, '#393543');
-    px(0, 5, 1, 1, '#b1b0bc');
-    px(7, 5, 1, 1, '#3e2e3f');
-    px(0, 6, 1, 3, '#403b48');
-    px(1, 6, 1, 1, '#777485');
-    px(2, 6, 4, 1, '#828291');
-    px(6, 6, 3, 3, '#403b48');
-    px(9, 6, 5, 1, '#828291');
-    px(14, 6, 2, 2, '#403b48');
-    px(1, 7, 5, 1, '#403b48');
-    px(9, 7, 5, 1, '#403b48');
-    px(1, 8, 1, 1, '#b1b0bc');
-    px(2, 8, 2, 1, '#b8b6c1');
-    px(4, 8, 1, 1, '#bcbdc9');
-    px(5, 8, 1, 1, '#b1b0bc');
-    px(9, 8, 1, 1, '#b1b0bc');
-    px(10, 8, 2, 1, '#b8b6c1');
-    px(12, 8, 1, 1, '#bcbdc9');
-    px(13, 8, 1, 1, '#b1b0bc');
-    px(14, 8, 1, 1, '#403b48');
-    px(15, 8, 1, 1, '#393543');
-    px(0, 9, 1, 5, '#b1b0bc');
-    px(1, 9, 6, 5, '#828291');
-    px(7, 9, 1, 3, '#403b48');
-    px(8, 9, 1, 5, '#b8b6c1');
-    px(9, 9, 6, 5, '#828291');
-    px(15, 9, 1, 2, '#403b48');
-    px(15, 11, 1, 3, '#393543');
-    px(7, 12, 1, 2, '#393543');
-    px(0, 14, 1, 2, '#403b48');
-    px(1, 14, 5, 1, '#828291');
-    px(6, 14, 3, 2, '#403b48');
-    px(9, 14, 5, 1, '#828291');
-    px(14, 14, 2, 2, '#403b48');
-    px(1, 15, 1, 1, '#444653');
-    px(2, 15, 4, 1, '#403b48');
-    px(9, 15, 5, 1, '#403b48');
-};
-/** Os dois tiles como canvas 16×16 — a forma que `worldCanvas` consumia das imagens carregadas. */
-export function cityTiles() {
-    return { fill: pixelCanvas(16, 16, paintTileFill), surface: pixelCanvas(16, 16, paintTileSurface) };
-}

package/dist-pkg/render/draw.d.ts

@@ -1,149 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import type { PlayerView } from '../core/entity.js';
-import { type AnimPlayer, type Frame, type PlayerTextures } from './player-anim.js';
-import type { RenderizarEm } from './port.js';
-/** O que este módulo toca de um `PIXI.Graphics`. Superconjunto do `DrawGraphics` de wheelchair-sprites. */
-export interface GraphicsLike {
-    clear(): unknown;
-    lineStyle(width: number, color?: number, alpha?: number): unknown;
-    beginFill(color: number, alpha?: number): unknown;
-    endFill(): unknown;
-    drawRect(x: number, y: number, w: number, h: number): unknown;
-    moveTo(x: number, y: number): unknown;
-    lineTo(x: number, y: number): unknown;
-    drawCircle(x: number, y: number, r: number): unknown;
-}
-/** O sprite do personagem — só posição, escala, alpha, visibilidade e textura. */
-export interface PlayerSprite {
-    x: number;
-    y: number;
-    alpha: number;
-    visible: boolean;
-    scale: {
-        set(x: number, y: number): void;
-    };
-    texture: unknown;
-}
-/** `camera` (PIXI.Container): daqui só a posição importa; ela é passada opaca ao renderer. */
-export interface CameraLike {
-    x: number;
-    y: number;
-}
-/** `app.renderer` — só a passada em render-texture do caminho multi-tela. */
-/** O sprite de um item declarado: o mínimo que o desenho toca. */
-export interface ItemSprite {
-    visible: boolean;
-    alpha: number;
-}
-/**
- * Um power-up, do ponto de vista do DESENHO: um sprite, e nada mais.
- *
- * Era `extends Powerup`, importado de `game/powerups` — e esse `import type` era a ÚLTIMA aresta deste módulo
- * para o jogo. Tipo apagado em tempo de compilação não entra no pacote, é verdade; mas ele obriga o arquivo a
- * existir para o `tsc`, e obriga QUALQUER jogo a ter um power-up com aquela forma. O desenho toca `sprite` e
- * mais nada — declarar só isso é a fatia mínima, a mesma regra de `core/entity`.
- */
-interface PowerupWithSprite {
-    sprite?: {
-        visible: boolean;
-    } | null;
-    /**
-     * ⚠️ `kind` NÃO é lido aqui — e entrou mesmo assim, em 2026-08-26. O desenho ENTREGA o power-up ao
-     * `powerupVisibleTo` injetado, e é ele que lê o `kind` (a chave do portão é global; o resto é por
-     * jogador). Uma fatia mínima descreve o que o módulo CONSOME; em posição de parâmetro ela precisa
-     * descrever também o que ele ENTREGA, senão o callback real não cabe no ctx.
-     *
-     * É a quinta vez que esta forma aparece na árvore — `held` em audio-nav, `setSquash` na física, o
-     * menu de pausa no gamepad, o `navPause` — e a lição é a mesma: repassar é uma exigência, não uma
-     * leitura. A fatia continua mínima: dois campos, e nenhum tipo de `game/` importado.
-     */
-    kind: string;
-}
-/** O jogador, do ponto de vista do DESENHO (a animação usa `AnimPlayer`, do qual este é superconjunto). */
-/**
- * O jogador visto pelo DESENHO: tudo o que a animação lê, mais posição, dano e apresentação.
- * `sq`/`sqT` são o squash&stretch (amplitude e relógio, escritos por render/fx.setSquash); `easy` desenha a
- * hitbox de coleta tolerante translúcida; `viz` é o modo de visão, que recolore por viewport.
- */
-export type DrawPlayer = AnimPlayer & PlayerView<'i' | 'x' | 'y' | 'facing' | 'hurtTimer' | 'sq' | 'sqT' | 'easy' | 'visual' | 'sprite'>;
-/** Flags de Movimento Reduzido que o DESENHO consulta (o objeto `rm` do game.js tem mais chaves). */
-export interface ReducedMotion {
-    items?: boolean;
-}
-export interface DrawCtx {
-    /** Quantos jogadores/telas. Estado de RODADA (ADR-0038): vem da instância que a raiz possui.
-     *  Era `numPlayers`, um `let` de `core/state` importado como binding vivo — e um `let` de módulo
-     *  é compartilhado por qualquer segundo jogo que a mesma página carregue (D13 do `demos`). */
-    getNumPlayers: () => number;
-    /** Os jogadores. Estado de RODADA, pelo mesmo motivo. `readonly unknown[]` porque cada consumidor
-     *  estreita para a SUA fatia — o tipo real é do jogo, não da engine (ADR-0033). */
-    getPlayers: () => readonly unknown[];
-    camera: CameraLike;
-    renderizarEm: RenderizarEm;
-    caneLayer: GraphicsLike;
-    chairLayer: GraphicsLike;
-    /**
-     * CAIXA DE COLISÃO do jogador (largura × altura, em px). ENTRA em vez de ser importada de `game/player`, e
-     * isso não é política nova: `render/scene-city`, `render/scene-sky` e `platform/audio-nav` já a recebem
-     * assim — este módulo é que tinha ficado para trás, sozinho na camada de render importando do jogo.
-     *
-     * Ela aparece em três lugares e sempre pela mesma razão: `pl.y` é o PÉ do jogador, e meia caixa acima é o
-     * meio do corpo. É conhecimento de gênero — um top-down não ancora no pé, um quiz não tem corpo — e por
-     * isso pertence a quem tem corpo, não a quem desenha.
-     */
-    BOX: {
-        w: number;
-        h: number;
-    };
-    easyHitbox: GraphicsLike;
-    getVpTex(): unknown[];
-    isWheelchair(): boolean;
-    getFxClock(): number;
-    getPowerups(): readonly PowerupWithSprite[];
-    /**
-     * Os sprites dos ITENS declarados, na ordem em que o jogo os declara. Era `getCoinSprites()`, importado de
-     * `game/coin-spawning` — o desenho sabia que os itens são moedas.
-     */
-    getItemSprites(): readonly (ItemSprite | null | undefined)[];
-    /** O item `j` aparece para o jogador `i`? Era `!cn.taken` — a regra "coletado some" é do jogo. */
-    itemVisibleTo(j: number, playerIndex: number): boolean;
-    /**
-     * O item `j` é DESTE jogador? Era `cn.owner === i`, e o que o desenho faz com a resposta é esmaecer o item
-     * alheio (lote C). A ideia de POSSE é do jogo: um cooperativo responde `true` sempre e ninguém esmaece nada.
-     */
-    itemOwnedBy(j: number, playerIndex: number): boolean;
-    /**
-     * O power-up `pu` aparece para o jogador `i`? Era `!puTaken(pu, i)`, que trazia a regra "chave é global,
-     * o resto é por jogador" — uma frase sobre ESTE jogo, dentro do desenho.
-     */
-    powerupVisibleTo(pu: PowerupWithSprite, playerIndex: number): boolean;
-    rm: ReducedMotion;
-    WORLD_PX_W(): number;
-    WORLD_PX_H(): number;
-    caneOn(pl: DrawPlayer): boolean;
-    updateParallax(camX: number, camY: number): void;
-    drawElevators(): void;
-    markSeen(camX: number, camY: number): void;
-    redrawMinimapIfDirty(): void;
-    drawMinimapPlayer(worldX: number, worldY: number): void;
-    applySharedTextures(viz: string): void;
-    renderVpOverlay(i: number, viz: string): void;
-    playerVizTex(base: Frame, viz: string): unknown;
-    updateGameHud(): void;
-    playerTextures(): PlayerTextures;
-    held(pl: AnimPlayer, act: string): boolean;
-}
-export interface DrawApi {
-    /** Enquadra `pl`, aplica clamp+tremor+arredondamento e reposiciona o parallax.
-     *  `i` é o índice do jogador, e existe porque CADA JOGADOR TEM A SUA CÂMERA (ver `camDe`). */
-    placeCam(pl: DrawPlayer, i?: number): {
-        camX: number;
-        camY: number;
-    };
-    /** Desenha o quadro inteiro (era `draw()` no game.js). */
-    drawFrame(): void;
-    /** Escolhe o quadro de animação de `pl` e o aplica no sprite (era a cauda do `stepPlayer`). */
-    animatePlayer(pl: DrawPlayer, dt: number, dir: number): Frame;
-}
-export declare function initDraw(ctx: DrawCtx): DrawApi;
-export {};

package/dist-pkg/render/draw.js

@@ -1,231 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/draw.ts — O QUADRO. Onde a câmera para e o que é carimbado nela, uma vez por tick, depois que
-// `update()` já simulou o mundo. Extraído verbatim do game.js (`placeCam` + `draw`), mais a aplicação da
-// textura escolhida no sprite do jogador (a última linha do antigo `stepPlayer`).
-//
-// O QUE ENTROU
-//   · `placeCam(pl)`     — a câmera: enquadra o jogador, CLAMPA nas bordas do mundo, aplica o tremor de tela
-//                          (render/fx.shakeAmp) RE-CLAMPANDO (senão o tremor mostraria o vazio fora do mapa),
-//                          arredonda para pixel inteiro (o jogo é 320×180: meio pixel é tremulação) e
-//                          reposiciona o parallax. Devolve `{camX,camY}` PRÉ-arredondamento, que é o que o
-//                          minimapa usa para marcar o que já foi visto.
-//   · `drawFrame()`      — o quadro inteiro: transform dos sprites de jogador (squash&stretch com easing,
-//                          ancorado nos pés + piscada de dano), elevadores, partículas, bengala, cadeira de
-//                          rodas, hitbox tolerante do modo Fácil, e ENTÃO um dos DOIS caminhos de câmera
-//                          (tela única direta vs. multi-tela com uma render-texture por viewport), clima e HUD.
-//   · `animatePlayer()`  — chama a decisão de quadro (render/player-anim) e a aplica no sprite, passando pelo
-//                          recolor do modo de visão (`playerVizTex`).
-//
-// POR QUE A FRONTEIRA CAIU AQUI
-// `placeCam` e `draw` são inseparáveis: os DOIS caminhos de câmera do `draw` chamam `placeCam`, e o de
-// multi-tela depende do efeito colateral dela (mover `camera` antes de cada `renderer.render`). Separá-los
-// só produziria dois módulos que se importam. Já `animatePlayer` veio junto por outro motivo: a escolha do
-// quadro é pura e mora em render/player-anim.ts, mas APLICÁ-LA toca um `PIXI.Sprite` e o cache de recolor de
-// render/viewports — exatamente o tipo de coisa que este módulo já faz. Deixá-la no game.js manteria lá uma
-// linha órfã de render dentro de uma função de lógica de jogo.
-//
-// O QUE FICOU DE FORA, E POR QUÊ
-//   · `configureRender()` — a MONTAGEM do multi-tela (criar/destruir as render-textures, os sprites de
-//     viewport, as molduras e as bolinhas). É ciclo de vida do render-graph, não desenho de quadro; e vive
-//     colada ao `app.renderer.resize` e ao HUD. Fica no game.js para uma rodada própria.
-//   · `updateParallax()` — mexe nos `TilingSprite` criados no game.js e na decor de tela da v3; entra
-//     injetada.
-//   · `applySharedTextures()` (render/viz-setters) e `renderVpOverlay()` (render/viewports) — já são módulos;
-//     entram injetados porque suas instâncias são criadas no game.js.
-//   · A coleta de moedas, os power-ups e o portão que precediam a animação no `stepPlayer`: são LÓGICA DE
-//     JOGO (dependem de `coins`, `powerups`, `gate`, quiz e HUD) e continuam no game.js.
-//
-// INJEÇÃO — a regra e as EXCEÇÕES conscientes
-// Vale a regra da casa: o que o game.js REATRIBUI entra por getter; o que é estável entra por valor. Daí
-// `getVpTex` (o `let vpTex` que `configureRender` troca a cada mudança de nº de telas), `isWheelchair`
-// (`let wheelchair`), `getFxClock` (`let fxClock`, o relógio do cintilar) e `getPowerups` (`let powerups`)
-// serem GETTERS. `rm` (o objeto de Movimento Reduzido) é `const` e mutado IN PLACE → entra por valor.
-//
-// EXCEÇÃO (desvio consciente da instrução de recorte, que pedia getters também para `numPlayers`, `coins` e
-// `players`): esses três são `export let` de core/state.ts, ou seja, BINDINGS VIVOS de ES Modules. Importá-los
-// aqui já entrega o valor atual a cada leitura — `setNumPlayersValue`/`setCoins` são vistos na hora, sem
-// getter. Getter aqui não acrescentaria correção, só uma indireção a mais e um ctx maior; e o precedente do
-// repositório é este (game/coin-spawning.ts importa `coins`+`setCoins` direto; game/physics.ts importa
-// `players`). A regra do getter vale para o que mora no ESCOPO PRIVADO do game.js, que módulo nenhum enxerga.
-//
-// PIXI POR INTERFACE ESTRUTURAL, não por `import * as PIXI` — mesmo precedente de render/viewports.ts e
-// render/scene-sky.ts. `camera`, `renderer`, as camadas de `Graphics` e os sprites entram como interfaces com
-// só os membros que este módulo toca, para o arquivo carregar no project `node` do Vitest.
-// Pelo mesmo motivo, os colaboradores que importam PIXI (game/level-geometry.drawElevators,
-// render/minimap.*) entram por closure em vez de import: o game.js já tem as camadas deles em mão.
-// São importados direto só os módulos-folha node-safe: constantes, RNG, render/fx, render/wheelchair-sprites,
-// render/viz-modes, game/powerups, game/coin-spawning e core/state.
-//
-// ORDEM DE BOOT: `initDraw` não faz I/O nem toca o render-graph — só fecha closures. Pode ser chamada em
-// qualquer ponto do game.js posterior às camadas de `Graphics`, à `camera` e ao `app`; o resto do ctx é
-// função e resolve tarde. Ver docs/5-Refactoring/plano-modularizacao-mapa.md (C1).
-import { LOGICAL_W, LOGICAL_H, EASY } from '../core/constants.js';
-// A corrente da DECORACAO, nao a do jogo: uma particula sorteada aqui nao pode mover o sorteio
-// das moedas. Ver o cabecalho de core/rng.ts (issue #107).
-import { rngDecoracao } from '../core/rng.js';
-const rnd = rngDecoracao.rnd;
-import { JUICE, easeOut3, shakeAmp, drawFx } from './fx.js';
-import { criarCamera } from './camera.js';
-import { drawCane, drawRunCane, drawChair } from './wheelchair-sprites.js';
-import { chaveDeTextura, ehBaixaVisao } from './viz-axes.js';
-// (`game/powerups` e `game/coin-spawning` SAÍRAM daqui no item 19 — ver o bloco "ITENS DECLARADOS" abaixo.)
-import { drawWeather } from './weather.js';
-import { choosePlayerFrame } from './player-anim.js';
-export function initDraw(ctx) {
-    /* ===================== câmera ===================== */
-    // A CONTA saiu para `render/camera` (item 22: M1 extraiu as fórmulas, M2 as embrulhou num OBJETO). Aqui
-    // ficou o CARIMBO dela no render-graph: o sorteio do tremor, a escrita no container e o aviso ao parallax.
-    //
-    // ========================= UMA CÂMERA POR JOGADOR, E POR QUÊ AGORA =========================
-    // O caminho multi-tela chama `placeCam(PLS[i])` para CADA jogador dentro do MESMO quadro. Com uma câmera
-    // só, a posição do jogador i entraria como ponto de partida da do jogador i+1. Hoje isso não daria em
-    // nada — com zona-morta 0×0 a câmera é sem memória e `seguir` equivale a `enquadrar`, letra por letra
-    // (`tests/camera.node.test.js` prende essa igualdade). No dia em que a zona deixar de ser zero, daria: as
-    // câmeras dos jogadores se puxariam. É mais barato separar antes de o defeito existir do que depois, e
-    // separar agora não muda um pixel do que a criança vê.
-    //
-    // ⚠️ `pular()` AINDA NÃO TEM CHAMADOR. Ele é para nascer/renascer/trocar de fase, e enquanto a zona é zero
-    // não faz falta nenhuma — `seguir` já centra. Quando o Dev escolher uma zona, o nascimento sem `pular`
-    // aparece como um deslize da câmera até o jogador no primeiro quadro da fase. Fica anotado aqui, e não
-    // fingido de resolvido.
-    const cams = new Map();
-    const camDe = (i) => {
-        let c = cams.get(i);
-        if (!c) {
-            c = criarCamera({ w: ctx.WORLD_PX_W(), h: ctx.WORLD_PX_H() }, { w: LOGICAL_W, h: LOGICAL_H });
-            cams.set(i, c);
-        }
-        // O mundo muda de tamanho ao trocar de fase, e a câmera não é avisada por ninguém — reprender todo quadro
-        // custa duas contas e dispensa um evento que hoje não existe.
-        else
-            c.redimensionar({ w: ctx.WORLD_PX_W(), h: ctx.WORLD_PX_H() }, { w: LOGICAL_W, h: LOGICAL_H });
-        return c;
-    };
-    function placeCam(pl, i = 0) {
-        const c = camDe(i);
-        // `pl.y` é o PÉ do jogador; o meio do corpo fica meia caixa acima. Esta conversão é a única coisa de
-        // PLATAFORMA que havia no enquadramento, e agora ela mora aqui, onde o corpo existe — e não na câmera.
-        c.seguir(pl.x, pl.y - ctx.BOX.h / 2);
-        const k = shakeAmp(); // JUICE: tremor decai linearmente (render/fx)
-        // Os dois sorteios ficam DENTRO do `if`, como no original: com `k === 0` ele não chamava `rnd()`, e
-        // chamá-lo duas vezes por quadro deslocaria o fluxo do gerador COMPARTILHADO — mesma semente, outro jogo.
-        const cam = k > 0 ? c.quadro(k, rnd() * 2 - 1, rnd() * 2 - 1) : c.base;
-        ctx.camera.x = -Math.round(cam.camX);
-        ctx.camera.y = -Math.round(cam.camY);
-        ctx.updateParallax(cam.camX, cam.camY);
-        return cam;
-    }
-    /* ===================== animação do personagem ===================== */
-    function animatePlayer(pl, dt, dir) {
-        const tx = choosePlayerFrame(pl, {
-            dt, dir, wheelchair: ctx.isWheelchair(), held: ctx.held, rnd, tex: ctx.playerTextures(),
-        });
-        // solo/default; no MP o drawFrame troca a textura por viewport (applySharedTextures)
-        // ⚠️ `chaveDeTextura` E NÃO A ASSINATURA DE `playerVizTex`. Medido na etapa 0 da #104: aquela função só
-        // age quando existe `DIRECT_CFG[mode]`, e devolve a textura como veio para todo o resto. Então o que
-        // muda é o CHAMADOR — a metade do estado que interessa à textura — e a porta fica onde estava.
-        if (pl.sprite)
-            pl.sprite.texture = ctx.playerVizTex(tx, chaveDeTextura(pl.visual));
-        return tx;
-    }
-    /* ===================== o quadro ===================== */
-    function drawFrame() {
-        const PLS = ctx.getPlayers();
-        for (const pl of PLS) {
-            if (!pl.sprite)
-                continue;
-            pl.sprite.x = pl.x;
-            pl.sprite.y = pl.y + 1;
-            // JUICE: squash&stretch com easing, ancorado nos pés
-            const q = (JUICE.squash && !pl.rmWalk && (pl.sqT || 0) > 0) ? (pl.sq || 0) * easeOut3((pl.sqT || 0) / 8) : 0;
-            // sem escala procedural de respiração (parecia mastigar) — respiração é por FRAMES
-            pl.sprite.scale.set((pl.facing < 0 ? -1 : 1) * (1 - q * 0.7), 1 + q);
-            pl.sprite.alpha = pl.hurtTimer > 0 ? (Math.floor(pl.hurtTimer / 4) % 2 ? 0.4 : 1) : 1;
-        }
-        ctx.drawElevators(); // cadeirante: plataforma do elevador sob os pés (largo/fino)
-        drawFx(); // JUICE: partículas (poeira/brilhos) na camada acima dos players
-        const shimOn = JUICE.shimmer && !ctx.rm.items; // JUICE: cintilar dos itens (respeita Movimento Reduzido)
-        const fxClock = ctx.getFxClock();
-        // modo cego: bengala SÓ andando (corrida = bengala de roda); nada parado/nadando/voando/escada
-        ctx.caneLayer.clear();
-        for (const pl of PLS) {
-            if (!ctx.caneOn(pl) || !pl.sprite || !pl.sprite.visible)
-                continue;
-            if (pl.running)
-                drawRunCane(ctx.caneLayer, pl);
-            else if (pl.walking)
-                drawCane(ctx.caneLayer, pl);
-        }
-        // cadeirante: desenha a cadeira nos jogadores (exceto nadando/voando)
-        ctx.chairLayer.clear();
-        if (ctx.isWheelchair()) {
-            for (const pl of PLS) {
-                if (pl.sprite && pl.sprite.visible && !pl.inWater && !pl.flying)
-                    drawChair(ctx.chairLayer, pl);
-            }
-        }
-        // Fácil: hitbox de coleta tolerante (retângulo translúcido) — só para os jogadores em Fácil
-        ctx.easyHitbox.clear();
-        const pad = EASY.pad;
-        for (const pl of PLS) {
-            if (!pl.easy)
-                continue;
-            ctx.easyHitbox.lineStyle(1, 0xffffff, 0.45);
-            ctx.easyHitbox.beginFill(0xffffff, 0.10);
-            ctx.easyHitbox.drawRect(pl.x - ctx.BOX.w / 2 - pad, pl.y - ctx.BOX.h - pad, ctx.BOX.w + 2 * pad, ctx.BOX.h + 2 * pad);
-            ctx.easyHitbox.endFill();
-        }
-        if (ctx.getNumPlayers() <= 1) {
-            // O CINTILAR fica: é juice da engine (render/fx), e vale para moeda, estrela ou peça de tabuleiro.
-            const itens = ctx.getItemSprites();
-            for (let j = 0; j < itens.length; j++) {
-                const s = itens[j];
-                if (s)
-                    s.alpha = shimOn ? 0.8 + 0.2 * Math.sin(fxClock * 0.12 + j * 1.7) : 1;
-            }
-            const { camX, camY } = placeCam(PLS[0]);
-            ctx.markSeen(camX, camY);
-            ctx.redrawMinimapIfDirty();
-            ctx.drawMinimapPlayer(PLS[0].x, PLS[0].y - ctx.BOX.h / 2);
-        }
-        else {
-            // Otimização: se TODOS estão no mesmo modo (caso comum), troca as texturas UMA vez; senão, por viewport.
-            // ⚠️ A COMPARAÇÃO PASSOU A SER PELA CHAVE DE TEXTURA, e isso é output-preservador e mais barato ao
-            // mesmo tempo. `applySharedTextures` só usa o modo para escolher TEXTURA (`worldTexFor`,
-            // `parallaxTexFor`, `treeTexFor`, `spriteTexFor`, `pupTexFor`), e todas devolvem a base para o que não
-            // está em `DIRECT_CFG` — conferido em `high-contrast.worldTexFor`. Antes, dois jogadores em `normal` e
-            // `fix-deuter` contavam como modos DIFERENTES e disparavam uma re-aplicação de texturas que produzia
-            // exactamente as mesmas texturas. Agora contam como iguais, porque para a textura eles são.
-            const v0 = chaveDeTextura(PLS[0].visual);
-            const allSame = PLS.every((p) => chaveDeTextura(p.visual) === v0);
-            const anyOverlay = PLS.some((p) => ehBaixaVisao(p.visual));
-            if (allSame)
-                ctx.applySharedTextures(v0);
-            for (let i = 0, n = ctx.getNumPlayers(); i < n; i++) {
-                const viz = chaveDeTextura(PLS[i].visual);
-                if (!allSame)
-                    ctx.applySharedTextures(viz); // só troca por viewport quando os modos diferem
-                const itens2 = ctx.getItemSprites();
-                for (let j = 0; j < itens2.length; j++) {
-                    const s = itens2[j];
-                    if (!s)
-                        continue;
-                    s.visible = ctx.itemVisibleTo(j, i);
-                    // Lote C: item alheio esmaecido — quem é "alheio" é o jogo que diz; JUICE: cintilar multiplicativo
-                    s.alpha = (ctx.itemOwnedBy(j, i) ? 1 : 0.4) * (shimOn ? 0.8 + 0.2 * Math.sin(fxClock * 0.12 + j * 1.7) : 1);
-                }
-                for (const pu of ctx.getPowerups()) {
-                    if (pu.sprite)
-                        pu.sprite.visible = ctx.powerupVisibleTo(pu, i);
-                }
-                placeCam(PLS[i], i);
-                ctx.renderizarEm(ctx.camera, ctx.getVpTex()[i], true); // LIMPA: cada quadro é um quadro, não um acúmulo
-                if (anyOverlay)
-                    ctx.renderVpOverlay(i, viz); // passada extra só se algum jogador está em baixa visão
-            }
-        }
-        drawWeather(); // chuva/clarão em tela-espaço, sobre tudo
-        ctx.updateGameHud(); // HUD por jogador (moedas + poder) em DOM sobreposto (alta definição)
-    }
-    return { placeCam, drawFrame, animatePlayer };
-}

package/dist-pkg/render/fx.d.ts

@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-export interface Particle {
-    x: number;
-    y: number;
-    vx: number;
-    vy: number;
-    life: number;
-    max: number;
-    color: number;
-    size: number;
-    g: number;
-}
-export interface JuiceFlags {
-    dust: boolean;
-    sparkle: boolean;
-    squash: boolean;
-    hitstop: boolean;
-    shake: boolean;
-    shimmer: boolean;
-}
-/** Juice toggles (persisted in localStorage; edited in the ?debug panel + Sensibilidade → Movimento). */
-export declare const JUICE: JuiceFlags;
-export declare function saveJuice(): void;
-/** Standard easing (squash recovery, particle fade). Shared → exported (game.js render reads it too). */
-export declare const easeOut3: (t: number) => number;
-/** Minimal PIXI.Graphics surface drawFx needs (kept structural so the module stays PIXI-free for node tests). */
-interface FxGraphics {
-    clear(): void;
-    beginFill(color: number, alpha?: number): unknown;
-    drawRect(x: number, y: number, w: number, h: number): unknown;
-    endFill(): unknown;
-}
-interface ReducedMotion {
-    particles?: boolean;
-    parallax?: boolean;
-}
-interface Squashable {
-    rmWalk?: boolean;
-    sq?: number;
-    sqT?: number;
-}
-export declare function initFx(deps: {
-    fxG: FxGraphics;
-    rm: ReducedMotion;
-    getPlayers: () => readonly unknown[];
-}): void;
-export declare function spawnParticle(x: number, y: number, vx: number, vy: number, life: number, color: number, size: number, grav?: number): void;
-export declare function puffDust(x: number, y: number, n: number): void;
-export declare function burstSparkle(x: number, y: number, color?: number, n?: number): void;
-export declare function addShake(mag: number, dur: number): void;
-export declare function addHitstop(t: number): void;
-export declare function setSquash(pl: Squashable, amt: number): void;
-/** Advance particles + decay shake/squash. (fxClock is stepped by game.js — see header.) */
-export declare function stepFx(dt: number): void;
-export declare function drawFx(): void;
-/** Decrement hit-stop and report whether the world is still frozen (game.js early-returns on true). */
-export declare function tickHitstop(dt: number): boolean;
-/** Current screen-shake amplitude (0 = none); the camera applies the random jitter. */
-export declare function shakeAmp(): number;
-export declare const getParticles: () => Particle[];
-export declare const getHitstopT: () => number;
-export declare const getShakeT: () => number;
-export {};