primocode 10.10.1 → 10.11.1

package/lib/estudio/kit/natural.js

@@ -0,0 +1,161 @@
+/* kit/natural.js — o movimento com PESO: as curvas que tiram o 3D do robótico.
+ *
+ *   "a animação do boneco, a movimentação, é muito robótico" (Joel, 14/10)
+ *
+ * O boneco mexia em seno puro: todo membro no mesmo tempo, a mesma volta
+ * idêntica para sempre, parada seca quando a ação acabava e o corpo congelado
+ * quando não falava. Aqui moram os princípios de animação, em funções puras
+ * (o node testa, o kit/voxel.jsx e o kit/personagem.jsx desenham):
+ *  - mola: massa e amortecimento — acelera, passa um pouco do ponto e assenta;
+ *  - antecipa: recua antes de ir e passa um tico depois (follow-through);
+ *  - atraso: tronco, cabeça, braço e mão com tempos diferentes (sobreposição);
+ *  - ruido: a micro variação que nunca repete, igual em todo render (semente);
+ *  - respiracao: inspira mais rápido do que expira, o ritmo varia um pouco;
+ *  - salto: agacha, estica no impulso, cai acelerando, amassa no pouso e assenta;
+ *  - passo: o quadril que balança, o corpo que desce no contato, o tronco que
+ *    gira contra o quadril e o braço que vai atrasado da perna.
+ * Nada de Math.random nem Date.now: o mesmo quadro sai igual sempre. */
+'use strict';
+
+const clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
+const suave = (x) => { const k = clamp(x); return k * k * (3 - 2 * k); };
+
+/** Um número de 0 a 1 a partir de um número inteiro e de uma semente (texto ou número). */
+function sementeDe(s) {
+    if (typeof s === 'number') return s;
+    let h = 2166136261;
+    for (const c of String(s || '')) { h ^= c.charCodeAt(0); h = Math.imul(h, 16777619); }
+    return (h >>> 0) % 100000;
+}
+function sorte(n, semente = 0) {
+    const x = Math.sin(n * 127.1 + sementeDe(semente) * 311.7) * 43758.5453;
+    return x - Math.floor(x);
+}
+
+/** Ruído suave de -1 a 1 (dois tons somados): a deriva que nunca repete igual. */
+function ruido(t, semente = 0) {
+    const tom = (x, s) => {
+        const i = Math.floor(x), f = x - i;
+        const a = sorte(i, s) * 2 - 1, b = sorte(i + 1, s) * 2 - 1;
+        const k = f * f * f * (f * (f * 6 - 15) + 10);   // o quíntico: sem quina na emenda
+        return a + (b - a) * k;
+    };
+    const s = sementeDe(semente);
+    return tom(t, s) * 0.68 + tom(t * 2.17 + 13.3, s + 7) * 0.32;
+}
+
+/**
+ * A MOLA: a resposta de massa-mola-amortecedor indo de 0 a 1, `s` segundos
+ * depois do gatilho. `freq` em Hz, `amort` < 1 passa do ponto e volta.
+ */
+function mola(s, { freq = 2.2, amort = 0.5 } = {}) {
+    if (s <= 0) return 0;
+    const w = 2 * Math.PI * freq;
+    if (amort >= 1) return 1 - Math.exp(-w * s) * (1 + w * s);
+    const wd = w * Math.sqrt(1 - amort * amort);
+    return 1 - Math.exp(-amort * w * s) * (Math.cos(wd * s) + (amort * w / wd) * Math.sin(wd * s));
+}
+
+/**
+ * A curva de 0 a 1 que RECUA antes de ir (antecipação) e passa um tico do fim
+ * antes de assentar (follow-through). Lenta nas pontas, rápida no meio.
+ */
+function antecipa(x, { recuo = 0.1, passa = 0.06 } = {}) {
+    const k = clamp(x);
+    const base = suave(k);
+    const antes = -recuo * Math.sin(Math.PI * clamp(k / 0.3)) * (k < 0.3 ? 1 : 0);
+    const depois = passa * Math.sin(Math.PI * clamp((k - 0.62) / 0.38)) * (k > 0.62 ? 1 : 0);
+    return base + antes + depois;
+}
+
+/**
+ * O PESO DE UMA AÇÃO entre `de` e `ate` (segundos): entra com mola (passa e
+ * assenta), sai devagar, e nunca corta seco. `atraso` é a sobreposição: o
+ * membro que vem depois (cotovelo depois do ombro, cabeça depois do tronco).
+ */
+function envelope(t, de, ate, { atraso = 0, entra = 2.4, sai = 0.55, amort = 0.55 } = {}) {
+    const tt = t - atraso;
+    if (tt < de) return 0;
+    const dentro = mola(tt - de, { freq: entra, amort });   // passa de 1 e volta: o membro assenta
+    const fora = tt > ate ? 1 - suave((tt - ate) / sai) : 1;
+    return Math.max(0, dentro * fora);
+}
+
+/**
+ * O GESTO de ênfase, `s` segundos depois de começar: o braço cai um pouco
+ * (antecipação), sobe rápido passando do ponto, segura e desce devagar.
+ * Dura ~1,1 s; fora disso é 0.
+ */
+function golpe(s) {
+    if (s <= 0 || s >= 1.15) return 0;
+    const sobe = s < 0.1 ? -0.14 * Math.sin(Math.PI * s / 0.1) : mola(s - 0.1, { freq: 2.6, amort: 0.5 });
+    const desce = 1 - suave((s - 0.55) / 0.6);
+    return sobe * desce;
+}
+
+/**
+ * A RESPIRAÇÃO de 0 a 1: inspira em ~40% do ciclo, expira no resto, e o
+ * ciclo (≈3,4 s) varia um pouco a cada volta, pela semente.
+ */
+function respiracao(t, semente = 0) {
+    const periodo = 3.4;
+    const fase = t / periodo + 0.12 * ruido(t * 0.15, semente) + sorte(1, semente);
+    const p = fase - Math.floor(fase);
+    return p < 0.4 ? suave(p / 0.4) : 1 - suave((p - 0.4) / 0.6);
+}
+
+/**
+ * O SALTO, num ciclo de `periodo` s: agacha (amassa), impulsiona (estica),
+ * sobe e cai em parábola (a gravidade: a queda acelera), amassa no pouso e
+ * assenta. Devolve {y, sx, sy}: a altura e a escala de amassar/esticar
+ * (o volume fica: sx ≈ 1/√sy).
+ */
+function salto(t, { periodo = 0.95, altura = 0.32, fase = 0 } = {}) {
+    const p = ((t / periodo + fase) % 1 + 1) % 1;
+    const AGACHA = 0.16, AR = 0.6, POUSO = 1 - AGACHA - AR;
+    let y = 0, sy = 1;
+    if (p < AGACHA) {
+        const k = p / AGACHA;
+        const amassa = Math.sin(Math.PI * Math.min(1, k * 1.25)) * (k < 0.8 ? 1 : 0);
+        sy = 1 - 0.14 * amassa;
+        y = -0.05 * altura * amassa;
+        if (k >= 0.8) sy = 1 + 0.12 * suave((k - 0.8) / 0.2);   // o impulso: estica antes de sair do chão
+    } else if (p < AGACHA + AR) {
+        const q = (p - AGACHA) / AR;
+        y = altura * 4 * q * (1 - q);                 // a parábola: sobe freando, desce acelerando
+        sy = 1 + 0.12 * Math.pow(Math.abs(1 - 2 * q), 1.5);   // estica com a velocidade, redondo no alto
+    } else {
+        const k = (p - AGACHA - AR) / POUSO;
+        const amortece = Math.exp(-4.2 * k) * Math.cos(k * Math.PI * 2.2);
+        sy = 1 - 0.18 * amortece;                     // o pouso amassa e assenta em mola
+        y = -0.04 * altura * Math.max(0, amortece);
+    }
+    return { y, sy, sx: 1 / Math.sqrt(Math.max(0.5, sy)) };
+}
+
+/**
+ * O PASSO, `t` em s, `ritmo` em passos por segundo (andar ≈ 1,8, correr ≈ 3).
+ * Devolve os ângulos (rad) e o deslocamento do corpo:
+ *  perna[esq,dir]  balanço da coxa (para frente é negativo no eixo X)
+ *  braco[esq,dir]  o braço oposto à perna, atrasado (sobreposição)
+ *  quadril         o rolar do quadril para o lado da perna que apoia
+ *  giro            o tronco que gira contra o quadril
+ *  sobe            o corpo desce no contato e sobe na passagem
+ */
+function passo(t, { ritmo = 1.8, amplitude = 0.42, correr = false, semente = 0 } = {}) {
+    const f = Math.PI * ritmo * t + sorte(3, semente) * 0.3;
+    // A perna vai para frente mais rápido do que volta no apoio: a onda torta.
+    const onda = (x) => Math.sin(x + 0.22 * Math.sin(x));
+    const a = amplitude * (correr ? 1.6 : 1);
+    const atrasoBraco = correr ? 0.18 : 0.32;           // o braço chega depois da perna
+    return {
+        perna: [onda(f) * a, onda(f + Math.PI) * a],
+        braco: [onda(f + Math.PI - atrasoBraco) * a * 0.9, onda(f - atrasoBraco) * a * 0.9],
+        quadril: Math.sin(f - 0.35) * (correr ? 0.03 : 0.055),
+        giro: -Math.sin(f - 0.15) * (correr ? 0.12 : 0.07),
+        sobe: (0.5 + 0.5 * Math.cos(2 * f)) * (correr ? 0.09 : 0.045),
+        inclina: correr ? 0.14 : 0.03,                  // quem corre vai com o tronco para frente
+    };
+}
+
+module.exports = { clamp, suave, sorte, ruido, mola, antecipa, envelope, golpe, respiracao, salto, passo };

