@the-inclusionist/engine 6.36.1

package/dist-pkg/render/recycling-tex.d.ts

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import type { PixelPainter } from './canvas.js';
+export type Material = 'papel' | 'plastico' | 'metal' | 'vidro';
+export type Lixeira = 'azul' | 'vermelha' | 'amarela' | 'verde';
+/** Latinha de alumínio 6×9 — corpo prateado, tampa e base mais escuras, brilho de uma coluna. */
+export declare const paintLatinha: PixelPainter;
+/** Garrafa PET 6×11 — gargalo estreito, tampa, corpo translúcido esverdeado. */
+export declare const paintGarrafaPet: PixelPainter;
+/** Pote de vidro 8×9 — boca larga, tampa metálica, corpo azulado transparente. */
+export declare const paintPoteDeVidro: PixelPainter;
+/** Caixa de papelão 10×9 — papelão liso, aba superior e fita no meio. */
+export declare const paintCaixaDePapelao: PixelPainter;
+/** Catálogo dos objetos: tamanho do canvas + pintor. As chaves são os `Material` de `game/recycling`. */
+export declare const LIXO_ART: Readonly<Record<Material, {
+    w: number;
+    h: number;
+    paint: PixelPainter;
+}>>;
+export declare const LIXEIRA_W = 12, LIXEIRA_H = 15;
+/** A cor de cada lixeira, na CONAMA 275/2001. Corpo e um tom escuro para tampa, aro e sombra. */
+export declare const COR_DA_LIXEIRA: Readonly<Record<Lixeira, {
+    corpo: string;
+    escuro: string;
+}>>;
+/**
+ * Uma lixeira 12×15 — corpo levemente cônico, tampa saliente, alça e o símbolo da reciclagem em três traços.
+ *
+ * ⚠️ O SÍMBOLO É CLARO SOBRE O CORPO, e não uma quinta cor: em alto contraste e nos filtros de daltonismo, o que
+ * distingue as quatro lixeiras é a cor do corpo, e um símbolo colorido competiria com ela. Claro sobre escuro
+ * sobrevive a qualquer um dos dezesseis modos de visão.
+ */
+export declare const paintLixeira: (cor: Lixeira) => PixelPainter;
+export declare const PLACA_W = 20, PLACA_H = 28;
+/**
+ * A placa 20×28: disco vermelho vazado, a pessoa jogando lixo em preto, a barra da proibição e o poste.
+ *
+ * Ela é o rosto de uma regra que o jogo NÃO pune (ver `game/recycling`): quem carrega lixo simplesmente não
+ * passa daqui. A placa existe para que a criança saiba POR QUE não passou — sem ela, a barreira seria um bug
+ * aos olhos de quem joga.
+ */
+export declare const paintPlaca: PixelPainter;
+export interface RecyclingTextures {
+    lixo: Record<Material, unknown>;
+    lixeira: Record<Lixeira, unknown>;
+    placa: unknown;
+}
+/** Assa tudo uma vez. Chamada pela raiz de composição no boot — nunca no import (ver o cabeçalho). */
+export declare function createRecyclingTextures(): RecyclingTextures;

