castle-web-cli 0.4.113 → 0.4.115

package/kits/physics-2d/engine/tone.js

@@ -0,0 +1,112 @@
+// A synthesized note: one oscillator through an attack/release envelope. This
+// is the sound a deck can make with no audio file at all -- a blip on a pickup,
+// a beep on a wrong answer -- and it costs nothing to ship.
+//
+// Deliberately one voice and two envelope stages, matching what the classic
+// Castle editor's "tone" sample offers. Anything richer is an instrument, and an
+// instrument belongs in a music system, not here.
+
+import { getAudioContext, resumeAudioContext } from './audioContext';
+
+export const WAVEFORMS = ['square', 'sawtooth', 'sine', 'triangle', 'noise'];
+
+// Voices currently sounding, so play mode can be silenced on Stop.
+const voices = new Set();
+
+// MIDI note number to Hz. 69 is A440, 12 notes to the octave.
+export function noteToFrequency(note) {
+  const midi = Number.isFinite(note) ? note : 60;
+  return 440 * Math.pow(2, (midi - 69) / 12);
+}
+
+// A short burst of white noise, made once and reused. Noise is the one waveform
+// an oscillator can't produce, and it's what a percussive hit wants.
+let noiseBuffer = null;
+function getNoiseBuffer(ctx) {
+  if (noiseBuffer && noiseBuffer.sampleRate === ctx.sampleRate) return noiseBuffer;
+  const frames = Math.floor(ctx.sampleRate * 2);
+  const buffer = ctx.createBuffer(1, frames, ctx.sampleRate);
+  const data = buffer.getChannelData(0);
+  for (let i = 0; i < frames; i++) data[i] = Math.random() * 2 - 1;
+  noiseBuffer = buffer;
+  return buffer;
+}
+
+function makeSource(ctx, waveform, frequency) {
+  if (waveform === 'noise') {
+    const source = ctx.createBufferSource();
+    source.buffer = getNoiseBuffer(ctx);
+    source.loop = true;
+    return source;
+  }
+  const osc = ctx.createOscillator();
+  osc.type = WAVEFORMS.includes(waveform) ? waveform : 'square';
+  osc.frequency.value = frequency;
+  return osc;
+}
+
+// Play one note. Returns `{ stop, finished }` -- `finished` resolves when the
+// release has run out, so a caller can wait for it the way a Sound can.
+export function playTone({ note = 60, waveform = 'square', attack = 0, release = 0.4, volume = 1, pan = 0 } = {}) {
+  const ctx = getAudioContext();
+  if (!ctx) return { stop() {}, finished: Promise.resolve() };
+  resumeAudioContext();
+
+  const level = Number.isFinite(volume) ? Math.min(1, Math.max(0, volume)) : 1;
+  const rise = Math.max(0, Number.isFinite(attack) ? attack : 0);
+  // A note with no release at all clicks; give it a floor short enough to still
+  // read as instant.
+  const fall = Math.max(0.01, Number.isFinite(release) ? release : 0.4);
+  const start = ctx.currentTime;
+  const end = start + rise + fall;
+
+  const source = makeSource(ctx, waveform, noteToFrequency(note));
+  const gain = ctx.createGain();
+  gain.gain.setValueAtTime(0, start);
+  gain.gain.linearRampToValueAtTime(level, start + rise);
+  gain.gain.linearRampToValueAtTime(0, end);
+
+  let tail = gain;
+  if (pan && ctx.createStereoPanner) {
+    const panner = ctx.createStereoPanner();
+    panner.pan.value = Math.min(1, Math.max(-1, pan));
+    gain.connect(panner);
+    tail = panner;
+  }
+  source.connect(gain);
+  tail.connect(ctx.destination);
+  source.start(start);
+  source.stop(end);
+
+  const voice = { source, gain };
+  voices.add(voice);
+  const finished = new Promise((resolve) => {
+    source.addEventListener('ended', () => {
+      voices.delete(voice);
+      resolve();
+    });
+  });
+  return {
+    stop() {
+      voices.delete(voice);
+      try {
+        source.stop();
+      } catch {
+        // Already stopped -- nothing to do.
+      }
+    },
+    finished,
+  };
+}
+
+// Silence every sounding note. Play mode ending must not leave one ringing.
+export function stopAllTones() {
+  for (const voice of voices) {
+    try {
+      voice.source.stop();
+    } catch {
+      // Already stopped.
+    }
+  }
+  voices.clear();
+}

package/kits/physics-2d/systems/media.js

@@ -0,0 +1,34 @@
+// Registers sound / video playback as a runtime system. Auto-discovered by
+// engine/systemRegistry.js (`systems/*.js`) and invoked by makeScene, so the
+// media pool plugs in without the shared engine referencing it.
+//
+// The system owns the LIFECYCLE only -- behaviors decide what plays. It reaps
+// idle elements once a frame (a despawned actor's sound stops), and silences
+// everything on `reset` (a scene load / restart / transition) and on `dispose`
+// (the player unmounting, i.e. pressing Stop).
+//
+// It also puts `scene.sound` on the runtime: the scene-wide controls, which
+// belong to nobody's actor.
+
+import { reapUnusedMedia, stopAllMedia } from '../engine/media';
+import { stopAllTones } from '../engine/tone';
+
+function silence() {
+  stopAllMedia();
+  stopAllTones();
+}
+
+export function installSystem(runtime) {
+  runtime.sound = {
+    // Everything this scene is playing, off. The blunt instrument for a game
+    // over, a pause, or leaving a level: individual actors need not be found.
+    stopAll: silence,
+  };
+  runtime.registerSystem({
+    afterBehaviors(scene) {
+      reapUnusedMedia(new Set(scene.actors.keys()));
+    },
+    reset: silence,
+    dispose: silence,
+  });
+}

package/kits/physics-2d/systems/physics.js

@@ -1,8 +1,17 @@
 // Registers the physics simulation as a runtime system. Auto-discovered by
 // engine/systemRegistry.js (`systems/*.js`) and invoked by makeScene, so the
-// physics module plugs in without the shared engine ever referencing it.
-import { installPhysics } from '../physics';
+// shared engine never has to reference physics directly.
+//
+// The simulation itself lives in `engine/physics/`; its behaviors (RigidBody,
+// Joints, and the touch-first controls) are ordinary behaviors in `behaviors/`.
+import { PhysicsSystem } from '../engine/physics/PhysicsSystem';
 
+// Register a physics system on a runtime and wire up `runtime.physics`. Cheap
+// to call on every runtime -- the matter engine is created lazily on the first
+// simulation step.
 export function installSystem(runtime) {
-  installPhysics(runtime);
+  const system = new PhysicsSystem();
+  runtime.registerSystem(system);
+  system.attach(runtime);
+  return system;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.113",
+  "version": "0.4.115",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"