@the-inclusionist/engine 6.36.1

package/dist-pkg/render/viz-modes.js

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+export const VIZ_MODES = [
+    { key: 'normal', kind: 'normal', nome: 'viz.normal', desc: 'viz.desc.normal' },
+    { key: 'hc-direto', kind: 'hcnew', nome: 'viz.hc-direto', desc: 'viz.desc.hc-direto' },
+    { key: 'hc-direto-45', kind: 'hcnew', nome: 'viz.hc-direto-45', desc: 'viz.desc.hc-direto-45' },
+    { key: 'hc-direto-7', kind: 'hcnew', nome: 'viz.hc-direto-7', desc: 'viz.desc.hc-direto-7' },
+    { key: 'sim-deuter', sim: true, kind: 'filter', nome: 'viz.sim-deuter', desc: 'viz.desc.sim-deuter' },
+    { key: 'sim-protan', sim: true, kind: 'filter', nome: 'viz.sim-protan', desc: 'viz.desc.sim-protan' },
+    { key: 'sim-tritan', sim: true, kind: 'filter', nome: 'viz.sim-tritan', desc: 'viz.desc.sim-tritan' },
+    { key: 'fix-protan', kind: 'filter', nome: 'viz.fix-protan', desc: 'viz.desc.fix-protan' },
+    { key: 'fix-deuter', kind: 'filter', nome: 'viz.fix-deuter', desc: 'viz.desc.fix-deuter' },
+    { key: 'fix-tritan', kind: 'filter', nome: 'viz.fix-tritan', desc: 'viz.desc.fix-tritan' },
+    { key: 'lv-blur', sim: true, kind: 'lowvision', lv: 'blur', nome: 'viz.lv-blur', desc: 'viz.desc.lv-blur' },
+    { key: 'lv-haze', sim: true, kind: 'lowvision', lv: 'haze', nome: 'viz.lv-haze', desc: 'viz.desc.lv-haze' },
+    { key: 'lv-tunnel', sim: true, kind: 'lowvision', lv: 'tunnel', nome: 'viz.lv-tunnel', desc: 'viz.desc.lv-tunnel' },
+    { key: 'lv-macular', sim: true, kind: 'lowvision', lv: 'macular', nome: 'viz.lv-macular', desc: 'viz.desc.lv-macular' },
+    { key: 'lv-diabetic', sim: true, kind: 'lowvision', lv: 'diabetic', nome: 'viz.lv-diabetic', desc: 'viz.desc.lv-diabetic' },
+    { key: 'blind', sim: true, kind: 'blind', nome: 'viz.blind', desc: 'viz.desc.blind' },
+];
+export const VIZ_BY_KEY = Object.fromEntries(VIZ_MODES.map((m) => [m.key, m]));
+export const VIZ_FILTER = { 'sim-deuter': 'url(#cvd-deuter)', 'sim-protan': 'url(#cvd-protan)', 'sim-tritan': 'url(#cvd-tritan)',
+    'fix-protan': 'url(#cvd-fix-protan)', 'fix-deuter': 'url(#cvd-fix-deuter)', 'fix-tritan': 'url(#cvd-fix-tritan)',
+    'lv-blur': 'blur(2.4px)', 'lv-haze': 'contrast(.58) brightness(1.14) blur(.6px)', 'lv-tunnel': 'blur(.5px)', 'lv-macular': '', 'lv-diabetic': 'blur(.8px)', 'blind': 'brightness(0)' };
+export const VIZ_CYCLE = VIZ_MODES.map((m) => m.key);
+/**
+ * Este modo simula uma deficiência? Chave desconhecida (ou vazia) → false, porque a pergunta que o chamador
+ * está fazendo é "posso desligar isto sem tirar nada de ninguém?", e a resposta honesta diante do
+ * desconhecido é não.
+ */
+export function simulatesDisability(key) {
+    return VIZ_BY_KEY[key]?.sim === true;
+}
+/**
+ * As CORREÇÕES de daltonismo: daltonizam a tela para quem TEM a condição. Derivadas do catálogo, nunca
+ * listadas à mão — são exatamente os filtros que não simulam.
+ *
+ * Existem como lista própria porque moram no menu de ACESSIBILIDADE VISUAL, e não no de empatia (decisão do
+ * Dev, issue #60). Ficaram anos no menu errado por um motivo que este arquivo agora conserta: `kind` não
+ * distinguia simular de corrigir, então o painel de empatia, que se recorta por `kind:'filter'`, arrastava as
+ * três junto. Dois públicos opostos na mesma lista — quem quer sentir como é ser daltônico e quem é.
+ */
+export const VIZ_CORRECTIONS = VIZ_MODES.filter((m) => m.kind === 'filter' && !m.sim);
+/* ===================== AS DUAS PILHAS COM UM NOME SÓ (achado 8, item 19) ===================== */
+//
+// O segundo consumidor mediu, e a medição é o motivo desta seção existir:
+//
+//     "O ALTO CONTRASTE NÃO VIAJA, e a razão é estrutural, não um defeito. Os modos `hcnew` REPINTAM
+//      TEXTURAS de tile na PIXI; um quiz não tem tiles, e não há o que repintar. Ou seja: o que o menu chama
+//      de 'acessibilidade visual' são DUAS pilhas com um nome só — uma de DOM/CSS (filtros de daltonismo,
+//      tipografia, caixa alta) que serve a qualquer jogo; uma de CANVAS (renderização direta, contornos,
+//      cores de papel) que só existe onde há mundo. O painel as apresenta numa lista única de 7 modos… A
+//      divisão do passo 5 precisa cortar AQUI."
+//
+// Este é o corte, e ele é de DADO e não de arquivo — os arquivos já estavam separados (`render/cvd-matrices`
+// é DOM puro; `render/high-contrast` importa `core/collision.tileAt`). O que faltava era a tabela DIZER a
+// qual pilha cada modo pertence, para que ninguém mais reconstruísse a resposta de cabeça.
+//
+// E era reconstruída: o segundo consumidor escrevia
+//     `VIZ_MODES.filter((m) => m.kind === 'normal' || (m.kind === 'filter' && !simulatesDisability(m.key)))`
+// — uma expressão que mistura DUAS perguntas diferentes ("precisa de canvas?" e "isto simula deficiência?")
+// e que todo consumidor futuro teria de reinventar, com a chance de acertar uma e errar a outra.
+/** Este modo precisa de um CANVAS de mundo para existir? Só os `hcnew` precisam: eles repintam texturas. */
+export function needsCanvas(key) {
+    return VIZ_BY_KEY[key]?.kind === 'hcnew';
+}
+/**
+ * Os modos que funcionam em QUALQUER jogo — os que se aplicam como filtro de CSS sobre um elemento.
+ *
+ * Derivada, nunca listada à mão: um modo novo entra na pilha certa por causa do `kind` que ele declara, e não
+ * porque alguém lembrou de acrescentá-lo aqui. É a mesma regra de `VIZ_CORRECTIONS`.
+ */
+export const VIZ_DOM_ONLY = VIZ_MODES.filter((m) => !needsCanvas(m.key));
+/** Os modos que EXIGEM mundo. Complemento exato de `VIZ_DOM_ONLY` — juntos, os 16, sem sobra nem repetição. */
+export const VIZ_CANVAS_ONLY = VIZ_MODES.filter((m) => needsCanvas(m.key));

