@the-inclusionist/engine 9.0.0 → 11.0.0

package/dist-pkg/render/fx.js

@@ -1,123 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/fx — Juice / micro-feedback (Estágio 4, Tier 2): particles (dust/sparkle), screen shake, hit-stop,
-// squash&stretch, + the JUICE toggles. Formulas are verbatim from game.js (behavior-preserving). The reduce-
-// motion flags (`rm`), the PIXI graphics layer (`fxG`) and the round's player list are INJECTED via initFx.
-// `fxClock` is NOT here — it is a general animation clock (coin shimmer reads it) and stays in game.js.
-// Shake/hit-stop state is read by the camera/update/__incl via getters. See docs/5-Refactoring/plano-modularizacao-mapa.md.
-// 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 * as store from '../platform/storage.js';
-/** Juice toggles (persisted in localStorage; edited in the ?debug panel + Sensibilidade → Movimento). */
-export const JUICE = (() => {
-    const d = { dust: true, sparkle: true, squash: true, hitstop: true, shake: true, shimmer: true };
-    const s = store.getJSON(store.KEYS.juice, null);
-    if (s && typeof s === 'object')
-        for (const k of Object.keys(d))
-            if (k in s)
-                d[k] = !!s[k];
-    return d;
-})();
-export function saveJuice() {
-    store.setJSON(store.KEYS.juice, JUICE);
-}
-/** Standard easing (squash recovery, particle fade). Shared → exported (game.js render reads it too). */
-export const easeOut3 = (t) => 1 - Math.pow(1 - t, 3);
-let particles = [];
-let hitstopT = 0, shakeT = 0, shakeDur = 1, shakeMag = 0;
-let fxG = null;
-let rm = {};
-// A LISTA DE JOGADORES entra por injeção desde 2026-08-26. 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`, ADR-0038). O que entra aqui é o GETTER da rodada que a raiz
-// possui; o `let` que sobra guarda a função, não a lista.
-let getPlayers = () => [];
-export function initFx(deps) {
-    fxG = deps.fxG;
-    rm = deps.rm;
-    getPlayers = deps.getPlayers;
-}
-export function spawnParticle(x, y, vx, vy, life, color, size, grav) {
-    if (particles.length >= 160)
-        particles.shift();
-    particles.push({ x, y, vx, vy, life, max: life, color, size, g: grav || 0 });
-}
-export function puffDust(x, y, n) {
-    if (!JUICE.dust || rm.particles)
-        return;
-    for (let i = 0; i < n; i++)
-        spawnParticle(x + (rnd() - 0.5) * 8, y - 1 - rnd() * 2, (rnd() - 0.5) * 0.9, -0.2 - rnd() * 0.4, 14 + rnd() * 10, 0xcfc6b8, rnd() < 0.4 ? 2 : 1, 0.02);
-}
-export function burstSparkle(x, y, color, n) {
-    if (!JUICE.sparkle || rm.particles)
-        return;
-    const N = n || 8;
-    for (let i = 0; i < N; i++) {
-        const a = (i / N) * Math.PI * 2 + rnd() * 0.5, sp = 0.5 + rnd() * 0.9;
-        spawnParticle(x, y, Math.cos(a) * sp, Math.sin(a) * sp - 0.3, 18 + rnd() * 12, color || 0xffd23f, rnd() < 0.5 ? 2 : 1, 0.015);
-    }
-}
-export function addShake(mag, dur) {
-    if (!JUICE.shake || rm.parallax)
-        return;
-    shakeMag = Math.max(shakeMag, mag);
-    shakeDur = dur;
-    shakeT = Math.max(shakeT, dur);
-}
-export function addHitstop(t) {
-    if (!JUICE.hitstop)
-        return;
-    hitstopT = Math.max(hitstopT, t);
-}
-export function setSquash(pl, amt) {
-    if (!JUICE.squash || pl.rmWalk)
-        return;
-    pl.sq = Math.max(-0.28, Math.min(0.2, amt));
-    pl.sqT = 8;
-}
-/** Advance particles + decay shake/squash. (fxClock is stepped by game.js — see header.) */
-export function stepFx(dt) {
-    if (shakeT > 0)
-        shakeT = Math.max(0, shakeT - dt);
-    for (const pl of getPlayers())
-        if (pl.sqT && pl.sqT > 0)
-            pl.sqT = Math.max(0, pl.sqT - dt);
-    for (let i = particles.length - 1; i >= 0; i--) {
-        const p = particles[i];
-        p.life -= dt;
-        if (p.life <= 0) {
-            particles.splice(i, 1);
-            continue;
-        }
-        p.vy += p.g * dt;
-        p.x += p.vx * dt;
-        p.y += p.vy * dt;
-    }
-}
-export function drawFx() {
-    if (!fxG)
-        return;
-    fxG.clear();
-    for (const p of particles) {
-        const f = p.life / p.max;
-        fxG.beginFill(p.color, 0.9 * easeOut3(f));
-        fxG.drawRect(p.x - p.size / 2, p.y - p.size / 2, p.size, p.size);
-        fxG.endFill();
-    }
-}
-/** Decrement hit-stop and report whether the world is still frozen (game.js early-returns on true). */
-export function tickHitstop(dt) {
-    if (hitstopT > 0) {
-        hitstopT = Math.max(0, hitstopT - dt);
-        return true;
-    }
-    return false;
-}
-/** Current screen-shake amplitude (0 = none); the camera applies the random jitter. */
-export function shakeAmp() {
-    return shakeT > 0 && shakeMag > 0 ? shakeMag * (shakeT / shakeDur) : 0;
-}
-export const getParticles = () => particles;
-export const getHitstopT = () => hitstopT;
-export const getShakeT = () => shakeT;

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

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import * as PIXI from 'pixi.js';
-export declare function initMinimap(stage: PIXI.Container, W: number, H: number): void;
-export declare function markSeen(camX: number, camY: number): void;
-export declare function redrawMinimapIfDirty(): void;
-export declare function drawMinimapPlayer(worldX: number, worldY: number): void;
-export declare function resetMinimap(): void;
-export declare function setMinimapCorner(touch: boolean): void;
-export declare function setMinimapVisible(v: boolean): void;
-export declare function getMinimap(): PIXI.Container | null;
-export declare function minimapSeenCount(): number;

