// Maximum Power Transfer: Match the Load to the Source — Manimo lesson scene.
// A source with internal resistance R_s drives a load R_L. P_L = V_s²·R_L/(R_s+R_L)²
// is zero at both endpoints (R_L=0 short-circuits the load voltage; R_L=∞ kills
// the current) and peaks at R_L = R_s with P_max = V_s²/(4R_s). Genuine motion
// lives in Beat 3: an R_L slider sweeps from 0 to 4R_s and a marker traces the
// power curve in real time.
//
// Beats (timed to single-track narration in motion/ade/audio/max-power-transfer/):
// 0.00– 5.00 Manimo enters; hook
// 5.00–14.00 Circuit: V_s + R_s feeding R_L; I and P_L formulas
// 14.00–27.00 Power-vs-R_L curve traces as R_L slider sweeps
// 27.00–38.00 R_L = R_s payoff; P_max = V_s²/(4R_s); 50% efficiency
// 38.00–46.00 Takeaway: matching maximises power, not efficiency.
const SCENE_DURATION = 61;
const NARRATION = [
/* 0.00– 5.00 */ 'What load pulls the most power out of a source?',
/* 5.00–14.00 */ 'A real source has an internal resistance R sub s. The current through any load R sub L equals V sub s divided by R sub s plus R sub L. The power delivered into the load is I squared times R sub L.',
/* 14.00–27.00 */ 'Sweep the load from very small to very large. With a tiny load, the current is huge but the load voltage is nearly zero — almost no power. With a huge load, the voltage is full but the current is nearly zero — also almost no power. The peak sits in the middle.',
/* 27.00–38.00 */ 'At the peak the load equals R sub s, and the delivered power is V sub s squared over four R sub s. Half the source energy goes to the load, half is wasted in R sub s — fifty percent efficiency at maximum power transfer.',
/* 38.00–46.00 */ 'Match the load when you want maximum power — useful for antennas and signal receivers, wasteful for power distribution.',
];
const NARRATION_AUDIO = 'audio/max-power-transfer/scene.mp3';
function Scene() {
return (
);
}
// ─── Beat 2: Circuit setup ───────────────────────────────────────────────
function CircuitSetupBeat() {
const portrait = usePortrait();
// Geometry: source(V_s) + R_s on left, terminals, R_L on right with arrow
// making it a variable resistor.
const G = portrait
? { vbW: 600, vbH: 580, srcX: 130, srcY: 220,
rsX: 280, rsY: 220, rsW: 70, rsH: 30,
termX: 420, termTopY: 180, termBotY: 320,
rlX: 480, rlY: 240, rlW: 56, rlH: 90,
formulaY1: 390, formulaY2: 460,
fontFormula: 24, captionY: 540 }
: { vbW: 1000, vbH: 480, srcX: 180, srcY: 220,
rsX: 360, rsY: 220, rsW: 90, rsH: 36,
termX: 540, termTopY: 170, termBotY: 280,
rlX: 620, rlY: 240, rlW: 70, rlH: 110,
formulaY1: 370, formulaY2: 425,
fontFormula: 26, captionY: 0 };
return (
);
}
// ─── Beat 3: Sweep R_L and trace P_L curve ──────────────────────────────
// Genuine motion: parameter sweep. R_L slider moves left-to-right and a
// marker on the P_L vs R_L curve follows. The curve itself reveals
// progressively up to the slider position. Peak emerges visually at R_L = R_s.
function SweepBeat() {
const portrait = usePortrait();
const { localTime } = useSprite();
const G = portrait
? { vbW: 600, vbH: 560, gx: 100, gy: 110, gw: 420, gh: 360,
fontAxis: 18, captionY: 530 }
: { vbW: 1100, vbH: 430, gx: 160, gy: 60, gw: 720, gh: 320,
fontAxis: 18, captionY: 415 };
const ax0 = G.gx, ay0 = G.gy + G.gh;
const axEnd = G.gx + G.gw;
const ayEnd = G.gy;
// Sweep R_L from 0 to 4·R_s. The peak (R_L = R_s) sits 1/4 of the way along.
const RL_MAX = 4; // in units of R_s
const peakFrac = 1 / RL_MAX;
const peakX = ax0 + peakFrac * (axEnd - ax0);
// Curve sample: P_L_norm(r) = 4r / (1+r)² scaled to peak at 1.0 when r=1.
function pNorm(r) { return (4 * r) / Math.pow(1 + r, 2); }
const SAMPLES = 100;
const sampleXs = [], sampleYs = [];
for (let s = 0; s <= SAMPLES; s++) {
const r = (s / SAMPLES) * RL_MAX;
const x = ax0 + (s / SAMPLES) * (axEnd - ax0);
const y = ay0 - pNorm(r) * (ay0 - ayEnd) * 0.92; // 0.92 keeps a tiny top margin
sampleXs.push(x); sampleYs.push(y);
}
// Slider sweep: 0 → 1 in seconds 1.5 → 8.5.
const SLIDE_START = 1.5;
const SLIDE_END = 8.5;
const u = clamp((localTime - SLIDE_START) / (SLIDE_END - SLIDE_START), 0, 1);
// The slider does a "tour": fast through the small-R region, slows around
// the peak, then continues to the far end. ease-in-out keeps eye tracking
// comfortable.
const eased = Easing.easeInOutCubic(u);
const sliderIdx = Math.floor(eased * SAMPLES);
const sliderX = sampleXs[sliderIdx];
const sliderRy = sampleYs[sliderIdx];
// Curve path: full curve as a thin baseline, with the "revealed" portion
// drawn in amber. This way the audience sees both the shape and the
// progress without a TraceIn (which would not respect the eased slider).
const fullD = sampleXs.map((x, k) => (k === 0 ? `M ${x} ${sampleYs[k]}` : `L ${x} ${sampleYs[k]}`)).join(' ');
const traceD = sampleXs.slice(0, sliderIdx + 1)
.map((x, k) => (k === 0 ? `M ${x} ${sampleYs[k]}` : `L ${x} ${sampleYs[k]}`)).join(' ');
// Peak y-coordinate (used for the P_max y-axis label).
const peakY = sampleYs[Math.floor(SAMPLES * peakFrac)];
return (