@the-inclusionist/engine 8.0.0 → 10.0.0

package/dist-pkg/render/textures.js

@@ -1,240 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/textures — procedural texture generators for in-world GLYPHS: soma/subtração SHAPES, sílabas LETTERS,
-// and power-up ICONS (+ their alto-contraste variant). Verbatim from game.js (behavior-preserving). `disp`
-// (letterCase-aware) and the DIRECT_CFG/directSpriteCanvas alto-contraste plumbing are SHARED with other texture
-// pipelines (world/coin/tree/parallax) that stay in game.js — INJECTED via initTextures, never read from a
-// global. Caches are filled BY initTextures (not at import time) so importing this module stays I/O-free, same
-// discipline as render/sprites.ts (Fase 2.24). See docs/5-Refactoring/plano-modularizacao-mapa.md.
-import { makeCanvas, tex } from './canvas.js';
-import { spriteToCanvas } from './sprite-fx.js';
-let disp = (s) => String(s).toLowerCase(); // safe pre-init default (matches letterCase='lower')
-let directCfg = {};
-let directSpriteCanvas = (src) => src; // safe pre-init default (fg=0 → sem contorno)
-/* ===================== soma/subtração: formas ===================== */
-/** Vertex list for the polygon shapes (PURE — no canvas). null = drawn via an arc/ellipse/rect primitive instead. */
-export function shapePoints(id, cx, cy, r) {
-    switch (id) {
-        case 'triangulo': return [[cx, cy - r], [cx + r, cy + r], [cx - r, cy + r]];
-        case 'losango': return [[cx, cy - r], [cx + r, cy], [cx, cy + r], [cx - r, cy]];
-        case 'paralelogramo': return [[cx - r + 3, cy - r * 0.6], [cx + r, cy - r * 0.6], [cx + r - 3, cy + r * 0.6], [cx - r, cy + r * 0.6]];
-        case 'trapezio': return [[cx - r * 0.5, cy - r * 0.7], [cx + r * 0.5, cy - r * 0.7], [cx + r, cy + r * 0.7], [cx - r, cy + r * 0.7]];
-        case 'pentagono': return Array.from({ length: 5 }, (_, i) => { const a = -Math.PI / 2 + i * 2 * Math.PI / 5; return [cx + r * Math.cos(a), cy + r * Math.sin(a)]; });
-        case 'hexagono': return Array.from({ length: 6 }, (_, i) => { const a = i * 2 * Math.PI / 6; return [cx + r * Math.cos(a), cy + r * Math.sin(a)]; });
-        default: return null;
-    }
-}
-/** 16×16 icon for a soma/subtração shape id (cyan fill + dark outline). */
-export function shapeTexture(id) {
-    const cv = makeCanvas(16, 16), c = cv.getContext('2d');
-    c.fillStyle = '#7fdcff';
-    c.strokeStyle = '#04121a';
-    c.lineWidth = 1.5;
-    const cx = 8, cy = 8, r = 6;
-    c.beginPath();
-    const pts = shapePoints(id, cx, cy, r);
-    if (pts) {
-        pts.forEach(([x, y], i) => c[i ? 'lineTo' : 'moveTo'](x, y));
-        c.closePath();
-    }
-    else
-        switch (id) {
-            case 'circulo':
-                c.arc(cx, cy, r, 0, 7);
-                break;
-            case 'oval':
-                c.ellipse(cx, cy, r, r * 0.66, 0, 0, 7);
-                break;
-            case 'quadrado':
-                c.rect(cx - r, cy - r, 2 * r, 2 * r);
-                break;
-            case 'retangulo':
-                c.rect(cx - r, cy - r * 0.6, 2 * r, r * 1.2);
-                break;
-            default: c.arc(cx, cy, r, 0, 7);
-        }
-    c.fill();
-    c.stroke();
-    return tex(cv);
-}
-/** Cache keyed by shape id — filled by initTextures (the injected id list never changes at runtime). */
-export const SHAPE_TEX = {};
-/* ===================== sílabas: letra ===================== */
-/** 16×16 rounded-square tile with a single letter (uses the injected `disp`, which honors letterCase). */
-export function letterTexture(ch) {
-    const cv = makeCanvas(16, 16), c = cv.getContext('2d');
-    c.fillStyle = '#ffd23f';
-    c.strokeStyle = '#1a1400';
-    c.lineWidth = 1.5;
-    c.beginPath();
-    if (c.roundRect)
-        c.roundRect(2, 2, 12, 12, 3);
-    else
-        c.rect(2, 2, 12, 12);
-    c.fill();
-    c.stroke();
-    c.fillStyle = '#1a1400';
-    c.font = 'bold 11px system-ui,sans-serif';
-    c.textAlign = 'center';
-    c.textBaseline = 'middle';
-    c.fillText(disp(ch), 8, 9);
-    return tex(cv);
-}
-/* ===================== power-ups: ícone (+ alto contraste) ===================== */
-//
-// A LISTA E A ARTE ENTRAM JUNTAS, e nenhuma das duas mora aqui (item 19). Era
-//     const PUP_KINDS = ['superjump', 'ultrajump', 'turbo', 'fly', 'wallcling', 'key', 'runcane'] as const;
-// mais `import { powerupCanvas } from './props.js'` — os sete poderes DESTE jogo e o desenho deles, dentro de
-// um módulo de render. É o mesmo defeito que `SHAPE_TEX` tinha e pelo qual `shapes` já entra por ctx: um
-// segundo jogo herdava sete ícones que não são dele e não tinha como não herdar.
-//
-// A diferença em relação a `shapes` vale nota: das formas, a engine recebe só os IDS e DESENHA (`shapeTexture`
-// é geometria — polígono, arco, retângulo — e serve a qualquer jogo). Dos power-ups ela recebe o CANVAS
-// PRONTO, porque uma ventosa, uma asa e uma bengala de corrida não são geometria: são arte, e arte é do jogo.
-const PUP_CANVAS = {};
-/** Normal-mode cache — filled by initTextures. */
-export const PUP_TEX = {};
-const _pupTexHC = {}; // {mode:{kind:tex}} — outlined alto-contraste variant
-/** Power-up texture for `mode` (normal or alto-contraste-direto). Cached per mode×kind. */
-export function pupTexFor(kind, mode) {
-    const hc = (_pupTexHC[mode] = _pupTexHC[mode] || {});
-    if (directCfg[mode]) {
-        if (!hc[kind])
-            hc[kind] = tex(directSpriteCanvas(PUP_CANVAS[kind], mode));
-        return hc[kind];
-    }
-    return PUP_TEX[kind];
-}
-/** 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 function resetPupTexCache() {
-    for (const k in _pupTexHC)
-        delete _pupTexHC[k];
-}
-/** 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 function initTextures(ctx) {
-    disp = ctx.disp;
-    directCfg = ctx.directCfg;
-    directSpriteCanvas = ctx.directSpriteCanvas;
-    // LIMPA ANTES DE ENCHER. Enquanto as formas eram uma tabela FIXA importada, o cache só podia ser preenchido
-    // com o mesmo conteúdo e a diferença nunca apareceu — a função é chamada uma vez no boot. Com a lista
-    // INJETADA, "encher" tinha de deixar de significar "acrescentar": um segundo consumidor que inicializasse
-    // com as formas dele herdaria as nossas por cima, e o sintoma seria texturas de matemática num jogo que não
-    // tem matemática. Achado por um teste meu que afirmava a coisa errada e reprovou por isso.
-    for (const k of Object.keys(SHAPE_TEX))
-        delete SHAPE_TEX[k];
-    for (const id of ctx.shapes)
-        SHAPE_TEX[id] = shapeTexture(id);
-    // Mesma regra de limpar-antes-de-encher, pelo mesmo motivo do bloco acima: com a lista INJETADA, um segundo
-    // consumidor herdaria os poderes do primeiro por cima dos dele.
-    for (const k of Object.keys(PUP_CANVAS))
-        delete PUP_CANVAS[k];
-    for (const k of Object.keys(PUP_TEX))
-        delete PUP_TEX[k];
-    for (const p of ctx.powerups) {
-        PUP_CANVAS[p.kind] = p.canvas;
-        PUP_TEX[p.kind] = tex(p.canvas);
-    }
-}
-/* ===================== personagem: arte indexada (DEFERRED — não é código morto) =====================
-   FASE ATUAL: o jogo usa o PIXEL ART do PixelLab DIRETO (PNG nativo por quadro, render/sprites.ts — Fase 2.24).
-   A conversão deste personagem PROCEDURAL SEMÂNTICO/indexado (PIP_* abaixo) para a arte real do jogo "fica para
-   uma fase posterior" — comentário original de game.js, preservado aqui junto do código. ZERO chamadores hoje
-   (indexedToCanvas/silhouetteCanvasIdx não são invocadas por ninguém) — isso é trabalho ESTACIONADO de propósito,
-   não descartado. Ver docs/plano-arte-procedural.md. */
-export const PIP_W = 24, PIP_H = 32;
-export const PIP_PAL = ['#fcd7ab', '#e2aa86', '#9d6e62', '#5d2e22', '#472a1e', '#231c1c', '#1e1011', '#ff00ff', '#050809', '#010909'];
-export const PIP_IDLE = ['.....99444446666888.....', '...9444444444444448.....', '..924444444444444488....', '.9422442444444444439....', '.94424222442424495338...', '894444444424224495348...', '964664444444444915548...', '966664455444449101658...', '966666595689998000859...', '966659986991891000859...', '96656919911011009819....', '.99969111890000910119...', '990099198999008998819...', '902281890990001920929...', '91133119889000089099....', '.911111121500003409.....', '....991100003330009.....', '.....9821000000009......', '.....999821111198.......', '....92223999998429......', '...9022222399823229.....', '...99888822222283829....', '...91118892222281008....', '..9910000182224910089...', '.939211001844449300829..', '.9335821139999999229329.', '92355589985335229999939.', '939955955255552589..99..', '99..99952555958129......', '.....928899.9925489.....', '....991999..99554339....', '........................'];
-export const PIP_WALK = [
-    ['.....5566655...........', '...69344433365666......', '..533344434444336......', '.66224444444443466.....', '.54324444443444436.....', '6644442234424499346....', '66466433422323999444...', '66666344434434929445...', '66666448944939313935...', '66666659969856121945...', '66666889992191000945...', '6699681601102018929....', '6921981999900040026....', '9013891806960689926....', '903382190550009905.....', '.41231100220002306.....', '...592100000220006.....', '.....921100000006......', '.....56661111186.......', '....9622269999825......', '....9522222992525......', '....9968862222989......', '....8910062222929......', '.....810082222828......', '.....8100922229919.....', '.....9100996699914.....', '.....6200092559916.....', '.....5100094558988.....', '.....98112989689.......', '.....99889899119.......', '.....9558...95554......', '.....94444.............'],
-    ['.....6656655...........', '...68443344466665......', '..933444444444336......', '.98224444443344466.....', '.63424444443444435.....', '6544442244424499446....', '65366434422413695444...', '66566444434433618445...', '66666449944939213845...', '65656869969946122945...', '66666889992191000845...', '6588690911101019919....', '6900881998600080026....', '6012891509950499926....', '813362191860005805.....', '.51131100230002306.....', '...992100000220019.....', '.....921100000008......', '.....98951111189.......', '....8422299989924......', '...99411222992925......', '...89996992222999......', '...99910082222999......', '....981009222299.......', '.....81009222299.......', '.....89206198999.......', '......9200095499.......', '.....54622292499.......', '.....9556999659........', '.....999999.1198.......', '.....9349...64444......', '.....83455.............'],
-    ['.....6665656...........', '...96444444466665......', '..633444443444446......', '.55324444443444466.....', '.64424444333444435.....', '6644432244222369334....', '66466433422413699444...', '66666444444444929634...', '66566339944948813934...', '66666649969958121635...', '66666999992081000945...', '6699681922101016629....', '6921991989800081016....', '8002961505950499625....', '903361160550005506.....', '.50131110440003306.....', '...861100000330004.....', '.....961200000115......', '.....59891111189.......', '....9222266989926......', '...99222222992629......', '...99999992222999......', '...99920060022999......', '....99200610229........', '....992229222299.......', '.....992200999999......', '.....999200925999......', '.....55822292598.......', '....95599999969........', '....985589992289.......', '....9489...933223......', '....94469..............'],
-    ['.....5665566...........', '...98444443366666......', '..644444444444446......', '.96224444444444456.....', '.63313444443443436.....', '6543332243424469434....', '65466434422324499434...', '66666334444444939444...', '66665349944936312934...', '66666859958968122934...', '66666999992081000934...', '6686691611101009625....', '6922991989800060015....', '9013991508960699825....', '903381190650006506.....', '.51221110420002406.....', '...992200000220006.....', '.....931100000116......', '......9991111169.......', '.....522299899315......', '...89222222992225......', '...99888922222866......', '...99200942222929......', '....8100992222829......', '....810099222298166....', '....810899998899216....', '....810099925999216....', '....91006454459895.....', '....91216355928........', '.....99959992158.......', '......8689.943444......', '......94465............'],
-    ['.....6665655...........', '...56444444356665......', '..633333344443446......', '.86314444443444466.....', '.83423434433434445.....', '6633432243423399434....', '66456434422413899434...', '66566434434434828636...', '66566349944949213935...', '66666659969968111636...', '66666989982091000645...', '6699691922201018829....', '6811991999900081016....', '6002961505960499625....', '603361160560005506.....', '.51131100440002206.....', '...981100000230015.....', '.....961100000116......', '.....99991111189.......', '....9222296966825......', '...89222222992625......', '...99998922222996......', '...99200932222826......', '....62009922229138.....', '....810099222299169....', '....910699898899206....', '....810099525599219....', '....91008545559988.....', '....82119946529........', '.....99899991169.......', '......9555.833323......', '......95555............'],
-    ['.....6556656...........', '...56443344456566......', '..833444444443336......', '.56224444444443466.....', '.64324434343444435.....', '6644442244424499349....', '65466444422313695444...', '66566344444333619446...', '66666439944939223945...', '65665669969949121945...', '66666899982190000845...', '6699690911101019919....', '6911991996600081026....', '8113891609960499925....', '913381191980005606.....', '.51131100430002306.....', '...992100000220019.....', '.....821100000006......', '.....99961111196.......', '....9222269899924......', '...99222222992625......', '...99998922222995......', '...89100922222929......', '....92008822229215.....', '....920089222299139....', '....620099988999108....', '....610009523399129....', '....91000855249998.....', '....9922299989998......', '.....899999.81198......', '.....99559..943445.....', '.....995548............'],
-];
-/** Valid palette digit (7 = transparent background, skipped); robust to short/ragged rows. */
-export const isPix = (ch) => ch >= '0' && ch <= '9' && ch !== '7';
-export function indexedToCanvas(rows) {
-    const cv = makeCanvas(PIP_W, PIP_H), c = cv.getContext('2d');
-    for (let y = 0; y < PIP_H; y++) {
-        const r = rows[y];
-        if (!r)
-            continue;
-        for (let x = 0; x < PIP_W; x++) {
-            const ch = r[x];
-            if (!isPix(ch))
-                continue;
-            c.fillStyle = PIP_PAL[+ch];
-            c.fillRect(x, y, 1, 1);
-        }
-    }
-    return cv;
-}
-export function silhouetteCanvasIdx(rows) {
-    const cv = makeCanvas(PIP_W, PIP_H), c = cv.getContext('2d');
-    c.fillStyle = '#ffe600';
-    for (let y = 0; y < PIP_H; y++) {
-        const r = rows[y];
-        if (!r)
-            continue;
-        for (let x = 0; x < PIP_W; x++) {
-            if (isPix(r[x]))
-                c.fillRect(x, y, 1, 1);
-        }
-    }
-    return cv;
-}
-/* ===================== personagem: sprite indexado ANTIGO (achado, não é o mesmo caso do PIP_*) =====================
-   ACHADO — relatado, não consertado: TEX + PLAYER_IDLE/WALK/CLIMB/HURT abaixo já tinham ZERO chamadores no
-   game.js original (nenhuma referência além da própria definição de TEX) — diferente do bloco PIP_* acima, este
-   não carrega comentário de "fase posterior"; é vestígio pré-PixelLab, plenamente substituído pelo pipeline PNG
-   (render/sprites.ts: TEX_IDLE/TEX_WALK/TEX_CLIMB/…, Fase 2.24). Preservado verbatim (a tarefa pede não apagar);
-   TEX passou de constante eager para função sob demanda (buildLegacyPlayerTex) só para este módulo poder ser
-   importado sem `document` (disciplina de render/sprites.ts) — comportamento IDÊNTICO se algum dia for chamada. */
-export const PLAYER_IDLE = [
-    '................', '................', '.....HHHHHH.....', '....HHHHHHHH....',
-    '....HHSSSSHH....', '....HSSSSSSH....', '....HSKSSKSH....', '....HSSSSSSH....',
-    '....HSSWWSSH....', '....HSSSSSSH....', '.....HSSSSH.....', '......SSSS......',
-    '.....RRRRRR.....', '....RRRRRRRR....', '...RRRRRRRRRR...', '..SRRRRRRRRRRS..',
-    '..SRRRRRRRRRRS..', '..SRRRRRRRRRRS..', '..SRRRRRRRRRRS..', '...RRRRRRRRRR...',
-    '...RRRRRRRRRR...', '....RRRRRRRR....', '....BBBBBBBB....', '....BBBBBBBB....',
-    '....BBB..BBB....', '....BBB..BBB....', '....BBB..BBB....', '....BBB..BBB....',
-    '....BBB..BBB....', '....BBB..BBB....', '...KKKK..KKKK...', '...KKKK..KKKK...',
-];
-export const PLAYER_WALK = [
-    '................', '................', '.....HHHHHH.....', '....HHHHHHHH....',
-    '....HHSSSSHH....', '....HSSSSSSH....', '....HSKSSKSH....', '....HSSSSSSH....',
-    '....HSSWWSSH....', '....HSSSSSSH....', '.....HSSSSH.....', '......SSSS......',
-    '.....RRRRRR.....', '....RRRRRRRR....', '...RRRRRRRRRR...', '..SRRRRRRRRRRS..',
-    '..SRRRRRRRRRRS..', '..SRRRRRRRRRRS..', '..SRRRRRRRRRRS..', '...RRRRRRRRRR...',
-    '...RRRRRRRRRR...', '....RRRRRRRR....', '....BBBBBBBB....', '...BBBB..BBB....',
-    '..BBB....BBB....', '.BBB.....BBB....', 'KKKK.....KKKK...', '................',
-    '................', '................', '................', '................',
-];
-export const PLAYER_CLIMB = [
-    '................', '................', '.....HHHHHH.....', '....HHHHHHHH....',
-    '....HHHHHHHH....', '....HHHHHHHH....', '....HHHHHHHH....', '....HHHHHHHH....',
-    '....HHHHHHHH....', '....HHHHHHHH....', '.....HHHHHH.....', '......SSSS......',
-    '.....RRRRRR.....', '....RRRRRRRR....', '...RRRRRRRRRR...', '..SRRRRRRRRRRS..',
-    '..SRRRRRRRRRRS..', '..SRRRRRRRRRRS..', '..SRRRRRRRRRRS..', '...RRRRRRRRRR...',
-    '...RRRRRRRRRR...', '....RRRRRRRR....', '....BBBBBBBB....', '....BBBBBBBB....',
-    '....BBB..BBB....', '....BBB..BBB....', '....BBB..BBB....', '....BBB..BBB....',
-    '....BBB..BBB....', '....BBB..BBB....', '...KKKK..KKKK...', '...KKKK..KKKK...',
-];
-export const PLAYER_HURT = [
-    '................', '................', '.....HHHHHH.....', '....HHHHHHHH....',
-    '....HHSSSSHH....', '....HSSSSSSH....', '....HSWWWWSH....', '....HSWKKWSH....',
-    '....HSSSSSSH....', '....HSKKKKSH....', '.....HSSSSH.....', '......SSSS......',
-    '.....RRRRRR.....', '....RRRRRRRR....', '...RRRRRRRRRR...', '..SRRRRRRRRRRS..',
-    '..SRRRRRRRRR.S..', '..SRRRRRRRR.SS..', '...RRRRRRRRSS...', '...RRRRRRRRRR...',
-    '...RRRRRRRRRR...', '....RRRRRRRR....', '....BBBBBBBB....', '....BBBBBBBB....',
-    '....BBB..BBB....', '....BBB..BBB....', '....BBB..BBB....', '....BBB..BBB....',
-    '....BBB..BBB....', '....BBB..BBB....', '...KKKK..KKKK...', '...KKKK..KKKK...',
-];
-/** 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 function buildLegacyPlayerTex() {
-    return { idle: tex(spriteToCanvas(PLAYER_IDLE)), walk: tex(spriteToCanvas(PLAYER_WALK)), climb: tex(spriteToCanvas(PLAYER_CLIMB)), hurt: tex(spriteToCanvas(PLAYER_HURT)) };
-}

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

@@ -1,46 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import type { Desenho } from './port.js';
-type Gfx = Desenho;
-export interface TitleSceneCtx {
-    /** The PIXI.Graphics layer this scene draws into (created + z-ordered in game.js). */
-    titleG: Gfx;
-    /** Live screen size (pass `app.screen` — width/height read fresh on every draw()). */
-    screen: {
-        width: number;
-        height: number;
-    };
-    /** Reduced-motion flags; only `.parallax` (reduced parallax/animation) matters here. */
-    getRm: () => {
-        parallax?: boolean;
-    };
-}
-export interface TitleScene {
-    /** Redraws the title backdrop for the current frame (clears `titleG` first). */
-    draw: () => void;
-}
-/** The 4 title-screen clouds' logical (unscaled) positions — v3 exact. */
-export interface TitleCloudDef {
-    cx: number;
-    cy: number;
-}
-export declare const TITLE_CLOUDS: readonly TitleCloudDef[];
-/** Horizon row (sky/grass split), in screen pixels. */
-export declare function titleHorizonY(H: number): number;
-/** Sky gradient color for scanline `y` (0-indexed from the top), given the horizon row count. RGB
- * interpolation rgb(26→58, 26→76, 58→180) — exact v3 formula, packed as 0xRRGGBB. */
-export declare function titleSkyRowColor(y: number, horizon: number): number;
-/** This frame's cloud-drift offset: frozen at 0 under reduced motion, else sub-pixel accumulation of the
- * per-draw frame counter (titleT/6) — corrects #21a (no more Math.floor → no "jumps 1px every 6 frames"). */
-export declare function titleCloudDriftOffset(titleT: number, reducedMotion: boolean): number;
-/** Screen-space x of one title cloud, with whole-body wrap (#21b: the 28px-wide cloud only re-enters once it
- * has left the screen entirely). */
-export declare function titleCloudX(cx: number, k: number, off: number, W: number): number;
-export interface TitleGrassRow {
-    xStart: number;
-    xStep: number;
-    y: number;
-}
-/** The 3 staggered dotted-grass rows below the horizon — v3 exact. */
-export declare function titleGrassRows(k: number, horizon: number): TitleGrassRow[];
-export declare function createTitleScene(ctx: TitleSceneCtx): TitleScene;
-export {};

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