package/dist-pkg/render/recycling-tex.js

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// render/recycling-tex — a ARTE PROCEDURAL do lixo reciclável e das quatro lixeiras.
+//
+// Mesma técnica de `render/city-tex` (retângulos carimbados por `pixelCanvas`), e por isso mesmo um módulo à
+// parte e não um bloco lá dentro: `city-tex` é a arte DA RUA — bichos, pedestres, carros —, e o seu cabeçalho
+// diz com todas as letras que "props é decoração de QUALQUER cenário" e fica fora. Lixo e lixeira aparecem em
+// qualquer tema, então seguem a regra que aquele arquivo escreveu para si.
+//
+// SEM I/O NO IMPORT, pelo mesmo motivo que lá: `makeCanvas` toca `document`, e um módulo de `render/` é
+// importado pelo project `node` do Vitest. Não há constante pronta aqui — há `createRecyclingTextures()`, que a
+// raiz de composição chama uma vez no boot.
+//
+// ========================= POR QUE PROCEDURAL, E NÃO PNG =========================
+// O pilar diz "arte = dados: nenhum PNG embutido no jogo" (ADR-0010/0018). Quatro objetos e quatro lixeiras em
+// PNG seriam oito arquivos a versionar, precachear e recolorir à mão em cada modo de visão. Como retângulos,
+// eles são LIDOS pelo alto contraste e pelos filtros de daltonismo como o resto do mundo, sem exceção e sem
+// arquivo `_hc` paralelo — que é a dívida que o atlas de sprites do personagem ainda carrega.
+//
+// ========================= AS CORES SÃO CONTEÚDO =========================
+// As lixeiras seguem a Resolução CONAMA 275/2001, que é o padrão da rua brasileira: AZUL papel, VERMELHA
+// plástico, AMARELA metal, VERDE vidro. A criança que aprende a cor aqui reconhece a de fora — trocar uma por
+// gosto ensina errado. O gate compara este arquivo com `game/recycling`, que é quem decide o acerto, para que
+// as duas listas não possam divergir em silêncio.
+import { pixelTexture } from './canvas.js';
+/* ===================== os quatro objetos ===================== */
+// Miúdos de propósito: ficam no chão, ao lado de moedas, num mundo de 320×180. Grandes demais viram obstáculo
+// visual; pequenos demais somem para quem tem baixa visão — a faixa útil aqui é 6 a 11 px de largura.
+/** Latinha de alumínio 6×9 — corpo prateado, tampa e base mais escuras, brilho de uma coluna. */
+export const paintLatinha = (px) => {
+    px(1, 1, 4, 7, '#b9c2cc'); // corpo
+    px(1, 0, 4, 1, '#8b949e'); // tampa
+    px(1, 8, 4, 1, '#8b949e'); // base
+    px(2, 2, 1, 5, '#e6ecf2'); // brilho
+    px(0, 2, 1, 5, '#8b949e'); // sombra do lado
+};
+/** Garrafa PET 6×11 — gargalo estreito, tampa, corpo translúcido esverdeado. */
+export const paintGarrafaPet = (px) => {
+    px(2, 0, 2, 1, '#2f6fd0'); // tampa azul
+    px(2, 1, 2, 2, '#bfe6d8'); // gargalo
+    px(1, 3, 4, 7, '#a8dcc9'); // corpo
+    px(2, 4, 1, 5, '#dcf3ea'); // brilho
+    px(1, 10, 4, 1, '#7fbfa8'); // base
+};
+/** Pote de vidro 8×9 — boca larga, tampa metálica, corpo azulado transparente. */
+export const paintPoteDeVidro = (px) => {
+    px(1, 0, 6, 1, '#8b949e'); // tampa
+    px(1, 1, 6, 1, '#6f7883'); // aro
+    px(1, 2, 6, 6, '#a9cfe0'); // corpo
+    px(2, 3, 1, 4, '#e2f2f8'); // brilho
+    px(1, 8, 6, 1, '#7fa8ba'); // base
+};
+/** Caixa de papelão 10×9 — papelão liso, aba superior e fita no meio. */
+export const paintCaixaDePapelao = (px) => {
+    px(0, 1, 10, 8, '#c39a63'); // corpo
+    px(0, 0, 10, 1, '#a37f4f'); // aba de cima
+    px(4, 0, 2, 9, '#d9bb90'); // fita vertical
+    px(0, 4, 10, 1, '#a37f4f'); // vinco
+};
+/** Catálogo dos objetos: tamanho do canvas + pintor. As chaves são os `Material` de `game/recycling`. */
+export const LIXO_ART = Object.freeze({
+    metal: { w: 6, h: 9, paint: paintLatinha },
+    plastico: { w: 6, h: 11, paint: paintGarrafaPet },
+    vidro: { w: 8, h: 9, paint: paintPoteDeVidro },
+    papel: { w: 10, h: 9, paint: paintCaixaDePapelao },
+});
+/* ===================== as quatro lixeiras ===================== */
+export const LIXEIRA_W = 12, LIXEIRA_H = 15;
+/** A cor de cada lixeira, na CONAMA 275/2001. Corpo e um tom escuro para tampa, aro e sombra. */
+export const COR_DA_LIXEIRA = Object.freeze({
+    azul: { corpo: '#2f6fd0', escuro: '#1e4a8c' },
+    vermelha: { corpo: '#c8372d', escuro: '#8d251e' },
+    amarela: { corpo: '#e0b423', escuro: '#a07d13' },
+    verde: { corpo: '#2f9e52', escuro: '#1d6b36' },
+});
+/**
+ * Uma lixeira 12×15 — corpo levemente cônico, tampa saliente, alça e o símbolo da reciclagem em três traços.
+ *
+ * ⚠️ O SÍMBOLO É CLARO SOBRE O CORPO, e não uma quinta cor: em alto contraste e nos filtros de daltonismo, o que
+ * distingue as quatro lixeiras é a cor do corpo, e um símbolo colorido competiria com ela. Claro sobre escuro
+ * sobrevive a qualquer um dos dezesseis modos de visão.
+ */
+export const paintLixeira = (cor) => (px) => {
+    const { corpo, escuro } = COR_DA_LIXEIRA[cor];
+    px(1, 3, 10, 11, corpo); // corpo
+    px(0, 1, 12, 2, escuro); // tampa
+    px(5, 0, 2, 1, escuro); // alça
+    px(1, 14, 10, 1, escuro); // base
+    px(2, 4, 1, 9, escuro); // vinco esquerdo
+    px(9, 4, 1, 9, escuro); // vinco direito
+    px(4, 6, 4, 1, '#f2f5f7'); // símbolo: traço de cima
+    px(4, 8, 4, 1, '#f2f5f7'); // símbolo: traço do meio
+    px(4, 10, 4, 1, '#f2f5f7'); // símbolo: traço de baixo
+};
+/* ===================== a placa de proibido jogar lixo =====================
+ *
+ * ⚠️ SEGUNDA VERSÃO, e a primeira era pequena demais para dizer o que dizia. Tinha 11×16 e resolvia o disco
+ * de proibição com quatro retângulos — na tela virava um quadradinho vermelho com um risco branco, que a
+ * criança lê como "algum objeto", não como "aqui não". O Dev mandou a referência da placa de verdade (o
+ * pictograma da pessoa jogando lixo dentro do círculo cortado) e pediu: "a placa deveria ser grande, com o
+ * símbolo identificável da pessoa jogando coisas e o sinal de proibido."
+ *
+ * Agora são 20×28: prancha de 20×20 e poste de 8. O círculo vem de TABELA DE LINHAS, como a roda do carro —
+ * é o mesmo problema, e pela mesma razão: numa arte de retângulos, o que o olho já sabe que é redondo
+ * denuncia o desenho inteiro se sair quadrado.
+ *
+ * ⚠️ E A LEITURA É EM TRÊS CAMADAS, na ordem em que a criança precisa delas: a prancha clara separa a placa
+ * do fundo; o pictograma PRETO sobre claro é o contraste mais alto que existe e sobrevive aos dezesseis
+ * modos de visão; a barra vermelha vem por último, por cima de tudo, porque é ela que transforma "uma pessoa
+ * jogando lixo" em "não jogue lixo". Trocar essa ordem inverte o sentido do desenho. */
+export const PLACA_W = 20, PLACA_H = 28;
+/** Disco Ø18: `[recuo, largura]` por linha. Mesma técnica da roda do carro. */
+const DISCO = [
+    [6, 6], [4, 10], [3, 12], [2, 14], [1, 16], [1, 16], [0, 18], [0, 18], [0, 18],
+    [0, 18], [0, 18], [0, 18], [1, 16], [1, 16], [2, 14], [3, 12], [4, 10], [6, 6],
+];
+/** Miolo Ø14, no mesmo formato — abre o vazio claro dentro do aro vermelho. */
+const MIOLO = [
+    [5, 4], [3, 8], [2, 10], [1, 12], [1, 12], [0, 14], [0, 14],
+    [0, 14], [0, 14], [1, 12], [1, 12], [2, 10], [3, 8], [5, 4],
+];
+const VERMELHO = '#d42a1e', CLARO = '#f2f5f7', PRETO = '#1a1d24', POSTE = '#6f7883';
+/**
+ * A placa 20×28: disco vermelho vazado, a pessoa jogando lixo em preto, a barra da proibição e o poste.
+ *
+ * Ela é o rosto de uma regra que o jogo NÃO pune (ver `game/recycling`): quem carrega lixo simplesmente não
+ * passa daqui. A placa existe para que a criança saiba POR QUE não passou — sem ela, a barreira seria um bug
+ * aos olhos de quem joga.
+ */
+export const paintPlaca = (px) => {
+    px(1, 0, 18, 20, CLARO); // prancha
+    px(0, 0, 20, 1, PRETO);
+    px(0, 19, 20, 1, PRETO); // moldura: topo e base
+    px(0, 1, 1, 18, PRETO);
+    px(19, 1, 1, 18, PRETO); // moldura: laterais
+    DISCO.forEach(([dx, w], i) => px(1 + dx, 1 + i, w, 1, VERMELHO));
+    MIOLO.forEach(([dx, w], i) => px(3 + dx, 3 + i, w, 1, CLARO));
+    // O pictograma, dentro do miolo (x 3..16, y 3..16): cabeça, tronco, braço estendido e as pernas.
+    px(7, 5, 3, 3, PRETO); // cabeça
+    px(7, 8, 3, 5, PRETO); // tronco
+    px(10, 9, 3, 1, PRETO); // braço que joga
+    px(7, 13, 1, 3, PRETO);
+    px(9, 13, 1, 3, PRETO); // pernas
+    px(13, 11, 1, 1, PRETO);
+    px(14, 13, 1, 1, PRETO);
+    px(12, 14, 1, 1, PRETO); // o lixo caindo
+    // A barra da proibição POR ÚLTIMO: é ela que faz o desenho dizer "não".
+    for (let k = 0; k < 12; k++)
+        px(4 + k, 4 + k, 3, 2, VERMELHO);
+    px(9, 20, 2, 7, POSTE);
+    px(7, 27, 6, 1, POSTE); // poste e pé
+};
+/** Assa tudo uma vez. Chamada pela raiz de composição no boot — nunca no import (ver o cabeçalho). */
+export function createRecyclingTextures() {
+    const lixo = {};
+    for (const m of Object.keys(LIXO_ART)) {
+        const a = LIXO_ART[m];
+        lixo[m] = pixelTexture(a.w, a.h, a.paint);
+    }
+    const lixeira = {};
+    for (const c of Object.keys(COR_DA_LIXEIRA)) {
+        lixeira[c] = pixelTexture(LIXEIRA_W, LIXEIRA_H, paintLixeira(c));
+    }
+    return { lixo, lixeira, placa: pixelTexture(PLACA_W, PLACA_H, paintPlaca) };
+}

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

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import type { Desenho, Visivel } from './port.js';
+type Gfx = Desenho & Visivel;
+type VisibleLayer = Visivel;
+interface DarkRegion {
+    set: Set<string>;
+}
+interface Pl {
+    x: number;
+    y: number;
+    quit?: boolean;
+}
+export interface SceneCityCtx {
+    cityDecoG: Gfx;
+    abandonG: Gfx;
+    lavaFxG: Gfx;
+    waterFxG: Gfx;
+    skyLayer: VisibleLayer;
+    darkRegions: DarkRegion[];
+    solidAt: (x: number, y: number) => boolean;
+    tileAt: (x: number, y: number) => number;
+    lifeSurfaceAt: (tx: number) => number;
+    WORLD_W: number;
+    WORLD_H: number;
+    TILE: number;
+    WORLD_PX_W: number;
+    WORLD_PX_H: number;
+    LOGICAL_W: number;
+    LOGICAL_H: number;
+    BOX: {
+        h: number;
+    };
+    DIRECT_CFG: Record<string, unknown>;
+    getCenario: () => string;
+    getVizMode: () => string;
+    getPlayers: () => Pl[];
+    getFxClock: () => number;
+    getRm: () => {
+        decor?: boolean;
+    };
+    onCenarioChange?: (city: boolean) => void;
+}
+export interface SceneCity {
+    buildCityDeco: () => void;
+    applyCenarioVida: () => void;
+    stepTileFx: () => void;
+}
+/** Coluna com poste de luz na fachada (a cada 11 tiles). */
+export declare function isStreetlampColumn(tx: number): boolean;
+/** Coluna com letreiro na fachada (a cada 9 tiles, exige parede 3 tiles acima — checado pelo chamador). */
+export declare function isSignageColumn(tx: number): boolean;
+export declare const SIGNAGE_COLORS: readonly [3656096, 16747610, 6598911, 16765503];
+/** Cor do letreiro daquela coluna (4 variações, cíclicas por tx). */
+export declare function signageColor(tx: number): number;
+/** Tipo de decoração da célula abandonada (entulho/viga/pichação/vazio) — hash determinístico em tx,ty. */
+export declare function abandonedDecorKind(tx: number, ty: number): number;
+export declare const GRAFFITI_COLORS: readonly [13193174, 5232250, 14076239];
+/** Cor da pichação daquela coluna (3 variações, cíclicas por tx). */
+export declare function graffitiColor(tx: number): number;
+/** Deriva horizontal (0..3) dos tracinhos de lava — avança 1 tile a cada 8 ticks do fxClock. */
+export declare function lavaStreakOffset(fxClock: number, worldX: number): number;
+/** Hash determinístico por coluna, usado p/ escolher o "leito" da água (coral/algas/vazio). */
+export declare function waterBedHash(tx: number): number;
+/** Tipo de leito da coluna: 0=coral, 1=algas, 2=vazio. */
+export declare function waterBedKind(tx: number): number;
+export declare const CORAL_COLORS: readonly [15234107, 15909198, 9187129];
+/** Cor do coral daquela coluna (3 variações, derivadas do mesmo hash do leito). */
+export declare function coralColor(tx: number): number;
+/** Hash determinístico por célula, usado p/ decidir se há peixe nadando ali (água aberta). */
+export declare function fishHash(tx: number, ty: number): number;
+/** ~1/7 das células de água aberta recebe um peixe. */
+export declare function fishSpawnsAt(tx: number, ty: number): boolean;
+export declare const FISH_COLORS: readonly [15026253, 3829413, 4763754];
+/** Cor do peixe daquela célula (3 variações, derivadas do hash de peixe). */
+export declare function fishColor(tx: number, ty: number): number;
+export declare function initSceneCity(ctx: SceneCityCtx): SceneCity;
+export {};

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

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// render/scene-city — city scenario decoration: sidewalk/streetlamp/signage facade band, water-tank walls,
+// abandoned-interior clutter (darkRegions, drawn under the darkness layer), and the live water/lava tile fx
+// (waves/coral/algae/fish, lava streaks). Extracted from game.js. The layers (cityDecoG/abandonG/lavaFxG/
+// waterFxG/skyLayer) are CREATED in game.js — z-order stays soldered there — and INJECTED here; we move only
+// the LOGIC. Formulas copied verbatim. `applyCenarioVida` is the thin scenario-toggle orchestrator: it flips
+// only this module's own layers and calls an injected hook so the coordinator can wire game/life and
+// game/traffic's own scenario reactions (see the module boundary note in the extraction report).
+// ---- Seleção de tile/decoração por posição (lógica pura, determinística — hash em tx/ty, sem PIXI) ----
+/** Coluna com poste de luz na fachada (a cada 11 tiles). */
+export function isStreetlampColumn(tx) { return tx % 11 === 4; }
+/** Coluna com letreiro na fachada (a cada 9 tiles, exige parede 3 tiles acima — checado pelo chamador). */
+export function isSignageColumn(tx) { return tx % 9 === 2; }
+export const SIGNAGE_COLORS = [0x37c9a0, 0xff8c5a, 0x64b0ff, 0xffd23f];
+/** Cor do letreiro daquela coluna (4 variações, cíclicas por tx). */
+export function signageColor(tx) { return SIGNAGE_COLORS[tx % 4]; }
+/** Tipo de decoração da célula abandonada (entulho/viga/pichação/vazio) — hash determinístico em tx,ty. */
+export function abandonedDecorKind(tx, ty) { return (tx * 13 + ty * 7) % 10; }
+export const GRAFFITI_COLORS = [0xc94fd6, 0x4fd67a, 0xd6c94f];
+/** Cor da pichação daquela coluna (3 variações, cíclicas por tx). */
+export function graffitiColor(tx) { return GRAFFITI_COLORS[tx % 3]; }
+/** Deriva horizontal (0..3) dos tracinhos de lava — avança 1 tile a cada 8 ticks do fxClock. */
+export function lavaStreakOffset(fxClock, worldX) { return (Math.floor(fxClock / 8) + worldX) % 4; }
+/** Hash determinístico por coluna, usado p/ escolher o "leito" da água (coral/algas/vazio). */
+export function waterBedHash(tx) { return (tx * 2654435761) >>> 0; }
+/** Tipo de leito da coluna: 0=coral, 1=algas, 2=vazio. */
+export function waterBedKind(tx) { return waterBedHash(tx) % 3; }
+export const CORAL_COLORS = [0xe8743b, 0xf2c14e, 0x8c2f39];
+/** Cor do coral daquela coluna (3 variações, derivadas do mesmo hash do leito). */
+export function coralColor(tx) { return CORAL_COLORS[(waterBedHash(tx) >>> 3) % 3]; }
+/** Hash determinístico por célula, usado p/ decidir se há peixe nadando ali (água aberta). */
+export function fishHash(tx, ty) { return (tx * 40503 + ty * 12289) >>> 0; }
+/** ~1/7 das células de água aberta recebe um peixe. */
+export function fishSpawnsAt(tx, ty) { return fishHash(tx, ty) % 7 === 0; }
+export const FISH_COLORS = [0xe5484d, 0x3a6ea5, 0x48b06a];
+/** Cor do peixe daquela célula (3 variações, derivadas do hash de peixe). */
+export function fishColor(tx, ty) { return FISH_COLORS[fishHash(tx, ty) % 3]; }
+export function initSceneCity(ctx) {
+    // buildCityDeco v3: desenhado UMA vez (mapa é estático) — calçada+postes+letreiros na fachada mais baixa,
+    // paredes/linha d'água da caixa d'água (bounding box dos tiles de água, tipo 3), e entulho/viga/pichação
+    // sob a escuridão das áreas secretas (abandonG, camada abaixo de darkLayer no game.js).
+    function buildCityDeco() {
+        const g = ctx.cityDecoG;
+        g.clear();
+        const a = ctx.abandonG;
+        a.clear();
+        const TILE = ctx.TILE;
+        // ---- FACHADA (banda mais baixa, por onde o personagem anda): calçada + postes + letreiros.
+        // Placas de PARE ficam na rua da frente (game/traffic), junto dos carros.
+        const BASE_TY = ctx.WORLD_H - 9;
+        for (let tx = 1; tx < ctx.WORLD_W - 1; tx++) {
+            const ty = ctx.lifeSurfaceAt(tx);
+            if (ty < BASE_TY)
+                continue;
+            const X = tx * TILE, y = ty * TILE;
+            g.beginFill(0x9aa0ad, 0.9).drawRect(X, y, TILE, 2).endFill(); // calçada clara
+            g.beginFill(0x565e70, 1).drawRect(X, y + 2, TILE, 1).endFill(); // meio-fio
+            if (isStreetlampColumn(tx)) {
+                g.beginFill(0x3a4152).drawRect(X + 7, y - 30, 2, 30).endFill();
+                g.beginFill(0x3a4152).drawRect(X + 7, y - 30, 8, 2).endFill(); // poste + braço
+                g.beginFill(0xffe9a8, 1).drawRect(X + 13, y - 29, 3, 3).endFill();
+                g.beginFill(0xffe9a8, 0.18).drawRect(X + 9, y - 31, 11, 8).endFill(); // lâmpada + halo FIXO (sem piscar)
+            }
+            if (isSignageColumn(tx) && ctx.solidAt(tx, ty - 3)) {
+                const c = signageColor(tx); // letreiro na fachada
+                g.beginFill(0x141824).drawRect(X + 2, y - 3.5 * TILE, 12, 6).endFill();
+                g.beginFill(c, 1).drawRect(X + 3, y - 3.5 * TILE + 1, 10, 4).endFill();
+                g.beginFill(c, 0.15).drawRect(X, y - 3.5 * TILE - 2, 16, 10).endFill(); // brilho estável
+            }
+        }
+        // ---- CAIXA D'ÁGUA: paredes metálicas nas bordas do corpo d'água (tile 3) + linha d'água no topo
+        let wx0 = 1e9, wx1 = -1, wy0 = 1e9, wy1 = -1;
+        for (let ty = 0; ty < ctx.WORLD_H; ty++)
+            for (let tx = 0; tx < ctx.WORLD_W; tx++) {
+                if (ctx.tileAt(tx, ty) === 3) {
+                    wx0 = Math.min(wx0, tx);
+                    wx1 = Math.max(wx1, tx);
+                    wy0 = Math.min(wy0, ty);
+                    wy1 = Math.max(wy1, ty);
+                }
+            }
+        if (wx1 >= 0) {
+            const X0 = wx0 * TILE, X1 = (wx1 + 1) * TILE, Y0 = wy0 * TILE, Y1 = (wy1 + 1) * TILE;
+            g.beginFill(0x6a7486, 0.85).drawRect(X0 - 3, Y0 - 6, 3, Y1 - Y0 + 6).drawRect(X1, Y0 - 6, 3, Y1 - Y0 + 6).endFill(); // paredes do tanque
+            for (let ry = Y0; ry < Y1; ry += 12) {
+                g.beginFill(0x49515f).drawRect(X0 - 3, ry, 3, 2).drawRect(X1, ry, 3, 2).endFill();
+            } // rebites
+            g.beginFill(0xbfe6ff, 0.5).drawRect(X0, Y0, X1 - X0, 1.5).endFill(); // linha d'água
+        }
+        // ---- ABANDONADO (darkRegions): entulho, viga e pichação — desenhado sob a escuridão
+        for (const reg of ctx.darkRegions) {
+            for (const key of reg.set) {
+                const [tx, ty] = key.split(',').map(Number);
+                const X = tx * TILE, Y = ty * TILE, h = abandonedDecorKind(tx, ty);
+                if (ctx.solidAt(tx, ty + 1) && h < 3) {
+                    a.beginFill(0x555b66).drawRect(X + 2, Y + TILE - 5, 7, 5).endFill();
+                    a.beginFill(0x434955).drawRect(X + 7, Y + TILE - 3, 6, 3).endFill();
+                } // entulho
+                else if (h === 4) {
+                    a.beginFill(0x6b4e2e, 0.9).drawRect(X, Y + 3, TILE, 3).endFill();
+                } // viga exposta
+                else if (h === 7) {
+                    const c = graffitiColor(tx);
+                    a.beginFill(c, 0.55).drawRect(X + 3, Y + 6, 9, 2).drawRect(X + 5, Y + 9, 6, 2).endFill();
+                } // pichação
+            }
+        }
+    }
+    // applyCenarioVida: orquestrador FINO do troca-de-cenário. Só liga/desliga as camadas que este módulo possui
+    // (deco da cidade + o céu procedural da cidade); trânsito (carLayer + cars) e vida (criaturas) são de outros
+    // dois módulos e reagem via onCenarioChange — nunca tocados diretamente daqui.
+    function applyCenarioVida() {
+        const city = ctx.getCenario() === 'cidade';
+        ctx.cityDecoG.visible = city;
+        ctx.skyLayer.visible = city; // deco/céu da cidade SÓ na Cidade
+        ctx.onCenarioChange?.(city);
+    }
+    // stepTileFx v3: água (ondas de superfície + leito coral/algas + peixes esparsos) e lava (tracinhos claros à
+    // deriva) — só perto de cada jogador (câmera), com dedupe por célula entre jogadores em tela dividida.
+    function stepTileFx() {
+        ctx.lavaFxG.clear();
+        ctx.waterFxG.clear();
+        if (ctx.DIRECT_CFG[ctx.getVizMode()] || ctx.getRm().decor)
+            return; // HC repinta o mundo; viewDecor off na v3 = só a base estática
+        const TILE = ctx.TILE, t = ctx.getFxClock(), seen = new Set();
+        for (const pl of ctx.getPlayers()) {
+            if (pl.quit)
+                continue;
+            const camX = Math.max(0, Math.min(pl.x - ctx.LOGICAL_W / 2, ctx.WORLD_PX_W - ctx.LOGICAL_W));
+            const camY = Math.max(0, Math.min((pl.y - ctx.BOX.h / 2) - ctx.LOGICAL_H / 2, ctx.WORLD_PX_H - ctx.LOGICAL_H));
+            const tx0 = Math.max(0, Math.floor(camX / TILE) - 1), tx1 = Math.min(ctx.WORLD_W - 1, Math.floor((camX + ctx.LOGICAL_W) / TILE) + 1);
+            const ty0 = Math.max(0, Math.floor(camY / TILE) - 1), ty1 = Math.min(ctx.WORLD_H - 1, Math.floor((camY + ctx.LOGICAL_H) / TILE) + 1);
+            for (let ty = ty0; ty <= ty1; ty++)
+                for (let tx = tx0; tx <= tx1; tx++) {
+                    const tt = ctx.tileAt(tx, ty);
+                    if (tt !== 3 && tt !== 9)
+                        continue; // só água(3)/lava(9)
+                    const k = tx + ',' + ty;
+                    if (seen.has(k))
+                        continue;
+                    seen.add(k);
+                    const X = tx * TILE, Y = ty * TILE;
+                    if (tt === 9) {
+                        const off = lavaStreakOffset(t, X); // lava v3: tracinhos claros que derivam
+                        ctx.lavaFxG.beginFill(0xff7755).drawRect(X + off, Y + 3, 3, 1).drawRect(X + ((off + 6) % TILE), Y + 8, 3, 1).endFill();
+                        continue;
+                    }
+                    // ÁGUA v3: ondulação verde sutil que deriva
+                    ctx.waterFxG.beginFill(0x46a078, 0.12).drawRect(X, Y + 7 + Math.round(2 * Math.sin(tx * 1.3 + t * 0.04)), TILE, 2).endFill();
+                    if (ctx.tileAt(tx, ty - 1) !== 3) {
+                        const off = Math.sin(t * 0.05 + X * 0.1) > 0 ? 1 : 0; // linha de superfície SÓ na borda de cima
+                        ctx.waterFxG.beginFill(0xffffff, 0.35).drawRect(X + off, Y + 1, TILE - off, 1).endFill();
+                    }
+                    if (ctx.solidAt(tx, ty + 1)) {
+                        const kind = waterBedKind(tx); // leito: coral / algas (determinísticos por coluna)
+                        if (kind === 0) {
+                            ctx.waterFxG.beginFill(coralColor(tx))
+                                .drawRect(X + 6, Y + 9, 2, 7).drawRect(X + 4, Y + 10, 2, 4).drawRect(X + 9, Y + 8, 2, 5).drawRect(X + 3, Y + 12, 1, 2).drawRect(X + 11, Y + 11, 1, 2).endFill();
+                        }
+                        else if (kind === 1) {
+                            ctx.waterFxG.beginFill(0x3fae6a);
+                            const sway = 2 * Math.sin(t * 0.06 + tx); // algas balançando
+                            for (let a2 = 0; a2 < 9; a2++) {
+                                ctx.waterFxG.drawRect(X + 7 + Math.round(sway * (a2 / 9)), Y + 15 - a2, 1, 1);
+                                if (a2 % 2 === 0)
+                                    ctx.waterFxG.drawRect(X + 9 + Math.round(sway * (a2 / 9)), Y + 15 - a2, 1, 1);
+                            }
+                            ctx.waterFxG.endFill();
+                        }
+                    }
+                    else if (fishSpawnsAt(tx, ty)) { // água aberta: peixinho esparso nadando (com olho!)
+                        const fx2 = X + 6 + Math.round(5 * Math.sin(t * 0.04 + tx + ty)), fy2 = Y + 7 + Math.round(2 * Math.sin(t * 0.07 + ty));
+                        const dir = Math.cos(t * 0.04 + tx + ty) >= 0 ? 1 : -1;
+                        ctx.waterFxG.beginFill(fishColor(tx, ty)).drawRect(fx2, fy2, 3, 2).drawRect(fx2 - dir, fy2, 1, 2).endFill();
+                        ctx.waterFxG.beginFill(0xffffff, 1).drawRect(fx2 + (dir > 0 ? 2 : 0), fy2, 1, 1).endFill();
+                    }
+                }
+        }
+    }
+    return { buildCityDeco, applyCenarioVida, stepTileFx };
+}

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

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import type { CenarioTema, TemaMorros, TemaPredios, FaixaDePredios } from './cenario-data.js';
+/** Um sol baixo com leque de raios, assado na textura do céu. Ver `pintarSol`. */
+export interface Sol {
+    cor: string;
+    x: number;
+    y: number;
+}
+/** Hill silhouette height at column `x` (v3 drawHillBand: double sine). `near` = the front (taller) band. */
+export declare function hillHeight(x: number, near: boolean): number;
+/** City placeholder backdrop (the 4 v3 themes have their own sky/hills below). */
+export declare function parallaxPlaceholder(i: number): unknown;
+/** Largura da textura do céu. 64 basta para um gradiente (ele é constante em x); um SOL precisa da tela toda. */
+export declare function larguraDoCeu(T: CenarioTema): number;
+/**
+ * Onde cada cor do céu cai, em PIXELS de altura. Separado do desenho porque é a parte que se pode AFERIR: o
+ * desenho precisa de um canvas, esta conta não, e é ela que decide se o vermelho do pôr do sol vai parar na
+ * linha do horizonte ou atrás dos morros.
+ */
+export declare function paradasDoCeu(cores: readonly string[], h?: number): {
+    y: number;
+    cor: string;
+}[];
+/**
+ * Sol baixo e leque de raios, DENTRO da textura do céu (e não numa camada própria).
+ *
+ * Aqui e não em `render/scene-sky` de propósito: o sol pertence ao FUNDO mais distante, e é na textura do céu
+ * que ele herda de graça as duas coisas que o fazem parecer distante — a rolagem de fator 0,10 (ele quase não
+ * anda) e o recolor de alto contraste (viz-setters repinta a textura crua; um sol desenhado por fora ficaria
+ * de fora do recolor e brilharia em amarelo no modo de contraste, que é exatamente o que a opção existe para
+ * eliminar).
+ *
+ * O leque aponta para CIMA, com abertura de ±35°, e cada raio desbota até zero por um gradiente radial. As
+ * duas coisas juntas mantêm o desenho longe das bordas da textura: um raio cortado na borda reapareceria do
+ * outro lado a cada repetição do azulejo, e essa emenda é o defeito mais visível que um céu pode ter.
+ */
+export declare function pintarSol(c: CanvasRenderingContext2D, w: number, h: number, sol: Sol): void;
+/** Theme sky: vertical gradient over `T.sky` (evenly spaced stops), plus the theme's sun when it has one. */
+export declare function themeSkyTexture(T: CenarioTema): unknown;
+/** Ruído reprodutível em [0,1) a partir de um inteiro. Substitui `Math.random` onde a arte precisa variar. */
+export declare function hash01(n: number): number;
+/** Desenha UM elemento de silhueta. `topo` é a linha do morro naquele x; tudo cresce para cima a partir dela. */
+type Elemento = (c: CanvasRenderingContext2D, x: number, topo: number, alt: number) => void;
+interface Silhueta {
+    el: Elemento;
+    passo: number;
+    alt: [number, number];
+}
+export declare const SILHUETAS: Readonly<Record<string, {
+    far?: Silhueta;
+    near?: Silhueta;
+}>>;
+/**
+ * Uma camada inteira: a banda do FUNDO (tom claro, mais alta, mais simples) e a da FRENTE por cima.
+ *
+ * As duas profundidades são o que o original tem e a primeira versão não tinha — sem elas a camada é uma
+ * fileira só, e a cidade perde o ar de cidade.
+ *
+ * Exportada para o teste: o contexto entra por parâmetro, como em `pintarSol`, e um contexto falso que grava
+ * os `fillRect` deixa afirmar as propriedades da faixa sem navegador nenhum.
+ */
+export declare function desenharPredios(c: CanvasRenderingContext2D, w: number, h: number, faixa: FaixaDePredios, semente: number): void;
+/**
+ * Camada 0 da Cidade: o céu inteiro E os prédios distantes assados nele.
+ *
+ * É a única camada OPACA das três, e é assim no original — o `c4.png` não tinha transparência nenhuma.
+ */
+export declare function themeCitySkyTexture(T: TemaPredios): unknown;
+/** Camadas 1 e 2 da Cidade: prédios sobre TRANSPARÊNCIA, para o céu da camada 0 aparecer atrás. */
+export declare function themeSkylineTexture(faixa: FaixaDePredios, semente: number): unknown;
+export declare function themeHillsTexture(T: TemaMorros, near: boolean, tema?: string): unknown;
+export {};