package/dist-pkg/render/viz-setters.d.ts

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import { type VizMode } from './viz-modes.js';
+import type { DomQuery } from '../core/dom-query.js';
+import type { ComFiltro, ComTextura, Visivel, DesenhoComCirculo, AplicarFiltroCss, AlcanceDoFiltro, AplicarAltoContrasteNoDom } from './port.js';
+/**
+ * Até onde o filtro deste modo vai. MELHORIA alcança os menus; EMPATIA fica no mundo (ver `AlcanceDoFiltro`).
+ * Derivado de `sim`, do catálogo — a mesma flag que já distingue os dois, e não uma segunda lista para
+ * alguém esquecer de atualizar.
+ */
+export declare function alcanceDoModo(mode: string): AlcanceDoFiltro;
+/** Modo por chave, com o fallback do original: chave desconhecida (ou nula) CAI em `normal`. */
+export declare function resolveViz(key: string | null | undefined): VizMode;
+/** É um dos três níveis de Renderização Direta (alto contraste)? Mesmo teste do original: `!!DIRECT_CFG[mode]`. */
+export declare function isDirectMode(mode: string): boolean;
+/** Filtro CSS da canvas no SOLO: simulação/correção de visão + realce L→Q, compostos e sem vazios. */
+export declare function cssFilterFor(mode: string, lq: string): string;
+/** Bolinha indicadora de um viewport: só cegueira (branca) e baixa visão (verde) acendem. */
+export declare function vizDotFor(m: VizMode | undefined): {
+    visible: boolean;
+    fill: number | null;
+};
+/** Bolinha GLOBAL (#viz-indicator) para um `kind`: visível, classes e rótulo de leitor de tela. */
+export declare function vizIndicatorFor(kind: string): {
+    on: boolean;
+    blind: boolean;
+    low: boolean;
+    label: string;
+};
+/** Classe do overlay DOM de baixa visão (`lv-haze`/`lv-tunnel`/…); '' para qualquer outro kind. */
+export declare function lvOverlayClassFor(m: VizMode): string;
+/** HTML do grupo de rádios de modos visuais (uma linha por modo; o atual marcado). Verbatim do game.js. */
+export declare function vizGroupHtml(modes: readonly VizMode[], cur: string): string;
+/** Fala do leitor de tela ao escolher um modo: prefixa "Jogador N:" só em multi-tela. */
+export declare function vizGroupSay(numPlayers: number, sel: number, nome: string): string;
+type Filtered = ComFiltro;
+type Textured = ComTextura;
+/** PIXI.Graphics da bolinha por viewport — só o que updateVpDots realmente usa. */
+type DotGfx = Visivel & DesenhoComCirculo;
+interface ClassListHost {
+    classList: {
+        toggle(token: string, force?: boolean): unknown;
+        remove(...tokens: string[]): unknown;
+    };
+}
+interface Pl {
+    viz: string;
+    sprite?: Textured | null;
+    _tx?: unknown;
+}
+interface Pu {
+    kind: string;
+    sprite?: Textured | null;
+}
+export interface VizSettersCtx {
+    /** O seletor do jogo (#viz-overlay, #viz-indicator, listas do painel). `DomQuery` de `core/dom-query`
+     *  desde 2026-08-26: a versão local era NÃO-GENÉRICA, e uma função genérica atribuída a uma
+     *  assinatura não-genérica é instanciada pela RESTRIÇÃO. O `El` estrutural continua abaixo — ele é a
+     *  fatia que este módulo LÊ, e `HTMLElement` a satisfaz. */
+    $: DomQuery;
+    body: ClassListHost;
+    srSay: (s: string) => void;
+    aplicarFiltroCss: AplicarFiltroCss;
+    /** Alto contraste no DOM — o filtro não o alcança porque ele não É filtro. Issue #83. */
+    aplicarAltoContrasteNoDom: AplicarAltoContrasteNoDom;
+    camera: Filtered;
+    worldSprite: Textured;
+    parallaxLayers: Textured[];
+    decoSprites: Textured[];
+    getVpSpr: () => Filtered[];
+    getVpDots: () => DotGfx[];
+    /**
+     * Os sprites dos ITENS declarados (o array vive no jogo e pode ser recriado — por isso getter).
+     *
+     * Era `getCoinSprites`, e o nome dizia o que eles são. Mesma fatia que `render/draw` recebe desde o corte
+     * das entidades declaradas: uma lista de sprites, sem o desenho saber o que cada um representa.
+     */
+    getItemSprites: () => (Textured | null | undefined)[];
+    /**
+     * Como o JOGO chama os itens dele no cache de recoloração de `render/high-contrast`.
+     *
+     * Era `spriteTexFor('coin', mode)` — a string cravada aqui dentro. O cache já não tinha forma de moeda
+     * (ele chaveia por `(id, modo)`); quem ainda nomeava uma era este módulo. Repare no vizinho de baixo: os
+     * power-ups sempre carregaram o próprio `kind`, e a engine só o repassa. Os itens não carregavam nada, e
+     * por isso o nome tinha de estar em algum lugar — agora está do lado de quem o escolheu.
+     */
+    itemTexId: string;
+    getPowerups: () => readonly Pu[];
+    getPlayers: () => Pl[];
+    getNumPlayers: () => number;
+    getSelVizPlayer: () => number;
+    setSelVizPlayer: (i: number) => void;
+    getSharedViz: () => string | null;
+    setSharedViz: (mode: string) => void;
+    invalidateSharedViz: () => void;
+    parallaxTexFor: (i: number, mode: string) => unknown;
+    treeTexFor: (mode: string) => unknown;
+    playerVizTex: (base: unknown, mode: string) => unknown;
+    pixiFilterFor: (mode: string) => unknown;
+    clearPlayerDirectCache: () => void;
+    setFrontDim: (on: boolean) => void;
+    rebuildExtras: () => void;
+    rebuildCoins: () => void;
+    setModoCego: (on: boolean) => void;
+    hideTouchControls: (reason?: string) => void;
+    reflectVizButtons: () => void;
+    renderVisualPanel: () => void;
+    renderEmpathyPanel: () => void;
+}
+export interface VizSettersApi {
+    /** Multi-tela: aplica as texturas ESTÁTICAS do modo (memoizado) + a do quadro atual de cada jogador. */
+    applySharedTextures(mode: string): void;
+    /** Bolinhas indicadoras por viewport (fora do filtro do viewport — visíveis mesmo em cegueira). */
+    updateVpDots(): void;
+    /** Filtro PIXI de cada viewport = modo do jogador daquela tela. */
+    applyVpFilters(): void;
+    /** Troca o modo de UM jogador: persiste, invalida o render estático e reaplica pelo caminho certo. */
+    setPlayerViz(i: number, mode: string): void;
+    /** Caminho SOLO: filtro CSS na canvas + texturas globais + overlay DOM + bolinha. */
+    applyVizGlobal(mode: string): void;
+    /** Reaplica tudo depois de uma mudança estrutural (cenário, nº de telas). */
+    reapplyVizAll(): void;
+    /** Bolinha global (#viz-indicator) para um `kind`. */
+    updateVizIndicator(kind: string): void;
+    /** Invalida os caches de textura direta (mundo/moeda/power-up/jogador) e re-renderiza. */
+    rebakeDirect(): void;
+    /** Grupo de rádios de modos visuais nos painéis (visual/empatia). */
+    renderVizGroup(listSel: string, tabsSel: string, modes: readonly VizMode[]): void;
+}
+export declare function initVizSetters(ctx: VizSettersCtx): VizSettersApi;
+export {};