@@ -1,75 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/title-scene — title-screen BACKDROP: sky gradient + 4 drifting clouds + dotted grass, drawn into
-// `titleG` (v3.1.100 formulas, verbatim). Extracted from game.js's drawTitleScene(). The `titleG` PIXI.Graphics
-// layer is CREATED in game.js (`app.stage.addChildAt(titleG, app.stage.getChildIndex(weatherLayer))`) — its
-// z-order is soldered into the render-graph assembly there, same precedent as render/scene-sky.ts — and is
-// INJECTED here; only the drawing logic moves. cloudWrapX (sub-pixel, whole-body wrap, bug #21) is imported
-// straight from render/scene-sky.ts rather than re-implemented — it is already a leaf pure function there.
-import { LOGICAL_H } from '../core/constants.js';
-import { cloudWrapX } from './scene-sky.js';
-export const TITLE_CLOUDS = [
-    { cx: 40, cy: 30 }, { cx: 180, cy: 52 }, { cx: 265, cy: 22 }, { cx: 110, cy: 72 },
-];
-/** Horizon row (sky/grass split), in screen pixels. */
-export function titleHorizonY(H) {
-    return Math.round(H * 0.735);
-}
-/** Sky gradient color for scanline `y` (0-indexed from the top), given the horizon row count. RGB
- * interpolation rgb(26→58, 26→76, 58→180) — exact v3 formula, packed as 0xRRGGBB. */
-export function titleSkyRowColor(y, horizon) {
-    const f = y / horizon;
-    const r = Math.round(26 + 32 * f), g = Math.round(26 + 50 * f), b = Math.round(58 + 122 * f);
-    return (r << 16) | (g << 8) | b;
-}
-/** This frame's cloud-drift offset: frozen at 0 under reduced motion, else sub-pixel accumulation of the
- * per-draw frame counter (titleT/6) — corrects #21a (no more Math.floor → no "jumps 1px every 6 frames"). */
-export function titleCloudDriftOffset(titleT, reducedMotion) {
-    return reducedMotion ? 0 : titleT / 6;
-}
-/** Screen-space x of one title cloud, with whole-body wrap (#21b: the 28px-wide cloud only re-enters once it
- * has left the screen entirely). */
-export function titleCloudX(cx, k, off, W) {
-    return cloudWrapX(cx * k - off, -28 * k, W + 28 * k);
-}
-/** The 3 staggered dotted-grass rows below the horizon — v3 exact. */
-export function titleGrassRows(k, horizon) {
-    return [
-        { xStart: 0, xStep: 3 * k, y: horizon },
-        { xStart: 1 * k, xStep: 4 * k, y: horizon + 3 * k },
-        { xStart: 2 * k, xStep: 5 * k, y: horizon + 6 * k },
-    ];
-}
-// ---------------------------------------------------------------------------------------------
-// PIXI-facing (thin) — requires the injected `titleG` layer
-// ---------------------------------------------------------------------------------------------
-export function createTitleScene(ctx) {
-    let titleT = 0; // frame counter (module-local state, mirrors the old closure-level `let titleT=0`)
-    function drawCloud(g, cx, cy, k, off, W) {
-        const x = titleCloudX(cx, k, off, W), s = k;
-        g.beginFill(0xf6f5f0)
-            .drawRect(x, cy * s, 28 * s, 6 * s)
-            .drawRect(x + 6 * s, (cy - 4) * s, 16 * s, 6 * s)
-            .drawRect(x + 2 * s, (cy + 6) * s, 24 * s, 4 * s)
-            .endFill();
-    }
-    function draw() {
-        const g = ctx.titleG;
-        g.clear();
-        const W = ctx.screen.width, H = ctx.screen.height, k = H / LOGICAL_H;
-        const HOR = titleHorizonY(H);
-        for (let y = 0; y < HOR; y++)
-            g.beginFill(titleSkyRowColor(y, HOR)).drawRect(0, y, W, 1).endFill();
-        titleT++;
-        const off = titleCloudDriftOffset(titleT, !!ctx.getRm().parallax);
-        for (const c of TITLE_CLOUDS)
-            drawCloud(g, c.cx, c.cy, k, off, W);
-        g.beginFill(0x3f7d20).drawRect(0, HOR, W, H - HOR).endFill();
-        g.beginFill(0x2d5b16);
-        for (const row of titleGrassRows(k, HOR)) {
-            for (let x = row.xStart; x < W; x += row.xStep)
-                g.drawRect(x, row.y, k, k);
-        }
-        g.endFill();
-    }
-    return { draw };
-}

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