package/dist-pkg/render/minimap.js

@@ -1,94 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/minimap.ts — minimapa com FOG-OF-WAR (Estágio 4, Tier 1). Um container PixiJS no canto do stage: fundo
-// + tiles JÁ VISTOS (revelados pela câmera) + ponto do jogador. O que já foi visto persiste até o fim da fase.
-// initMinimap cria os objetos (import PURO — nada de PIXI no import); markSeen revela; redrawMinimapIfDirty
-// repinta só quando mudou; drawMinimapPlayer põe o ponto; resetMinimap re-escurece (fim de fase). Cor do tile
-// vem de core/collision (tileAt/isSolidType). Deps: PIXI (npm), constants (TILE/LOGICAL_*), collision.
-import * as PIXI from 'pixi.js';
-import { LOGICAL_W, LOGICAL_H, TILE } from '../core/constants.js';
-import { tileAt, isSolidType } from '../core/collision.js';
-const MM_SCALE = 0.8, MM_PAD = 4;
-let _minimap = null;
-let _mmTiles = null, _mmPlayer = null;
-let _seen = [];
-let _dirty = false;
-let _W = 0, _H = 0, _mmW = 0, _mmH = 0;
-// Cria o container + graphics no stage e a grade de "visto" (W×H). Chamado uma vez no boot do game.js.
-export function initMinimap(stage, W, H) {
-    _W = W;
-    _H = H;
-    _mmW = W * MM_SCALE;
-    _mmH = H * MM_SCALE;
-    _minimap = new PIXI.Container();
-    _minimap.x = MM_PAD;
-    _minimap.y = LOGICAL_H - _mmH - MM_PAD;
-    _minimap.alpha = 0.92;
-    stage.addChild(_minimap);
-    const mmBg = new PIXI.Graphics();
-    mmBg.beginFill(0x05070f, 0.72);
-    mmBg.drawRect(-1, -1, _mmW + 2, _mmH + 2);
-    mmBg.endFill();
-    _mmTiles = new PIXI.Graphics();
-    _mmPlayer = new PIXI.Graphics();
-    _minimap.addChild(mmBg, _mmTiles, _mmPlayer);
-    _seen = Array.from({ length: H }, () => new Uint8Array(W));
-    _dirty = false;
-}
-// Marca como visto todos os tiles dentro da janela da câmera (camX,camY = canto sup-esq do viewport, em px).
-export function markSeen(camX, camY) {
-    const tx0 = Math.max(0, (camX / TILE) | 0), tx1 = Math.min(_W - 1, ((camX + LOGICAL_W) / TILE) | 0);
-    const ty0 = Math.max(0, (camY / TILE) | 0), ty1 = Math.min(_H - 1, ((camY + LOGICAL_H) / TILE) | 0);
-    for (let ty = ty0; ty <= ty1; ty++)
-        for (let tx = tx0; tx <= tx1; tx++)
-            if (!_seen[ty][tx]) {
-                _seen[ty][tx] = 1;
-                _dirty = true;
-            }
-}
-// Repinta os tiles vistos SÓ se algo novo foi revelado (barato: o fog muda pouco por frame). Cor por tipo.
-export function redrawMinimapIfDirty() {
-    if (!_dirty || !_mmTiles)
-        return;
-    _mmTiles.clear();
-    for (let ty = 0; ty < _H; ty++)
-        for (let tx = 0; tx < _W; tx++) {
-            if (!_seen[ty][tx])
-                continue;
-            const t = tileAt(tx, ty);
-            const col = isSolidType(t) ? 0x9a93b5 : (t === 3 ? 0x2f6fae : (t === 9 ? 0xff5b3a : 0x232038)); // sólido / água / lava / ar
-            _mmTiles.beginFill(col, 1);
-            _mmTiles.drawRect(tx * MM_SCALE, ty * MM_SCALE, MM_SCALE + 0.4, MM_SCALE + 0.4);
-            _mmTiles.endFill();
-        }
-    _dirty = false;
-}
-// Ponto do jogador (worldX,worldY em px do mundo; o game.js passa o centro do corpo).
-export function drawMinimapPlayer(worldX, worldY) {
-    if (!_mmPlayer)
-        return;
-    _mmPlayer.clear();
-    _mmPlayer.beginFill(0xffd23f, 1);
-    _mmPlayer.drawRect((worldX / TILE) * MM_SCALE - 1, (worldY / TILE) * MM_SCALE - 1, 2.6, 2.6);
-    _mmPlayer.endFill();
-}
-// Fim de fase: o fog-of-war volta a escurecer (o mapa some até ser revisto).
-export function resetMinimap() { _seen.forEach((r) => r.fill(0)); _dirty = true; }
-// Reposiciona o minimapa: no toque vai p/ o canto sup-dir (não briga com os controles); senão inf-esq.
-export function setMinimapCorner(touch) {
-    if (!_minimap)
-        return;
-    if (touch) {
-        _minimap.x = LOGICAL_W - _mmW - MM_PAD;
-        _minimap.y = MM_PAD;
-    }
-    else {
-        _minimap.x = MM_PAD;
-        _minimap.y = LOGICAL_H - _mmH - MM_PAD;
-    }
-}
-export function setMinimapVisible(v) { if (_minimap)
-    _minimap.visible = v; } // some no título / no multiplayer
-export function getMinimap() { return _minimap; } // p/ o __incl (debug/teste)
-export function minimapSeenCount() { let n = 0; for (const r of _seen)
-    for (const v of r)
-        n += v; return n; } // stat de fog revelado

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

