// Joule Heating: How a Resistor Turns Current into Heat — Manimo lesson scene.
// Every charge crossing a resistor drops V volts, giving up V·q of potential
// energy that becomes lattice vibration — heat. Power P = V·I = I²R = V²/R is
// the rate; energy W = P·t is the running total. Genuine motion lives in
// Beat 2 (charge dots stream through the resistor while heat-glow accumulates)
// and Beat 4 (a (t, W) point slides up a linear ramp showing energy piling up).
//
// Beats (timed to single-track narration in motion/ade/audio/joule-heating/):
// 0.00– 5.00 Manimo enters; hook
// 5.00–16.00 Circuit with battery + resistor, charge dots flow, heat glow grows
// 16.00–28.00 Three forms: P = VI = I²R = V²/R with Ohm's-law substitution arrows
// 28.00–37.00 W = P·t ramp graph — heat piles up while current flows
// 37.00–42.00 Takeaway: not loss, transformation
const SCENE_DURATION = 47;
const NARRATION = [
/* 0.00– 5.00 */ 'Current flows through a resistor — where does the energy actually go?',
/* 5.00–16.00 */ "Each charge that crosses the resistor drops by V volts, so it gives up an amount of energy equal to V times q. That energy doesn't vanish — it jiggles the lattice and the resistor warms.",
/* 16.00–28.00 */ "Multiply V times q over time — that's V times I, the power dissipated. Ohm's law gives two more forms: I squared R, and V squared over R. Same wattage, three faces.",
/* 28.00–37.00 */ 'Power is the rate, not the total. Energy is power times time — keep the current flowing and the heat piles up, joule by joule, second by second.',
/* 37.00–42.00 */ "It's not loss — it's transformation. A resistor's job is to convert electrical energy into heat.",
];
const NARRATION_AUDIO = 'audio/joule-heating/scene.mp3';
function Scene() {
return (
);
}
// ─── Beat 2: Charges streaming through a resistor + growing heat glow ─────
// Genuine motion: charge dots travel around the loop on a continuous path,
// dimming as they cross the resistor (energy given up). A heat-glow halo
// around the resistor brightens linearly with elapsed time, expressing the
// energy accumulating in the lattice.
function ChargesThroughResistorBeat() {
const portrait = usePortrait();
const { localTime, duration: spriteDur } = useSprite();
const G = portrait
? { vbW: 600, vbH: 620,
srcX: 130, srcY: 280, srcGap: 22,
loopTopY: 160, loopBotY: 440,
resX: 240, resY: 160, resW: 220, resAmp: 22,
formulaY: 310, fontFormula: 26,
captionY: 540, fontCaption: 13 }
: { vbW: 1000, vbH: 440,
srcX: 180, srcY: 240, srcGap: 22,
loopTopY: 130, loopBotY: 360,
resX: 360, resY: 130, resW: 380, resAmp: 22,
formulaY: 250, fontFormula: 28,
captionY: 410, fontCaption: 14 };
// Resistor zigzag: 6 humps along loopTopY.
const Z = 6;
const zigStartX = G.resX, zigEndX = G.resX + G.resW;
const zigDx = (zigEndX - zigStartX) / (Z * 2);
const zigPts = [`M ${zigStartX} ${G.loopTopY}`];
for (let k = 1; k <= Z * 2; k++) {
const x = zigStartX + k * zigDx;
const y = G.loopTopY + (k % 2 === 1 ? -G.resAmp : G.resAmp);
zigPts.push(`L ${x.toFixed(1)} ${y.toFixed(1)}`);
}
zigPts.push(`L ${zigEndX} ${G.loopTopY}`);
const resD = zigPts.join(' ');
// Wires: src(+) → up → loopTopY → zigStartX ; zigEndX → right end → down → loopBotY → src(−)
const wireTopLeftD = `M ${G.srcX + G.srcGap} ${G.srcY - 10} L ${G.srcX + G.srcGap} ${G.loopTopY} L ${zigStartX} ${G.loopTopY}`;
const wireTopRightD = `M ${zigEndX} ${G.loopTopY} L ${zigEndX + 40} ${G.loopTopY} L ${zigEndX + 40} ${G.loopBotY}`;
const wireBotD = `M ${zigEndX + 40} ${G.loopBotY} L ${G.srcX + G.srcGap} ${G.loopBotY} L ${G.srcX + G.srcGap} ${G.srcY + 10}`;
// Build waypoint loop for charge-dot animation.
const wp = [
{ x: G.srcX + G.srcGap, y: G.srcY - 10 },
{ x: G.srcX + G.srcGap, y: G.loopTopY },
{ x: zigStartX, y: G.loopTopY },
{ x: zigEndX, y: G.loopTopY }, // skip zigzag detail; dots travel along its mean line
{ x: zigEndX + 40, y: G.loopTopY },
{ x: zigEndX + 40, y: G.loopBotY },
{ x: G.srcX + G.srcGap, y: G.loopBotY },
{ x: G.srcX + G.srcGap, y: G.srcY + 10 },
];
const segLens = [];
let totalLen = 0;
for (let k = 0; k < wp.length - 1; k++) {
const dx = wp[k + 1].x - wp[k].x, dy = wp[k + 1].y - wp[k].y;
const L = Math.hypot(dx, dy);
segLens.push(L); totalLen += L;
}
function posAt(u) {
const target = u * totalLen;
let acc = 0;
for (let k = 0; k < segLens.length; k++) {
if (acc + segLens[k] >= target) {
const f = (target - acc) / segLens[k];
return {
x: wp[k].x + (wp[k + 1].x - wp[k].x) * f,
y: wp[k].y + (wp[k + 1].y - wp[k].y) * f,
};
}
acc += segLens[k];
}
return wp[wp.length - 1];
}
// Charge dots: dim brightness while inside the resistor zone (x in zigStartX..zigEndX on top wire).
const DOTS = 9;
const dotSpeed = 0.10; // cycles/sec
const tElapsed = Math.max(0, localTime - 0.8);
// Heat-glow: ramps up over time, reaches ~85% at end of beat.
const heatStart = 1.2;
const heatFrac = clamp((localTime - heatStart) / (spriteDur - heatStart - 0.5), 0, 0.85);
return (