@@ -1,96 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-import type { DesenhoComLinha } from './port.js';
-/** A single rain drop's screen-space position + falling speed. */
-export interface RainDrop {
-    x: number;
-    y: number;
-    len: number;
-    spd: number;
-}
-/**
- * L5 (rotina do José): tempo bom nos primeiros 30s; depois LOOP de 60s = garoa 5s → chuva 5s → garoa 5s → bom 45s.
- * Skipped when scene decor is reduced-motion.
- *
- * QUEM TEM CHUVA É DADO DO TEMA (`CENARIOS[...].chuva`), e não uma condição escrita aqui. Era
- * `cenario === 'cidade'` — verdade enquanto a Cidade era o único tema com chuva, e mentira no dia em que o Dev
- * pediu chuva na Floresta. O defeito de uma condição dessas não é estar errada, é ser INVISÍVEL de onde a
- * pessoa procura: quem abre a tabela de cenários para dar chuva a um tema novo não encontra nada para mudar.
- *
- * @param sec elapsed weather-clock time, in seconds
- * @param temChuva true when the active theme declares `chuva`
- * @param reduceDecor true when reduced-motion scene decor (rm.decor) is on
- * @returns target rain level: 0 (dry), 0.35 (garoa) or 1 (chuva)
- */
-export declare function rainLevelTarget(sec: number, temChuva: boolean, reduceDecor: boolean): number;
-/** Onde estamos DENTRO do ciclo de 60s, em segundos. 0 = a primeira gota; 59 = um segundo antes dela. */
-export declare function faseDoClima(sec: number): number;
-/**
- * AGLOMERAÇÃO DAS NUVENS: 0 = espalhadas e altas, com o céu aparecendo entre elas; 1 = fechadas numa manta.
- *
- * O pedido do Dev foi de um MOVIMENTO, não de um estado: as nuvens se juntam, chove, elas se separam e o pôr
- * do sol aparece nas frestas. Quem faz isso ler como causa e não como coincidência é a ANTECEDÊNCIA — a manta
- * fecha OITO SEGUNDOS ANTES da primeira gota. Se fechasse junto, a chuva pareceria vir do nada e as nuvens
- * pareceriam reagir a ela; fechando antes, é a nuvem que traz a chuva, que é o que uma criança já sabe.
- *
- * Anda no MESMO ciclo da chuva (`faseDoClima`), e não num relógio próprio, porque dois relógios independentes
- * desandam um do outro — não de imediato, mas depois de alguns minutos, e aí ninguém liga o defeito à causa.
- * Devolve uma rampa contínua: não precisa de suavização depois.
- */
-export declare function aglomeracaoAlvo(sec: number, temChuva: boolean, reduceDecor: boolean): number;
-/** Ramps `current` toward `target` by at most `step`, snapping to `target` once within 0.02 (no "quase seco" flicker). */
-export declare function rampRainLevel(current: number, target: number, step: number): number;
-/** Thunder cooldown/flash step (só na chuva forte, > 0.45). Calls `onThunder(inten)` — e.g. platform/audio-ambient's `thunder`. */
-export interface ThunderStep {
-    thunderCD: number;
-    flash: number;
-}
-export declare function stepThunder(rainLevel: number, thunderCD: number, flash: number, rndFn: () => number, onThunder: (inten: number) => void): ThunderStep;
-/** Seeds `n` rain drops at random positions across the WxH screen (lazy — built once on first rain). */
-export declare function makeRainDrops(n: number, W: number, H: number, rndFn: () => number): RainDrop[];
-/** Advances one drop by its own speed; wraps to the top (new random x) past H. GAG: drops freeze when `moving` is false (pause). */
-export declare function stepRainDrop(d: RainDrop, W: number, H: number, moving: boolean, rndFn: () => number): void;
-type Gfx = DesenhoComLinha & {
-    parent: unknown;
-};
-interface StageLike {
-    children: {
-        length: number;
-    };
-    setChildIndex(child: unknown, index: number): void;
-}
-export interface WeatherCtx {
-    /** The PIXI.Graphics layer this module draws into (created + z-ordered in game.js, kept on top of the stage). */
-    weatherLayer: Gfx;
-    /** The PIXI.Container `weatherLayer` lives on — used only to re-pin it as the topmost child every draw. */
-    stage: StageLike;
-    /** Live screen size (pass `app.screen`; width/height read fresh on every draw()). */
-    screen: {
-        width: number;
-        height: number;
-    };
-    /** Reduced-motion flags; only `.decor` (scene decor/animation) matters here. */
-    getRm: () => {
-        decor?: boolean;
-    };
-    /** Called when thunder should rumble (platform/audio-ambient's `ambient.thunder`). */
-    thunder: (inten: number) => void;
-    /** Chove no cenário atual? Uma PERGUNTA e não o id do cenário: quem tem o catálogo responde. */
-    temChuva: () => boolean;
-    /** O mundo está rodando? Um BOOLEANO e não a fase — a engine não conhece o vocabulário de cenas deste
-     *  jogo (ADR-0030 C3). Era `phase === 'playing'`, importado de `core/state`. É o que congela as gotas na
-     *  pausa: elas param no ar em vez de continuarem caindo por trás do menu. */
-    mundoRodando: () => boolean;
-}
-export declare function initWeather(ctx: WeatherCtx): void;
-/** Per-frame clima update (game.js calls this only while `phase==='playing'`, same as before). */
-export declare function updateWeather(): void;
-/** Redraws the rain/flash overlay (chuva/clarão em tela-espaço, sobre tudo). */
-export declare function drawWeather(): void;
-/** The clima→áudio bridge: platform/audio-ambient.ts reads this (never the raw value) so its rain track follows the visual. */
-export declare function getRainLevel(): number;
-/** A ponte clima→céu: render/scene-sky lê isto para juntar e separar as nuvens no compasso da chuva. */
-export declare function getAglomeracao(): number;
-/** Weather-clock read/write — the game.js `window.__incl.weatherT` debug hook fast-forwards the cycle via this. */
-export declare function getWeatherT(): number;
-export declare function setWeatherT(v: number): void;
-export {};

