// Energy in an Inductor: Why It's One Half L I Squared — Manimo lesson scene.
// Dual of capacitor-energy. Ramping current through a coil builds a magnetic
// field; the work integral ∫v·i dt collapses to ½LI² because Φ = L·i is a
// straight line in the (i, Φ) plane. Genuine motion lives in Beat 2 (current
// ramps, expanding field rings) and Beat 3 (value-driven triangle area filling
// under the Φ = L·i line).
//
// Beats (timed to single-track narration in motion/ade/audio/inductor-energy/):
// 0.00– 5.00 Manimo enters; hook question
// 5.00–15.00 Coil + switch; current ramps, field rings expand, v = L·di/dt
// 15.00–26.00 Φ–i graph: line traces, triangle area sweeps in with point
// 26.00–37.00 Three equivalent forms: ½LI², ½ΦI, Φ²/(2L)
// 37.00–44.00 Takeaway: energy lives in the magnetic field
const SCENE_DURATION = 49;
const NARRATION = [
/* 0.00– 5.00 */ 'Push current through an inductor — where does the energy go?',
/* 5.00–15.00 */ 'Close the switch and the current ramps from zero up to I. A magnetic field grows around the coil, and the inductor pushes back with a voltage v equal to L times the rate of change of current.',
/* 15.00–26.00 */ 'Plot flux against current. Φ equals L times i — a straight line. The work to push the current from zero up to I is the area under that line, a triangle with area one half L I squared.',
/* 26.00–37.00 */ 'Three faces of the same energy: one half L I squared, one half Φ I, and Φ squared over two L. Use whichever two quantities you know.',
/* 37.00–44.00 */ 'The energy lives in the magnetic field around the coil. Open the switch and the field collapses — releasing every joule back into the circuit.',
];
const NARRATION_AUDIO = 'audio/inductor-energy/scene.mp3';
function Scene() {
return (
);
}
// ─── Beat 2: Ramping current, growing field ──────────────────────────────
// Genuine motion: a current pulse travels around the loop with density scaling
// as i ramps from 0 to 1, while three concentric field-line ovals scale up
// around the coil core to make B-field growth visible.
function RampingCurrentBeat() {
const portrait = usePortrait();
const { localTime } = useSprite();
const RAMP_START = 1.0;
const RAMP_END = 7.0;
const i = clamp((localTime - RAMP_START) / (RAMP_END - RAMP_START), 0, 1);
const G = portrait
? { vbW: 600, vbH: 620,
srcX: 100, srcY: 160, coilCx: 380, coilCy: 320, coilR: 70,
wireTopY: 160, wireBotY: 420,
formulaX: 300, formulaY: 500, fontFormula: 26,
captionY: 580, fontCaption: 13 }
: { vbW: 1000, vbH: 440,
srcX: 140, srcY: 220, coilCx: 600, coilCy: 220, coilR: 70,
wireTopY: 130, wireBotY: 310,
formulaX: 820, formulaY: 220, fontFormula: 28,
captionY: 410, fontCaption: 14 };
// Coil glyph: six bumps in a stacked column.
const bumps = 6;
const bumpSpacing = (G.coilR * 2 - 16) / bumps;
const coilTop = G.coilCy - G.coilR + 8;
const coilBot = G.coilCy + G.coilR - 8;
// Build the coil "loops" as a single sinuous path (six humps to the right).
const coilD = (() => {
const pts = [`M ${G.coilCx} ${coilTop}`];
for (let b = 0; b < bumps; b++) {
const y0 = coilTop + b * bumpSpacing;
const y1 = y0 + bumpSpacing;
const cy = y0 + bumpSpacing / 2;
// Half-circle bump to the right.
pts.push(`Q ${G.coilCx + 24} ${cy}, ${G.coilCx} ${y1}`);
}
return pts.join(' ');
})();
// Wire route: source(+) → top wire → coil top, coil bottom → bot wire → source(−).
const topWireD = `M ${G.srcX + 22} ${G.srcY - 10} L ${G.srcX + 22} ${G.wireTopY} L ${G.coilCx} ${G.wireTopY} L ${G.coilCx} ${coilTop}`;
const botWireD = `M ${G.coilCx} ${coilBot} L ${G.coilCx} ${G.wireBotY} L ${G.srcX + 22} ${G.wireBotY} L ${G.srcX + 22} ${G.srcY + 10}`;
// Current dots flow around the loop. Build evenly-spaced positions along
// a parameterised path: source-top → top wire → coil column → bottom wire →
// source-bottom. For simplicity, we sample positions on the top + coil +
// bottom segments and animate them by sliding indices.
const DOTS = 8;
// Each dot's base phase (0..1), phase rolls with time.
const speed = 0.18; // cycles per second at full current
const phase = (t) => (t * speed * i) % 1;
// Build a polyline of waypoint positions to interpolate along.
// Waypoints (clockwise, starting at source top terminal):
const wp = [
{ x: G.srcX + 22, y: G.srcY - 10 },
{ x: G.srcX + 22, y: G.wireTopY },
{ x: G.coilCx, y: G.wireTopY },
{ x: G.coilCx, y: coilTop },
{ x: G.coilCx, y: coilBot },
{ x: G.coilCx, y: G.wireBotY },
{ x: G.srcX + 22, y: G.wireBotY },
{ x: G.srcX + 22, y: G.srcY + 10 },
];
// Cumulative lengths for parameterisation.
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) {
// u in [0, 1) maps to position along total path
const target = u * totalLen;
let acc = 0;
for (let k = 0; k < segLens.length; k++) {
if (acc + segLens[k] >= target) {
const localFrac = (target - acc) / segLens[k];
return {
x: wp[k].x + (wp[k + 1].x - wp[k].x) * localFrac,
y: wp[k].y + (wp[k + 1].y - wp[k].y) * localFrac,
};
}
acc += segLens[k];
}
return wp[wp.length - 1];
}
// Field-line ovals around the coil — three concentric ellipses scaling with i.
const fieldOpacity = 0.55 * i + 0.05;
const fieldRings = [1.0, 1.45, 1.9];
return (