primocode 10.5.0 → 10.6.0

package/lib/estudio/mundo.js

@@ -0,0 +1,305 @@
+/**
+ * mundo.js — o lugar, os bichos e as coisas do vídeo 3D, a partir do PEDIDO.
+ *
+ *   "não quero que ele só troque as falas e os textos ... se eu pedir dois
+ *    humanos ele vai fazer dois humanos, se eu pedir um cachorro ele vai fazer,
+ *    se eu pedir um humano na praia ele vai fazer — vai mudar o cenário, vai
+ *    mudar as coisas, e não é coisa pré-definida" (Joel, 11/10)
+ *
+ * Até a 10.5 o 3D tinha UM set (a parede de telas) e o elenco era gente ou o
+ * mascote. Aqui o set vira um MUNDO montado de peças:
+ *
+ *   · o LUGAR (praia, cidade, floresta, espaço, cozinha…): céu, chão, água,
+ *     luz e hora do dia; vem do texto livre ("numa praia ao pôr do sol");
+ *   · os ELEMENTOS: o que há no lugar. Uma palavra do catálogo (palmeira, carro,
+ *     prédio, foguete…) vira uma peça de blocos desenhada no kit/mundo.jsx; uma
+ *     palavra FORA do catálogo vira um ícone 3D da biblioteca (colecao.js,
+ *     1.595 objetos) transformado em blocos na hora do render — é isso que
+ *     tira o "pré-definido": qualquer coisa que tenha ícone entra na cena;
+ *   · o ELENCO: pessoa, robô/mascote, BICHO (cachorro, gato, cavalo, vaca,
+ *     pinguim, peixe, dinossauro… — o kit/mundo.jsx monta cada espécie) ou
+ *     COISA (um ícone em blocos que fala: "uma pizza conversando com um café").
+ *     E os FIGURANTES: quem está na cena sem falar ("um humano com o cachorro").
+ *
+ * A IA decide (roteiro.cena, roteiro.personagens, parte.cenario); o que ela
+ * não disse sai do texto do pedido e das falas — a mesma regra do resto do
+ * Estúdio: o modelo manda, a leitura do texto só completa. É o que faz um
+ * modelo local pequeno, que só escreve as falas, ainda ganhar a praia que a
+ * pessoa pediu.
+ */
+
+'use strict';
+
+const sem = (s) => String(s || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+
+/* ── OS LUGARES ─────────────────────────────────────────────────────────
+   ceu: [alto, horizonte] · chao: {tipo, cor, cor2} · agua: cor do mar ·
+   dentro: set fechado (parede no fundo) · props: o que o lugar tem quando a
+   cena não disse. As palavras são lidas sem acento. */
+const LUGARES = {
+    /* A COBERTURA À NOITE (2ª referência do Joel, 11/10): a janela de vidro
+       com a cidade acesa lá fora, as luzes grandes desfocadas (bokeh), o
+       parapeito escuro e os CARTÕES de interface flutuando na frente (o
+       assunto do vídeo, desfocados pela lente). É o set padrão quando o
+       pedido não diz lugar. */
+    cobertura: { palavras: /\b(cobertura|terraco|rooftop|janela|vista da cidade|apartamento alto|predio alto|escritorio a noite)\b/, dentro: true, cobertura: true,
+        parede: '#050816', chao: { tipo: 'madeira', cor: '#2a1f1a', cor2: '#241a16' }, luz: '#ffd2b0', recorte: '#6f8bff', acento: '#ff6a2b', props: [] },
+    telas: { palavras: /\b(estudio|podcast|tecnologia|telas?|set|programa|live|transmissao)\b/, dentro: true, telas: true,
+        parede: '#07061a', chao: { tipo: 'ladrilho', cor: '#4338ca', cor2: '#3b32b8' }, luz: '#ffd2b0', recorte: '#8b7bff', acento: '#ff7a45', props: [] },
+    praia: { palavras: /\b(praia|mar|litoral|beira[ -]mar|areia|orla|surf\w*|ilha)\b/, ceu: ['#3d8fe0', '#c4e8ff'], agua: '#1d8bc9',
+        chao: { tipo: 'areia', cor: '#ead29c', cor2: '#dfc48a' }, luz: '#fff2d6', recorte: '#ffd08a', acento: '#ff7a45', sol: true,
+        props: ['palmeira', 'palmeira', 'guarda-sol', 'cadeira de praia', 'palmeira', 'castelo de areia', 'pedra'] },
+    cidade: { palavras: /\b(cidade|rua|avenida|centro|predios?|esquina|calcada|metropole|urbano)\b/, ceu: ['#5b9be6', '#dbeaff'],
+        chao: { tipo: 'asfalto', cor: '#5b5e67', cor2: '#53565f' }, luz: '#fff1dc', recorte: '#9fc3ff', acento: '#facc15', sol: true,
+        props: ['predio', 'predio', 'predio', 'poste', 'carro', 'arvore', 'predio', 'poste', 'carro', 'predio'] },
+    floresta: { palavras: /\b(floresta|mata|selva|bosque|trilha|acampamento|amazonia)\b/, ceu: ['#6fb3e8', '#dcf2d6'],
+        chao: { tipo: 'grama', cor: '#4f9a3c', cor2: '#468c35' }, luz: '#fff0d0', recorte: '#b6f0a0', acento: '#facc15', sol: true, neblina: 0.6,
+        props: ['arvore', 'pinheiro', 'arvore', 'pinheiro', 'arbusto', 'pedra', 'arvore', 'pinheiro', 'cogumelo', 'arvore'] },
+    parque: { palavras: /\b(parque|jardim|praca|gramado|piquenique)\b/, ceu: ['#58a6ee', '#d9eeff'],
+        chao: { tipo: 'grama', cor: '#5aa845', cor2: '#4f9a3c' }, luz: '#fff2d6', recorte: '#c8f0b0', acento: '#f472b6', sol: true,
+        props: ['arvore', 'banco', 'flor', 'arvore', 'poste', 'flor', 'arbusto', 'arvore', 'flor'] },
+    fazenda: { palavras: /\b(fazenda|sitio|roca|interior|celeiro|curral|plantacao|colheita)\b/, ceu: ['#68aef0', '#f3ecd0'],
+        chao: { tipo: 'grama', cor: '#6aa84f', cor2: '#5e9a44' }, luz: '#fff1d0', recorte: '#ffe0a0', acento: '#dc2626', sol: true,
+        props: ['celeiro', 'cerca', 'cerca', 'arvore', 'feno', 'cerca', 'arvore', 'feno'] },
+    neve: { palavras: /\b(neve|inverno|gelo|polo|nevando|esqui|frio)\b/, ceu: ['#9fbfe6', '#eef4fb'],
+        chao: { tipo: 'neve', cor: '#f4f8fc', cor2: '#e6eef6' }, luz: '#eef4ff', recorte: '#a8c8ff', acento: '#38bdf8', sol: true,
+        props: ['pinheiro nevado', 'pinheiro nevado', 'boneco de neve', 'montanha', 'pinheiro nevado', 'pedra', 'pinheiro nevado'] },
+    deserto: { palavras: /\b(deserto|duna|sertao|saara|oasis)\b/, ceu: ['#f0a35a', '#ffe2ae'],
+        chao: { tipo: 'areia', cor: '#e2b06c', cor2: '#d6a05c' }, luz: '#ffe6c0', recorte: '#ffb070', acento: '#ea580c', sol: true,
+        props: ['cacto', 'cacto', 'pedra', 'montanha', 'cacto', 'pedra'] },
+    espaco: { palavras: /\b(espaco|lua|planeta|galaxia|foguete|astronauta|marte|orbita|estrelas|universo|nave)\b/, ceu: ['#02020f', '#0d0b2c'], estrelas: true,
+        chao: { tipo: 'lua', cor: '#a1a1ad', cor2: '#90909c' }, luz: '#e8ecff', recorte: '#8b7bff', acento: '#a78bfa',
+        props: ['planeta', 'foguete', 'pedra', 'planeta', 'cratera', 'pedra'] },
+    fundo_do_mar: { palavras: /\b(fundo do mar|submarino|oceano|aquario|mergulh\w*|recife|coral)\b/, ceu: ['#022c46', '#0b6f94'], subaquatico: true,
+        chao: { tipo: 'areia', cor: '#c9b98a', cor2: '#bba97a' }, luz: '#bfefff', recorte: '#38bdf8', acento: '#f97316', neblina: 1,
+        props: ['alga', 'coral', 'pedra', 'alga', 'coral', 'bau', 'alga'] },
+    escritorio: { palavras: /\b(escritorio|trabalho|reuniao|empresa|firma|coworking|startup)\b/, dentro: true, parede: '#d8d0c2',
+        chao: { tipo: 'madeira', cor: '#9a7350', cor2: '#8d6846' }, luz: '#fff1dc', recorte: '#ffe2b8', acento: '#2563eb',
+        props: ['mesa', 'computador', 'planta', 'estante', 'cadeira', 'quadro'] },
+    sala: { palavras: /\b(sala|casa|sofa|quarto|lar|apartamento|sala de estar)\b/, dentro: true, parede: '#e6d6c3',
+        chao: { tipo: 'madeira', cor: '#a87b52', cor2: '#9a6e47' }, luz: '#ffe8c8', recorte: '#ffd6a0', acento: '#e11d48',
+        props: ['sofa', 'luminaria', 'planta', 'estante', 'tapete', 'quadro'] },
+    cozinha: { palavras: /\b(cozinha|restaurante|padaria|cafeteria|cafe|lanchonete|confeitaria|pizzaria|bar)\b/, dentro: true, parede: '#efe4d2',
+        chao: { tipo: 'ladrilho', cor: '#e8e1d4', cor2: '#cfc5b4' }, luz: '#fff0d6', recorte: '#ffd9a0', acento: '#dc2626',
+        props: ['balcao', 'mesa', 'cadeira', 'planta', 'estante', 'luminaria'] },
+    escola: { palavras: /\b(escola|sala de aula|aula|professor|faculdade|universidade|colegio)\b/, dentro: true, parede: '#dfe8dc',
+        chao: { tipo: 'madeira', cor: '#b08458', cor2: '#a3794f' }, luz: '#fffaf0', recorte: '#d6f0ff', acento: '#16a34a',
+        props: ['lousa', 'mesa', 'mesa', 'estante', 'planta'] },
+    palco: { palavras: /\b(palco|show|teatro|concerto|festa|balada|evento)\b/, dentro: true, parede: '#0b0612',
+        chao: { tipo: 'madeira', cor: '#3a2a20', cor2: '#33251c' }, luz: '#ffe1f5', recorte: '#ff4fd8', acento: '#22d3ee', holofotes: true,
+        props: ['caixa de som', 'caixa de som', 'luminaria'] },
+    campo: { palavras: /\b(campo|montanhas?|colina|natureza|ao ar livre|vale)\b/, ceu: ['#5aa3ec', '#dcefff'],
+        chao: { tipo: 'grama', cor: '#5ca846', cor2: '#529b3e' }, luz: '#fff2d6', recorte: '#c8f0b0', acento: '#facc15', sol: true,
+        props: ['montanha', 'arvore', 'flor', 'arvore', 'pedra', 'montanha', 'flor'] },
+};
+// O que o set antigo chamava por outro nome.
+const APELIDOS_LUGAR = { neon: 'palco', oceano: 'fundo_do_mar', terra: 'deserto', podcast: 'telas', estudio: 'telas', noite: 'telas' };
+
+const HORAS = {
+    noite: { palavras: /\b(noite|noturn\w*|madrugada|luar|a noite|de noite)\b/, ceu: ['#070b24', '#1c2552'], luz: '#b8c6ff', forca: 0.45, lua: true, estrelas: true },
+    por_do_sol: { palavras: /\b(por do sol|entardecer|fim de tarde|crepusculo|poente|anoitecer)\b/, ceu: ['#46368a', '#ff9a5a'], luz: '#ffb27a', forca: 0.8, solBaixo: true },
+    amanhecer: { palavras: /\b(amanhecer|nascer do sol|alvorada|de manha cedo)\b/, ceu: ['#6a8fd8', '#ffd2a8'], luz: '#ffd9b0', forca: 0.85, solBaixo: true },
+};
+
+/* ── O CATÁLOGO DE PEÇAS (kit/mundo.jsx desenha cada uma) ───────────────
+   A chave é a peça; as palavras são como a pessoa (ou a IA) diz. */
+const PECAS = {
+    palmeira: /\bpalmeiras?|coqueiros?\b/, arvore: /\barvores?|arvorezinha\b/, pinheiro: /\bpinheiros?\b/, 'pinheiro nevado': /\bpinheiros? nevados?\b/,
+    arbusto: /\barbustos?|moitas?\b/, flor: /\bflor(es)?\b/, pedra: /\bpedras?|rochas?\b/, cacto: /\bcactos?\b/, montanha: /\bmontanhas?|morros?\b/,
+    casa: /\bcasas?|casinha\b/, predio: /\bpredios?|edificios?|arranha[- ]ceus?\b/, celeiro: /\bceleiros?\b/, poste: /\bpostes?\b/,
+    carro: /\bcarros?|automove(l|is)\b/, 'guarda-sol': /\bguarda[- ]sois?|guarda[- ]sol\b/, 'cadeira de praia': /\bcadeiras? de praia\b/,
+    'castelo de areia': /\bcastelos? de areia\b/, mesa: /\bmesas?\b/, cadeira: /\bcadeiras?\b/, sofa: /\bsofas?\b/, planta: /\bplantas?|vasos?\b/,
+    estante: /\bestantes?|prateleiras?\b/, computador: /\bcomputador(es)?|notebooks?|pc\b/, luminaria: /\bluminarias?|abajur\b/,
+    quadro: /\bquadros?\b/, lousa: /\blousas?|quadro negro\b/, balcao: /\bbalca(o|oes)\b/, tapete: /\btapetes?\b/, banco: /\bbancos? de praca|banquinhos?\b/,
+    cerca: /\bcercas?\b/, feno: /\bfenos?\b/, 'boneco de neve': /\bbonecos? de neve\b/, foguete: /\bfoguetes?\b/, planeta: /\bplanetas?\b/,
+    cratera: /\bcrateras?\b/, alga: /\balgas?\b/, coral: /\bcorais?|coral\b/, bau: /\bbaus?|tesouros?\b/, cogumelo: /\bcogumelos?\b/,
+    nuvem: /\bnuvens?\b/, fogueira: /\bfogueiras?\b/, barraca: /\bbarracas?|tendas?\b/, barco: /\bbarcos?|canoas?\b/,
+    'caixa de som': /\bcaixas? de som|alto[- ]falantes?\b/,
+};
+
+/* ── AS ESPÉCIES (kit/mundo.jsx monta cada uma de blocos) ────────────── */
+const ESPECIES = {
+    cachorro: /\b(cachorr\w*|cao|caes|cachorrinho|dog|vira[- ]lata|labrador|filhote)\b/, gato: /\b(gat[oa]s?|gatinh\w*|felino)\b/,
+    cavalo: /\b(caval\w*|egua|potro|pônei|ponei)\b/, vaca: /\b(vacas?|boi|bois|touro|bezerro)\b/, porco: /\b(porc\w*|leitao)\b/,
+    ovelha: /\b(ovelhas?|carneiros?|cordeiro)\b/, raposa: /\b(raposas?)\b/, lobo: /\b(lob[oa]s?)\b/, urso: /\b(urs[oa]s?)\b/,
+    panda: /\b(pandas?)\b/, coelho: /\b(coelh\w*)\b/, leao: /\b(leao|leoes|leoa)\b/, tigre: /\b(tigres?)\b/, elefante: /\b(elefantes?)\b/,
+    girafa: /\b(girafas?)\b/, galinha: /\b(galinhas?|galos?|pintinhos?)\b/, pato: /\b(pat[oa]s?|patinho)\b/, pinguim: /\b(pinguins?)\b/,
+    passaro: /\b(passar\w*|ave|aves|passarinho)\b/, papagaio: /\b(papagaios?|arara)\b/, coruja: /\b(corujas?)\b/,
+    peixe: /\b(peixes?|peixinho)\b/, tubarao: /\b(tubara(o|oes))\b/, golfinho: /\b(golfinhos?)\b/, tartaruga: /\b(tartarugas?|jabuti)\b/,
+    dinossauro: /\b(dinossauros?|dino|t[- ]?rex)\b/, sapo: /\b(sapos?|ra)\b/, macaco: /\b(macac\w*)\b/,
+};
+
+const PESSOA = /\b(humanos?|pessoas?|homens?|mulher(es)?|menin[oa]s?|crianc\w*|amig[oa]s?|garot[oa]s?|rapaz|mo[cç][oa]s?|senhor(a|es)?|vov[oóô]|av[oóô]s?|casal|familia|cliente|vendedor\w*|professor\w*|alun[oa]s?|medic[oa]s?|astronautas?|surfistas?|chef|cozinheir[oa]s?)\b/;
+const ROBO = /\b(robo|robos|ia|inteligencia artificial|mascote|claude|chatgpt|gpt|gemini|assistente|bot)\b/;
+const NUMEROS = { um: 1, uma: 1, dois: 2, duas: 2, tres: 3, quatro: 4, cinco: 5, casal: 2, par: 2 };
+
+function contar(texto, re) {
+    // "dois humanos", "3 cachorros", "um casal": o número logo antes da palavra.
+    const s = sem(texto);
+    if (re === PESSOA && /\b(um )?casal\b/.test(s)) return 2;
+    const m = new RegExp(`(\\d+|um|uma|dois|duas|tres|quatro|cinco)\\s+(?:\\w+\\s+)?${re.source.replace(/^\\b|\\b$/g, '')}`).exec(s);
+    if (m) return Math.min(4, Number(m[1]) || NUMEROS[m[1]] || 1);
+    return re.test(s) ? 1 : 0;
+}
+
+/** O lugar e a hora que o texto pede, ou null. */
+function lerLugar(texto) {
+    const s = sem(texto);
+    let lugar = null, onde = -1;
+    // O mais específico primeiro: "fundo do mar" antes de "mar", "sala de aula" antes de "sala".
+    const ordem = ['cobertura', 'fundo_do_mar', 'escola', 'praia', 'espaco', 'neve', 'deserto', 'fazenda', 'floresta', 'parque', 'cidade', 'cozinha', 'escritorio', 'palco', 'sala', 'campo', 'telas'];
+    for (const n of ordem) { const m = LUGARES[n].palavras.exec(s); if (m) { lugar = n; onde = m.index; break; } }
+    /* A hora vale para AQUELE lugar: "na praia, depois na cidade à noite" é
+       praia de dia. Com lugar no texto, só a hora a até 40 letras dele. */
+    let hora = null;
+    for (const [n, h] of Object.entries(HORAS)) {
+        const m = h.palavras.exec(s);
+        if (!m) continue;
+        if (onde < 0) { hora = n; break; }
+        // Outro lugar no meio ("praia, depois vão pra cidade à noite"): a hora é DELE.
+        const entre = s.slice(Math.min(m.index, onde) + 1, Math.max(m.index, onde));
+        const outroLugar = Object.entries(LUGARES).some(([k, L]) => k !== lugar && L.palavras.test(entre));
+        if (!outroLugar && Math.abs(m.index - onde) <= 40) { hora = n; break; }
+    }
+    return { lugar, hora };
+}
+
+/** As peças do catálogo e os bichos que o texto cita (em ordem de aparição). */
+function lerCoisas(texto) {
+    const s = sem(texto);
+    const pecas = [];
+    for (const [nome, re] of Object.entries(PECAS)) {
+        const m = re.exec(s);
+        if (m) pecas.push({ nome, em: m.index });
+    }
+    // "pinheiro nevado" ganha de "pinheiro"; "cadeira de praia" ganha de "cadeira".
+    const filtradas = pecas.filter((p) => !pecas.some((q) => q !== p && q.nome.startsWith(p.nome + ' ') && Math.abs(q.em - p.em) < 3)
+        && !pecas.some((q) => q !== p && q.nome.includes(p.nome) && q.nome !== p.nome && Math.abs(q.em - p.em) < 12));
+    const bichos = [];
+    for (const [esp, re] of Object.entries(ESPECIES)) {
+        const m = re.exec(s);
+        if (m) bichos.push({ especie: esp, em: m.index, quantos: contar(texto, re) || 1 });
+    }
+    return { pecas: filtradas.sort((a, b) => a.em - b.em).map((p) => p.nome), bichos: bichos.sort((a, b) => a.em - b.em) };
+}
+
+/** O que o PEDIDO descreve do elenco: quantas pessoas, que bichos, se há IA. */
+function lerElenco(texto) {
+    const s = sem(texto);
+    const { bichos } = lerCoisas(texto);
+    return { pessoas: contar(texto, PESSOA), robo: ROBO.test(s), bichos };
+}
+
+/* ── O MUNDO MONTADO ────────────────────────────────────────────────────
+   A peça é posta numa faixa ATRÁS e DOS LADOS do elenco, nunca no corredor
+   entre a câmera e quem fala. Com mar, a faixa é a areia antes da água. */
+function rngDe(semente) {
+    let s = (Number(semente) >>> 0) || 1;
+    return () => { s = (Math.imul(s ^ (s >>> 15), 2246822507) + 0x9e3779b9) >>> 0; return s / 4294967296; };
+}
+
+const ehCor = (c) => typeof c === 'string' && /^#[0-9a-f]{6}$/i.test(c);
+
+function posicionar(nomes, { semente = 1, agua = false, dentro = false, largura = 1 } = {}) {
+    const r = rngDe(semente);
+    const out = [];
+    const livre = (x, z, raio) => out.every((p) => Math.hypot(p.x - x, p.z - z) > raio + (p.raio || 0.8));
+    nomes.forEach((nome, i) => {
+        const grande = /predio|montanha|celeiro|planeta|foguete|palmeira|pinheiro|arvore/.test(typeof nome === 'string' ? nome : '');
+        const raio = grande ? 1.3 : 0.75;
+        for (let tent = 0; tent < 40; tent++) {
+            let x, z;
+            if (dentro) {
+                // Encostado na parede do fundo ou nos lados do set.
+                x = (r() * 2 - 1) * 4.6 * largura; z = -3.1 + r() * 0.9;
+                if (Math.abs(x) < 1.7 && tent < 30) continue;
+            } else if (agua) {
+                const lado = i % 2 ? 1 : -1;
+                x = lado * (1.9 + r() * 4.5) * largura; z = -4.2 + r() * 3.6;
+            } else {
+                const lado = i % 2 ? 1 : -1;
+                const longe = grande ? 0.55 + r() * 0.45 : r();
+                x = lado * (1.8 + r() * 5.5) * largura; z = -1.6 - longe * 9;
+                if (r() < 0.25 && !grande) { x = lado * (2.2 + r() * 1.5); z = -0.4 + r() * 1.4; }
+            }
+            if (!livre(x, z, raio) && tent < 39) continue;
+            out.push({ x: Math.round(x * 100) / 100, z: Math.round(z * 100) / 100, raio, giro: Math.round((r() * 2 - 1) * 60) / 100, escala: Math.round((0.85 + r() * 0.35) * 100) / 100 });
+            break;
+        }
+    });
+    return out;
+}
+
+/**
+ * O mundo de um trecho do vídeo.
+ * @param {string|object} pedido  "praia ao pôr do sol" ou {lugar, hora, elementos, ceu, chao, ...}
+ * @param {object} op  {texto (o pedido e as falas: completa o lugar), pedidoTexto (só o
+ *                      pedido da pessoa: as coisas que ele cita entram na cena), semente, nElenco}
+ */
+function mundoDe(pedido, { texto = '', pedidoTexto = '', semente = 1, nElenco = 1 } = {}) {
+    const obj = pedido && typeof pedido === 'object' ? pedido : { lugar: String(pedido || '') };
+    const descr = [obj.lugar, obj.descricao, obj.hora].filter(Boolean).join(' ');
+    let { lugar, hora } = lerLugar(descr);
+    const nomeDireto = sem(obj.lugar).replace(/\s+/g, '_');
+    if (!lugar && LUGARES[nomeDireto]) lugar = nomeDireto;
+    if (!lugar && APELIDOS_LUGAR[nomeDireto]) lugar = APELIDOS_LUGAR[nomeDireto];
+    // Sem lugar no pedido da cena, o texto do vídeo (o pedido da pessoa e as falas) completa.
+    const doTexto = lerLugar(texto);
+    if (!lugar) lugar = doTexto.lugar || 'cobertura';
+    if (!hora) hora = doTexto.hora;
+    if (APELIDOS_LUGAR[lugar]) lugar = APELIDOS_LUGAR[lugar];
+    const L = LUGARES[lugar];
+    const H = hora && !L.dentro ? HORAS[hora] : null;
+
+    // Os elementos: os que a cena listou (qualquer palavra) + os que o texto cita + os do lugar.
+    const pedidos = Array.isArray(obj.elementos) ? obj.elementos.map((e) => (typeof e === 'string' ? e : (e && (e.nome || e.tipo)) || '')).filter(Boolean) : [];
+    // As falas citam coisa de passagem ("comprei um carro"): só o PEDIDO põe coisa na cena.
+    const citados = lerCoisas([descr, pedidoTexto, Array.isArray(obj.elementos) ? '' : String(obj.elementos || '')].join(' ')).pecas;
+    const nomes = [];
+    for (const e of [...pedidos, ...citados]) {
+        const s = sem(e).trim();
+        const peca = Object.keys(PECAS).find((k) => PECAS[k].test(s) || sem(k) === s);
+        nomes.push(peca ? { peca } : { icone: s.slice(0, 40) });
+    }
+    // O lugar completa até 7 peças: a cena nunca fica vazia, e o que a IA pediu vem primeiro.
+    for (const p of L.props) if (nomes.length < 7 || nomes.length < L.props.length) nomes.push({ peca: p });
+    const lugares = posicionar(nomes.map((n) => n.peca || n.icone), { semente, agua: !!L.agua, dentro: !!L.dentro, largura: nElenco > 2 ? 1.25 : 1 });
+    const props = nomes.slice(0, lugares.length).map((n, i) => ({ ...n, ...lugares[i] }));
+
+    const ceu = Array.isArray(obj.ceu) && obj.ceu.every(ehCor) ? obj.ceu : (H ? H.ceu : L.ceu) || null;
+    const chao = { ...L.chao, ...(obj.chao && typeof obj.chao === 'object' ? obj.chao : {}), ...(ehCor(obj.chao) ? { cor: obj.chao, cor2: obj.chao } : {}) };
+    return {
+        nome: lugar + (H ? ':' + hora : ''), lugar, hora: H ? hora : null,
+        dentro: !!L.dentro, telas: !!L.telas, cobertura: !!L.cobertura, parede: ehCor(obj.parede) ? obj.parede : L.parede || null,
+        ceu, chao, agua: L.agua || null, subaquatico: !!L.subaquatico, holofotes: !!L.holofotes,
+        sol: !!(L.sol && !(H && H.lua)), solBaixo: !!(H && H.solBaixo), lua: !!(H && H.lua), estrelas: !!(L.estrelas || (H && H.estrelas)),
+        neblina: L.neblina || 0,
+        luz: ehCor(obj.luz) ? obj.luz : (H ? H.luz : L.luz), forca: H ? H.forca : 1,
+        recorte: L.recorte, acento: ehCor(obj.acento) ? obj.acento : L.acento,
+        props,
+    };
+}
+
+/** Os ícones que o mundo e o elenco precisam baixar (colecao.js) antes do render. */
+function iconesPendentes(partitura) {
+    const out = new Set();
+    for (const m of partitura.mundos || []) for (const p of m.props) if (p.icone && !p.src) out.add(p.icone);
+    for (const e of [...(partitura.elenco || []), ...(partitura.figurantes || [])]) if (e.tipo === 'coisa' && !e.src) out.add(e.icone);
+    return [...out];
+}
+
+/** Põe o PNG baixado em cada peça e personagem que pediu aquele ícone; o que não achou ícone sai da cena. */
+function aplicarIcones(partitura, achados) {
+    for (const m of partitura.mundos || []) {
+        m.props = m.props.filter((p) => !p.icone || achados[p.icone]).map((p) => (p.icone ? { ...p, src: achados[p.icone] } : p));
+    }
+    for (const e of [...(partitura.elenco || []), ...(partitura.figurantes || [])]) {
+        if (e.tipo === 'coisa') {
+            if (achados[e.icone]) e.src = achados[e.icone];
+            else { e.tipo = 'robo'; e.cor = e.cor || '#d97757'; }   // sem ícone, a coisa que fala vira o mascote
+        }
+    }
+    return partitura;
+}
+
+module.exports = { mundoDe, lerLugar, lerCoisas, lerElenco, iconesPendentes, aplicarIcones, LUGARES, HORAS, PECAS, ESPECIES, sem };

package/lib/estudio/personagem.js

@@ -28,6 +28,8 @@
 'use strict';
 
 const { volumesDaTrilha } = require('./ritmo.js');
+const mundo = require('./mundo.js');
+const colecao = require('./colecao.js');
 
 const FPS = 30;
 const r2 = (x) => Math.round(x * 100) / 100;
@@ -63,7 +65,7 @@ const CENARIOS_VOXEL = {
 // O nome antigo do set (podcast, estúdio…) tem um par no voxel.
 const VOXEL_DO_LISO = { podcast: 'telas', estudio: 'oceano', escritorio: 'terra', noite: 'neon' };
 // O mascote é laranja (o do Claude) a menos que o roteiro diga a cor.
-const CORES_MASCOTE = { claude: '#d97757', gpt: '#10a37f', chatgpt: '#10a37f', gemini: '#4f7cff', primo: '#22b8d8', primocode: '#22b8d8' };
+const CORES_MASCOTE = { claude: '#dd5a2b', gpt: '#10a37f', chatgpt: '#10a37f', gemini: '#4f7cff', primo: '#22b8d8', primocode: '#22b8d8' };
 const ROUPAS_VOXEL = ['#c2452f', '#2f4cdd', '#1f8a5b', '#d08a1e', '#7b5cff', '#e8e2d6'];
 // A pele de bloco é um tom mais fundo: sob a luz quente, o tom claro estourava.
 const PELES_VOXEL = ['#d9a07a', '#c08660', '#a8704c', '#8a5a3c', '#6b4229'];
@@ -84,12 +86,44 @@ function rng(semente) {
 }
 
 /** A aparência de quem fala: o que o roteiro disse vale; o resto sai do nome. */
+/* O TIPO de quem fala (11/10, "se eu pedir um cachorro ele vai fazer"):
+   pessoa · robo (o mascote) · animal (uma espécie que o kit/mundo.jsx monta) ·
+   coisa (qualquer objeto com ícone 3D, em blocos: "a pizza conversando com o
+   café"). O que o roteiro disse vale; senão, o NOME decide. */
+const TIPOS = ['pessoa', 'robo', 'animal', 'coisa'];
+function especieDe(txt) {
+    const s = mundo.sem(txt);
+    return Object.keys(mundo.ESPECIES).find((k) => mundo.ESPECIES[k].test(s) || k === s) || null;
+}
+function iconeDe(txt) {
+    const t = String(txt || '').trim().toLowerCase();
+    if (!t) return null;
+    return colecao.melhorIcone3d(t, 80) || (colecao.PT_EN[t] || colecao.PT_EN[mundo.sem(t)] ? colecao.melhorIcone3d(t, 40) : null);
+}
+function tipoDe(nome, pedido = {}) {
+    if (TIPOS.includes(pedido.tipo)) return pedido.tipo;
+    if (pedido.especie) return 'animal';
+    if (pedido.icone || pedido.coisa) return 'coisa';
+    if (especieDe(nome)) return 'animal';
+    if (EH_ROBO.test(nome)) return 'robo';
+    if (iconeDe(nome)) return 'coisa';
+    return 'pessoa';
+}
+
 function aparencia(nome, pedido = {}) {
     const k = (s) => hashDe(nome + ':' + s);
-    const tipo = pedido.tipo === 'robo' || pedido.tipo === 'pessoa' ? pedido.tipo : (EH_ROBO.test(nome) ? 'robo' : 'pessoa');
+    const tipo = tipoDe(nome, pedido);
     const rotulo = String(pedido.rotulo || pedido.nome || nome || '').trim().slice(0, 24);
+    if (tipo === 'animal') {
+        const especie = especieDe(pedido.especie || '') || especieDe(nome) || 'cachorro';
+        return { nome, rotulo, tipo, especie, ...(pedido.cor ? { cor: pedido.cor } : {}), ...(pedido.cor2 ? { cor2: pedido.cor2 } : {}) };
+    }
+    if (tipo === 'coisa') {
+        const termo = String(pedido.icone || pedido.coisa || nome);
+        return { nome, rotulo, tipo, icone: termo, ...(pedido.src ? { src: pedido.src } : {}) };
+    }
     if (tipo === 'robo') {
-        return { nome, rotulo, tipo, cor: pedido.cor || pegar(ROBOS, k('cor')), olhos: pedido.olhos || null };
+        return { nome, rotulo, tipo, cor: pedido.cor || pegar(ROBOS, k('cor')), olhos: pedido.olhos || null, ...(pedido.bigode ? { bigode: true } : {}) };
     }
     return {
         nome, rotulo, tipo,
@@ -99,6 +133,9 @@ function aparencia(nome, pedido = {}) {
         roupa: pedido.roupa || pegar(ROUPAS, k('roupa')),
         oculos: pedido.oculos != null ? !!pedido.oculos : k('oculos') < 0.3,
         barba: !!pedido.barba,   // só quando pedida: sorteada, ficava estranha em quem tem cabelo longo
+        bigode: !!pedido.bigode,
+        // A cabeça facetada (low-poly) é o padrão; 'cubo' é o rosto de pixel da 10.5.
+        ...(pedido.cabeca === 'cubo' ? { cabeca: 'cubo' } : {}),
     };
 }
 
@@ -119,6 +156,22 @@ function destaqueDe(pt, texto) {
     return m ? m[1].trim() : null;
 }
 
+/* O que o corpo faz na fala, além de falar. O roteiro diz (parte.acao); sem
+   ele, o texto sugere: "oi"/"tchau" acena, "olha"/"aqui" aponta, "!" de
+   vitória comemora. kit/voxel.jsx e kit/mundo.jsx desenham cada uma. */
+const ACOES = ['falar', 'acenar', 'apontar', 'pular', 'dancar', 'comemorar', 'pensar', 'andar', 'correr', 'sentar'];
+function acaoDe(pt, texto) {
+    const a = mundo.sem(pt.acao || '').replace(/[^a-z]/g, '');
+    const achada = ACOES.find((x) => a.startsWith(x.slice(0, 5)));
+    if (achada) return achada;
+    const s = mundo.sem(texto);
+    if (/^(oi|ola|e ai|fala,|bom dia|boa tarde|boa noite)\b|\b(tchau|ate mais|ate logo|valeu, ate)\b/.test(s)) return 'acenar';
+    if (/\b(consegui|conseguimos|ganhamos|vencemos|incrivel|isso ai|uhu|eba|viva)\b.*!/.test(s)) return 'comemorar';
+    if (/\b(olha|olhe|veja|repara|ali|aqui o|esse aqui)\b/.test(s)) return 'apontar';
+    if (/\b(sera que|hmm+|deixa eu pensar|pensando)\b/.test(s)) return 'pensar';
+    return 'falar';
+}
+
 const falaDe = (pt) => String(pt.texto || pt.fala || pt.narracao || pt.titulo || '').trim();
 
 /* Sem os tempos da voz, cada fala ganha o tempo de leitura (2,6 palavras/s)
@@ -206,6 +259,36 @@ function paineisDe(falas, roteiro = {}) {
     return out.length ? out : [{ titulo: String(roteiro.titulo || 'Agora').slice(0, 18), linha: '' }];
 }
 
+
+/* BICHO NÃO FALA (11/10, "e o cachorro fala? mds kkk"): fala de bicho com voz
+   de gente fica ridícula. A parte do bicho SAI da narração e ele fica na cena
+   como figurante (abanando o rabo). Ele só fala se o pedido disser que fala:
+   "cachorro falante", "um gato que fala", "o cachorro falando". Muda o
+   roteiro no lugar (o array de partes é o mesmo) e devolve quem calou. */
+function calarBichos(roteiro, pedido = '') {
+    const partes = Array.isArray(roteiro && roteiro.partes) ? roteiro.partes : [];
+    const pedidos = (roteiro && roteiro.personagens) || {};
+    const ped = mundo.sem(pedido);
+    const calados = [];
+    for (let i = partes.length - 1; i >= 0; i--) {
+        const pt = partes[i];
+        const nome = typeof (pt && pt.falante) === 'string' ? pt.falante.trim().toLowerCase() : '';
+        if (!nome) continue;
+        const dado = pedidos[nome] || pedidos[Object.keys(pedidos).find((k) => k.toLowerCase() === nome)] || {};
+        const fala = mundo.sem(partes.filter((x) => String(x.falante || '').trim().toLowerCase() === nome).map(falaDe).join(' '));
+        const latido = /\bau[ -]?au\b|\bau!|\bmiau|\bmu+u\b|\boinc\b|\bquack\b|\bcocoric/.test(fala);
+        const tipo = dado.tipo || (dado.especie ? 'animal' : (especieDe(nome) || latido ? 'animal' : null));
+        if (tipo !== 'animal' || dado.fala === true) continue;
+        const esp = especieDe(dado.especie || '') || especieDe(nome) || (/\bmiau/.test(fala) ? 'gato' : 'cachorro');
+        const falante = new RegExp(`\\b(${Object.keys(mundo.ESPECIES).join('|')}|bicho|animal|${nome})\\w*\\s+(falante|que fala|falando|fala)\\b`).test(ped);
+        if (falante) continue;
+        partes.splice(i, 1);
+        if (!calados.some((c) => c.nome === nome)) calados.push({ nome, especie: esp });
+    }
+    if (calados.length) roteiro.figurantesExtra = [...(roteiro.figurantesExtra || []), ...calados.map((c) => ({ nome: c.nome, tipo: 'animal', especie: c.especie }))];
+    return calados;
+}
+
 /** A partitura inteira: o que o kit/personagem.jsx desenha, quadro a quadro. */
 function partituraDe({ roteiro = {}, largura = 1920, altura = 1080, tempos = [] }) {
     const partes = (roteiro.partes || []).filter((p) => p && typeof p === 'object' && falaDe(p));
@@ -220,9 +303,20 @@ function partituraDe({ roteiro = {}, largura = 1920, altura = 1080, tempos = []
         if (!nomes.includes(f)) nomes.push(f);
     }
     const pedidos = roteiro.personagens && typeof roteiro.personagens === 'object' ? roteiro.personagens : {};
-    const pedidoDe = (n) => pedidos[n] || pedidos[Object.keys(pedidos).find((k) => k.toLowerCase() === n)] || {};
-    // No set cabem dois; o terceiro em diante divide o lugar (raro num diálogo).
-    const elenco = nomes.slice(0, 2).map((n, i) => ({ ...aparencia(n, pedidoDe(n)), lado: nomes.length > 1 ? (i === 0 ? -1 : 1) : 0 }));
+    /* Quem LATE é cachorro: um falante sem tipo cuja fala tem a voz de um
+       bicho ("Au au!", "Miau") vira aquele bicho — o modelo pequeno escreve o
+       diálogo e esquece de dizer que o Rex é um cachorro. */
+    const VOZ_DE_BICHO = [[/\bau[ -]?au\b|\bau!|\bauau\b|\bwoof\b/, 'cachorro'], [/\bmiau+\b/, 'gato'], [/\bmu+u\b/, 'vaca'], [/\boinc\b/, 'porco'],
+        [/\bquack\b|\bqua[ -]?qua\b/, 'pato'], [/\bcocoric[oó]\b/, 'galinha'], [/\bpiu[ -]?piu\b/, 'passaro'], [/\bme+h+\b|\bbe+h+\b/, 'ovelha'], [/\brua+r+\b|\broar\b/, 'leao']];
+    const pedidoDe = (n) => {
+        const dado = pedidos[n] || pedidos[Object.keys(pedidos).find((k) => k.toLowerCase() === n)] || {};
+        if (dado.tipo || dado.especie) return dado;
+        const fala = mundo.sem(partes.filter((pt) => String(pt.falante || '').trim().toLowerCase() === n).map(falaDe).join(' '));
+        const bicho = VOZ_DE_BICHO.find(([re]) => re.test(fala));
+        return bicho ? { ...dado, tipo: 'animal', especie: bicho[1] } : dado;
+    };
+    // Até QUATRO falam no set ("três amigos no parque"); do quinto em diante dividem o lugar.
+    const elenco = nomes.slice(0, 4).map((n, i) => ({ ...aparencia(n, pedidoDe(n)), lado: nomes.length > 1 ? (i < nomes.length / 2 ? -1 : 1) : 0, ordem: i }));
     const quemDe = (pt) => {
         const f = typeof pt.falante === 'string' && pt.falante.trim() ? pt.falante.trim().toLowerCase() : 'apresentador';
         return nomes.indexOf(f) % Math.max(1, elenco.length);
@@ -235,7 +329,7 @@ function partituraDe({ roteiro = {}, largura = 1920, altura = 1080, tempos = []
             .map((w) => ({ t: String(w.texto || w.word || ''), de: r2(w.de), ate: r2(w.ate) }));
         return {
             quem: quemDe(pt), de: r2(t.de != null ? t.de : (palavras[0] || {}).de || 0), ate: r2(t.ate != null ? t.ate : (palavras[palavras.length - 1] || {}).ate || 0),
-            texto, palavras, emocao: emocaoDe(pt, texto), destaque: destaqueDe(pt, texto),
+            texto, palavras, emocao: emocaoDe(pt, texto), destaque: destaqueDe(pt, texto), acao: acaoDe(pt, texto),
         };
     });
     const duracao = r2((falas.length ? falas[falas.length - 1].ate : 3) + 1.2);
@@ -258,14 +352,72 @@ function partituraDe({ roteiro = {}, largura = 1920, altura = 1080, tempos = []
         cenarioFinal = { nome: nomeV, ...CENARIOS_VOXEL[nomeV] };
         if (roteiro.acento && /^#[0-9a-f]{6}$/i.test(roteiro.acento)) cenarioFinal.acento = roteiro.acento;
         for (const e of elenco) {
-            if (e.tipo === 'robo' && !(pedidoDe(e.nome) || {}).cor) e.cor = CORES_MASCOTE[e.nome] || '#d97757';
+            if (e.tipo === 'robo' && !(pedidoDe(e.nome) || {}).cor) e.cor = CORES_MASCOTE[e.nome] || '#dd5a2b';
             if (e.tipo === 'pessoa' && !(pedidoDe(e.nome) || {}).roupa) e.roupa = pegar(ROUPAS_VOXEL, hashDe(e.nome + ':roupa'));
             if (e.tipo === 'pessoa' && !(pedidoDe(e.nome) || {}).pele) e.pele = pegar(PELES_VOXEL, hashDe(e.nome + ':pele'));
             if (e.tipo === 'pessoa' && !(pedidoDe(e.nome) || {}).corCabelo) e.corCabelo = pegar(CABELOS_VOXEL, hashDe(e.nome + ':corCabelo'));
         }
     }
+    /* O MUNDO (mundo.js): o lugar e as coisas. roteiro.cena (texto livre ou
+       objeto) é o do vídeo; parte.cenario muda o lugar a partir daquela fala.
+       O pedido da pessoa e as falas completam o que a cena não disse. */
+    const pedidoTexto = String(roteiro.pedido || roteiro.descricao || '');
+    const textoTodo = [pedidoTexto, roteiro.titulo, ...falas.map((f) => f.texto)].filter(Boolean).join(' ');
+    const cenaBase = roteiro.cena || roteiro.cenario || '';
+    const mundos = [];
+    const indiceDe = (pedido) => {
+        const chave = JSON.stringify(pedido || '');
+        const ja = mundos.findIndex((m) => m.chave === chave);
+        if (ja >= 0) return ja;
+        mundos.push({ chave, ...mundo.mundoDe(pedido, { texto: textoTodo, pedidoTexto, semente: semente + mundos.length * 7, nElenco: elenco.length }) });
+        return mundos.length - 1;
+    };
+    indiceDe(cenaBase);
+    let atual = 0;
+    partes.forEach((pt, i) => {
+        const pedidoParte = pt.cena || pt.cenario;
+        if (pedidoParte) atual = indiceDe(pedidoParte);
+        if (falas[i]) falas[i].mundo = atual;
+    });
+    for (const m of mundos) delete m.chave;
+    // O set da referência (telas) segue com as cores dele; os outros lugares trazem as suas.
+    if (mundos[0].lugar !== 'telas') cenarioFinal = { ...cenarioFinal, nome: mundos[0].nome, parede: mundos[0].parede || mundos[0].ceu?.[1] || cenarioFinal.parede, acento: mundos[0].acento };
+
+    /* OS FIGURANTES: quem o pedido põe na cena e não fala ("um humano com o
+       cachorro", "dois humanos" com um narrador só). roteiro.figurantes manda;
+       senão, os bichos e as pessoas do pedido que sobraram do elenco. */
+    const figurantes = [];
+    if (Array.isArray(roteiro.figurantes)) {
+        for (const f of roteiro.figurantes.slice(0, 4)) {
+            const pedidoF = typeof f === 'string' ? { tipo: tipoDe(f, {}), especie: especieDe(f) || undefined, icone: f } : f || {};
+            const nomeF = typeof f === 'string' ? f : String(f.nome || f.especie || f.icone || 'figurante');
+            figurantes.push({ ...aparencia(nomeF, pedidoF) });
+        }
+    } else if (pedidoTexto) {
+        const lido = mundo.lerElenco(pedidoTexto);
+        const temEspecie = (esp) => elenco.some((e) => e.tipo === 'animal' && e.especie === esp);
+        for (const b of lido.bichos) {
+            for (let k = 0; k < b.quantos - (temEspecie(b.especie) ? 1 : 0) && figurantes.length < 3; k++) {
+                figurantes.push(aparencia(`${b.especie} ${k + 1}`, { tipo: 'animal', especie: b.especie }));
+            }
+        }
+        const pessoas = elenco.filter((e) => e.tipo === 'pessoa').length;
+        for (let k = pessoas; k < lido.pessoas && figurantes.length < 4; k++) figurantes.push(aparencia(`pessoa ${k + 1}`, { tipo: 'pessoa' }));
+    }
+    // Os bichos que calaram (calarBichos) entram como figurantes, antes de tudo.
+    for (const f of (Array.isArray(roteiro.figurantesExtra) ? roteiro.figurantesExtra : []).slice(0, 3)) {
+        if (!figurantes.some((x) => x.nome === f.nome)) figurantes.unshift(aparencia(f.nome, { tipo: 'animal', especie: f.especie }));
+    }
+    // O mesmo bicho que o pedido já pôs como figurante não aparece duas vezes.
+    for (let k = figurantes.length - 1; k > 0; k--) if (figurantes.slice(0, k).some((x) => x.tipo === 'animal' && x.especie === figurantes[k].especie && x !== figurantes[k] && /\d$/.test(figurantes[k].nome))) figurantes.splice(k, 1);
+    if (visual === 'voxel') {
+        for (const e of figurantes) {
+            if (e.tipo === 'pessoa') { e.roupa = pegar(ROUPAS_VOXEL, hashDe(e.nome + ':roupa')); e.pele = pegar(PELES_VOXEL, hashDe(e.nome + ':pele')); e.corCabelo = pegar(CABELOS_VOXEL, hashDe(e.nome + ':corCabelo')); }
+        }
+    }
+
     return {
-        versao: 1, fps: FPS, largura, altura, duracao, semente, cenario: cenarioFinal, elenco, falas, planos, visual,
+        versao: 2, fps: FPS, largura, altura, duracao, semente, cenario: cenarioFinal, elenco, falas, planos, visual, mundos, figurantes,
         paineis: paineisDe(falas, roteiro),
         legenda: roteiro.legenda !== false,
         titulo: typeof roteiro.titulo === 'string' ? roteiro.titulo.slice(0, 60) : '',
@@ -296,8 +448,9 @@ function montarPersonagem({ roteiro, largura = 1920, altura = 1080, tempos = [],
     };
     return {
         ok: true, plano, partitura,
-        resumo: { visual: partitura.visual, cenas: 1, segundos: DUR, fps: FPS, cenario: partitura.cenario.nome, elenco: partitura.elenco.map((e) => `${e.rotulo} (${e.tipo})`), planos: partitura.planos.length, falas: partitura.falas.length },
+        resumo: { visual: partitura.visual, cenas: 1, segundos: DUR, fps: FPS, cenario: partitura.cenario.nome, elenco: partitura.elenco.map((e) => `${e.rotulo} (${e.tipo === 'animal' ? e.especie : e.tipo})`),
+            figurantes: partitura.figurantes.map((e) => (e.tipo === 'animal' ? e.especie : e.tipo)), lugares: partitura.mundos.map((m) => m.nome), planos: partitura.planos.length, falas: partitura.falas.length },
     };
 }
 
-module.exports = { montarPersonagem, partituraDe, planosDe, paineisDe, aparencia, destaqueDe, emocaoDe, CENARIOS, CENARIOS_VOXEL, EH_ROBO, FPS };
+module.exports = { calarBichos, montarPersonagem, partituraDe, planosDe, paineisDe, aparencia, tipoDe, acaoDe, destaqueDe, emocaoDe, CENARIOS, CENARIOS_VOXEL, EH_ROBO, FPS };