package/lib/estudio/kit/personagem.jsx

@@ -16,6 +16,8 @@ import { ThreeCanvas } from '@remotion/three';
 import * as THREE from 'three';
 import { useThree } from '@react-three/fiber';
 import { RoomEnvironment } from 'three/examples/jsm/environments/RoomEnvironment.js';
+// O movimento com peso (mola, antecipação, sobreposição, respiração): kit/natural.js.
+import { ruido, envelope, golpe, respiracao } from './natural';
 
 const clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
 const lerp = (a, b, k) => a + (b - a) * k;
@@ -93,10 +95,10 @@ function gesto(falas, quem, t) {
     if (f.quem !== quem || t < f.de - 0.5 || t > f.ate + 1) continue;
     f.palavras.forEach((w, k) => {
       if (String(w.t).replace(/[^\p{L}\d]/gu, '').length < 6 && !/\d/.test(w.t)) return;
-      const x = (t - (w.de - 0.15)) / 0.9;
-      if (x < 0 || x > 1) return;
-      const b = Math.sin(Math.PI * x);
-      if (k % 2) esq = Math.max(esq, b); else dir = Math.max(dir, b);
+      // Recua, sobe passando do ponto e desce devagar (natural.golpe), não um seno.
+      const b = golpe(t - (w.de - 0.15));
+      if (b === 0) return;
+      if (k % 2) esq = Math.abs(b) > Math.abs(esq) ? b : esq; else dir = Math.abs(b) > Math.abs(dir) ? b : dir;
     });
   }
   return [esq, dir];
