@al8b/audio 0.1.0

package/dist/core/audio-core.js

@@ -0,0 +1,664 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/audio-core.ts
+var audio_core_exports = {};
+__export(audio_core_exports, {
+  AudioCore: () => AudioCore
+});
+module.exports = __toCommonJS(audio_core_exports);
+var import_diagnostics = require("@al8b/diagnostics");
+
+// src/constants.ts
+var A4_FREQUENCY = 440;
+var SEMITONE_RATIO = 2 ** (1 / 12);
+var A4_MIDI_NOTE = 69;
+
+// src/devices/beeper.ts
+var Beeper = class {
+  static {
+    __name(this, "Beeper");
+  }
+  audio;
+  notes = {};
+  plainNotes = {};
+  currentOctave = 5;
+  currentDuration = 0.5;
+  currentVolume = 0.5;
+  currentSpan = 1;
+  currentWaveform = "square";
+  constructor(audio) {
+    this.audio = audio;
+    this.initializeNotes();
+  }
+  /**
+  * Initialize note mappings
+  */
+  initializeNotes() {
+    const noteNames = [
+      [
+        "C",
+        "DO"
+      ],
+      [
+        "C#",
+        "DO#",
+        "Db",
+        "REb"
+      ],
+      [
+        "D",
+        "RE"
+      ],
+      [
+        "D#",
+        "RE#",
+        "Eb",
+        "MIb"
+      ],
+      [
+        "E",
+        "MI"
+      ],
+      [
+        "F",
+        "FA"
+      ],
+      [
+        "F#",
+        "FA#",
+        "Gb",
+        "SOLb"
+      ],
+      [
+        "G",
+        "SOL"
+      ],
+      [
+        "G#",
+        "SOL#",
+        "Ab",
+        "LAb"
+      ],
+      [
+        "A",
+        "LA"
+      ],
+      [
+        "A#",
+        "LA#",
+        "Bb",
+        "SIb"
+      ],
+      [
+        "B",
+        "SI"
+      ]
+    ];
+    for (let i = 0; i <= 127; i++) {
+      this.notes[i] = i;
+      const oct = Math.floor(i / 12) - 1;
+      for (const n of noteNames[i % 12]) {
+        this.notes[n + oct] = i;
+      }
+      if (oct === -1) {
+        for (const n of noteNames[i % 12]) {
+          this.plainNotes[n] = i;
+        }
+      }
+    }
+  }
+  /**
+  * Parse and play beep sequence
+  */
+  beep(input) {
+    let status = "normal";
+    const sequence = [];
+    const loops = [];
+    let note;
+    const parsed = input.split(" ");
+    for (const t of parsed) {
+      if (t === "") continue;
+      switch (status) {
+        case "normal":
+          if (this.notes[t] !== void 0) {
+            note = this.notes[t];
+            this.currentOctave = Math.floor(note / 12);
+            sequence.push({
+              frequency: A4_FREQUENCY * SEMITONE_RATIO ** (note - A4_MIDI_NOTE),
+              volume: this.currentVolume,
+              span: this.currentSpan,
+              duration: this.currentDuration,
+              waveform: this.currentWaveform
+            });
+          } else if (this.plainNotes[t] !== void 0) {
+            note = this.plainNotes[t] + this.currentOctave * 12;
+            sequence.push({
+              frequency: A4_FREQUENCY * SEMITONE_RATIO ** (note - A4_MIDI_NOTE),
+              volume: this.currentVolume,
+              span: this.currentSpan,
+              duration: this.currentDuration,
+              waveform: this.currentWaveform
+            });
+          } else if ([
+            "square",
+            "sine",
+            "saw",
+            "noise"
+          ].includes(t)) {
+            this.currentWaveform = t;
+          } else if ([
+            "tempo",
+            "duration",
+            "volume",
+            "span",
+            "loop",
+            "to"
+          ].includes(t)) {
+            status = t;
+          } else if (t === "-") {
+            sequence.push({
+              frequency: A4_FREQUENCY,
+              volume: 0,
+              span: this.currentSpan,
+              duration: this.currentDuration,
+              waveform: this.currentWaveform
+            });
+          } else if (t === "end") {
+            if (loops.length > 0 && sequence.length > 0) {
+              sequence.push({
+                frequency: A4_FREQUENCY,
+                volume: 0,
+                span: this.currentSpan,
+                duration: 0,
+                waveform: this.currentWaveform
+              });
+              const lop = loops.splice(loops.length - 1, 1)[0];
+              sequence[sequence.length - 1].loopto = lop.start;
+              sequence[sequence.length - 1].repeats = lop.repeats;
+            }
+          }
+          break;
+        case "tempo": {
+          status = "normal";
+          const tempo = Number.parseFloat(t);
+          if (!Number.isNaN(tempo) && tempo > 0) {
+            this.currentDuration = 60 / tempo;
+          }
+          break;
+        }
+        case "duration": {
+          status = "normal";
+          const duration = Number.parseFloat(t);
+          if (!Number.isNaN(duration) && duration > 0) {
+            this.currentDuration = duration / 1e3;
+          }
+          break;
+        }
+        case "volume": {
+          status = "normal";
+          const volume = Number.parseFloat(t);
+          if (!Number.isNaN(volume)) {
+            this.currentVolume = volume / 100;
+          }
+          break;
+        }
+        case "span": {
+          status = "normal";
+          const span = Number.parseFloat(t);
+          if (!Number.isNaN(span)) {
+            this.currentSpan = span / 100;
+          }
+          break;
+        }
+        case "loop": {
+          status = "normal";
+          loops.push({
+            start: sequence.length
+          });
+          const repeats = Number.parseFloat(t);
+          if (!Number.isNaN(repeats)) {
+            loops[loops.length - 1].repeats = repeats;
+          }
+          break;
+        }
+        case "to":
+          status = "normal";
+          if (note !== void 0) {
+            let n;
+            if (this.notes[t] !== void 0) {
+              n = this.notes[t];
+            } else if (this.plainNotes[t] !== void 0) {
+              n = this.plainNotes[t] + this.currentOctave * 12;
+            }
+            if (n !== void 0 && n !== note) {
+              const step = n > note ? 1 : -1;
+              for (let i = note + step; step > 0 ? i <= n : i >= n; i += step) {
+                sequence.push({
+                  frequency: A4_FREQUENCY * SEMITONE_RATIO ** (i - A4_MIDI_NOTE),
+                  volume: this.currentVolume,
+                  span: this.currentSpan,
+                  duration: this.currentDuration,
+                  waveform: this.currentWaveform
+                });
+              }
+              note = n;
+            }
+          }
+          break;
+      }
+    }
+    if (loops.length > 0 && sequence.length > 0) {
+      const lop = loops.splice(loops.length - 1, 1)[0];
+      sequence.push({
+        frequency: A4_FREQUENCY,
+        volume: 0,
+        span: this.currentSpan,
+        duration: 0,
+        waveform: this.currentWaveform
+      });
+      sequence[sequence.length - 1].loopto = lop.start;
+      sequence[sequence.length - 1].repeats = lop.repeats;
+    }
+    this.audio.addBeeps(sequence);
+  }
+};
+
+// src/core/audio-worklet.ts
+var AUDIO_WORKLET_CODE = `
+class L8bAudioProcessor extends AudioWorkletProcessor {
+    constructor() {
+        super();
+        this.beeps = [];
+        this.last = 0;
+        this.port.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            if (data.name === "cancel_beeps") {
+                this.beeps = [];
+            } else if (data.name === "beep") {
+                const seq = data.sequence;
+                // Link sequence notes together
+                for (let i = 0; i < seq.length; i++) {
+                    const note = seq[i];
+                    if (i > 0) {
+                        seq[i - 1].next = note;
+                    }
+                    // Resolve loopto index to actual note reference
+                    if (note.loopto != null) {
+                        note.loopto = seq[note.loopto];
+                    }
+                    // Initialize phase and time
+                    note.phase = 0;
+                    note.time = 0;
+                }
+                // Add first note to beeps queue
+                if (seq.length > 0) {
+                    this.beeps.push(seq[0]);
+                }
+            }
+        };
+    }
+
+    process(inputs, outputs, parameters) {
+        const output = outputs[0];
+        
+        for (let i = 0; i < output.length; i++) {
+            const channel = output[i];
+            
+            if (i > 0) {
+                // Copy first channel to other channels
+                for (let j = 0; j < channel.length; j++) {
+                    channel[j] = output[0][j];
+                }
+            } else {
+                // Generate audio for first channel
+                for (let j = 0; j < channel.length; j++) {
+                    let sig = 0;
+                    
+                    for (let k = this.beeps.length - 1; k >= 0; k--) {
+                        const b = this.beeps[k];
+                        let volume = b.volume;
+                        
+                        if (b.time / b.duration > b.span) {
+                            volume = 0;
+                        }
+                        
+                        // Generate waveform
+                        switch (b.waveform) {
+                            case "square":
+                                sig += b.phase > 0.5 ? volume : -volume;
+                                break;
+                            case "saw":
+                                sig += (b.phase * 2 - 1) * volume;
+                                break;
+                            case "noise":
+                                sig += (Math.random() * 2 - 1) * volume;
+                                break;
+                            default: // sine
+                                sig += Math.sin(b.phase * Math.PI * 2) * volume;
+                        }
+                        
+                        b.phase = (b.phase + b.increment) % 1;
+                        b.time += 1;
+                        
+                        if (b.time >= b.duration) {
+                            b.time = 0;
+                            
+                            if (b.loopto != null) {
+                                if (b.repeats != null && b.repeats > 0) {
+                                    if (b.loopcount == null) {
+                                        b.loopcount = 0;
+                                    }
+                                    b.loopcount++;
+                                    
+                                    if (b.loopcount >= b.repeats) {
+                                        b.loopcount = 0;
+                                        if (b.next != null) {
+                                            b.next.phase = b.phase;
+                                            this.beeps[k] = b.next;
+                                        } else {
+                                            this.beeps.splice(k, 1);
+                                        }
+                                    } else {
+                                        b.loopto.phase = b.phase;
+                                        this.beeps[k] = b.loopto;
+                                    }
+                                } else {
+                                    b.loopto.phase = b.phase;
+                                    this.beeps[k] = b.loopto;
+                                }
+                            } else if (b.next != null) {
+                                b.next.phase = b.phase;
+                                this.beeps[k] = b.next;
+                            } else {
+                                this.beeps.splice(k, 1);
+                            }
+                        }
+                    }
+                    
+                    this.last = this.last * 0.9 + sig * 0.1;
+                    channel[j] = this.last;
+                }
+            }
+        }
+        
+        return true;
+    }
+}
+
+registerProcessor("l8b-audio-processor", L8bAudioProcessor);
+`;
+
+// src/core/audio-core.ts
+var AudioCore = class {
+  static {
+    __name(this, "AudioCore");
+  }
+  context;
+  buffer = [];
+  playing = [];
+  wakeupList = [];
+  workletNode;
+  beeper;
+  runtime;
+  masterVolume = 1;
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.getContext();
+  }
+  /**
+  * Check if audio context is running
+  */
+  isStarted() {
+    return this.context.state === "running";
+  }
+  /**
+  * Add item to wakeup list (for mobile audio activation)
+  */
+  addToWakeUpList(item) {
+    this.wakeupList.push(item);
+  }
+  interfaceCache = null;
+  /**
+  * Set master volume (0-1). Applied as a multiplier to all sound/music playback.
+  */
+  setVolume(volume) {
+    this.masterVolume = Math.max(0, Math.min(1, volume));
+  }
+  /**
+  * Get current master volume (0-1)
+  */
+  getVolume() {
+    return this.masterVolume;
+  }
+  /**
+  * Get interface for game code
+  */
+  getInterface() {
+    if (this.interfaceCache) {
+      return this.interfaceCache;
+    }
+    this.interfaceCache = {
+      beep: /* @__PURE__ */ __name((sequence) => this.beep(sequence), "beep"),
+      cancelBeeps: /* @__PURE__ */ __name(() => this.cancelBeeps(), "cancelBeeps"),
+      playSound: /* @__PURE__ */ __name((sound, volume, pitch, pan, loopit) => this.playSound(sound, volume, pitch, pan, loopit), "playSound"),
+      playMusic: /* @__PURE__ */ __name((music, volume, loopit) => this.playMusic(music, volume, loopit), "playMusic"),
+      setVolume: /* @__PURE__ */ __name((volume) => this.setVolume(volume), "setVolume"),
+      getVolume: /* @__PURE__ */ __name(() => this.getVolume(), "getVolume"),
+      stopAll: /* @__PURE__ */ __name(() => this.stopAll(), "stopAll")
+    };
+    return this.interfaceCache;
+  }
+  /**
+  * Play sound effect
+  */
+  playSound(sound, volume = 1, pitch = 1, pan = 0, loopit = false) {
+    if (typeof sound === "string") {
+      const soundName = sound.replace(/\//g, "-");
+      const s = this.runtime.sounds[soundName];
+      if (!s) {
+        (0, import_diagnostics.reportRuntimeError)(this.runtime?.listener, import_diagnostics.APIErrorCode.E7013, {
+          soundName
+        });
+        return 0;
+      }
+      return s.play(volume * this.masterVolume, pitch, pan, loopit);
+    }
+    return 0;
+  }
+  /**
+  * Play music
+  */
+  playMusic(music, volume = 1, loopit = false) {
+    if (typeof music === "string") {
+      const musicName = music.replace(/\//g, "-");
+      const m = this.runtime.music[musicName];
+      if (!m) {
+        (0, import_diagnostics.reportRuntimeError)(this.runtime?.listener, import_diagnostics.APIErrorCode.E7014, {
+          musicName
+        });
+        return 0;
+      }
+      return m.play(volume * this.masterVolume, loopit);
+    }
+    return 0;
+  }
+  /**
+  * Get or create audio context (lazy initialization - created on first use)
+  * Note: Browser may suspend context until user interaction, which is handled automatically
+  */
+  getContext() {
+    if (!this.context) {
+      const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+      this.context = new AudioContextClass();
+      if (this.context.state !== "running") {
+        const activate = /* @__PURE__ */ __name(() => {
+          if (this.context && this.context.state !== "running") {
+            this.context.resume();
+            if (this.beeper) {
+              this.start();
+            }
+            for (const item of this.wakeupList) {
+              item.wakeUp();
+            }
+            document.body.removeEventListener("touchend", activate);
+            document.body.removeEventListener("mouseup", activate);
+            document.body.removeEventListener("click", activate);
+            document.body.removeEventListener("keydown", activate);
+          }
+        }, "activate");
+        document.body.addEventListener("touchend", activate, {
+          once: true
+        });
+        document.body.addEventListener("mouseup", activate, {
+          once: true
+        });
+        document.body.addEventListener("click", activate, {
+          once: true
+        });
+        document.body.addEventListener("keydown", activate, {
+          once: true
+        });
+      } else if (this.beeper) {
+        this.start();
+      }
+    }
+    return this.context;
+  }
+  /**
+  * Start audio processor
+  */
+  async start() {
+    if (this.workletNode) return;
+    try {
+      const blob = new Blob([
+        AUDIO_WORKLET_CODE
+      ], {
+        type: "application/javascript"
+      });
+      const url = URL.createObjectURL(blob);
+      await this.context.audioWorklet.addModule(url);
+      this.workletNode = new AudioWorkletNode(this.context, "l8b-audio-processor");
+      this.workletNode.connect(this.context.destination);
+      this.flushBuffer();
+    } catch (e) {
+      (0, import_diagnostics.reportRuntimeError)(this.runtime?.listener, import_diagnostics.APIErrorCode.E7012, {
+        error: String(e)
+      });
+    }
+  }
+  /**
+  * Flush buffered messages
+  */
+  flushBuffer() {
+    if (!this.workletNode) return;
+    while (this.buffer.length > 0) {
+      this.workletNode.port.postMessage(this.buffer.splice(0, 1)[0]);
+    }
+  }
+  /**
+  * Get or create beeper
+  */
+  getBeeper() {
+    if (!this.beeper) {
+      this.beeper = new Beeper(this);
+      if (this.context.state === "running") {
+        this.start();
+      }
+    }
+    return this.beeper;
+  }
+  /**
+  * Play beep sequence
+  */
+  beep(sequence) {
+    this.getBeeper().beep(sequence);
+  }
+  /**
+  * Add beeps to audio processor
+  */
+  addBeeps(beeps) {
+    for (const b of beeps) {
+      b.duration *= this.context.sampleRate;
+      b.increment = b.frequency / this.context.sampleRate;
+    }
+    if (this.workletNode) {
+      this.workletNode.port.postMessage(JSON.stringify({
+        name: "beep",
+        sequence: beeps
+      }));
+    } else {
+      this.buffer.push(JSON.stringify({
+        name: "beep",
+        sequence: beeps
+      }));
+    }
+  }
+  /**
+  * Cancel all beeps
+  */
+  cancelBeeps() {
+    if (this.workletNode) {
+      this.workletNode.port.postMessage(JSON.stringify({
+        name: "cancel_beeps"
+      }));
+    } else {
+      this.buffer.push(JSON.stringify({
+        name: "cancel_beeps"
+      }));
+    }
+    this.stopAll();
+  }
+  /**
+  * Add playing sound/music to list
+  */
+  addPlaying(item) {
+    this.playing.push(item);
+  }
+  /**
+  * Remove playing sound/music from list
+  */
+  removePlaying(item) {
+    const index = this.playing.indexOf(item);
+    if (index >= 0) {
+      this.playing.splice(index, 1);
+    }
+  }
+  /**
+  * Stop all playing sounds/music
+  */
+  stopAll() {
+    for (const p of this.playing) {
+      try {
+        p.stop();
+      } catch (err) {
+        (0, import_diagnostics.reportRuntimeError)(this.runtime?.listener, import_diagnostics.APIErrorCode.E7016, {
+          error: String(err)
+        });
+      }
+    }
+    this.playing = [];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioCore
+});
+//# sourceMappingURL=audio-core.js.map