castle-web-cli 0.4.127 → 0.4.129

package/kits/physics-2d/behaviors/Sound.jsx

@@ -1,163 +0,0 @@
-import { resolveDeckFile } from 'castle-web-sdk';
-import React from 'react';
-import { mediaElement, playMedia, playOneShot, setMediaPan, stopMedia } from '../engine/media';
-import { mediaFilesOfKind } from '../engine/files';
-import { Panel, SelectField } from '../engine/ui';
-import { AutoFields, overrideProps } from '../engine/autoInspector';
-import { PAN, UNIT } from '../engine/propertyRanges';
-
-// Plays a sound file (.mp3 / .wav / .m4a) from an actor.
-//
-// Two ways to use it. Set `playOnStart` and it plays when the scene starts --
-// music, ambience, a jingle on a game-over screen. Or leave it off and trigger
-// it from a behavior, through the handle this puts on the actor:
-//
-//   scene.getActor('sfx').runtime.sound.play();   // from the top
-//   await actor.runtime.sound.play();             // ...and wait for it to end
-//   actor.runtime.sound.stop();
-//
-// `play()` on a `polyphonic` sound overlaps copies instead of cutting the last
-// one off, which is what a sound effect fired twice in a row should do. Without
-// it, a second play restarts the one element, which is what music wants.
-//
-// Sound only plays during play, never in the editor: `update` is what wires the
-// element up, and the editor doesn't run it. Pressing Stop silences everything,
-// as does `scene.sound.stopAll()` (see systems/media.js).
-//
-// Browsers refuse to play audio until the player has touched the page. A sound
-// that starts before that isn't lost -- it's queued and starts on the first tap
-// or key (engine/media.js), which for a game is usually the first input anyway.
-export class Sound {
-  static behaviorName = 'Sound';
-
-  static defaultProps = {
-    file: '',
-    volume: 1,
-    playbackRate: 1,
-    pan: 0,
-    loop: false,
-    polyphonic: false,
-    playOnStart: true,
-  };
-
-  // Mirrors the clamps `readSettings` already applies at runtime, so the
-  // inspector can't author a value the sound would silently ignore -- including
-  // playbackRate's 0.01..10, where the classic editor's ceiling lives.
-  static propertyMeta = {
-    volume: UNIT,
-    playbackRate: { min: 0.01, max: 10, step: 0.05 },
-    pan: PAN,
-  };
-
-  constructor(props) {
-    this.props = props;
-  }
-
-  update(actor) {
-    if (!actor.runtime || actor.runtime.collected) return;
-    const file = resolveDeckFile(this.props.file);
-    const element = mediaElement(actor.id, 'audio', file);
-    if (!element) {
-      actor.runtime.sound = null;
-      return;
-    }
-    // Props are live: turning the volume down, the pitch up, or the loop on in
-    // the inspector takes effect on the sound already playing.
-    const settings = readSettings(this.props);
-    element.volume = settings.volume;
-    element.playbackRate = settings.playbackRate;
-    element.loop = settings.loop;
-    if (settings.pan !== 0) setMediaPan(element, settings.pan);
-
-    const handle = actor.runtime.sound;
-    if (!handle || handle.file !== file) {
-      actor.runtime.sound = makeHandle(file, element, () => readSettings(this.props));
-      if (this.props.playOnStart) void actor.runtime.sound.play();
-    } else {
-      handle.settings = settings;
-    }
-  }
-
-  static Inspector({ component, setComponent, override }) {
-    return (
-      <Panel title="Sound" overridden={override?.anyOverridden()}>
-        <SelectField
-          label="File"
-          value={component.file}
-          onChange={(file) => setComponent({ file })}
-          options={mediaFilesOfKind('audio')}
-          {...overrideProps(override, 'file')}
-        />
-        <AutoFields
-          defaultProps={Sound.defaultProps}
-          meta={Sound.propertyMeta}
-          component={component}
-          setComponent={setComponent}
-          only={['volume', 'playbackRate', 'pan', 'loop', 'polyphonic', 'playOnStart']}
-          override={override}
-        />
-      </Panel>
-    );
-  }
-}
-
-function clamp(value, min, max, fallback) {
-  return Number.isFinite(value) ? Math.min(max, Math.max(min, value)) : fallback;
-}
-
-function readSettings(props) {
-  return {
-    volume: clamp(props.volume, 0, 1, 1),
-    // The same ceiling the classic editor used: past 10x a sound is a click.
-    playbackRate: clamp(props.playbackRate, 0.01, 10, 1),
-    pan: clamp(props.pan, -1, 1, 0),
-    loop: Boolean(props.loop),
-    polyphonic: Boolean(props.polyphonic),
-  };
-}
-
-// What a behavior gets at `actor.runtime.sound`. Plain methods over the element,
-// so game code never has to know an <audio> is involved.
-//
-// `play()` returns a promise that resolves when the sound ends, so a behavior
-// can `await` one before doing the next thing. A looping sound resolves right
-// away rather than never -- awaiting something that by definition doesn't end
-// would hang the caller forever, and that is never what was meant.
-function makeHandle(file, element, currentSettings) {
-  const handle = {
-    file,
-    element,
-    settings: currentSettings(),
-    play() {
-      const s = handle.settings;
-      if (s.polyphonic) {
-        return playOneShot(file, { volume: s.volume, playbackRate: s.playbackRate, pan: s.pan });
-      }
-      try {
-        element.currentTime = 0;
-      } catch {
-        // Not seekable yet (still loading) -- it plays from the start anyway.
-      }
-      playMedia(element);
-      if (s.loop) return Promise.resolve();
-      return new Promise((resolve) => {
-        const done = () => resolve();
-        element.addEventListener('ended', done, { once: true });
-        element.addEventListener('error', done, { once: true });
-      });
-    },
-    resume() {
-      playMedia(element);
-    },
-    pause() {
-      element.pause();
-    },
-    stop() {
-      stopMedia(element);
-    },
-    get playing() {
-      return !element.paused;
-    },
-  };
-  return handle;
-}