package/dist-pkg/render/weather.js

@@ -1,171 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// render/weather — visual CLIMA: rain intensity ramp, thunder cadence/flash, and the rain-drop layer drawn in
-// screen-space on top of everything. Extracted from game.js's updateWeather/drawWeather (behavior-preserving,
-// formulas verbatim). `weatherLayer` (the PIXI.Graphics) and `stage` are CREATED in game.js — the layer's z-order
-// is soldered into the render-graph assembly there, same precedent as render/scene-sky.ts — and are INJECTED via
-// initWeather(); only the logic moves. `_rainLevel` is the bridge to platform/audio-ambient.ts (thunder/rain
-// track follow the visual): exposed here ONLY via getRainLevel(), never the raw mutable value, exactly like the
-// game.js `get rainLevel(){return _rainLevel;}` it replaces. `cenario` is read as a live binding from
-// core/state.ts (shared state home); `rnd` from core/rng.ts's DECORATION stream — same pattern as render/fx.ts.
-// 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;
-/**
- * L5 (rotina do José): tempo bom nos primeiros 30s; depois LOOP de 60s = garoa 5s → chuva 5s → garoa 5s → bom 45s.
- * Skipped when scene decor is reduced-motion.
- *
- * QUEM TEM CHUVA É DADO DO TEMA (`CENARIOS[...].chuva`), e não uma condição escrita aqui. Era
- * `cenario === 'cidade'` — verdade enquanto a Cidade era o único tema com chuva, e mentira no dia em que o Dev
- * pediu chuva na Floresta. O defeito de uma condição dessas não é estar errada, é ser INVISÍVEL de onde a
- * pessoa procura: quem abre a tabela de cenários para dar chuva a um tema novo não encontra nada para mudar.
- *
- * @param sec elapsed weather-clock time, in seconds
- * @param temChuva true when the active theme declares `chuva`
- * @param reduceDecor true when reduced-motion scene decor (rm.decor) is on
- * @returns target rain level: 0 (dry), 0.35 (garoa) or 1 (chuva)
- */
-export function rainLevelTarget(sec, temChuva, reduceDecor) {
-    if (!(sec >= 30 && !reduceDecor && temChuva))
-        return 0;
-    const c = (sec - 30) % 60;
-    return c < 5 ? 0.35 : c < 10 ? 1 : c < 15 ? 0.35 : 0;
-}
-/** Onde estamos DENTRO do ciclo de 60s, em segundos. 0 = a primeira gota; 59 = um segundo antes dela. */
-export function faseDoClima(sec) { return (((sec - 30) % 60) + 60) % 60; }
-/**
- * AGLOMERAÇÃO DAS NUVENS: 0 = espalhadas e altas, com o céu aparecendo entre elas; 1 = fechadas numa manta.
- *
- * O pedido do Dev foi de um MOVIMENTO, não de um estado: as nuvens se juntam, chove, elas se separam e o pôr
- * do sol aparece nas frestas. Quem faz isso ler como causa e não como coincidência é a ANTECEDÊNCIA — a manta
- * fecha OITO SEGUNDOS ANTES da primeira gota. Se fechasse junto, a chuva pareceria vir do nada e as nuvens
- * pareceriam reagir a ela; fechando antes, é a nuvem que traz a chuva, que é o que uma criança já sabe.
- *
- * Anda no MESMO ciclo da chuva (`faseDoClima`), e não num relógio próprio, porque dois relógios independentes
- * desandam um do outro — não de imediato, mas depois de alguns minutos, e aí ninguém liga o defeito à causa.
- * Devolve uma rampa contínua: não precisa de suavização depois.
- */
-export function aglomeracaoAlvo(sec, temChuva, reduceDecor) {
-    if (!(sec >= 22 && !reduceDecor && temChuva))
-        return 0; // 22s = exatamente a fase 52, onde a rampa começa
-    const f = faseDoClima(sec);
-    if (f >= 52)
-        return (f - 52) / 8; // 8s juntando, antes da primeira gota
-    if (f < 12)
-        return 1; // fechado durante a garoa e a chuva
-    if (f < 22)
-        return 1 - (f - 12) / 10; // 10s abrindo — é aqui que o pôr do sol reaparece
-    return 0;
-}
-/** Ramps `current` toward `target` by at most `step`, snapping to `target` once within 0.02 (no "quase seco" flicker). */
-export function rampRainLevel(current, target, step) {
-    let next = current + Math.max(-step, Math.min(step, target - current));
-    if (Math.abs(target - next) < 0.02)
-        next = target;
-    return next;
-}
-export function stepThunder(rainLevel, thunderCD, flash, rndFn, onThunder) {
-    if (rainLevel > 0.45) {
-        thunderCD--;
-        if (thunderCD <= 0) {
-            thunderCD = 200 + Math.floor(rndFn() * 420);
-            const inten = 0.35 + rndFn() * 0.65;
-            flash = Math.max(flash, inten);
-            onThunder(inten);
-        }
-    }
-    if (flash > 0)
-        flash = Math.max(0, flash - 0.05);
-    return { thunderCD, flash };
-}
-/** Seeds `n` rain drops at random positions across the WxH screen (lazy — built once on first rain). */
-export function makeRainDrops(n, W, H, rndFn) {
-    const drops = [];
-    for (let i = 0; i < n; i++)
-        drops.push({ x: rndFn() * W, y: rndFn() * H, len: 6 + rndFn() * 9, spd: 8 + rndFn() * 7 });
-    return drops;
-}
-/** Advances one drop by its own speed; wraps to the top (new random x) past H. GAG: drops freeze when `moving` is false (pause). */
-export function stepRainDrop(d, W, H, moving, rndFn) {
-    if (!moving)
-        return;
-    d.y += d.spd;
-    d.x -= d.spd * 0.35;
-    if (d.y > H) {
-        d.y = -d.len;
-        d.x = rndFn() * W;
-    }
-    if (d.x < 0)
-        d.x += W;
-}
-let _weatherLayer = null;
-let _stage = null;
-let _screen = null;
-let _getRm = null;
-let _thunder = null;
-let _temChuva = null;
-let _mundoRodando = () => true;
-let _rainLevel = 0, _weatherT = 0, _flash = 0, _thunderCD = 240, _aglomeracao = 0;
-let _rainDrops = null;
-export function initWeather(ctx) {
-    _weatherLayer = ctx.weatherLayer;
-    _stage = ctx.stage;
-    _screen = ctx.screen;
-    _getRm = ctx.getRm;
-    _thunder = ctx.thunder;
-    _temChuva = ctx.temChuva;
-    _mundoRodando = ctx.mundoRodando;
-}
-/** Per-frame clima update (game.js calls this only while `phase==='playing'`, same as before). */
-export function updateWeather() {
-    _weatherT++;
-    const sec = _weatherT / 60;
-    const rm = _getRm ? _getRm() : {};
-    const temChuva = _temChuva ? _temChuva() : false;
-    const target = rainLevelTarget(sec, temChuva, !!rm.decor);
-    _rainLevel = rampRainLevel(_rainLevel, target, 1 / 30); // rampa ~1s
-    _aglomeracao = aglomeracaoAlvo(sec, temChuva, !!rm.decor); // já é rampa: nada a suavizar aqui
-    const step = stepThunder(_rainLevel, _thunderCD, _flash, rnd, (inten) => { if (_thunder)
-        _thunder(inten); });
-    _thunderCD = step.thunderCD;
-    _flash = step.flash;
-}
-/** Redraws the rain/flash overlay (chuva/clarão em tela-espaço, sobre tudo). */
-export function drawWeather() {
-    if (!_weatherLayer)
-        return;
-    const g = _weatherLayer;
-    if (_stage && g.parent === _stage)
-        _stage.setChildIndex(g, _stage.children.length - 1); // mantido no topo em draw
-    g.clear();
-    const W = _screen ? _screen.width : 0, H = _screen ? _screen.height : 0;
-    if (_rainLevel <= 0 && _flash <= 0)
-        return;
-    if (_rainLevel > 0) {
-        g.beginFill(0x0a0e1a, _rainLevel * 0.34);
-        g.drawRect(0, 0, W, H);
-        g.endFill(); // céu mais escuro
-        if (!_rainDrops)
-            _rainDrops = makeRainDrops(110, W, H, rnd);
-        const mv = _mundoRodando(); // GAG: gotas congelam na pausa
-        g.lineStyle(1, 0xaebfe0, 0.5 * _rainLevel);
-        for (const d of _rainDrops) {
-            stepRainDrop(d, W, H, mv, rnd);
-            g.moveTo(d.x, d.y);
-            g.lineTo(d.x - 2, d.y + d.len);
-        }
-        g.lineStyle(0);
-    }
-    if (_flash > 0) {
-        g.beginFill(0xe4ecff, _flash * 0.55);
-        g.drawRect(0, 0, W, H);
-        g.endFill();
-    } // clarão do relâmpago
-}
-/** The clima→áudio bridge: platform/audio-ambient.ts reads this (never the raw value) so its rain track follows the visual. */
-export function getRainLevel() { return _rainLevel; }
-/** A ponte clima→céu: render/scene-sky lê isto para juntar e separar as nuvens no compasso da chuva. */
-export function getAglomeracao() { return _aglomeracao; }
-/** Weather-clock read/write — the game.js `window.__incl.weatherT` debug hook fast-forwards the cycle via this. */
-export function getWeatherT() { return _weatherT; }
-export function setWeatherT(v) { _weatherT = v; }