diff --git a/PROJECT.md b/PROJECT.md index 5837d7e..fd439ea 100644 --- a/PROJECT.md +++ b/PROJECT.md @@ -520,6 +520,37 @@ no penalty because there was no way to earn one. - Ten tests now (26 total), including a named regression for the auto-aim being gone and one that deals 40 rounds and asserts colours, counts and shapes all move. +**THIRD PASS, same day — "the drill mode immediately goes into some horrible audio loop" (phone).** +Never reproduced on desktop, and that is the tell: **three of the four defects behind it can only +happen on a phone, and my whole verification had been stepping frames with rAF killed on a machine +whose AudioContext was already running.** All four are in `voiceSeq`, which is new code, and every +one of them is a rule `voice()` had followed for months and my function quietly broke: + +1. **A SUSPENDED AudioContext HAS A FROZEN CLOCK.** On a phone the context starts suspended and + `currentTime` does not advance until it resumes. Scheduling four clips at `currentTime + 0, +0.9, + +1.7, +2.4` against a frozen clock puts every one of them in the PAST by the time the context + actually starts — so they all fire on the same instant, on top of each other, through a 1.3 s + reverb tail. Resume FIRST, and re-read the clock after the decode. +2. **A SECOND CALL LAYERED INSTEAD OF REPLACING.** `voice()` has always enforced one man, one + microphone; `voiceSeq` SET that clock (`voiceUntil`) and never checked it. Two calls close + together = two overlapping lists. It stops the outstanding one now. +3. **CANCELLING A LIST HAS TO GIVE BACK THE TIME IT BOOKED.** The first cut of fix 2 stopped the old + sources but left `voiceUntil` standing, so the replacement queued behind a list that would never + play — measured at **6.6 s of silence** before the call the player is waiting on, and every + redeal made it worse. `seqUntilBefore` rewinds the booking. +4. **THE AMPLIFIER, in drill.js: the empty-court net redealt ON THE SPOT**, which makes the repair + rate the FRAME RATE — and every deal calls the umpire. It goes through the ordinary + between-rounds beat now, so the worst case is one redeal every `drillBeat` seconds: a mode that + limps instead of a phone screaming at you. Pinned by a test that empties the court every frame + for six seconds and asserts at most one call per beat. + +**And a measurement lesson worth more than the fix.** The first "it's clean" reading was taken by +counting `fetch`es of `assets/audio/*` — which proved nothing, because `VOICE[]` caches every clip +and a repeat play never fetches again. The honest probe tags each decoded buffer with the file it +came from (patch `decodeAudioData`, pair it with the pending fetch URL) and counts +`AudioBufferSourceNode.start` — then "did two umpire lines overlap" is a real question with a real +answer. Counting requests measures loading; counting `start()` measures sound. + **Open, and every one of them is Oliver's call after he plays it:** 1. **A ball that carries through the lane can complete two steps at once** — measured: one serve killed bib 1 and then bib 2 standing behind it, banking two correct steps in one shot. Had the diff --git a/index.html b/index.html index 66b283a..6934295 100644 --- a/index.html +++ b/index.html @@ -399,6 +399,6 @@ - + diff --git a/src/audio.js b/src/audio.js index fc182e8..d4aa51e 100644 --- a/src/audio.js +++ b/src/audio.js @@ -61,16 +61,42 @@ function loadVoice(name) { // rule is satisfied by construction rather than fought. Fire-and-forget — the caller's beat clock // runs at its own pace, and a late decode simply means he starts a moment later. Returns the total // speaking time (0 until the clips are cached) so a beat CAN be sized to it if one ever needs to be. +// THREE THINGS THIS HAS TO GET RIGHT, and the first cut got all three wrong. It shipped a phone-only +// garble that never once reproduced on desktop, so read this before touching it. +// +// 1. **A SUSPENDED CONTEXT HAS A FROZEN CLOCK.** On a phone the AudioContext starts suspended and +// `currentTime` does not advance until it resumes. Scheduling four clips at currentTime + 0, +// +0.9, +1.7, +2.4 against a frozen clock puts every one of them in the PAST by the time it +// actually runs — so they all fire on the same instant, on top of each other, through a 1.3 s +// reverb tail. Resume FIRST, and re-read the clock after the decode. +// 2. **A SECOND CALL MUST REPLACE THE FIRST, NOT LAYER ON IT.** `voice()` has always enforced one +// man, one microphone; this function SET that clock and never checked it, so anything that called +// it twice in quick succession got two overlapping lists. It stops the outstanding one now. +// 3. **NEVER SCHEDULE INTO THE PAST**, even with a running clock: a slow decode can land after the +// time we picked. Every start is clamped forward. +// 4. **STOPPING A LIST MUST GIVE BACK THE TIME IT RESERVED.** `voiceUntil` is how long the umpire is +// booked for. Cancelling the outstanding list without rewinding it left the booking standing, so +// the REPLACEMENT queued behind a list that is never going to play — measured at 6.6 seconds of +// silence before the call the player is waiting on. Every redeal made it worse. +let seqSources = [], seqUntilBefore = 0; export function voiceSeq(names, gap = 0.12) { - Promise.all(names.map(loadVoice)).then(bufs => { - const ac = audio(); - let at = ac.currentTime + 0.05; + const ac = audio(); // resumes a suspended context (see audio()) + if (seqSources.length) { // the new list replaces the old one, booking and all + for (const s of seqSources) { try { s.stop(); } catch (e) {} } + voiceUntil = seqUntilBefore; + } + seqSources = []; + seqUntilBefore = voiceUntil; + const ready = ac.state === 'running' ? Promise.resolve() : ac.resume().catch(() => {}); + Promise.all([ready, ...names.map(loadVoice)]).then(([, ...bufs]) => { + let at = Math.max(ac.currentTime + 0.08, voiceUntil); // clock re-read AFTER the decode + resume for (const buf of bufs) { const src = ac.createBufferSource(); src.buffer = buf; src.connect(ac.destination); const send = ac.createGain(); send.gain.value = 1.8; src.connect(send).connect(reverb(ac)); - src.start(at); + src.start(Math.max(at, ac.currentTime)); // never behind the clock + seqSources.push(src); at += buf.duration + gap; } voiceUntil = at; // he is busy for the whole list — ordinary lines stay out of the way diff --git a/src/drill.js b/src/drill.js index f861681..9082f71 100644 --- a/src/drill.js +++ b/src/drill.js @@ -127,9 +127,15 @@ export function updateDrill(dt) { // latches loaded) and could not reproduce it afterwards, which is precisely the kind of bug that // comes back in front of a player. Unrepaired it is a dead mode: no targets, no timer, nothing to // tap. Deal a fresh round and leave evidence, same contract as watchdog()'s invariant net. + // It goes through the ordinary between-rounds BEAT rather than dealing on the spot, and that is + // the load-bearing half: dealing here directly makes the repair rate the FRAME RATE, so a court + // that keeps coming up empty redeals sixty times a second — and every deal calls the umpire. + // Through the beat, the worst case is one redeal every drillBeat seconds, which is a mode that + // limps instead of a phone screaming at you. if (!zombies.some(z => z.bib !== undefined)) { - logSwing({ result: 'INVARIANT', reason: 'drill court emptied from outside the round — redealt' }); - return newDrillRound(); + logSwing({ result: 'INVARIANT', reason: 'drill court emptied from outside the round — redealing' }); + d.beat = TUNE.drillBeat; + return; } if (d.callT > 0) { // the walk-on: they take their marks d.callT -= dt; diff --git a/test.js b/test.js index 3db978d..580c77c 100644 --- a/test.js +++ b/test.js @@ -402,6 +402,29 @@ test('being caught costs the point, not the run', () => { assert.equal(zombies.length, 0, 'and the court is cleared for the next one'); }); +test('an emptied court cannot machine-gun the umpire', () => { + // Oliver, on a phone: "the drill mode immediately goes into some horrible audio loop". The trigger + // was never reproduced on desktop (a suspended AudioContext has a frozen clock, so a scheduled + // sequence all fires at once on resume — see voiceSeq), but the AMPLIFIER was here: the + // empty-court net used to redeal on the spot, which makes the repair rate the frame rate, and + // every deal calls the umpire. Whatever empties the court, it must never announce more than once + // per beat. + drillPlaying(); + let deals = 0; + const seq0 = G.drill.seq; + for (let i = 0; i < 60 * 6; i++) { // six seconds with the court emptied every single frame + zombies.length = 0; + update(DT); + if (G.drill.seq !== seq0 && G.drill.callT > 0 && zombies.length) { deals++; } + if (zombies.length) zombies.length = 0; // ...and emptied again, so it can never settle + } + const repairs = G.missLog.filter(m => m.result === 'INVARIANT').length; + assert.ok(repairs > 0, 'the net notices and leaves evidence'); + assert.ok(repairs <= 6 / TUNE.drillBeat + 2, + 'at most one repair per drillBeat, not one per frame — got ' + repairs); + assert.ok(deals <= 6 / TUNE.drillBeat + 2, 'and at most one deal (one umpire call) per beat — got ' + deals); +}); + test('endDrill hands the court back', () => { drillPlaying(); endDrill();