package/kits/physics-2d/behaviors/Tone.jsx

@@ -1,95 +0,0 @@
-import React from 'react';
-import { playTone, WAVEFORMS } from '../engine/tone';
-import { Panel, SelectField } from '../engine/ui';
-import { AutoFields, overrideProps } from '../engine/autoInspector';
-import { PAN, POSITIVE, UNIT } from '../engine/propertyRanges';
-
-// Plays a synthesized note -- no audio file involved. This is the cheapest sound
-// a deck can make: a blip on a pickup, a thud on a miss, a rising scale as a
-// counter climbs. Nothing is downloaded and nothing is stored.
-//
-//   actor.runtime.tone.play();          // the note as configured
-//   actor.runtime.tone.play({ note: 72 });  // ...or override it per play
-//   await actor.runtime.tone.play();    // wait for the release to finish
-//
-// `note` is a MIDI number: 60 is middle C, 72 an octave up, +1 a semitone. The
-// envelope is attack (silence up to full) then release (full down to silence),
-// so the note's whole length is attack + release seconds.
-export class Tone {
-  static behaviorName = 'Tone';
-
-  static defaultProps = {
-    note: 60,
-    waveform: 'square',
-    attack: 0,
-    release: 0.3,
-    volume: 0.5,
-    pan: 0,
-    playOnStart: false,
-  };
-
-  // `note` is MIDI, which is genuinely 0..127. `attack`/`release` are seconds,
-  // so they get a floor but no ceiling.
-  static propertyMeta = {
-    note: { min: 0, max: 127, step: 1 },
-    attack: POSITIVE,
-    release: POSITIVE,
-    volume: UNIT,
-    pan: PAN,
-  };
-
-  constructor(props) {
-    this.props = props;
-  }
-
-  update(actor) {
-    if (!actor.runtime || actor.runtime.collected) return;
-    const handle = actor.runtime.tone;
-    if (!handle) {
-      actor.runtime.tone = makeHandle(() => this.props);
-      if (this.props.playOnStart) void actor.runtime.tone.play();
-    } else {
-      handle.props = this.props;
-    }
-  }
-
-  static Inspector({ component, setComponent, override }) {
-    return (
-      <Panel title="Tone" overridden={override?.anyOverridden()}>
-        <SelectField
-          label="Waveform"
-          value={component.waveform}
-          onChange={(waveform) => setComponent({ waveform })}
-          options={WAVEFORMS}
-          {...overrideProps(override, 'waveform')}
-        />
-        <AutoFields
-          defaultProps={Tone.defaultProps}
-          meta={Tone.propertyMeta}
-          component={component}
-          setComponent={setComponent}
-          only={['note', 'attack', 'release', 'volume', 'pan', 'playOnStart']}
-          override={override}
-        />
-      </Panel>
-    );
-  }
-}
-
-// `actor.runtime.tone`. `play(overrides)` takes the same fields as the props, so
-// one Tone actor can cover a whole scale without a component per note.
-function makeHandle(currentProps) {
-  const handle = {
-    props: currentProps(),
-    voice: null,
-    play(overrides) {
-      handle.voice = playTone({ ...handle.props, ...overrides });
-      return handle.voice.finished;
-    },
-    stop() {
-      handle.voice?.stop();
-      handle.voice = null;
-    },
-  };
-  return handle;
-}

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

@@ -1,112 +0,0 @@
-// 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();
-}