Files
CenaForge/cartoon/src/motion.ts
T
MateuusandClaude Opus 5.5 2d8b1a582d Cartoon: mãos, membros e cenários novos; elenco de Noé e a Arca
- Mãos com formas e rotações próprias, membros articulados (limbs) e animais.
- Elementos de cenário separados (natureza, construções, interiores) e testes de lugares.
- Personagens reaproveitáveis de Noé e a Arca (Noé, esposa, Sem, Cam e Jafé) e a fonte Barlow Semi Condensed.
- História noe-e-a-arca: pauta, bíblia, roteiro do ep. 1, tomadas Cartoon e montagem.
- Montagem: narração mais corrida (tira silêncios longos) e cabeçalho com o número do vídeo.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 01:51:11 -03:00

223 lines
12 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Movimento do personagem: uma LINHA DO TEMPO de ações que se combinam (não animações prontas). Cada ação tem
// início (segundos `at`, fração do trecho `atP` ou a palavra da narração `cue`) e duração; o estado em cada
// quadro sai de aplicar as ações em ordem sobre a expressão/pose de base, mais a "vida" (piscar, respirar).
// Ações permanentes mudam o estado dali em diante (express, pose, walk, sit, fall, turn, look); as momentâneas
// voltam ao fim (nod, shake_head, tremble, bounce, wave, jump, talk, emote).
import { emphasisAt, speak, visemeAt, type SpokenWord } from "./lipsync";
import { blendBody, blendFace, bodyOf, faceOf, withBody, withFace, type BodyParams, type BodyPatch, type FaceParams, type FacePatch } from "./rig";
export const ACTIONS = ["express", "pose", "walk", "run", "enter", "exit", "jump", "nod", "shake_head", "tremble", "bounce", "fall",
"sit", "stand_up", "turn", "talk", "look", "emote", "wave", "hammer"] as const;
export type ActionKind = (typeof ACTIONS)[number];
export type Action = {
do: ActionKind;
/** Início: segundos, fração do trecho (0–1) ou a 1ª palavra da narração que começa com `cue`. */
at?: number; atP?: number; cue?: string;
dur?: number;
/** talk: termina no fim desta palavra da narração (a fala vai de `cue` até `cueEnd`). */
cueEnd?: string;
expression?: string; face?: FacePatch;
pose?: string; body?: BodyPatch;
/** walk/run/enter: x de destino (fração). */
to?: number;
/** look: para onde; fall: para que lado. */
dir?: "left" | "right" | "up" | "down";
/** nod/shake_head/bounce/wave: repetições. jump: altura (fração da altura do quadro). */
times?: number; height?: number;
/** emote: símbolo sobre a cabeça ("!", "?", "…", "♥", "zzz", "💢"). talk: o texto falado (sem tempos de palavra, é
* repartido pela duração). */
text?: string;
};
export type ActorInput = {
x: number; expression?: string; pose?: string; face?: FacePatch; body?: BodyPatch; flip?: boolean; timeline?: Action[];
};
export type ActorState = {
face: FaceParams; body: BodyParams;
x: number; dy: number; dx: number; rot: number; sx: number; sy: number; flip: boolean;
emote: { text: string; k: number } | null;
};
const DEFAULT_DUR: Record<ActionKind, number> = {
express: 0.25, pose: 0.35, walk: 1.6, run: 0.9, enter: 1.2, exit: 1.2, jump: 0.8, nod: 0.7, shake_head: 0.8, tremble: 1, bounce: 0.8,
fall: 0.6, sit: 0.5, stand_up: 0.5, turn: 0.3, talk: 1.5, look: 0.3, emote: 1.2, wave: 1.2, hammer: 2.4,
};
const clamp01 = (v: number) => Math.max(0, Math.min(1, v));
const ease = (p: number) => (p < 0.5 ? 2 * p * p : 1 - (-2 * p + 2) ** 2 / 2);
/** Passa um pouco do alvo e volta (dá vida às poses). */
const easeBack = (p: number) => { const c = 1.4; return 1 + (c + 1) * (p - 1) ** 3 + c * (p - 1) ** 2; };
const norm = (s: string) => s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]/g, "");
/** Início da ação em segundos (cue = palavra falada; sem a palavra, cai para atP/at/0). */
export function startOf(a: Action, durationS: number, words: { text: string; startS: number }[] = []): number {
if (a.cue) {
const c = norm(a.cue);
const w = words.find((x) => norm(x.text).startsWith(c));
if (w) return w.startS;
}
if (a.atP !== undefined) return a.atP * durationS;
return a.at ?? 0;
}
/** Piscar em intervalos variados (2,4–4,6 s), determinístico pela semente. */
function blinkAt(t: number, seed: number): number {
let s = 0.6 + (seed % 7) * 0.13;
let k = 1;
while (s < t + 0.2) {
const d = t - s;
if (d >= 0 && d < 0.13) k = Math.min(k, Math.abs(d - 0.065) / 0.065);
s += 2.4 + ((Math.sin(s * 12.9898 + seed) + 1) / 2) * 2.2;
}
return k;
}
/** Fala do trecho: palavras com tempo (narração) e, se houver, o volume do áudio quadro a quadro. */
export type Speech = { words: SpokenWord[]; env?: { values: number[]; fps: number } };
/** Fim da fala: o fim da palavra `cueEnd` (depois do início), senão início + dur. */
function endOf(a: Action, s: number, words: SpokenWord[]): number | null {
if (!a.cueEnd) return null;
const c = norm(a.cueEnd);
const w = words.find((x) => x.startS >= s - 0.01 && norm(x.text).startsWith(c));
return w ? w.endS : null;
}
export function evaluate(actor: ActorInput, t: number, durationS: number, seed = 1, speech: Speech = { words: [] }): ActorState {
const words = speech.words;
const st: ActorState = {
face: faceOf(actor.expression, actor.face), body: bodyOf(actor.pose, actor.body),
x: actor.x, dy: 0, dx: 0, rot: 0, sx: 1, sy: 1, flip: !!actor.flip, emote: null,
};
const timeline = (actor.timeline ?? []).map((a) => ({ a, s: startOf(a, durationS, words) })).sort((p, q) => p.s - q.s);
for (const { a, s } of timeline) {
if (t < s) break;
const end = a.do === "talk" ? endOf(a, s, words) : null;
const d = Math.max(0.05, end !== null ? end - s : a.dur ?? DEFAULT_DUR[a.do]);
const p = clamp01((t - s) / d);
const active = t - s < d;
const env = active ? Math.min(1, (t - s) / 0.15, (s + d - t) / 0.15) : 0; // entra e sai suave (momentâneas)
switch (a.do) {
case "express": {
const target = a.expression ? faceOf(a.expression, a.face) : withFace(st.face, a.face);
st.face = blendFace(st.face, target, ease(p));
break;
}
case "pose": {
const target = a.pose ? bodyOf(a.pose, a.body) : withBody(st.body, a.body);
st.body = blendBody(st.body, target, clamp01(easeBack(p)));
break;
}
case "walk": case "run": case "enter": case "exit": {
const from = a.do === "enter" ? (a.to ?? st.x) < 0.5 ? -0.25 : 1.25 : st.x;
const to = a.do === "exit" ? (st.x < 0.5 ? -0.3 : 1.3) : a.to ?? st.x;
const run = a.do === "run";
st.x = from + (to - from) * (run ? p : ease(p));
if (to !== from) st.flip = to < from;
if (active) {
const phase = (t - s) * Math.PI * 2 * (run ? 3.2 : 2.1);
const amp = run ? 1.6 : 1;
const sw = Math.sin(phase);
st.body = withBody(st.body, {
armL: { raise: 8 + sw * 20 * amp, bend: run ? 85 : 15 }, armR: { raise: 8 - sw * 20 * amp, bend: run ? 85 : 15 },
legL: { raise: 3 + Math.max(0, sw) * 6, bend: Math.max(0, sw) * 38 * amp }, legR: { raise: 3 + Math.max(0, -sw) * 6, bend: Math.max(0, -sw) * 38 * amp },
lean: (to < from ? -1 : 1) * (run ? 8 : 3),
});
st.dy -= Math.abs(Math.sin(phase)) * (run ? 0.012 : 0.006);
}
break;
}
case "jump": {
if (!active) break;
const h = a.height ?? 0.08;
if (p < 0.15) { st.sy *= 1 - 0.1 * (p / 0.15); st.sx *= 1 + 0.06 * (p / 0.15); st.body = withBody(st.body, { crouch: 0.35 * (p / 0.15) }); }
else if (p < 0.85) {
const q = (p - 0.15) / 0.7;
st.dy -= h * 4 * q * (1 - q);
st.sy *= 1.07; st.sx *= 0.95;
st.body = withBody(st.body, { arms: { raise: 120, bend: -10 }, legs: { raise: 6, bend: 30 } });
} else { const q = (p - 0.85) / 0.15; st.sy *= 1 - 0.08 * (1 - q); st.sx *= 1 + 0.05 * (1 - q); }
break;
}
case "nod": st.body = withBody(st.body, { headNod: st.body.headNod + Math.sin(p * Math.PI * 2 * (a.times ?? 2)) * 0.6 * env }); break;
case "shake_head": st.body = withBody(st.body, { headTurn: st.body.headTurn + Math.sin(p * Math.PI * 2 * (a.times ?? 2)) * 0.7 * env }); break;
case "tremble": if (active) { st.dx += Math.sin(t * 77.7) * 0.004 * env; st.dy += Math.cos(t * 91.3) * 0.002 * env; } break;
case "bounce": st.dy -= Math.abs(Math.sin(p * Math.PI * (a.times ?? 2))) * 0.02 * env; break;
case "fall": {
const side = a.dir === "right" ? 1 : -1;
st.rot = side * 88 * ease(p);
st.dy += 0.02 * ease(p);
st.face = blendFace(st.face, faceOf("shocked"), Math.min(1, p * 3));
break;
}
case "sit": st.body = blendBody(st.body, withBody(st.body, { crouch: 1, arms: { raise: 14, bend: 40 } }), ease(p)); break;
case "stand_up": st.body = blendBody(st.body, withBody(st.body, { crouch: 0 }), ease(p)); break;
case "turn": {
const flipped = !st.flip;
if (p >= 0.5) st.flip = flipped;
if (active) st.sx *= Math.max(0.15, Math.abs(Math.cos(p * Math.PI)));
break;
}
case "talk": {
if (!active) break;
// Palavras da narração dentro da fala; sem elas, o texto da ação repartido pela duração (vogal pesa mais).
let spoken = words.filter((w) => w.endS > s && w.startS < s + d);
if (!spoken.length && a.text) {
const list = a.text.split(/\s+/).filter(Boolean);
const total = list.reduce((n, w) => n + w.length + 1, 0);
let c = s;
spoken = list.map((w) => { const len = (d * (w.length + 1)) / total; const out = { text: w, startS: c, endS: c + len * 0.88 }; c += len; return out; });
}
if (spoken.length) {
st.face = speak(st.face, visemeAt(spoken, t, speech.env), Math.min(1, (t - s) / 0.08, (s + d - t) / 0.08 + 0.2), emphasisAt(t, speech.env));
} else {
const flap = Math.abs(Math.sin((t - s) * Math.PI * 2 * 4.3 + seed)) * (0.6 + 0.4 * Math.sin((t - s) * 9.1 + seed));
st.face = { ...st.face, mouthOpen: Math.max(st.face.mouthOpen, (0.12 + 0.5 * flap) * env), teeth: st.face.teeth || flap > 0.6 };
}
// Quem fala mexe a cabeça de leve e acompanha as sílabas fortes.
st.body = withBody(st.body, { headTilt: st.body.headTilt + Math.sin((t - s) * 5.3) * 2 * env, headNod: st.body.headNod + emphasisAt(t, speech.env) * 0.25 });
break;
}
case "look": {
const gx = a.dir === "left" ? -0.9 : a.dir === "right" ? 0.9 : 0;
const gy = a.dir === "up" ? -0.8 : a.dir === "down" ? 0.8 : 0;
const k = ease(p);
st.face = { ...st.face, gazeX: st.face.gazeX + (gx - st.face.gazeX) * k, gazeY: st.face.gazeY + (gy - st.face.gazeY) * k };
st.body = withBody(st.body, { headTurn: st.body.headTurn + (gx * 0.5 - st.body.headTurn) * k, headNod: st.body.headNod + (gy * -0.4 - st.body.headNod) * k });
break;
}
case "emote": if (active) st.emote = { text: a.text ?? "!", k: env }; break;
// Martelar: braço direito sobe e desce batendo (`times` golpes), cabeça acompanha cada batida.
case "hammer": if (active) {
const beat = Math.abs(Math.sin(p * Math.PI * (a.times ?? 5)));
st.body = withBody(st.body, { armR: { raise: 40 + beat * 95 * Math.min(1, env * 1.5), bend: 60 + beat * 40 }, headNod: st.body.headNod + (1 - beat) * 0.15 * env });
break;
}
case "wave": if (active) st.body = withBody(st.body, { armR: { raise: 140 * Math.min(1, env * 1.5), bend: -25 + Math.sin(p * Math.PI * 2 * (a.times ?? 3)) * 30 } }); break;
}
}
// Vida: piscar (a não ser de olhos quase fechados), respirar e um balanço leve de cabeça.
const blink = blinkAt(t, seed);
if (blink < 1) st.face = { ...st.face, eyeL: st.face.eyeL * Math.max(0.08, blink), eyeR: st.face.eyeR * Math.max(0.08, blink) };
st.body = withBody(st.body, { headTilt: st.body.headTilt + Math.sin(t * 0.9 + seed) * 1.2 });
return st;
}
/** Confere uma linha do tempo (lista de problemas; vazia = ok). */
export function validateTimeline(timeline: unknown): string[] {
if (timeline === undefined) return [];
if (!Array.isArray(timeline) || timeline.length > 40) return ["timeline: lista de até 40 ações"];
const errors: string[] = [];
timeline.forEach((a: Partial<Action>, i) => {
if (!a || !ACTIONS.includes(a.do as ActionKind)) errors.push(`timeline[${i}].do: ${ACTIONS.join(", ")}`);
for (const k of ["at", "atP", "dur", "to", "times", "height"] as const) {
if (a[k] !== undefined && (typeof a[k] !== "number" || !Number.isFinite(a[k]))) errors.push(`timeline[${i}].${k}: número`);
}
if (a.atP !== undefined && !(a.atP >= 0 && a.atP <= 1)) errors.push(`timeline[${i}].atP entre 0 e 1`);
if (a.dur !== undefined && !(a.dur > 0 && a.dur <= 30)) errors.push(`timeline[${i}].dur entre 0 e 30 s`);
});
return errors;
}