@@ -256,12 +258,14 @@ function RostoRobo({ p, est, acento }) {
 }
 
 /* ── O CORPO, OS BRAÇOS E O PERSONAGEM INTEIRO ───────────────────────────── */
-function Braco({ lado, g, cor, pele, robo, t }) {
-  // Repouso: o antebraço deitado na mesa. Gesto: a mão sobe e mexe um pouco.
-  const ombroX = lerp(-0.3, -0.62, g) + Math.sin(t * 6 + lado) * 0.05 * g;
-  const ombroZ = lado * lerp(0.08, 0.28, g);
-  const cotovelo = lerp(-1.17, -1.75, g) + Math.sin(t * 7.3 + lado * 2) * 0.12 * g;
-  const pulso = Math.sin(t * 9 + lado) * 0.25 * g;
+function Braco({ lado, g, gc = g, gp = gc, cor, pele, robo, t, sem = 0 }) {
+  // Repouso: o antebraço deitado na mesa, que deriva de leve (nunca congelado).
+  // Gesto: o ombro leva, o cotovelo (gc) e o pulso (gp) vêm depois — a sobreposição.
+  const deriva = ruido(t * 0.4, sem + lado * 5) * 0.03;
+  const ombroX = lerp(-0.3, -0.62, g) + Math.sin(t * 6 + lado) * 0.05 * Math.max(0, g) + deriva;
+  const ombroZ = lado * lerp(0.08, 0.28, Math.max(0, g));
+  const cotovelo = lerp(-1.17, -1.75, gc) + Math.sin(t * 7.3 + lado * 2 - 0.8) * 0.12 * Math.max(0, gc) + deriva * 0.5;
+  const pulso = Math.sin(t * 9 + lado - 1.4) * 0.25 * Math.max(0, gp) + ruido(t * 0.7, sem + lado) * 0.06;
   const tecido = robo ? <Mat c={cor} r={0.3} m={0.1} cc={1} /> : <Mat c={cor} r={0.85} sheen="#ffffff" />;
   return (
     <group position={[lado * 0.44, 1.18, 0]} rotation={[ombroX, 0, ombroZ]}>
@@ -279,7 +283,8 @@ function Braco({ lado, g, cor, pele, robo, t }) {
 function Personagem({ p, est, acento, pos, giro }) {
   const robo = p.tipo === 'robo';
   const corpo = robo ? p.cor : p.roupa;
-  const resp = 1 + Math.sin(est.t * 1.6 + pos[0]) * 0.012;
+  // O fôlego: inspira rápido, expira devagar, o ritmo varia (natural.respiracao).
+  const resp = 1 + respiracao(est.t, (est.semente || 0) + pos[0]) * 0.016;
   const [cy, cp, cr] = est.cabeca;
   return (
     <group position={pos} rotation={[0, giro, 0]}>
@@ -293,8 +298,7 @@ function Personagem({ p, est, acento, pos, giro }) {
           : <mesh position={[0, 1.27, 0]} rotation={[Math.PI / 2, 0, 0]}><torusGeometry args={[0.15, 0.04, 12, 32]} /><Mat c={new THREE.Color(corpo).multiplyScalar(0.7).getStyle()} r={0.85} /></mesh>}
         <mesh position={[0, 1.3, 0]}><cylinderGeometry args={[0.12, 0.13, 0.25, 24]} />{robo ? <Mat c="#3a3e48" r={0.4} m={0.6} /> : <Mat c={p.pele} r={0.6} sheen="#ff9a8a" />}</mesh>
       </group>
-      <Braco lado={-1} g={est.gesto[0]} cor={corpo} pele={p.pele} robo={robo} t={est.t} />
-      <Braco lado={1} g={est.gesto[1]} cor={corpo} pele={p.pele} robo={robo} t={est.t} />
+      {[-1, 1].map((l) => { const k = l > 0 ? 1 : 0; return <Braco key={l} lado={l} g={est.gesto[k]} gc={(est.gestoAtras || est.gesto)[k]} gp={(est.gestoMao || est.gesto)[k]} cor={corpo} pele={p.pele} robo={robo} t={est.t} sem={est.semente || 0} />; })}
       <group position={[0, 1.62, 0]} rotation={[cp, cy, cr]} castShadow>
         {robo ? <RostoRobo p={p} est={est} acento={acento} /> : <Rosto p={p} est={est} />}
       </group>
@@ -529,19 +533,31 @@ export function PersonagemCena({ el, t }) {
     for (const f of falas) if (f.quem === i && f.de <= t + 0.2) e = t <= f.ate + 2.5 ? f.emocao : 'neutro';
     return e;
   };
+  // O quanto cada um está falando (0 a 1, sem degrau): os acenos trocam com mola.
+  const pesoDaFala = (i, reacao = 0) => falas.reduce((m, f) => (f.quem === i ? Math.max(m, Math.min(1, envelope(t, f.de + reacao, f.ate, { entra: 2.6, sai: 0.45, amort: 0.7 }))) : m), 0);
   const estado = (i) => {
+    const sem = i * 13 + 1;
     const fala = falandoAgora(i);
-    const outro = dois && falandoAgora(1 - i);
+    const wFala = pesoDaFala(i);
+    // Quem ouve reage ~0,2 s depois, com mola, e volta devagar.
+    const wOuve = dois ? pesoDaFala(1 - i, 0.2) : 0;
     const enfase = gesto(falas, i, t);
-    const nod = Math.sin(t * (fala ? 5.2 : 1.4) + i) * (fala ? 0.035 : 0.015) + (outro ? Math.max(0, Math.sin(t * 2.1 + i)) * 0.04 : 0);
+    const nod = lerp(ruido(t * 0.5, sem + 3) * 0.015, Math.sin(t * 5.2 + i) * 0.028 + ruido(t * 2.4, sem + 2) * 0.016, wFala)
+      + wOuve * Math.max(0, Math.sin(t * 2.1 + i)) * 0.04;
     const emo = emocaoDe(i);
-    const e = EMO[emo] || EMO.neutro;
-    const micro = (hash(Math.floor(t * 1.5) + i * 7) - 0.5) * 0.08;
+    // A inclinação da emoção chega e vai embora com peso, não troca no quadro.
+    let inclina = 0;
+    for (const f of falas) {
+      if (f.quem !== i || f.de > t + 0.2) continue;
+      inclina = ((EMO[f.emocao] || EMO.neutro).inclina || 0) * Math.min(1.05, envelope(t, f.de - 0.2, f.ate + 2.5, { entra: 1.4, sai: 0.8, amort: 0.6 }));
+    }
+    const micro = (hash(Math.floor(t * 1.5 + hash(i) * 0.9) + i * 7) - 0.5) * 0.08;
     return {
-      t, falando: fala, emocao: emo, boca: boca(falas, i, t), pisca: piscada(i, t),
-      gesto: enfase, enfase: Math.max(enfase[0], enfase[1]),
+      t, semente: sem, falando: fala, emocao: emo, boca: boca(falas, i, t), pisca: piscada(i, t),
+      gesto: enfase, gestoAtras: gesto(falas, i, t - 0.08), gestoMao: gesto(falas, i, t - 0.15), enfase: Math.max(enfase[0], enfase[1], 0),
       olhar: dois ? [micro, 0.02] : [micro * 0.5, 0.04],
-      cabeca: [Math.sin(t * 0.7 + i * 2) * 0.08 + (outro ? 0.05 : 0), nod + (fala ? 0 : 0.03), (e.inclina || 0) * (i ? -1 : 1) + Math.sin(t * 0.5 + i) * 0.02],
+      // A cabeça deriva pelo ruído (nunca a mesma volta) e vem ~0,06 s atrás do corpo.
+      cabeca: [ruido((t - 0.06) * 0.35, sem + 5) * 0.09 + wOuve * 0.05, nod + (1 - wFala) * 0.03, inclina * (i ? -1 : 1) + ruido((t - 0.06) * 0.25, sem + 7) * 0.025],
     };
   };
   const posDe = (i) => (dois ? [(elenco[i].lado || 0) * 0.95, 0, 0] : [0, 0, 0]);

package/lib/estudio/kit/voxel.jsx

@@ -31,6 +31,8 @@ import { BokehPass } from 'three/examples/jsm/postprocessing/BokehPass.js';
 import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
 import { RoomEnvironment } from 'three/examples/jsm/environments/RoomEnvironment.js';
 import { Mundo, Animal, Coisa, alturaDoBicho, frenteDoBicho, useIcones } from './mundo.jsx';
+// O movimento com peso (mola, antecipação, sobreposição, respiração, salto, passo): kit/natural.js.
+import { ruido, envelope, golpe, respiracao, salto, passo } from './natural';
 
 const clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
 const lerp = (a, b, k) => a + (b - a) * k;
@@ -144,10 +146,10 @@ function gesto(falas, quem, t) {
     if (f.quem !== quem || t < f.de - 0.5 || t > f.ate + 1) continue;
     f.palavras.forEach((w, k) => {
       if (String(w.t).replace(/[^\p{L}\d]/gu, '').length < 6 && !/\d/.test(w.t)) return;
-      const x = (t - (w.de - 0.15)) / 1.0;
-      if (x < 0 || x > 1) return;
-      const b = Math.sin(Math.PI * x);
-      if (k % 2) esq = Math.max(esq, b); else dir = Math.max(dir, b);
+      // O braço recua, sobe passando do ponto e desce devagar (natural.golpe), não um seno.
+      const b = golpe(t - (w.de - 0.15));
+      if (b === 0) return;
+      if (k % 2) esq = Math.abs(b) > Math.abs(esq) ? b : esq; else dir = Math.abs(b) > Math.abs(dir) ? b : dir;
     });
   }
   return [esq, dir];
@@ -372,26 +374,36 @@ function CabecaFacetada({ p, est }) {
 /* A AÇÃO da fala mexe o braço por cima do gesto: acenar (a mão direita no
    alto, abanando), apontar (o braço esticado para a frente), comemorar (os
    dois para cima), pensar (a mão no queixo), dançar (os dois balançando). */
-function poseDoBraco(acao, lado, t, k) {
+function poseDoBraco(acao, lado, t, k, sem = 0) {
   if (!acao || k <= 0) return null;
   const dir = lado > 0;
-  if (acao === 'acenar' && dir) return { x: -0.25, z: 2.55 + Math.sin(t * 9) * 0.25, c: -0.55 + Math.sin(t * 9) * 0.35 };
-  if (acao === 'apontar' && dir) return { x: -1.45, z: 0.12, c: -0.05 };
-  if (acao === 'comemorar') return { x: -0.2, z: lado * (2.7 + Math.sin(t * 8 + lado) * 0.15), c: -0.25 };
-  if (acao === 'pensar' && dir) return { x: -1.5, z: -0.35, c: -2.1 };
-  if (acao === 'dancar') return { x: -0.6 + Math.sin(t * 6 + lado) * 0.5, z: lado * (0.6 + Math.sin(t * 6) * 0.3), c: -1.1 };
-  if (acao === 'correr') return { x: Math.sin(t * 13 + (lado > 0 ? 0 : Math.PI)) * 0.9, z: lado * 0.1, c: -1.3 };
-  if (acao === 'andar') return { x: Math.sin(t * 7 + (lado > 0 ? 0 : Math.PI)) * 0.45, z: lado * 0.06, c: -0.25 };
+  // O antebraço vem ATRASADO do braço (sobreposição): a mesma onda, a fase depois.
+  if (acao === 'acenar' && dir) return { x: -0.25, z: 2.55 + Math.sin(t * 9) * 0.22, c: -0.55 + Math.sin(t * 9 - 1.1) * 0.4 };
+  if (acao === 'apontar' && dir) return { x: -1.45 + ruido(t * 0.8, sem + 3) * 0.04, z: 0.12, c: -0.05 };
+  if (acao === 'comemorar') return { x: -0.2, z: lado * (2.7 + Math.sin(t * 8 + lado) * 0.15), c: -0.25 + Math.sin(t * 8 + lado - 1) * 0.2 };
+  if (acao === 'pensar' && dir) return { x: -1.5 + ruido(t * 0.5, sem + 4) * 0.05, z: -0.35, c: -2.1 };
+  if (acao === 'dancar') return { x: -0.6 + Math.sin(t * 6 + lado) * 0.5, z: lado * (0.6 + Math.sin(t * 6 - 0.5) * 0.3), c: -1.1 + Math.sin(t * 6 + lado - 0.9) * 0.3 };
+  // Andar e correr: o braço oposto à perna, atrasado dela (natural.passo).
+  if (acao === 'correr' || acao === 'andar') {
+    const ps = passo(t, { correr: acao === 'correr', semente: sem });
+    const b = ps.braco[dir ? 1 : 0];
+    return acao === 'correr' ? { x: b * 1.2, z: lado * 0.1, c: -1.3 + b * 0.25 } : { x: b, z: lado * 0.06, c: -0.25 + Math.min(0, b) * 0.5 };
+  }
   return null;
 }
 
-function BracoBloco({ lado, g, cor, pele, t, acao, k = 1 }) {
-  // Repouso: o braço caído, um tico para fora. Gesto: o antebraço sobe e a mão mexe.
-  let ombroX = lerp(0.08, -0.85, g) + Math.sin(t * 6 + lado) * 0.06 * g;
-  let ombroZ = lado * lerp(0.06, 0.22, g);
-  let cotovelo = lerp(-0.12, -1.05, g) + Math.sin(t * 7.3 + lado * 2) * 0.14 * g;
-  const pose = poseDoBraco(acao, lado, t, k);
-  if (pose) { ombroX = lerp(ombroX, pose.x, k); ombroZ = lerp(ombroZ, pose.z, k); cotovelo = lerp(cotovelo, pose.c, k); }
+function BracoBloco({ lado, g, gc = g, cor, pele, t, acao, k = 1, kc = k, ar = 0, sem = 0 }) {
+  // Repouso: o braço caído, um tico para fora — e nunca parado: ele acompanha o
+  // fôlego (abre na inspiração) e deriva pelo ruído. O cotovelo vem depois do
+  // ombro (gc e kc são o gesto e a ação de ~0,1 s antes): a sobreposição.
+  const deriva = ruido(t * 0.45, sem + lado * 5) * 0.035;
+  let ombroX = lerp(0.08, -0.85, g) + Math.sin(t * 6 + lado) * 0.06 * Math.max(0, g) + deriva;
+  let ombroZ = lado * (lerp(0.06, 0.22, Math.max(0, g)) + ar * 0.025);
+  let cotovelo = lerp(-0.12, -1.05, gc) + Math.sin(t * 7.3 + lado * 2 - 0.8) * 0.14 * Math.max(0, gc) + deriva * 0.6;
+  const pose = poseDoBraco(acao, lado, t, k, sem);
+  const poseC = poseDoBraco(acao, lado, t - 0.09, kc, sem);
+  if (pose) { ombroX = lerp(ombroX, pose.x, k); ombroZ = lerp(ombroZ, pose.z, k); }
+  if (poseC) cotovelo = lerp(cotovelo, poseC.c, kc);
   return (
     <group position={[lado * 0.47, 1.4, 0]} rotation={[ombroX, 0, ombroZ]}>
       <Bloco s={[0.2, 0.36, 0.2]} p={[0, -0.17, 0]} c={cor} r={0.04} rough={0.8} />
@@ -404,42 +416,65 @@ function BracoBloco({ lado, g, cor, pele, t, acao, k = 1 }) {
 }
 
 function PessoaBloco({ p, est }) {
-  const resp = Math.sin(est.t * 1.7) * 0.008;
+  const t = est.t, sem = est.semente || 0;
+  // O fôlego: inspira rápido, expira devagar, o ritmo varia (natural.respiracao).
+  const ar = respiracao(t, sem);
+  const resp = ar * 0.012;
   const [cy, cp, cr] = est.cabeca;
   const calca = escurecer(p.roupa, 0.35);
   const a = est.acao, ka = est.forcaAcao || 0;
-  // O corpo inteiro: pular e comemorar sobem, dançar balança, andar e correr marcham.
-  const pulo = (a === 'pular' || a === 'comemorar') ? Math.abs(Math.sin(est.t * 6.5)) * 0.32 * ka : 0;
-  const balanco = a === 'dancar' ? Math.sin(est.t * 6) * 0.14 * ka : 0;
-  const marcha = (a === 'andar' || a === 'correr') ? (a === 'correr' ? 13 : 7) : 0;
+  // O corpo inteiro. Pular e comemorar: agacha, estica, cai acelerando e amassa
+  // no pouso (natural.salto). Dançar: o quadril leva, o tronco e a cabeça vêm
+  // atrasados. Andar e correr: o passo com quadril, contato e contragiro.
+  const pula = a === 'pular' || a === 'comemorar';
+  const sl = pula ? salto(t, a === 'comemorar' ? { periodo: 0.8, altura: 0.22 } : { periodo: 0.95, altura: 0.36 }) : null;
+  const anda = a === 'andar' || a === 'correr';
+  const ps = anda ? passo(t, { correr: a === 'correr', semente: sem }) : null;
+  const danca = a === 'dancar';
+  // Parado, o peso troca de perna devagar: nunca congelado.
+  const peso = ruido(t * 0.22, sem + 11) * 0.018;
+  const y = (sl ? sl.y * ka : 0) + (ps ? ps.sobe * ka : 0) + (danca ? (0.5 + 0.5 * Math.cos(t * 12)) * 0.04 * ka : 0);
+  const sy = sl ? lerp(1, sl.sy, Math.min(1, ka)) : 1, sx = sl ? lerp(1, sl.sx, Math.min(1, ka)) : 1;
+  const quadril = peso + (ps ? ps.quadril * ka : 0) + (danca ? Math.sin(t * 6) * 0.14 * ka : 0);
+  // O tronco gira contra o quadril (andar) ou vem atrasado dele (dançar).
+  const troncoZ = danca ? -Math.sin(t * 6 - 0.6) * 0.07 * ka : -peso * 0.5;
+  const troncoY = ps ? ps.giro * ka : 0;
+  const troncoX = (ps ? ps.inclina * ka : 0) + ar * -0.006;
+  // A cabeça segura o olhar: desfaz parte do giro do tronco, e balança por último.
+  const cabecaZ = cr + (danca ? Math.sin(t * 6 - 1.2) * 0.08 * ka : 0) - quadril * 0.4;
   return (
-    <group position={[0, pulo, 0]} rotation={[0, 0, balanco]}>
+    <group position={[0, y, 0]} rotation={[0, 0, quadril]} scale={[sx, sy, sx]}>
       {/* as pernas e o sapato */}
       {[-1, 1].map((k) => {
-        const passo = marcha ? Math.sin(est.t * marcha + (k > 0 ? 0 : Math.PI)) * (a === 'correr' ? 0.7 : 0.4) * ka : 0;
+        const perna = ps ? ps.perna[k > 0 ? 1 : 0] * ka : 0;
         return (
-          <group key={k} position={[k * 0.15, 0.76, 0]} rotation={[passo, 0, 0]}>
+          <group key={k} position={[k * 0.15, 0.76, 0]} rotation={[perna, 0, -quadril * 0.8]}>
             <Bloco s={[0.25, 0.72, 0.27]} p={[0, -0.36, 0]} c={calca} r={0.03} rough={0.85} />
             <Bloco s={[0.27, 0.1, 0.36]} p={[0, -0.71, 0.04]} c="#1a1a1f" r={0.03} />
           </group>
         );
       })}
-      <group position={[0, resp, 0]}>
-        {/* o tronco, com a faixa branca da camisa da referência */}
-        <Bloco s={[0.76, 0.66, 0.4]} p={[0, 1.1, 0]} c={p.roupa} r={0.05} rough={0.8} />
-        <Bloco s={[0.06, 0.5, 0.02]} p={[0.17, 1.12, 0.205]} c="#dcd8d0" r={0.008} sombra={false} />
-        <Bloco s={[0.22, 0.08, 0.22]} p={[0, 1.46, 0]} c={escurecer(p.pele, 0.88)} r={0.02} />
-      </group>
-      <BracoBloco lado={-1} g={est.gesto[0]} cor={p.roupa} pele={p.pele} t={est.t} acao={a} k={ka} />
-      <BracoBloco lado={1} g={est.gesto[1]} cor={p.roupa} pele={p.pele} t={est.t} acao={a} k={ka} />
-      <group position={[0, 1.8 + resp, 0]} rotation={[cp, cy, cr]}>
-        {p.cabeca !== 'facetada' ? (
-          <>
-            <Bloco s={[CAB, CAB, CAB]} c={p.pele} r={0.04} rough={0.6} />
-            <RostoPixel p={p} est={est} />
-            <Cabelo estilo={p.cabelo} cor={p.corCabelo} />
-          </>
-        ) : <CabecaFacetada p={p} est={est} />}
+      {/* do quadril para cima: o tronco, os braços e a cabeça giram juntos no quadril */}
+      <group position={[0, 0.76, 0]} rotation={[troncoX, troncoY, troncoZ]}>
+        <group position={[0, -0.76, 0]}>
+          <group position={[0, resp, 0]} scale={[1 + ar * 0.008, 1 + ar * 0.014, 1 + ar * 0.02]}>
+            {/* o tronco, com a faixa branca da camisa da referência */}
+            <Bloco s={[0.76, 0.66, 0.4]} p={[0, 1.1, 0]} c={p.roupa} r={0.05} rough={0.8} />
+            <Bloco s={[0.06, 0.5, 0.02]} p={[0.17, 1.12, 0.205]} c="#dcd8d0" r={0.008} sombra={false} />
+            <Bloco s={[0.22, 0.08, 0.22]} p={[0, 1.46, 0]} c={escurecer(p.pele, 0.88)} r={0.02} />
+          </group>
+          <BracoBloco lado={-1} g={est.gesto[0]} gc={(est.gestoAtras || est.gesto)[0]} cor={p.roupa} pele={p.pele} t={t} acao={a} k={ka} kc={est.forcaAtras ?? ka} ar={ar} sem={sem} />
+          <BracoBloco lado={1} g={est.gesto[1]} gc={(est.gestoAtras || est.gesto)[1]} cor={p.roupa} pele={p.pele} t={t} acao={a} k={ka} kc={est.forcaAtras ?? ka} ar={ar} sem={sem} />
+          <group position={[0, 1.8 + resp * 1.2, 0]} rotation={[cp - troncoX * 0.6, cy - troncoY * 0.6, cabecaZ]}>
+            {p.cabeca !== 'facetada' ? (
+              <>
+                <Bloco s={[CAB, CAB, CAB]} c={p.pele} r={0.04} rough={0.6} />
+                <RostoPixel p={p} est={est} />
+                <Cabelo estilo={p.cabelo} cor={p.corCabelo} />
+              </>
+            ) : <CabecaFacetada p={p} est={est} />}
+          </group>
+        </group>
       </group>
     </group>
   );
@@ -454,15 +489,20 @@ function PessoaBloco({ p, est }) {
 function Mascote({ p, est }) {
   const cor = p.cor || '#d9532b';
   const [abre] = est.boca;
-  const pulo = (est.acao === 'pular' || est.acao === 'comemorar') ? Math.abs(Math.sin(est.t * 6)) * 0.25 * (est.forcaAcao || 0) : 0;
-  const respira = Math.sin(est.t * 1.9 + 0.7) * 0.012;
-  const estica = 1 + abre * 0.07 + respira, achata = 1 - abre * 0.035;
+  const ka = Math.min(1, est.forcaAcao || 0);
+  // O pulo com peso: agacha, estica no impulso, cai acelerando e amassa no pouso (natural.salto).
+  const sl = (est.acao === 'pular' || est.acao === 'comemorar') ? salto(est.t, { periodo: 0.85, altura: 0.3 }) : { y: 0, sx: 1, sy: 1 };
+  const pulo = sl.y * ka;
+  const respira = (respiracao(est.t, (est.semente || 0) + 0.7) - 0.5) * 0.024;
+  const estica = (1 + abre * 0.07 + respira) * lerp(1, sl.sy, ka), achata = (1 - abre * 0.035) * lerp(1, sl.sx, ka);
   const pisca = clamp(est.pisca);
   const [cy, cp, cr] = est.cabeca;
   const W = 1.0, H = 0.92, D = 0.78, perna = 0.46;
   const pernas = [-0.38, -0.19, 0, 0.19, 0.38];
+  // O corpo balança de leve sobre as perninhas, atrasado da cabeça (sobreposição).
+  const ginga = ruido(est.t * 0.3, (est.semente || 0) + 21) * 0.025;
   return (
-    <group position={[0, pulo, 0]} rotation={[0, cy * 0.8, cr * 0.5]}>
+    <group position={[0, pulo, 0]} rotation={[0, cy * 0.8, cr * 0.5 + ginga]}>
       {pernas.map((x, i) => (
         <group key={i}>
           <Bloco s={[0.13, perna, 0.13]} p={[x, perna / 2 + Math.max(0, Math.sin(est.t * 9 + i)) * (est.falando ? 0.015 : 0), D / 2 - 0.12]} c={escurecer(cor, 0.9)} r={0.015} rough={0.6} />
@@ -804,33 +844,58 @@ export function VoxelCena({ el, t }) {
     for (const f of falas) if (f.quem === i && f.de <= t + 0.2) e = t <= f.ate + 2.5 ? f.emocao : 'neutro';
     return e;
   };
-  // A ação da fala vale da voz até 0,6 s depois, entrando e saindo suave.
+  // A ação da fala vale da voz até 0,6 s depois: entra em mola (passa do ponto e
+  // assenta) e sai devagar. O cotovelo pega a mesma ação ~0,1 s depois (sobreposição).
   const acaoDe = (i) => {
     for (const f of falas) {
       if (f.quem !== i || !f.acao || f.acao === 'falar') continue;
-      if (t >= f.de - 0.3 && t <= f.ate + 0.6) return [f.acao, Math.min(suave((t - f.de + 0.3) / 0.4), 1 - suave((t - f.ate - 0.1) / 0.5))];
+      if (t >= f.de - 0.3 && t <= f.ate + 0.6) {
+        const opc = { entra: 2.2, sai: 0.5, amort: 0.55 };
+        return [f.acao, envelope(t, f.de - 0.3, f.ate + 0.1, opc), envelope(t, f.de - 0.3, f.ate + 0.1, { ...opc, atraso: 0.09 })];
+      }
     }
-    return [null, 0];
+    return [null, 0, 0];
   };
-  const quemFala = () => { const f = falas.find((x) => t >= x.de && t <= x.ate); return f ? f.quem : -1; };
+  // O quanto cada um está falando (0 a 1, sem degrau): o aceno de cabeça de quem
+  // fala e o de quem ouve trocam com mola, não num corte seco.
+  const pesoDaFala = (i, reacao = 0) => falas.reduce((m, f) => (f.quem === i ? Math.max(m, Math.min(1, envelope(t, f.de + reacao, f.ate, { entra: 2.6, sai: 0.45, amort: 0.7 }))) : m), 0);
   const estado = (i, figurante = false) => {
+    const sem = i * 13 + (figurante ? 101 : 1);
     const fala = !figurante && falandoAgora(i);
-    const qf = quemFala();
-    const outro = qf >= 0 && qf !== i;
+    const wFala = figurante ? 0 : pesoDaFala(i);
     const enfase = figurante ? [0, 0] : gesto(falas, i, t);
-    const nod = Math.sin(t * (fala ? 5.2 : 1.4) + i) * (fala ? 0.04 : 0.015) + (outro ? Math.max(0, Math.sin(t * 2.1 + i)) * 0.04 : 0);
+    const enfaseAtras = figurante ? [0, 0] : gesto(falas, i, t - 0.09);
+    // Quem ouve vira para quem fala com ~0,2 s de reação e mola, e volta devagar.
+    let paraQuemFala = 0, wOuve = 0, dx = 0;
+    if (!figurante) {
+      for (const f of falas) {
+        if (f.quem === i) continue;
+        const w = Math.min(1, envelope(t, f.de + 0.2, f.ate + 0.3, { entra: 1.6, sai: 0.7, amort: 0.62 }));
+        if (w > wOuve) { wOuve = w; dx = lugarDe(elenco, f.quem)[0] - lugarDe(elenco, i)[0]; }
+      }
+      paraQuemFala = clamp(dx * 0.35, -0.35, 0.35) * wOuve;
+    }
+    const nodFala = Math.sin(t * 5.2 + i) * 0.03 + ruido(t * 2.4, sem + 2) * 0.02;
+    const nodQuieto = ruido(t * 0.5, sem + 3) * 0.018;
+    const nod = lerp(nodQuieto, nodFala, wFala) + wOuve * Math.max(0, Math.sin(t * 2.1 + i)) * 0.04;
     const emo = figurante ? 'feliz' : emocaoDe(i);
-    const e = EMO[emo] || EMO.neutro;
-    const micro = (hash(Math.floor(t * 1.5) + i * 7) - 0.5) * 0.6;
-    // Quem ouve vira um pouco para quem fala; quem fala olha para a câmera de vez em quando.
-    const dx = outro && !figurante ? lugarDe(elenco, qf)[0] - lugarDe(elenco, i)[0] : 0;
-    const paraQuemFala = clamp(dx * 0.35, -0.35, 0.35);
-    const [acao, forcaAcao] = figurante ? [null, 0] : acaoDe(i);
+    // A inclinação da emoção chega e vai embora com peso, não troca no quadro.
+    let inclina = 0;
+    if (!figurante) {
+      for (const f of falas) {
+        if (f.quem !== i || f.de > t + 0.2) continue;
+        const ef = EMO[f.emocao] || EMO.neutro;
+        inclina = (ef.inclina || 0) * Math.min(1.05, envelope(t, f.de - 0.2, f.ate + 2.5, { entra: 1.4, sai: 0.8, amort: 0.6 }));
+      }
+    } else inclina = (EMO.feliz.inclina || 0);
+    const micro = (hash(Math.floor(t * 1.5 + hash(i) * 0.9) + i * 7) - 0.5) * 0.6;
+    const [acao, forcaAcao, forcaAtras] = figurante ? [null, 0, 0] : acaoDe(i);
     return {
-      t, falando: fala, emocao: emo, boca: figurante ? [0, 0.55] : boca(falas, i, t), pisca: piscada(i + (figurante ? 5 : 0), t),
-      gesto: enfase, enfase: Math.max(enfase[0], enfase[1]), acao, forcaAcao,
-      olhar: [micro + (outro ? Math.sign(dx) * 0.8 : 0), 0.1],
-      cabeca: [Math.sin(t * 0.7 + i * 2) * 0.07 + paraQuemFala, nod, (e.inclina || 0) * (i % 2 ? -1 : 1) + Math.sin(t * 0.5 + i) * 0.02],
+      t, semente: sem, falando: fala, emocao: emo, boca: figurante ? [0, 0.55] : boca(falas, i, t), pisca: piscada(i + (figurante ? 5 : 0), t),
+      gesto: enfase, gestoAtras: enfaseAtras, enfase: Math.max(enfase[0], enfase[1], 0), acao, forcaAcao, forcaAtras,
+      olhar: [micro + Math.sign(dx) * 0.8 * wOuve, 0.1],
+      // A cabeça deriva pelo ruído (nunca a mesma volta) e vem ~0,06 s atrás do corpo.
+      cabeca: [ruido((t - 0.06) * 0.35, sem + 5) * 0.08 + paraQuemFala, nod, inclina * (i % 2 ? -1 : 1) + ruido((t - 0.06) * 0.25, sem + 7) * 0.025],
     };
   };
   const desenhar = (p, est) => (p.tipo === 'robo' ? <Mascote p={p} est={est} />

package/lib/estudio/kit.js

@@ -67,7 +67,7 @@ const PECAS = {
     animacao: { precisa: ['src'] },
 };
 
-const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'mundo.jsx', 'voxel.jsx', 'animacao.jsx', 'index.jsx'];
+const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'mundo.jsx', 'voxel.jsx', 'animacao.jsx', 'natural.js', 'index.jsx'];
 
 /** Os arquivos do kit, para o projeto Remotion: [{nome: 'kit/base.jsx', conteudo}]. */
 function arquivos() {

package/lib/estudio/revisor.js

@@ -67,7 +67,10 @@ function revisar(plano, { semImagem = false } = {}) {
     const efeitos = ((plano.audio && plano.audio.efeitos) || []).slice().sort((a, b) => (a.t || 0) - (b.t || 0));
     if (efeitos.length) {
         const fica = [];
-        for (const e of efeitos) {
+        /* O micro (o tique, a escada de notas) não conta para o teto: é a
+           textura das referências, 2 a 3 por segundo, baixinho (14/10). */
+        const micros = efeitos.filter((e) => e.micro);
+        for (const e of efeitos.filter((x) => !x.micro)) {
             const ult = fica[fica.length - 1];
             if (ult && e.src === ult.src && (e.t || 0) - (ult.t || 0) < 0.3) {
                 if ((e.volume ?? 1) > (ult.volume ?? 1)) fica[fica.length - 1] = e;
@@ -88,7 +91,7 @@ function revisar(plano, { semImagem = false } = {}) {
             final = guardados.sort((a, b) => (a.t || 0) - (b.t || 0));
             consertos.push(`${fica.length} efeitos sonoros em ${r2(total)}s eram ruído — ficaram os ${final.length} mais fortes`);
         }
-        plano.audio.efeitos = final;
+        plano.audio.efeitos = [...final, ...micros].sort((a, b) => (a.t || 0) - (b.t || 0));
     }
 
     // 4. Texto que não dá tempo de ler.