Track running noise mode through pitch envelope on channel 0

The MOS writes the noise control register with the running pitch byte (low
3 bits) on every envelope tick, so PI/PN walk the noise type+rate over time
— that's what gives Elite hyperspace its warble. Previously expand() short-
circuited stepPitch on noise channel and the audio engine treated noise
mode as a single fixed value for the whole note. Now expand() runs pitch
envelope on all channels, the audio engine builds a one-shot noise buffer
matching the sample stream, and the LFSR is reset to 0x4000 only when the
running noise mode actually changes (matching jsbeeb's noisePoked).

UI: pitch envelope inputs are no longer greyed on noise channel since
they're meaningful there. Visualiser replaces the static noise caption
with a coloured strip showing how the mode evolves cs-by-cs (warm = white,
cool = periodic; brighter = faster shift rate).

Game presets: added Elite explosion / missile / hyperspace and Thrust
engine, decoded from the SFX tables in markmoxon/elite-source-code-bbc-
micro-cassette and the kieranhj/thrust-disassembly app_init.asm.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: kieranhj

src/audio.ts

@@ -11,9 +11,6 @@ let activeNodes: ActiveNodes | null = null;
 let playStart: number | null = null;
 let playDuration: number | null = null;
 
-// Noise buffer cache, keyed by `${type}:${rate}` and rebuilt per AudioContext.
-let noiseBufferCache: { ctx: AudioContext; buffers: Map<string, AudioBuffer> } | null = null;
-
 // BBC Micro feeds the SN76489 at 4 MHz. The TI datasheet documents the noise
 // shift rate as clock/N where N ∈ {512, 1024, 2048} — i.e., the divisors are
 // applied to the raw input clock (the chip's own /16 prescaler is implied
@@ -23,60 +20,73 @@ const BBC_CHIP_CLOCK_HZ = 4_000_000;
 const NOISE_DIVISORS = [512, 1024, 2048] as const;
 
 /**
- * Build a tiled mono AudioBuffer of the SN76489AN noise output for one
- * (type, rate) combination. We simulate a 15-bit LFSR — white feeds back the
- * XOR of bits 0 and 1, periodic feeds back bit 0 only (period 15 → the
- * characteristic BBC "drum" buzz). The LFSR is advanced sub-sample-accurately
- * with a fractional counter so the output is correct at any AudioContext rate.
+ * Build a one-shot mono AudioBuffer covering the entire sample stream for the
+ * noise channel. The MOS writes the running pitch byte to the noise control
+ * register on every envelope tick, so the LFSR's type (white/periodic) and
+ * shift rate evolve as PI/PN advance the pitch envelope. We mirror that here:
+ * each centisecond of output is generated using the noise mode encoded in
+ * (basePitch + sample.pitchOffset) & 7. P=3 / P=7 ("follows tone 2") are
+ * punted to medium rate.
  *
- * Two seconds is plenty: white noise loops imperceptibly, periodic loops at
- * ~30 Hz/8 Hz so two seconds easily contains a whole number of cycles.
+ * LFSR algorithm matches jsbeeb (src/soundchip.js):
+ *   white    — feedback = bit0 ^ bit1, shifted into bit 14 (15-bit LFSR)
+ *   periodic — pure right shift, reload to 0x4000 (bit 14) when it reaches 0
  */
-function buildNoiseBuffer(ac: AudioContext, mode: NoiseMode): AudioBuffer {
+function buildNoiseBufferForStream(ac: AudioContext, samples: Sample[], basePitch: number): AudioBuffer {
   const sampleRate = ac.sampleRate;
-  const seconds = 2;
-  const n = Math.floor(sampleRate * seconds);
+  const seconds = samples.length * CS;
+  const n = Math.max(1, Math.floor(sampleRate * seconds));
   const buf = ac.createBuffer(1, n, sampleRate);
   const data = buf.getChannelData(0);
 
-  // Rate 3 ("follows tone2") is punted to medium (rate 1).
-  const rateIdx = mode.rate === 3 ? 1 : mode.rate;
-  const shiftHz = BBC_CHIP_CLOCK_HZ / NOISE_DIVISORS[rateIdx]!;
-  const shiftsPerSample = shiftHz / sampleRate;
-
   let lfsr = 0x4000;
   let phase = 0;
   let out = (lfsr & 1) === 1 ? 1 : -1;
+  const samplesPerCs = sampleRate * CS;
+  let prevCsIdx = -1;
+  let prevModeP = -1;
 
   for (let i = 0; i < n; i++) {
+    const csIdx = Math.min(samples.length - 1, Math.floor(i / samplesPerCs));
+    const p = ((basePitch + samples[csIdx]!.pitchOffset) | 0) & 0x07;
+    if (csIdx !== prevCsIdx) {
+      // The MOS only writes the noise control register when the pitch byte
+      // (low 3 bits) actually changes — env3 trace confirms: pure-volume
+      // envelopes emit zero noise-register writes. jsbeeb's `noisePoked`
+      // resets the LFSR to 0x4000 only on those writes. Mirror that: keep
+      // LFSR running normally on flat-pitch envelopes (clean white noise),
+      // and reset it whenever PI/PN advance the noise mode (gives the BBC's
+      // characteristic warble for pitch-modulated effects like hyperspace).
+      if (p !== prevModeP) {
+        lfsr = 0x4000;
+        phase = 0;
+        out = (lfsr & 1) === 1 ? 1 : -1;
+      }
+      prevCsIdx = csIdx;
+      prevModeP = p;
+    }
+    const isWhite = (p & 0x04) !== 0;
+    const rateBits = p & 0x03;
+    const rateIdx = rateBits === 3 ? 1 : rateBits;
+    const shiftsPerSample = (BBC_CHIP_CLOCK_HZ / NOISE_DIVISORS[rateIdx]!) / sampleRate;
+
     phase += shiftsPerSample;
     while (phase >= 1) {
       phase -= 1;
-      const fb = mode.type === "white"
-        ? (lfsr & 1) ^ ((lfsr >> 1) & 1)
-        : (lfsr & 1);
-      lfsr = ((lfsr >> 1) | (fb << 14)) & 0x7fff;
-      if (lfsr === 0) lfsr = 0x4000; // guard against the trivial lock-up state
+      if (isWhite) {
+        const fb = (lfsr & 1) ^ ((lfsr >> 1) & 1);
+        lfsr = ((lfsr >> 1) | (fb << 14)) & 0x7fff;
+      } else {
+        lfsr = lfsr >> 1;
+        if (lfsr === 0) lfsr = 0x4000;
+      }
       out = (lfsr & 1) === 1 ? 1 : -1;
     }
     data[i] = out;
   }
   return buf;
 }
 
-function getNoiseBuffer(ac: AudioContext, mode: NoiseMode): AudioBuffer {
-  if (!noiseBufferCache || noiseBufferCache.ctx !== ac) {
-    noiseBufferCache = { ctx: ac, buffers: new Map() };
-  }
-  const key = `${mode.type}:${mode.rate}`;
-  let buf = noiseBufferCache.buffers.get(key);
-  if (!buf) {
-    buf = buildNoiseBuffer(ac, mode);
-    noiseBufferCache.buffers.set(key, buf);
-  }
-  return buf;
-}
-
 function getCtx(): AudioContext {
   if (!ctx) ctx = new (window.AudioContext || (window as unknown as { webkitAudioContext: typeof AudioContext }).webkitAudioContext)();
   return ctx;
@@ -116,8 +126,10 @@ export function play(samples: Sample[], basePitch: number, noiseMode: NoiseMode
 
   if (noiseMode) {
     const noiseSrc = ac.createBufferSource();
-    noiseSrc.buffer = getNoiseBuffer(ac, noiseMode);
-    noiseSrc.loop = true;
+    // The noise buffer is rendered to match the sample stream exactly,
+    // walking through whatever noise modes the running pitch byte selects
+    // each centisecond. No looping — playback length matches the envelope.
+    noiseSrc.buffer = buildNoiseBufferForStream(ac, samples, basePitch);
     noiseSrc.connect(gain).connect(ac.destination);
     source = noiseSrc;
   } else {

src/envelope.ts

@@ -81,7 +81,7 @@ export function decodeNoiseP(pitch: number): NoiseMode {
  * The returned stream covers attack + decay + sustain + release, i.e. the
  * full audible lifetime of the note.
  */
-export function expand(env: Envelope, soundAmplitude: number, soundDuration: number, hold = false, channel = 1): Sample[] {
+export function expand(env: Envelope, soundAmplitude: number, soundDuration: number, hold = false, _channel = 1): Sample[] {
   const samples: Sample[] = [];
 
   // SOUND amplitude argument: 0 = silence, -15..-1 = static volume, 1..4 = envelope number.
@@ -125,8 +125,11 @@ export function expand(env: Envelope, soundAmplitude: number, soundDuration: num
   //     resets offset and runs the same tick's step from section 0, so the
   //     wrap itself doesn't cost extra time (matches a normal step interval).
   const stepPitch = () => {
-    if (channel === 0) return; // noise channel ignores PI/PN entirely
     if (tStep === 0) return; // T=0 disables the pitch envelope
+    // Note: this runs on channel 0 too. The MOS writes the running pitch
+    // byte to the noise control register every envelope tick, so PI/PN
+    // walk the noise type+rate combinations over time — essential for
+    // effects like Elite's hyperspace warble.
     if (sectionIdx >= sections.length) {
       if (!repeat) return;
       sectionIdx = 0;

src/main.ts

@@ -277,20 +277,15 @@ noiseSelect.addEventListener("change", () => {
 noiseModeWrap.appendChild(noiseSelect);
 soundGrid.appendChild(noiseModeWrap);
 
-const pitchH3 = pitchGrid.previousElementSibling as HTMLElement;
 const pitchInputWrap = soundInputs.get("pitch")!.closest("label") as HTMLElement;
 
 function applyChannelMode(): void {
   const isNoise = sound.channel === 0;
-  // Grey out the pitch envelope inputs rather than hiding the section, so
-  // the layout doesn't jump when switching channels. Same treatment for the
-  // SOUND pitch number input (replaced by the noise-mode dropdown).
-  pitchH3.classList.toggle("disabled", isNoise);
-  pitchGrid.classList.toggle("disabled", isNoise);
-  for (const f of PITCH_FIELDS) {
-    const i = envInputs.get(f.key);
-    if (i) i.disabled = isNoise;
-  }
+  // The pitch envelope is editable on noise channel too: the MOS writes
+  // the running pitch byte (low 3 bits) to the noise control register on
+  // every envelope tick, so T/PI/PN walk the noise mode (white/periodic +
+  // shift rate) over time. Only the SOUND pitch input is swapped for the
+  // noise-mode dropdown that picks the *starting* mode.
   pitchInputWrap.classList.toggle("disabled", isNoise);
   const pitchInput = soundInputs.get("pitch");
   if (pitchInput) pitchInput.disabled = isNoise;

src/presets.ts

@@ -205,6 +205,30 @@ export const PRESETS: Preset[] = [
            aa: 22, ad: 0, as: 0, ar: -127, ala: 126, ald: 0 },
     sound: { channel: 3, amplitude: 4, pitch: 194, duration: 80 },
   },
+  {
+    name: "Elite: explosion",
+    description: "Elite — death / kill; SFX entry 24 in the cassette source — channel 0 white noise (P=7), originally static amp -15, duration 26",
+    // Original: SOUND 0,-15,7,26. Converted to a flat-max envelope with a
+    // hard release (AR=-127) so the noise cuts off cleanly when the SOUND
+    // duration ends — mimicking the real chip's gate behaviour.
+    env: { n: 1, t: 1, pi1: 0, pi2: 0, pi3: 0, pn1: 0, pn2: 0, pn3: 0,
+           aa: 127, ad: 0, as: 0, ar: -127, ala: 126, ald: 126 },
+    sound: { channel: 0, amplitude: 1, pitch: 7, duration: 26 },
+  },
+  {
+    name: "Elite: missile",
+    description: "Elite — missile launch / ship launching from station; SFX entry 48 — channel 0 white noise (P=6), originally static amp -15",
+    env: { n: 1, t: 1, pi1: 0, pi2: 0, pi3: 0, pn1: 0, pn2: 0, pn3: 0,
+           aa: 127, ad: 0, as: 0, ar: -127, ala: 126, ald: 126 },
+    sound: { channel: 0, amplitude: 1, pitch: 6, duration: 12 },
+  },
+  {
+    name: "Elite: hyperspace",
+    description: "Elite — hyperspace drive engaged; SFX entry 56 — channel 0 noise with envelope 2 (the same envelope used for laser hits) and pitch 96 (P&7 = 0 → periodic noise, high rate)",
+    env: { n: 2, t: 1, pi1: 14, pi2: -18, pi3: -1, pn1: 44, pn2: 32, pn3: 50,
+           aa: 6, ad: 1, as: 0, ar: -2, ala: 120, ald: 126 },
+    sound: { channel: 0, amplitude: 2, pitch: 96, duration: 16 },
+  },
   {
     name: "Chuckie: blip",
     description: "Chuckie Egg (1983, A&F / Alderton) — short percussive bleep used for collecting eggs and similar",
@@ -233,6 +257,16 @@ export const PRESETS: Preset[] = [
            aa: 126, ad: -4, as: -2, ar: -4, ala: 126, ald: 110 },
     sound: { channel: 2, amplitude: 3, pitch: 185, duration: 5 },
   },
+  {
+    name: "Thrust: engine",
+    description: "Thrust — engine-thrust noise blip retriggered every frame while thrusting; channel 0 white noise medium rate (P=5), originally static amp -10",
+    // Original sound block: $10,$00,$F6,$FF,$05,$00,$03,$00 → channel 0,
+    // amp -10, pitch 5, duration 3. Converted to an envelope holding at
+    // ~84/126 (the BBC level corresponding to static -10) for the duration.
+    env: { n: 1, t: 1, pi1: 0, pi2: 0, pi3: 0, pn1: 0, pn2: 0, pn3: 0,
+           aa: 127, ad: 0, as: 0, ar: -127, ala: 84, ald: 84 },
+    sound: { channel: 0, amplitude: 1, pitch: 5, duration: 4 },
+  },
   // Examples from the BBC Microcomputer User Guide chapter on SOUND/ENVELOPE.
   {
     name: "UG #1 wobble",

src/visualizer.ts

@@ -40,11 +40,7 @@ export function render(
   ctx.font = "12px system-ui, sans-serif";
   ctx.fillText("Amplitude (0..126)", padding, ampTop - 6);
   if (noiseMode) {
-    const rateLabels = ["high", "medium", "low", "follows tone2 (treated as medium)"] as const;
-    ctx.fillText(
-      `Noise: ${noiseMode.type}, ${rateLabels[noiseMode.rate]}  —  ${samples.length} centiseconds`,
-      padding, pitchTop - 6,
-    );
+    ctx.fillText(`Noise mode (${samples.length} centiseconds)`, padding, pitchTop - 6);
   } else {
     ctx.fillText(`Pitch (BBC units, 4 = 1 semitone)  —  ${samples.length} centiseconds`, padding, pitchTop - 6);
   }
@@ -175,26 +171,38 @@ export function render(
     }
     ctx.stroke();
   } else {
-    // Noise channel: pitch plot is replaced by a centred mode caption.
+    // Noise channel: pitch plot becomes a strip showing how the noise mode
+    // evolves over time. The MOS writes the running pitch byte (low 3 bits)
+    // into the noise control register on every envelope tick, so PI/PN walk
+    // the noise type+rate combinations during the note. We colour-band each
+    // cs by its current mode so the user can see when the chip switches.
+    const modeColour = (p: number): string => {
+      const isWhite = (p & 0x04) !== 0;
+      const rateBits = p & 0x03;
+      // White = warm, periodic = cool. Brightness encodes rate.
+      const whitePalette = ["#f4a261", "#e76f51", "#bc4749", "#6a040f"]; // high → low → tone2
+      const periodicPalette = ["#90e0ef", "#48cae4", "#0096c7", "#023e8a"];
+      return (isWhite ? whitePalette : periodicPalette)[rateBits]!;
+    };
+    const stripTop = pitchTop + halfH * 0.35;
+    const stripH = halfH * 0.3;
+    for (let i = 0; i < samples.length; i++) {
+      const x = xFor(i);
+      const xNext = i + 1 < samples.length ? xFor(i + 1) : padding + plotW;
+      const p = ((basePitch + samples[i]!.pitchOffset) | 0) & 0x07;
+      ctx.fillStyle = modeColour(p);
+      ctx.fillRect(x, stripTop, Math.max(1, xNext - x + 1), stripH);
+    }
     ctx.fillStyle = "#8b949e";
     ctx.textAlign = "center";
-    ctx.textBaseline = "middle";
-    ctx.font = "bold 14px system-ui, sans-serif";
-    ctx.fillText(
-      `${noiseMode.type.toUpperCase()} noise`,
-      padding + plotW / 2,
-      pitchTop + halfH / 2 - 8,
-    );
+    ctx.textBaseline = "alphabetic";
     ctx.font = "12px system-ui, sans-serif";
-    ctx.fillStyle = "#6e7681";
-    const rateNames = ["high (~7.8 kHz)", "medium (~3.9 kHz)", "low (~2.0 kHz)", "follows tone 2"] as const;
     ctx.fillText(
-      `LFSR shift rate: ${rateNames[noiseMode.rate]}`,
+      "Noise mode strip — warm = white, cool = periodic; brightness ↑ = faster shift rate",
       padding + plotW / 2,
-      pitchTop + halfH / 2 + 12,
+      stripTop - 6,
     );
     ctx.textAlign = "start";
-    ctx.textBaseline = "alphabetic";
   }
 
   if (playhead !== null && playhead >= 0 && playhead <= 1) {