@the-inclusionist/engine 9.0.0 → 11.0.0

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

@@ -1,295 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/scene-sky — céu de tela: deriva de nuvens (math pura + bug #21) + trilha viva da v3 (nuvens/pássaros do mundo,
-// estrelas/névoa, grama/minhocas/vagalumes/borboletas). Extraído do game.js (#43). As 6 CAMADAS (skyLayer/starsG/
-// skyDecoG/fogG/grassG/themeFxG) continuam sendo CRIADAS no game.js — a ordem-z delas está soldada na montagem do
-// render-graph (parallax/worldSprite/lifeLayer/carLayer) — e são INJETADAS aqui; movemos só a LÓGICA. Fórmulas copiadas
-// verbatim da v3.1.100. Injeção por closure. Ver docs/5-Refactoring/plano-modularizacao-mapa.md (#43).
-/**
- * Posição horizontal de uma nuvem à deriva, com wrap SUB-PIXEL e pelo CORPO INTEIRO. Corrige #21:
- * (a) NÃO arredonda → deriva suave mesmo a <1px/frame; (b) só reentra quando a nuvem inteira saiu.
- * @param phase distância de deriva acumulada (float; cresce → direita, decresce → esquerda)
- * @param enterAt x de (re)entrada — passe `-larguraDaNuvem` p/ reentrar TOTALMENTE fora da tela
- * @param span período do wrap — passe `larguraDaTela + larguraDaNuvem` p/ só reentrar depois de sair inteira
- */
-export function cloudWrapX(phase, enterAt, span) {
-    return ((phase % span) + span) % span + enterAt;
-}
-/** Largura e altura do cúmulo base, antes de `esc`. Quem mede cobertura precisa das duas. */
-export const NUVEM_W = 26, NUVEM_H = 13;
-/** Quantas fileiras a manta fechada tem. É o que a faz cobrir do topo ao horizonte em vez de só o topo. */
-const FILEIRAS = 3;
-/**
- * Onde estão as `n` nuvens de tela neste instante.
- *
- * Os fatores 37, 13, 7 e 5 são PRIMOS COM 3 de propósito: a fileira é `i % 3`, e qualquer variação tirada de
- * `i` com um fator múltiplo de 3 sairia CONSTANTE dentro de uma fileira — a fileira 0, que é a que se vê no
- * tempo bom, teria todas as nuvens do mesmo tamanho, à mesma velocidade e na mesma altura. Já aconteceu.
- *
- * @param t relógio de efeitos (0 congela a deriva — movimento reduzido)
- * @param vw largura do viewport
- * @param n quantas nuvens no total (a fileira 0, ~n/3, é a que aparece no tempo bom)
- * @param junta 0 = poucas e altas (o pôr do sol aparece) · 1 = as três fileiras cobrindo o céu inteiro
- */
-export function nuvensDeTela(t, vw, n, junta) {
-    const j = Math.max(0, Math.min(1, junta)), nuvens = [];
-    for (let i = 0; i < n; i++) {
-        const sp = 0.05 + ((i * 7) % 4) * 0.021; // velocidades diferentes: elas se alcançam e se abrem
-        const esc = (1.15 + ((i * 37) % 5) * 0.18) * (1 + 0.6 * j); // crescem ao fechar até uma encostar na outra
-        const larg = NUVEM_W * esc;
-        const x = cloudWrapX(t * sp + (i * (vw + larg)) / Math.max(1, n), -larg, vw + larg);
-        const aberto = 4 + ((i * 37) % 26); // altura de repouso: a faixa alta do céu
-        const fechado = (i % FILEIRAS) * 27 + ((i * 13) % 7); // altura de manta: a fileira desta nuvem
-        // A fileira 0 é permanente; as outras entram entre 0,15 e 0,65 de aglomeração — antes da chuva, portanto.
-        const surge = i % FILEIRAS === 0 ? 1 : Math.max(0, Math.min(1, (j - 0.15) / 0.5));
-        nuvens.push({ x, y: (1 - j) * aberto + j * fechado, esc, alpha: (0.72 + 0.28 * j) * surge });
-    }
-    return nuvens;
-}
-/**
- * Um cúmulo em retângulos: laje de base e três lóbulos de alturas diferentes. Retângulos e não arcos porque é
- * o que o `Gfx` do PIXI oferece aqui e porque é o que combina com o resto — a nuvem é pixel art, não um
- * desenho vetorial reduzido. `[x, y, w, h]` no espaço da nuvem base (NUVEM_W×NUVEM_H), multiplicado por `esc`.
- */
-const CUMULO = [
-    [0, 8, 26, 4], [2, 5, 9, 3], [3, 3, 6, 2], [4, 2, 4, 1],
-    [9, 4, 9, 4], [11, 2, 6, 2], [12, 1, 4, 1],
-    [17, 5, 7, 3], [18, 3, 4, 2],
-];
-/** A sombra sob a base — uma linha só. Na Floresta ela é alaranjada: a luz baixa bate por baixo. */
-const CUMULO_SOMBRA = [1, 12, 24, 1];
-export function createSceneSky(ctx) {
-    const clouds = [];
-    let birds = [];
-    let _birdT = 500;
-    // seedClouds v3: 7 nuvens à deriva no céu do MUNDO (skyLayer)
-    for (let i = 0; i < 7; i++) {
-        const s = ctx.criarSprite(ctx.CLOUD_TEX[i % 2]);
-        s.alpha = 0.5 + ((i * 37) % 30) / 100;
-        s.x = (i * 173) % ctx.WORLD_PX_W;
-        s.y = 8 + ((i * 61) % Math.floor(ctx.WORLD_PX_H * 0.30));
-        s._v = 0.02 + ((i * 13) % 10) / 300;
-        ctx.skyLayer.addChild(s);
-        clouds.push(s);
-    }
-    function stepSky(dt) {
-        if (ctx.getRm().decor) {
-            if (birds.length) {
-                birds.forEach((b) => { ctx.skyLayer.removeChild(b.s); b.s.destroy(); });
-                birds = [];
-            }
-            return;
-        }
-        for (const c of clouds) {
-            c.x += (c._v || 0) * dt;
-            if (c.x > ctx.WORLD_PX_W + 50)
-                c.x = -50;
-        }
-        if (birds.length < 3 && ++_birdT >= 520) {
-            _birdT = ctx.randInt(0, 300);
-            const dir = ctx.rnd() < 0.5 ? 1 : -1;
-            const s = ctx.criarSprite(ctx.BIRD_TEX[0]);
-            s.scale.x = dir;
-            s.x = dir > 0 ? -10 : ctx.WORLD_PX_W + 10;
-            s.y = 12 + ctx.rnd() * ctx.WORLD_PX_H * 0.25;
-            ctx.skyLayer.addChild(s);
-            birds.push({ s, dir, f: 0, t: 0 });
-        }
-        for (let i = birds.length - 1; i >= 0; i--) {
-            const b = birds[i];
-            b.s.x += b.dir * 0.7 * dt;
-            b.t += dt;
-            if (b.t >= 8) {
-                b.t = 0;
-                b.f = 1 - b.f;
-                b.s.texture = ctx.BIRD_TEX[b.f];
-            }
-            if (b.s.x < -16 || b.s.x > ctx.WORLD_PX_W + 16) {
-                ctx.skyLayer.removeChild(b.s);
-                b.s.destroy();
-                birds.splice(i, 1);
-            }
-        }
-    }
-    function drawV3Cloud(g, x, y, col) {
-        g.beginFill(ctx.hexN(col[0])).drawRect(x, y + 6, 24, 6).drawRect(x + 2, y + 4, 8, 4).drawRect(x + 3, y + 2, 6, 2)
-            .drawRect(x + 8, y + 2, 12, 6).drawRect(x + 10, y, 8, 2).drawRect(x + 16, y + 4, 8, 4).endFill();
-        g.beginFill(ctx.hexN(col[1])).drawRect(x + 1, y + 11, 22, 1).endFill();
-    }
-    function drawCumulo(g, nv, col) {
-        const e = nv.esc, R = (r) => {
-            g.drawRect(Math.round(nv.x + r[0] * e), Math.round(nv.y + r[1] * e), Math.round(r[2] * e), Math.round(r[3] * e));
-        };
-        g.beginFill(ctx.hexN(col[0]), nv.alpha);
-        for (const r of CUMULO)
-            R(r);
-        g.endFill();
-        g.beginFill(ctx.hexN(col[1]), nv.alpha);
-        R(CUMULO_SOMBRA);
-        g.endFill();
-    }
-    function drawV3Grass(g, tx, ty, fl, t) {
-        const TILE = ctx.TILE, x = tx * TILE, y = ty * TILE, wind = ctx.getRm().decor ? 0 : Math.sin(t * 0.045 + tx * 0.6);
-        g.beginFill(ctx.hexN(fl.base)).drawRect(x, y, TILE, 2).endFill();
-        g.beginFill(ctx.hexN(fl.top)).drawRect(x, y, TILE, 1).endFill();
-        const seed = (tx * 1103515245 + 12345) >>> 0;
-        for (let i = 0; i < 6; i++) {
-            const bx = (seed >> (i * 4)) & 15, bh = 2 + ((seed >> (i * 4 + 4)) & 1);
-            g.beginFill(ctx.hexN((i & 1) ? fl.bDk : fl.bLt));
-            for (let h = 0; h < bh; h++) {
-                const dx = Math.round(wind * (h / Math.max(1, bh - 1)) * 1.5);
-                g.drawRect(x + bx + dx, y - 1 - h, 1, 1);
-            }
-            g.endFill();
-        }
-        if ((seed >> 9) % 7 === 0) {
-            const fx = x + 4 + (seed % 7), sh = 4, cy = y - sh - 2;
-            g.beginFill(ctx.hexN(fl.bDk));
-            let topDx = 0;
-            for (let h = 0; h < sh; h++) {
-                topDx = Math.round(wind * (h / sh) * 2.4);
-                g.drawRect(fx + topDx, y - 1 - h, 1, 1);
-            }
-            g.endFill();
-            const bxC = fx + topDx;
-            g.beginFill(ctx.hexN(fl.petals[(seed >>> 17) % fl.petals.length])).drawRect(bxC - 1, cy + 1, 3, 1).drawRect(bxC, cy, 1, 3).endFill(); // >>> (v3 usava >> e o canvas engolia o índice; PIXI lança)
-            g.beginFill(ctx.hexN(fl.center)).drawRect(bxC, cy + 1, 1, 1).endFill();
-        }
-    }
-    function stepV3Decor() {
-        const T = ctx.CENARIOS[ctx.getCenario()] || {};
-        ctx.starsG.clear();
-        ctx.skyDecoG.clear();
-        ctx.nuvemG.clear();
-        ctx.fogG.clear();
-        ctx.grassG.clear();
-        ctx.themeFxG.clear();
-        ctx.themeFxBackG.clear();
-        // A pergunta é "este tema tem decoração viva?", e ela se responde OLHANDO A DECORAÇÃO. Antes era
-        // `!T.v3`, que respondia "este tema não é a Cidade" — o mesmo resultado por acidente, enquanto a Cidade
-        // era o único tema sem céu vivo. Um tema de fundo raster COM borboletas quebrava aquilo; este não.
-        if (!T.decor?.length || ctx.DIRECT_CFG[ctx.getVizMode()])
-            return; // alto contraste dispensa decor
-        const t = ctx.getFxClock(), d = T.decor || [], vw = ctx.LOGICAL_W, vh = ctx.LOGICAL_H, reduzido = !!ctx.getRm().decor;
-        // TELA: estrelas (sparkles v3) — cintilam a ~0,3Hz
-        if (!reduzido && d.includes('sparkles')) {
-            const top = Math.max(1, Math.floor(vh * 0.7));
-            for (let i = 0; i < 22; i++) {
-                const a = 0.3 + 0.35 * Math.sin(t * 0.03 + i * 1.3);
-                if (a <= 0.05)
-                    continue;
-                ctx.starsG.beginFill(0xffffff, a).drawRect((i * 73) % vw, (i * 49) % top, 1, 1).endFill();
-            }
-        }
-        // TELA: nuvens. Dois caminhos, e a diferença é DADO, não gosto:
-        //  · tema com `nuvens: N` (hoje só a Floresta) — manta viva de N cúmulos que fecha e abre com a chuva;
-        //  · os outros três — as 3 lajes da v3, derivas 0.08/0.05/0.11, VERBATIM. Não passaram por aqui de graça:
-        //    o Dev pediu o céu novo para a Floresta, e mudar a aparência dos outros três de carona seria alargar
-        //    o pedido por conta própria. Quando ele quiser, é trocar um número na tabela de cenários.
-        if (d.includes('nuvens') && T.cloud && T.nuvens) {
-            const col = T.cloud, junta = reduzido ? 0 : ctx.getAglomeracao();
-            // `nuvemG` e não `skyDecoG`: a manta fica ATRÁS das bandas de morro (ver a nota no ctx).
-            for (const nv of nuvensDeTela(reduzido ? 0 : t, vw, T.nuvens, junta))
-                drawCumulo(ctx.nuvemG, nv, col);
-        }
-        else if (d.includes('nuvens') && T.cloud) {
-            const col = T.cloud, defs = [{ y: 6, sp: 0.08, off: 0 }, { y: 20, sp: 0.05, off: 130 }, { y: 12, sp: 0.11, off: 250 }];
-            for (const c0 of defs) {
-                const x = cloudWrapX((reduzido ? 0 : t) * c0.sp + c0.off, -44, vw + 64);
-                drawV3Cloud(ctx.skyDecoG, x, c0.y, col);
-            }
-        }
-        if (!reduzido && d.includes('passaros')) {
-            ctx.skyDecoG.beginFill(0x282837, 0.7);
-            for (let i = 0; i < 3; i++) {
-                const bx = ((t * (0.25 + i * 0.07) + i * 90) % (vw + 20)) - 10, by = 14 + i * 9 + Math.sin(t * 0.04 + i) * 2, f = Math.sin(t * 0.2 + i) > 0 ? 1 : 2;
-                const X = Math.round(bx), Y = Math.round(by);
-                ctx.skyDecoG.drawRect(X - 2, Y + f, 2, 1).drawRect(X + 1, Y + f, 2, 1).drawRect(X, Y, 1, 1);
-            }
-            ctx.skyDecoG.endFill();
-        }
-        // TELA: névoa do amanhecer (3 camadas onduladas) — v3 exato, na FRENTE
-        if (d.includes('nevoa')) {
-            const base = Math.floor(vh * 0.72);
-            const Ls = [{ y: base, drift: 0.30, amp: 3, op: 0.06, freq: 0.080 }, { y: base + 6, drift: 0.55, amp: 4, op: 0.08, freq: 0.060 }, { y: base + 13, drift: 0.85, amp: 5, op: 0.10, freq: 0.050 }];
-            for (const L of Ls) {
-                ctx.fogG.beginFill(0xdee2ec, L.op);
-                for (let x = 0; x < vw; x += 2) {
-                    const top = L.y + Math.round(L.amp * Math.sin((x + (reduzido ? 0 : t) * L.drift) * L.freq));
-                    ctx.fogG.drawRect(x, top, 2, vh - top);
-                }
-                ctx.fogG.endFill();
-            }
-        }
-        // MUNDO (culled por jogador, dedupe): grama em TODA superfície + minhocas/vagalumes/borboletas
-        const fl = ctx.THEME_FLORA[ctx.getCenario()], seen = new Set();
-        for (const pl of ctx.getPlayers()) {
-            if (pl.quit)
-                continue;
-            const camX = Math.max(0, Math.min(pl.x - vw / 2, ctx.WORLD_PX_W - vw)), camY = Math.max(0, Math.min((pl.y - ctx.BOX.h / 2) - vh / 2, ctx.WORLD_PX_H - vh));
-            // Margem de recorte = 3 tiles em TODAS as direções: cobre a flutuação da fauna (borboleta sobe ~34px ≈ 2 tiles,
-            // deriva ~19px) E reduz pop-in do decor na beirada ao mover a câmera → mais fluido (José). (#69)
-            const tx0 = Math.max(0, Math.floor(camX / ctx.TILE) - 3), tx1 = Math.min(ctx.WORLD_W - 1, Math.floor((camX + vw) / ctx.TILE) + 3);
-            const ty0 = Math.max(0, Math.floor(camY / ctx.TILE) - 3), ty1 = Math.min(ctx.WORLD_H - 1, Math.floor((camY + vh) / ctx.TILE) + 3);
-            for (let tx = tx0; tx <= tx1; tx++) {
-                for (let ty = ty0; ty <= ty1; ty++) {
-                    const st = ctx.tileAt(tx, ty); // flora/fauna SÓ em PEDRA(2)/parede(6) — nunca em trampolim(5), lava(9) ou escada(4). #69
-                    if (!((st === 2 || st === 6) && !ctx.solidAt(tx, ty - 1) && ctx.tileAt(tx, ty - 1) !== 3 && ctx.tileAt(tx, ty - 1) !== 9))
-                        continue;
-                    const k = tx + ',' + ty;
-                    if (seen.has('g' + k))
-                        continue;
-                    seen.add('g' + k);
-                    // densidade: só uma FRAÇÃO das superfícies recebe flora (getGrassDensity), escolhidas por hash+semente da fase.
-                    if (fl && ((tx * 668265263 ^ ty * 2246822519 ^ ctx.getDecorSeed()) >>> 0) % 1000 < ctx.getGrassDensity() * 1000)
-                        drawV3Grass(ctx.grassG, tx, ty, fl, t);
-                    // #69: fauna distribuída POR SUPERFÍCIE (hash de tx,ty), não "1 por coluna no topo" — aparece em todas as
-                    // alturas, inclusive perto do player em corredores baixos / junto à lava (antes ancorava só na superfície + alta).
-                    if (d.includes('minhocas') && ((tx * 668265263 ^ ty * 374761393) >>> 0) % 6 === 0 && !seen.has('w' + k)) {
-                        seen.add('w' + k); // ~1/6 das superfícies
-                        ctx.themeFxG.beginFill(0xc47b8a);
-                        const bx = tx * ctx.TILE + 5, by = ty * ctx.TILE + 4;
-                        for (let s2 = 0; s2 < 5; s2++)
-                            ctx.themeFxG.drawRect(bx + s2, by + Math.round(reduzido ? 0 : Math.sin(t * 0.15 + tx * 0.7 + s2 * 0.8)), 1, 1);
-                        ctx.themeFxG.endFill();
-                    }
-                    const bh = (tx * 374761393 ^ ty * 668265263) >>> 0; // hash por superfície (cor + lado + gate)
-                    if (!reduzido && d.includes('borboletas') && bh % 7 === 0 && !seen.has('b' + k)) {
-                        seen.add('b' + k); // ~1/7 das superfícies
-                        const cols = [0xff8c42, 0xffd166, 0xef476f, 0xfca5d4, 0xf4a261, 0xe9c46a];
-                        const groundY = ty * ctx.TILE, wx = tx * ctx.TILE + 8 + 14 * Math.sin(t * 0.015 + tx + ty) + 5 * Math.cos(t * 0.04 + tx);
-                        const rise = 8 + 26 * (0.5 + 0.5 * Math.sin(t * 0.012 + tx * 1.3 + ty)), wy = groundY - rise + 4 * Math.sin(t * 0.05 + tx);
-                        const flap = Math.abs(Math.sin(t * 0.4 + tx * 0.7 + ty)), w = 1 + Math.round(flap * 2), X = Math.round(wx), Y = Math.round(wy);
-                        const bfg = (bh & 1) ? ctx.themeFxG : ctx.themeFxBackG; // metade ATRÁS / metade À FRENTE do player — #69
-                        bfg.beginFill(cols[bh % cols.length]).drawRect(X - w, Y, w, 2).drawRect(X + 2, Y, w, 2).endFill();
-                        bfg.beginFill(0x3a2a1a).drawRect(X, Y, 2, 2).endFill();
-                    }
-                    // (sem break: grama em TODAS as superfícies expostas da coluna, não só a mais alta — senão some perto do player. #69)
-                }
-            }
-            if (!reduzido && d.includes('vagalumes')) {
-                const cell = 64; // drawFireflies v3: grade hash fixa no mundo, só no ar
-                const cx0 = Math.floor(camX / cell) - 1, cx1 = Math.floor((camX + vw) / cell) + 1, cy0 = Math.floor(camY / cell) - 1, cy1 = Math.floor((camY + vh) / cell) + 1;
-                for (let cyi = cy0; cyi <= cy1; cyi++)
-                    for (let cxi = cx0; cxi <= cx1; cxi++) {
-                        const h = ((cxi * 73856093) ^ (cyi * 19349663)) >>> 0;
-                        if (h % 3 !== 0)
-                            continue;
-                        const k = 'f' + cxi + ',' + cyi;
-                        if (seen.has(k))
-                            continue;
-                        seen.add(k);
-                        const ph = ((h >> 4) % 628) / 100;
-                        const wx = cxi * cell + 8 + (h % (cell - 16)) + 8 * Math.sin(t * 0.013 + ph), wy = cyi * cell + 8 + ((h >> 9) % (cell - 16)) + 6 * Math.cos(t * 0.017 + ph * 1.3);
-                        const a = 0.45 + 0.45 * Math.sin(t * 0.05 + ph);
-                        if (a <= 0.06)
-                            continue;
-                        if (ctx.solidAt(Math.floor(wx / ctx.TILE), Math.floor(wy / ctx.TILE)))
-                            continue;
-                        ctx.themeFxBackG.beginFill(0xfff096, a * 0.35).drawRect(wx - 1, wy - 1, 3, 3).endFill(); // vaga-lumes ao FUNDO (atrás do player) — #69
-                        ctx.themeFxBackG.beginFill(0xffffbe, a).drawRect(wx, wy, 1, 1).endFill();
-                    }
-            }
-        }
-    }
-    return { stepSky, stepV3Decor, getClouds: () => clouds, getBirds: () => birds };
-}

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

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import { type CenarioTema } from './cenario-data.js';
-import type { Tileset } from './world-tex.js';
-/** `HTMLImageElement`, reduzido ao que o carregamento usa. */
-/** O tileset de um tema: interior + topo. Corresponde ao `Tileset` de render/world-tex. */
-/**
- * Os dois tiles do tema. `Tileset` vem de `render/world-tex`, que é o dono — ele os desenha, e por isso
- * sabe que são `CanvasImageSource`. A versão que estava aqui dizia `unknown` nos dois campos: uma
- * descrição que apenas SE PARECE com a real, que é o que o ADR-0039 proíbe. O `unknown` não protegia
- * nada — só empurrava a conversão para quem recebesse.
- */
-export type TilesDoTema = Tileset;
-/** `worldSprite` — só a troca de textura. */
-interface SpriteComTextura {
-    texture: unknown;
-}
-/**
- * Baixa `tile_fill.png` + `tile_surface.png` do tema. Resolve com os dois, ou com `null` se QUALQUER um falhar.
- *
- * Verbatim do `loadTileImages` do monólito, `fail` inclusive: quando uma das imagens erra, o `res(null)` sai na
- * hora e a outra, ao chegar, encontra `fail` ligado e não resolve por cima. A promessa nunca REJEITA — tema sem
- * arte é um caminho normal (a Cidade não tem tileset próprio), não um erro, e uma rejeição aqui derrubaria a
- * troca de cenário inteira. Nunca pendura: os dois lados de cada imagem estão cobertos.
- */
-export interface SetCenarioCtx {
-    setCenarioValue: (theme: string) => void;
-    getCenario: () => string;
-    aplicarTemaParallax: (theme: string, T: CenarioTema) => void;
-    /**
-     * Os tiles do tema, SÍNCRONOS. Eram dois PNG baixados por `carregarTilesDoTema`; hoje a Cidade os desenha
-     * (render/city-tiles) e os outros temas devolvem `null`, que é o caminho dos blocos v3 — o mesmo `null` de
-     * antes, agora imediato em vez de prometido.
-     */
-    getTiles: (tema: string) => TilesDoTema | null;
-    /** Builder da canvas do nível. `HTMLCanvasElement` e não `unknown`: é o que o `render/world-tex`
-     *  devolve, e o `unknown` só adiava a conversão até o `main.ts`, onde ela virava erro (ADR-0039). */
-    worldCanvas: (tiles: TilesDoTema | null) => HTMLCanvasElement;
-    tex: (canvas: HTMLCanvasElement) => unknown;
-    clearWorldTexCache: () => void;
-    /** Escreve `worldCanvasNormal`/`worldTexNormal` (os dois `let` do composition root), sempre em par. A
-     *  TEXTURA segue `unknown` de propósito — é objeto do PixiJS, e este módulo roda no project `node`. */
-    setWorldTextures: (canvas: HTMLCanvasElement, textura: unknown) => void;
-    isVizReady: () => boolean;
-    reapplyVizAll: () => void;
-    getWorldSprite: () => SpriteComTextura | null | undefined;
-    isVidaReady: () => boolean;
-    applyCenarioVida: () => void;
-}
-export interface SetCenarioApi {
-    /** Troca o cenário. Valida, persiste, repinta o fundo, refaz o mundo e avisa quem depende. */
-    setCenario(theme: string): void;
-}
-export declare function createSetCenario(ctx: SetCenarioCtx): SetCenarioApi;
-export {};

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

@@ -1,103 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/set-cenario — TROCAR DE CENÁRIO: a única porta por onde o jogo muda de mundo visual.
-//
-// `setCenario(tema)` é chamado de quatro lugares muito diferentes — o splash (a criança escolhe antes de
-// começar), a demonstração automática (game/attract.ts sorteia), o console de testes (`window.__incl`) e o
-// BOOT (restauração do tema salvo em `incl_cenario`) — e sempre faz a mesma sequência de cinco passos. Esta
-// função é ORQUESTRAÇÃO: ela não desenha nada, não gera textura nenhuma e não sabe fórmula alguma. Ela decide
-// QUEM é avisado, EM QUE ORDEM, e o que fazer quando a resposta demora.
-//
-// ======================= POR QUE ISTO É UM MÓDULO, E NÃO FIAÇÃO NO game.js =======================
-// A tentação era deixá-la no monólito como cola: quase toda linha dela chama alguém de fora, e o contexto
-// injetado aqui é largo. Três coisas decidiram o contrário, e nenhuma delas é estética:
-//
-//  1. A GUARDA DE CORRIDA. Os tiles do tema (`tile_fill.png`/`tile_surface.png`) chegam quando chegarem, e
-//     entre o pedido e a chegada a pessoa pode ter trocado de cenário de novo — no splash isso é UM segundo
-//     de distância, e na demonstração automática o troca-troca é o comportamento normal. Por isso o `.then`
-//     abre com `if (getCenario() !== theme) return`: um tileset atrasado do Campo não pode repintar o chão da
-//     Floresta. É a espécie de defeito que aparece uma vez a cada cem trocas, some quando alguém vai olhar, e
-//     não tem como ser reproduzido de mão com confiança. Fora de um módulo, ele não tem como ter teste.
-//  2. A ORDEM DOS AVISOS. `setCenarioValue` (core/state.js — valor, persistência e evento) vem ANTES de
-//     qualquer trabalho de textura, e é isso que faz a guarda de corrida do item 1 funcionar: quem compara
-//     `getCenario() !== theme` está comparando com o valor que ESTA chamada gravou. Inverter as duas linhas
-//     não quebra nada visível e desarma a guarda inteira, silenciosamente.
-//  3. A VALIDAÇÃO. "Tema desconhecido → 'cidade'" é a rede que segura um `incl_cenario` de uma versão antiga
-//     (e o boot ainda migra a chave 'noite' → 'espaco', do lado do game.js). Ela virou
-//     `normalizarCenario` em render/cenario-data.ts, com o comportamento atual PREGADO por teste, defeito de
-//     herança de protótipo incluído — ver o cabeçalho de lá.
-//
-// ======================= OS CINCO PASSOS, E POR QUE NESTA ORDEM =======================
-//   1. valida o tema           → `normalizarCenario`
-//   2. grava e persiste        → `setCenarioValue` (core/state.js). ANTES do resto: arma as guardas de corrida.
-//   3. veste o FUNDO           → `aplicarTemaParallax` (render/parallax.ts) — síncrono nos temas v3, PNG na Cidade
-//   4. pede os TILES do tema   → assíncrono; ao chegar, refaz a textura do MUNDO e reaplica os modos de visão
-//   5. avisa quem depende      → vida ambiente da Cidade (síncrono) e alto contraste (síncrono)
-// O passo 5 roda ANTES de o passo 4 terminar, e isso é de propósito: a vida ambiente e o recolor não esperam
-// download nenhum. O passo 4 reaplica o recolor DE NOVO quando os tiles chegam, porque aí a textura do mundo
-// mudou — os dois `reapplyVizAll` não são duplicação, são dois momentos.
-//
-// ======================= O QUE FICOU DE FORA, E POR QUÊ =======================
-//  · O DADO dos temas → render/cenario-data.ts (folha, sem dependência). Importado aqui, não injetado: é um
-//    módulo sem efeito nenhum, então importá-lo não cria risco de ordem de boot.
-//  · A geometria e a pintura das 3 camadas de fundo → render/parallax.ts. Este módulo só chama
-//    `aplicarTemaParallax` e não sabe o que é `tilePosition`.
-//  · As FÓRMULAS de céu/morros/placeholder → render/scene-parallax.ts (desde o Estágio 4).
-//  · O BUILDER da textura do mundo (`worldCanvas`) → render/world-tex.ts. Aqui só entra o resultado.
-//  · A migração da chave antiga ('noite' → 'espaco') e o `try/catch` do boot FICAM no game.js: são política de
-//    persistência e rede de segurança do arranque, não regra de cenário.
-//  · `worldCanvasNormal`/`worldTexNormal` continuam sendo `let` do game.js — são lidos por
-//    render/high-contrast (por getter) e pelo render estático. Este módulo os ESCREVE por um único
-//    `setWorldTextures(canvas, textura)`, para que a dupla nunca fique meio trocada.
-//
-// ======================= ⚠️ A ARMADILHA DE BOOT DESTA REGIÃO =======================
-// O `setCenario` do boot é chamado MUITO cedo — logo depois de `initViewports`, e antes de metade do jogo
-// existir. O monólito o embrulha num `try/catch` que cai para 'cidade' EM SILÊNCIO, e é por isso que uma
-// dependência ausente aqui não vira erro: vira "o tema que a criança escolheu não voltou, e ninguém sabe por
-// quê". Todas as dependências que ainda não existem naquele instante entram por GETTER ou por CALLBACK, nunca
-// por valor, exatamente para que a montagem do ctx não toque em `const` em TDZ:
-//   · `isVizReady`/`reapplyVizAll` — `vizReady` só vira `true` lá no fim do boot; no arranque as duas voltas
-//     de `reapplyVizAll` são puladas, e quem pinta é o `else if (worldSprite)` do passo 4.
-//   · `getWorldSprite` — o sprite do mundo nasce DEPOIS deste ponto no game.js. Só é tocado dentro do `.then`,
-//     que é assíncrono, mas o getter garante que a montagem do ctx não o dereferencie.
-//   · `isVidaReady`/`applyCenarioVida` — `sceneCity` nasce centenas de linhas depois; `_vidaReady` é `false`
-//     no boot justamente para que esta chamada seja pulada, e o game.js chama `applyCenarioVida()` uma vez, à
-//     mão, quando a cena da cidade fica pronta.
-//   · `clearWorldTexCache` vem de render/high-contrast, que é um módulo de verdade e já existe no import.
-//
-// SEM I/O NO IMPORT, e agora sem I/O NENHUM: `carregarTilesDoTema` (a carga assíncrona dos PNG de tile, com a
-// guarda de corrida que ela exigia) foi APAGADA no item 17 — os tiles da Cidade viraram dados em
-// `render/city-tiles`. O corpo do módulo não pede nada, e a troca de cenário virou síncrona.
-// Ver docs/5-Refactoring/plano-modularizacao-mapa.md (D2-b).
-import { CENARIOS, normalizarCenario } from './cenario-data.js';
-export function createSetCenario(ctx) {
-    function setCenario(theme) {
-        const tema = normalizarCenario(theme);
-        ctx.setCenarioValue(tema); // ANTES do trabalho de textura: é o valor com que as guardas de corrida comparam
-        const T = CENARIOS[tema];
-        ctx.aplicarTemaParallax(tema, T); // as 3 camadas de fundo (render/parallax.ts)
-        // TILES do tema: SÍNCRONOS. v3: blocos Clarity SEM recolor (o `worldCanvas` cai no desenho da v3 com null).
-        //
-        // A GUARDA DE CORRIDA MORREU JUNTO COM A CORRIDA. Havia um `if (getCenario() !== tema) return` aqui, e ele
-        // estava certo enquanto os tiles chegavam por `Promise`: trocar de cenário durante o download deixava a
-        // resposta antiga pintar por cima da nova. Sem download não há "durante", e guarda contra corrida que não
-        // existe mais é código que só pode confundir quem o ler depois.
-        const tiles = ctx.getTiles(tema);
-        const cv = ctx.worldCanvas(tiles), t = ctx.tex(cv);
-        ctx.setWorldTextures(cv, t);
-        ctx.clearWorldTexCache();
-        if (ctx.isVizReady())
-            ctx.reapplyVizAll();
-        else {
-            const sprite = ctx.getWorldSprite(); // no boot o recolor ainda não existe: pinta o sprite direto
-            if (sprite)
-                sprite.texture = t;
-        }
-        // (o Cenário saiu do menu de pausa — a escolha é do J1 no splash, antes de começar)
-        if (ctx.isVidaReady())
-            ctx.applyCenarioVida(); // liga/desliga carros/deco da cidade e semeia o tema
-        if (ctx.isVizReady())
-            ctx.reapplyVizAll(); // reaplica o cenário recolorido (só após o init montar tudo)
-        // incl_cenario é persistido por setCenarioValue (core/state.js)
-    }
-    return { setCenario };
-}

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

@@ -1,75 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import { tex } from './canvas.js';
-type Tex = ReturnType<typeof tex>;
-/** Alto-contraste plumbing this module needs but does not own — game.js keeps the mutable source of truth
- *  (world/coin/tree/parallax texture pipelines share the same DIRECT_CFG/directSpriteCanvas; `disp` also
- *  serves quiz rendering outside textures). Call once at boot, before the first letterTexture/pupTexFor. */
-export interface TexturesCtx {
-    /**
-     * IDS DAS FORMAS a pré-desenhar. Eram importados de `game/activity-content` (as dez formas da atividade de
-     * soma e subtração) — uma aresta de importação da ENGINE para o JOGO por causa de UMA linha do `initTextures`.
-     *
-     * O ADR-0027 conta essas arestas porque elas decidem o que um pacote arrasta: um módulo de render que importa
-     * conteúdo de matemática não se empacota sem levar o currículo junto. E o custo escondido era maior que a
-     * aresta — esta era também a única razão de `render/viz-setters` arrastar `game/`, por transitividade.
-     *
-     * Só os IDS, e não a lista de formas: este módulo desenha por id (`shapeTexture(id)`) e nunca leu o nome em
-     * português. Pedir a estrutura inteira seria pedir mais do que se usa, que é como uma aresta volta.
-     */
-    shapes: readonly string[];
-    /**
-     * OS PODERES a pré-desenhar, com a arte pronta. Mesma razão de `shapes`, um passo adiante: além da lista,
-     * entra o CANVAS de cada um — porque o ícone de voo, o de ventosa e o da bengala de corrida são arte deste
-     * jogo, e não geometria que a engine saiba desenhar sozinha.
-     *
-     * Era `PUP_KINDS` cravado aqui + `import { powerupCanvas } from './props.js'`. A arte mudou de camada no
-     * item 19 (`game/props`), e esta era a única aresta que a mudança criaria — some por injeção, e não por
-     * mudança de endereço.
-     */
-    powerups: readonly {
-        readonly kind: string;
-        readonly canvas: HTMLCanvasElement;
-    }[];
-    disp: (s: string) => string;
-    directCfg: Record<string, {
-        off: number;
-        mul: number;
-        bgMul: number;
-    }>;
-    directSpriteCanvas: (src: HTMLCanvasElement, mode: string) => HTMLCanvasElement;
-}
-/** Vertex list for the polygon shapes (PURE — no canvas). null = drawn via an arc/ellipse/rect primitive instead. */
-export declare function shapePoints(id: string, cx: number, cy: number, r: number): [number, number][] | null;
-/** 16×16 icon for a soma/subtração shape id (cyan fill + dark outline). */
-export declare function shapeTexture(id: string): Tex;
-/** Cache keyed by shape id — filled by initTextures (the injected id list never changes at runtime). */
-export declare const SHAPE_TEX: Record<string, Tex>;
-/** 16×16 rounded-square tile with a single letter (uses the injected `disp`, which honors letterCase). */
-export declare function letterTexture(ch: string): Tex;
-/** Normal-mode cache — filled by initTextures. */
-export declare const PUP_TEX: Record<string, Tex>;
-/** Power-up texture for `mode` (normal or alto-contraste-direto). Cached per mode×kind. */
-export declare function pupTexFor(kind: string, mode: string): Tex;
-/** Drops the alto-contraste power-up cache — game.js's _rebakeDirect clears world/coin/pup/player caches
- *  together whenever outline thickness or role colors change. Call it from there instead of touching a private. */
-export declare function resetPupTexCache(): void;
-/** Fills SHAPE_TEX/PUP_TEX (+ wires the alto-contraste deps). Call ONCE at boot, before the first rebuildCoins/
- *  rebuildExtras — mirrors game.js's old eager `const SHAPE_TEX=...; SOMASUB_SHAPES.forEach(...)` / PUP_CANVAS
- *  forEach, just deferred past import time so this module stays side-effect-free to import (node tests included). */
-export declare function initTextures(ctx: TexturesCtx): void;
-export declare const PIP_W = 24, PIP_H = 32;
-export declare const PIP_PAL: string[];
-export declare const PIP_IDLE: string[];
-export declare const PIP_WALK: string[][];
-/** Valid palette digit (7 = transparent background, skipped); robust to short/ragged rows. */
-export declare const isPix: (ch: string) => boolean;
-export declare function indexedToCanvas(rows: string[]): HTMLCanvasElement;
-export declare function silhouetteCanvasIdx(rows: string[]): HTMLCanvasElement;
-export declare const PLAYER_IDLE: string[];
-export declare const PLAYER_WALK: string[];
-export declare const PLAYER_CLIMB: string[];
-export declare const PLAYER_HURT: string[];
-/** Verbatim reproduction of game.js's old eager `const TEX={idle:tex(spriteToCanvas(PLAYER_IDLE)),...}` — never
- *  auto-run (see header note above). Unused today; kept callable in case a future caller resurfaces. */
-export declare function buildLegacyPlayerTex(): Record<string, Tex>;
-export {};