package/dist-pkg/render/viz-setters.js

@@ -0,0 +1,244 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// render/viz-setters — APLICAÇÃO dos modos de visão acessível (daltonismo, baixa visão, cegueira, alto
+// contraste), por jogador e globalmente. Extraído verbatim do game.js. É a camada de POLÍTICA — "qual modo
+// vale onde" — e não a de FÁBRICA: quem constrói pixel (pixiFilterFor / parallaxTexFor / playerVizTex /
+// lvOverlayTex / renderVpOverlay) fica no game.js e sai depois em `render/viewports` (grupo B); esses quatro
+// entram AQUI por injeção. Ver docs/5-Refactoring/plano-modularizacao-mapa.md (A16/B2).
+//
+// Fronteiras que este módulo NÃO reabre:
+//  · `_lastSharedViz` FICA no game.js — não é cache de visão, é o registro de qual modo o pipeline de render
+//    ESTÁTICO aplicou por último, escrito de cinco lugares (rebuildCoins/rebuildExtras/applySharedTextures/
+//    setPlayerViz/reapplyVizAll). Entra por `getSharedViz`/`setSharedViz`/`invalidateSharedViz`.
+//  · `selVizPlayer` idem: quatro escritores (renderVizGroup, aba de jogador, ui/settings-visual, menu de
+//    pausa) → get/set por ctx, o `let` continua no game.js até o D1.
+//  · `_playerDirect` é `let` do game.js reatribuído por estas funções → clear por ctx
+//    (binding importado não pode ser reatribuído).
+//
+// As camadas e sprites PIXI (camera/worldSprite/parallaxLayers/decoSprites/vpSpr/vpDots) são CRIADOS no
+// game.js — a ordem de addChild é a ordem de desenho — e entram injetados por interface ESTRUTURAL, para o
+// módulo rodar no project `node` sem importar PIXI. Mesmo precedente de render/scene-sky e game/traffic.
+// SEM I/O no import: initVizSetters(ctx) só fecha closures, não chama nada.
+import { VIZ_MODES, VIZ_BY_KEY, VIZ_FILTER, simulatesDisability } from './viz-modes.js';
+import { t } from '../core/i18n.js'; // VIZ_MODES guarda CHAVE i18n desde o item 14; quem exibe resolve
+import { DIRECT_CFG, worldTexFor, spriteTexFor, clearWorldTexCache, clearSpriteTexCache } from './high-contrast.js';
+import { pupTexFor, resetPupTexCache } from './textures.js';
+import { lqFilter } from './lq-filter.js';
+import { setVizModeValue } from '../core/state.js';
+import * as store from '../platform/storage.js';
+/* ===================== PURO (sem PIXI, sem DOM) — o que rende teste de verdade ===================== */
+/**
+ * Até onde o filtro deste modo vai. MELHORIA alcança os menus; EMPATIA fica no mundo (ver `AlcanceDoFiltro`).
+ * Derivado de `sim`, do catálogo — a mesma flag que já distingue os dois, e não uma segunda lista para
+ * alguém esquecer de atualizar.
+ */
+export function alcanceDoModo(mode) {
+    return simulatesDisability(mode) ? 'mundo' : 'mundo-e-menus';
+}
+/** Modo por chave, com o fallback do original: chave desconhecida (ou nula) CAI em `normal`. */
+export function resolveViz(key) {
+    return VIZ_BY_KEY[key] || VIZ_BY_KEY.normal;
+}
+/** É um dos três níveis de Renderização Direta (alto contraste)? Mesmo teste do original: `!!DIRECT_CFG[mode]`. */
+export function isDirectMode(mode) { return !!DIRECT_CFG[mode]; }
+/** Filtro CSS da canvas no SOLO: simulação/correção de visão + realce L→Q, compostos e sem vazios. */
+export function cssFilterFor(mode, lq) {
+    return [VIZ_FILTER[mode] || '', lq].filter(Boolean).join(' ');
+}
+/** Bolinha indicadora de um viewport: só cegueira (branca) e baixa visão (verde) acendem. */
+export function vizDotFor(m) {
+    const on = !!m && (m.kind === 'blind' || m.kind === 'lowvision');
+    return { visible: on, fill: on ? (m.kind === 'blind' ? 0xffffff : 0x36d36a) : null };
+}
+/** Bolinha GLOBAL (#viz-indicator) para um `kind`: visível, classes e rótulo de leitor de tela. */
+export function vizIndicatorFor(kind) {
+    return {
+        on: kind === 'blind' || kind === 'lowvision',
+        blind: kind === 'blind', low: kind === 'lowvision',
+        label: (kind === 'blind' ? 'Modo cegueira total' : 'Modo baixa visão') + '. Toque duas vezes para voltar às cores normais.',
+    };
+}
+/** Classe do overlay DOM de baixa visão (`lv-haze`/`lv-tunnel`/…); '' para qualquer outro kind. */
+export function lvOverlayClassFor(m) {
+    return m.kind === 'lowvision' ? 'lv-' + m.lv : '';
+}
+/** HTML do grupo de rádios de modos visuais (uma linha por modo; o atual marcado). Verbatim do game.js. */
+export function vizGroupHtml(modes, cur) {
+    return modes.map((m) => {
+        const sel = m.key === cur;
+        return `<div class="ctrl-row"><span><strong>${t(m.nome)}</strong><br><span class="opt-hint" style="margin:0">${t(m.desc)}</span></span>`
+            + `<button class="mode-btn${sel ? ' is-on' : ''}" role="radio" aria-checked="${sel}" data-viz="${m.key}" type="button">${sel ? '✓ Selecionado' : 'Selecionar'}</button></div>`;
+    }).join('');
+}
+/** Fala do leitor de tela ao escolher um modo: prefixa "Jogador N:" só em multi-tela. */
+export function vizGroupSay(numPlayers, sel, nome) {
+    return (numPlayers > 1 ? 'Jogador ' + (sel + 1) + ': ' : '') + nome + '.';
+}
+export function initVizSetters(ctx) {
+    // estáticos (mundo/parallax/moedas/itens) só re-aplicam quando o modo muda (_lastSharedViz mora no game.js)
+    function applySharedTextures(mode) {
+        if (mode !== ctx.getSharedViz()) {
+            ctx.setSharedViz(mode);
+            ctx.setFrontDim(!!DIRECT_CFG[mode]); // HC: carros/placas/semáforo (frente) escurecem como fundo
+            ctx.worldSprite.texture = worldTexFor(mode);
+            ctx.parallaxLayers.forEach((ts, j) => { ts.texture = ctx.parallaxTexFor(j, mode); });
+            ctx.decoSprites.forEach((s) => { s.texture = ctx.treeTexFor(mode); });
+            for (const s of ctx.getItemSprites()) {
+                if (s)
+                    s.texture = spriteTexFor(ctx.itemTexId, mode);
+            }
+            for (const pu of ctx.getPowerups()) {
+                if (pu.sprite)
+                    pu.sprite.texture = pupTexFor(pu.kind, mode);
+            }
+        }
+        for (const pl of ctx.getPlayers()) {
+            if (pl.sprite && pl._tx)
+                pl.sprite.texture = ctx.playerVizTex(pl._tx, mode);
+        } // player muda de quadro toda frame
+    }
+    // bolinhas indicadoras por viewport (sobre os sprites de saída → NÃO sofrem o filtro do viewport, ex. cegueira)
+    function updateVpDots() {
+        const dots = ctx.getVpDots(), players = ctx.getPlayers();
+        for (let i = 0; i < dots.length; i++) {
+            const g = dots[i], m = VIZ_BY_KEY[(players[i] && players[i].viz)];
+            if (!g)
+                continue;
+            const d = vizDotFor(m);
+            g.visible = d.visible;
+            if (d.visible) {
+                g.clear();
+                g.lineStyle(1, 0x000000, .6);
+                g.beginFill(d.fill);
+                g.drawCircle(0, 0, 5);
+                g.endFill();
+            }
+        }
+    }
+    function applyVpFilters() {
+        const spr = ctx.getVpSpr(), players = ctx.getPlayers();
+        for (let i = 0; i < ctx.getNumPlayers(); i++) {
+            if (spr[i])
+                spr[i].filters = ctx.pixiFilterFor(players[i].viz);
+        }
+    }
+    function setPlayerViz(i, mode) {
+        const m = resolveViz(mode);
+        ctx.getPlayers()[i].viz = m.key;
+        store.set(store.KEYS.vizP(i), m.key);
+        ctx.invalidateSharedViz();
+        if (m.kind === 'blind')
+            ctx.setModoCego(true); // empatia cegueira total liga o modo cego (áudio) por padrão
+        if (ctx.getNumPlayers() <= 1 && i === 0) {
+            applyVizGlobal(m.key);
+        }
+        else {
+            applyVpFilters();
+            updateVpDots();
+        }
+        ctx.reflectVizButtons();
+        ctx.renderVisualPanel();
+        ctx.renderEmpathyPanel();
+    }
+    function applyVizGlobal(mode) {
+        const m = resolveViz(mode);
+        mode = m.key;
+        setVizModeValue(mode); // core/state: valor + persistência (incl_viz) + evento
+        // ANTES daqui saía também `ctx.setHcMode(m.kind === 'hcnew')`, alimentando um `let hcMode` no game.js cujo
+        // único leitor era o gancho window.__incl. Era `vizMode` reescrito com outro nome: derivar de VIZ_BY_KEY
+        // custa uma comparação e não pode divergir. (O inicializador daquele `let` usava OUTRA fórmula,
+        // `vizMode!=='normal'`, e discordava do setter — sem efeito, porque applyVizGlobal roda no boot antes de
+        // o gancho existir, mas é o sintoma clássico de cópia de estado.)
+        ctx.aplicarFiltroCss(cssFilterFor(mode, lqFilter()), alcanceDoModo(mode));
+        ctx.aplicarAltoContrasteNoDom(m.kind === 'hcnew'); // não é filtro: ver `AplicarAltoContrasteNoDom` // sim. daltonismo/baixa-visão/cegueira + realce L/Q compostos
+        ctx.camera.filters = (m.kind === 'hcnew') ? ctx.pixiFilterFor(mode) : null; // solo: alto contraste experimental = filtro GPU na câmera
+        ctx.setFrontDim(!!DIRECT_CFG[mode]); // HC: frente (carros/placas/semáforo) escurece como fundo
+        ctx.worldSprite.texture = worldTexFor(mode); // alto contraste direto = Renderização Direta · resto=normal
+        ctx.parallaxLayers.forEach((ts, i) => { ts.texture = ctx.parallaxTexFor(i, mode); });
+        ctx.decoSprites.forEach((s) => { s.texture = ctx.treeTexFor(mode); });
+        ctx.rebuildExtras();
+        ctx.rebuildCoins();
+        // baixa visão = névoa+manchas (overlay) + bolinha verde; cegueira = tela preta (filtro) + esconde controles + bolinha branca
+        ctx.body.classList.toggle('lowvision-mode', m.kind === 'lowvision');
+        ctx.body.classList.toggle('blind-mode', m.kind === 'blind');
+        const ov = ctx.$('#viz-overlay');
+        if (ov) {
+            ov.hidden = (m.kind !== 'lowvision');
+            ov.className = lvOverlayClassFor(m);
+        }
+        if (m.kind === 'blind') {
+            ctx.hideTouchControls('cegueira');
+        }
+        updateVizIndicator(m.kind);
+        ctx.reflectVizButtons(); // (a guarda `typeof ...==='function'` do original morreu: era declaração de função, sempre verdadeira)
+        ctx.renderVisualPanel();
+        ctx.renderEmpathyPanel();
+    }
+    // bolinha indicadora (canto sup. dir.): branca=cegueira, verde=baixa visão; toque/clique 2× volta ao normal
+    function updateVizIndicator(kind) {
+        const el = ctx.$('#viz-indicator');
+        if (!el)
+            return;
+        const s = vizIndicatorFor(kind);
+        el.hidden = !s.on;
+        el.classList.toggle('blind', s.blind);
+        el.classList.toggle('low', s.low);
+        el.setAttribute('aria-label', s.label);
+    }
+    // MP: filtro CSS/overlay/bolinha globais OFF (por viewport agora)
+    function reapplyVizAll() {
+        ctx.invalidateSharedViz();
+        if (ctx.getNumPlayers() <= 1) {
+            applyVizGlobal(ctx.getPlayers()[0].viz);
+        }
+        else {
+            ctx.aplicarFiltroCss(lqFilter(), 'mundo-e-menus'); // realce L/Q é melhoria: alcança o menu
+            ctx.camera.filters = null;
+            ctx.body.classList.remove('lowvision-mode', 'blind-mode');
+            const ov = ctx.$('#viz-overlay');
+            if (ov)
+                ov.hidden = true;
+            updateVizIndicator('normal');
+            applyVpFilters();
+        }
+    }
+    // invalida os caches de textura direta (mundo depende de bg; sprites de fg) e re-renderiza
+    function rebakeDirect() {
+        clearWorldTexCache();
+        clearSpriteTexCache();
+        resetPupTexCache();
+        ctx.clearPlayerDirectCache();
+        ctx.invalidateSharedViz();
+        if (ctx.getNumPlayers() <= 1)
+            applyVizGlobal(ctx.getPlayers()[0].viz);
+        else
+            applyVpFilters();
+    }
+    function renderVizGroup(listSel, tabsSel, modes) {
+        const el = ctx.$(listSel);
+        if (!el)
+            return;
+        if (ctx.getSelVizPlayer() >= ctx.getNumPlayers())
+            ctx.setSelVizPlayer(0);
+        const tabs = ctx.$(tabsSel);
+        if (tabs) {
+            tabs.hidden = true; // E3: sem abas — cada jogador edita só o seu
+            tabs.innerHTML = '';
+            // NOTA (verbatim do original): o innerHTML acima já esvaziou `tabs`, então este querySelectorAll não
+            // acha nada e o listener nunca é ligado. Preservado como estava — ver relatório da extração.
+            tabs.querySelectorAll('button[data-vp]').forEach((b) => b.addEventListener('click', () => {
+                ctx.setSelVizPlayer(+b.dataset.vp);
+                ctx.renderVisualPanel();
+                ctx.renderEmpathyPanel();
+            }));
+        }
+        const players = ctx.getPlayers(), sel = ctx.getSelVizPlayer();
+        const cur = players[sel] ? players[sel].viz : 'normal';
+        el.innerHTML = vizGroupHtml(modes, cur);
+        el.querySelectorAll('button[data-viz]').forEach((btn) => btn.addEventListener('click', () => {
+            const key = btn.dataset.viz;
+            setPlayerViz(ctx.getSelVizPlayer(), key);
+            ctx.srSay(vizGroupSay(ctx.getNumPlayers(), ctx.getSelVizPlayer(), t(VIZ_MODES.find((m) => m.key === key).nome)));
+        }));
+    }
+    return { applySharedTextures, updateVpDots, applyVpFilters, setPlayerViz, applyVizGlobal, reapplyVizAll, updateVizIndicator, rebakeDirect, renderVizGroup };
+}

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

@@ -0,0 +1,96 @@
+// 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 {};