@@ -1,85 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import type { CenarioTema, TemaMorros, TemaPredios, FaixaDePredios } from './cenario-data.js';
-import type { CriarAzulejo } from './port.js';
-/** Uma camada de fundo: `factor` = quanto do movimento horizontal da câmera ela reproduz; `fy`, o vertical. */
-export interface CamadaParallax {
-    key: string;
-    factor: number;
-    fy: number;
-}
-export declare const PARALLAX: readonly CamadaParallax[];
-/** Índice da camada → número do arquivo PNG da Cidade (`c4.png`, `c3.png`, `c2.png`). */
-export declare const ARQUIVO_POR_CAMADA: readonly number[];
-/** Onde uma camada fica neste quadro. `x`/`y` = posição DENTRO do camera; `tileX`/`tileY` = rolagem da textura. */
-export interface PosicaoParallax {
-    x: number;
-    y: number;
-    tileX: number;
-    tileY: number;
-}
-/**
- * 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 declare function posicoesParallax(camX: number, camY: number, camadas?: readonly CamadaParallax[], reduzido?: boolean): PosicaoParallax[];
-/** `tilePosition` de um `TilingSprite` — só o `set`, que é como o original o escreve. */
-interface PontoObservavel {
-    set(x: number, y: number): void;
-}
-/** O que tocamos de um `PIXI.TilingSprite`, e só isso. */
-export interface TilingSpriteLike {
-    x: number;
-    y: number;
-    texture: unknown;
-    tilePosition: PontoObservavel;
-    /**
-     * A ordem-z. Este módulo NÃO a lê — quem a escreve é a raiz de composição, ao encaixar as três camadas
-     * no registro canônico do ADR-0020. Está aqui porque a interface é EXPORTADA: ela não descreve só o que
-     * o parallax toca, descreve o que ele DEVOLVE, e o consumidor precisa deste campo para posicionar.
-     */
-    zIndex: number;
-}
-/** `camera` — só a inserção em posição de z fixa. */
-interface ContainerLike {
-    addChildAt(child: unknown, index: number): unknown;
-}
-/** `starsG`/`skyDecoG`/`fogG`: contra-posicionados junto com o parallax. */
-interface PosicionavelLike {
-    position: {
-        set(x: number, y: number): void;
-    };
-}
-export interface ParallaxCtx {
-    camera: ContainerLike;
-    criarAzulejo: CriarAzulejo<TilingSpriteLike>;
-    placeholderTex: (i: number) => unknown;
-    skyTex: (T: CenarioTema) => unknown;
-    /** themeHillsTexture — banda de morros. O `tema` escolhe a SILHUETA plantada em cima (árvores, cerca). */
-    hillsTex: (T: TemaMorros, near: boolean, tema: string) => unknown;
-    /** themeCitySkyTexture — céu + prédios distantes da Cidade, a única camada opaca dela. */
-    citySkyTex: (T: TemaPredios) => unknown;
-    /** themeSkylineTexture — uma faixa de prédios sobre transparência. */
-    skylineTex: (faixa: FaixaDePredios, semente: number) => unknown;
-    rm: {
-        parallax?: boolean;
-    };
-    getCenario: () => string;
-    getVizMode: () => string;
-    clearParallaxTexCache: () => void;
-    getDecorDeTela: () => ReadonlyArray<PosicionavelLike | null | undefined>;
-}
-export interface ParallaxApi {
-    layers: TilingSpriteLike[];
-    texNormal: unknown[];
-    updateParallax(camX: number, camY: number): void;
-    aplicarTemaParallax(theme: string, T: CenarioTema): void;
-}
-/** Cria as 3 camadas dentro do `camera` e devolve a API que as move e as veste. */
-export declare function createParallax(ctx: ParallaxCtx): ParallaxApi;
-export {};

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;