1681-engine 0.0.0-stage → 0.5.9

package/dist/assets/AssetLoader.js

@@ -0,0 +1,202 @@
+import { sound as u } from "../audio/SoundEngine.js";
+import { parseTiled as f } from "../tilemap/tiled.js";
+import { collectAtlasPages as l, duplicateFrames as w, parseAtlas as p } from "./textureAtlas.js";
+function c(r, t) {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(r) || r.startsWith("/")) return r;
+  const a = (t.slice(0, t.lastIndexOf("/") + 1) + r).split("/"), s = [];
+  for (const i of a)
+    i === ".." && s.length && s[s.length - 1] !== ".." && s[s.length - 1] !== "" ? s.pop() : i !== "." && s.push(i);
+  return s.join("/");
+}
+async function m(r) {
+  const t = await createImageBitmap(r), e = document.createElement("canvas");
+  e.width = t.width, e.height = t.height;
+  const a = e.getContext("2d");
+  if (!a) throw new Error("AssetLoader: no 2D context (out of canvas memory?)");
+  return a.drawImage(t, 0, 0), t.close(), e;
+}
+async function g(r, t, e) {
+  if (typeof FontFace > "u" || typeof document > "u" || !document.fonts)
+    throw new Error(`AssetLoader: this browser cannot load the font "${r}" (no FontFace)`);
+  const a = new FontFace(r, t, e);
+  await a.load(), document.fonts.add(a);
+}
+class $ {
+  constructor(t, e = {}) {
+    this.textures = t, this.options = e, this.fetcher = e.fetch ?? ((a) => fetch(a)), this.toCanvas = e.toCanvas ?? m;
+  }
+  textures;
+  options;
+  queue = [];
+  data = /* @__PURE__ */ new Map();
+  maps = /* @__PURE__ */ new Map();
+  atlases = /* @__PURE__ */ new Map();
+  /** Decoded audio by key; a key with bytes only waits for a context (`decodeAudio`). */
+  audioBuffers = /* @__PURE__ */ new Map();
+  audioBytes = /* @__PURE__ */ new Map();
+  decoding = /* @__PURE__ */ new Map();
+  fetcher;
+  toCanvas;
+  total = 0;
+  done = 0;
+  image(t, e) {
+    return this.add(t, async () => {
+      this.textures.addCanvas(t, await this.toCanvas(await this.blob(e)));
+    });
+  }
+  /** An image cut into equal frames named 0, 1, 2…, left to right, then row by row. */
+  spritesheet(t, e, a) {
+    return this.add(t, async () => {
+      this.textures.addSpriteSheet(t, await this.toCanvas(await this.blob(e)), a);
+    });
+  }
+  json(t, e) {
+    return this.add(t, async () => {
+      this.data.set(t, await (await this.request(e)).json());
+    });
+  }
+  text(t, e) {
+    return this.add(t, async () => {
+      this.data.set(t, await (await this.request(e)).text());
+    });
+  }
+  /** A Tiled JSON map, then every tileset image it names (resolved beside the map file). */
+  tilemap(t, e, a = {}) {
+    return this.add(t, async () => {
+      const s = f(await (await this.request(e)).json());
+      this.maps.set(t, s);
+      const i = a.textureKey ?? ((n) => n.name);
+      for (const n of s.tilesets) this.image(i(n), c(n.image, e));
+    });
+  }
+  /**
+   * A TexturePacker (or Pixi) JSON atlas, hash or array format: its page image, and for a multipack atlas every page
+   * named in `meta.related_multi_packs` (each resolved beside the file naming it). The first page is the texture
+   * `key`, further pages `key~1`, `key~2`…, and every frame of every page is found as `textures.get(key, frameName)`.
+   * Counts as one asset in the progress.
+   */
+  atlas(t, e) {
+    return this.add(t, async () => {
+      const a = this.textures.addAtlas?.bind(this.textures);
+      if (!a) throw new Error(`AssetLoader: the texture sink cannot take atlases (no addAtlas) for "${t}"`);
+      const s = await l(
+        e,
+        async (o) => p(await (await this.request(o)).json(), o),
+        c
+      ), i = await Promise.all(s.map((o) => this.blob(c(o.page.image, o.url)).then((h) => this.toCanvas(h)))), n = w(s.map((o) => o.page));
+      n.length && console.warn(`[assets] atlas "${t}" names ${n.length} frame(s) on more than one page: ${n.slice(0, 5).join(", ")}`), a(t, s.map((o, h) => ({ canvas: i[h], frames: o.page.frames })));
+      const d = {};
+      for (const o of s) Object.assign(d, o.page.animations);
+      this.atlases.set(t, { frames: [...new Set(s.flatMap((o) => o.page.frames.map((h) => h.name)))], animations: d, pages: s.length });
+    });
+  }
+  /**
+   * A web font (woff2, woff, ttf) under `family`, added to `document.fonts` once loaded so canvas text and the DOM can
+   * use it at once — load fonts before the first `Text` is drawn, or it measures with the fallback.
+   */
+  font(t, e, a) {
+    const s = this.options.addFont ?? g;
+    return this.add(t, async () => {
+      await s(t, await this.bytes(e), a);
+    });
+  }
+  /**
+   * A sound file decoded into an `AudioBuffer` through the engine's audio context (`getAudio`). Before any context
+   * exists (browsers open one only after a gesture) the bytes are kept and decoded by `decodeAudio`, so a loading
+   * screen never has to wait for the player to click.
+   */
+  audio(t, e) {
+    return this.add(t, async () => {
+      const a = await this.bytes(e);
+      this.audioBuffers.delete(t), this.decoding.delete(t);
+      const s = (this.options.audioContext ?? (() => u.audioContext))();
+      s ? this.audioBuffers.set(t, await this.decode(s, a, e)) : this.audioBytes.set(t, a);
+    });
+  }
+  /** A loaded sound, decoded; null while it waits for an audio context (`decodeAudio`). */
+  getAudio(t) {
+    const e = this.audioBuffers.get(t);
+    if (e) return e;
+    if (this.audioBytes.has(t)) return null;
+    throw new Error(`AssetLoader: no audio loaded as "${t}"`);
+  }
+  /** A loaded sound, decoding its kept bytes through `ctx` (default: the loader's context) the first time. */
+  decodeAudio(t, e) {
+    const a = this.audioBuffers.get(t);
+    if (a) return Promise.resolve(a);
+    const s = this.decoding.get(t);
+    if (s) return s;
+    const i = this.audioBytes.get(t);
+    if (!i) return Promise.reject(new Error(`AssetLoader: no audio loaded as "${t}"`));
+    const n = e ?? (this.options.audioContext ?? (() => u.audioContext))();
+    if (!n) return Promise.reject(new Error(`AssetLoader: no audio context to decode "${t}" yet`));
+    const d = this.decode(n, i, t).then(
+      (o) => (this.audioBuffers.set(t, o), this.audioBytes.delete(t), this.decoding.delete(t), o),
+      (o) => {
+        throw this.decoding.delete(t), o;
+      }
+    );
+    return this.decoding.set(t, d), d;
+  }
+  /** What a loaded atlas holds: its frame names and animations. */
+  getAtlas(t) {
+    const e = this.atlases.get(t);
+    if (!e) throw new Error(`AssetLoader: no atlas loaded as "${t}"`);
+    return e;
+  }
+  /** Runs everything queued; `onProgress` after each asset. Safe to call again after queueing more. */
+  async load(t) {
+    const e = Math.max(1, this.options.concurrency ?? 6), a = async () => {
+      for (let s = this.queue.shift(); s; s = this.queue.shift())
+        await s.run(), this.done++, t?.({ done: this.done, total: this.total, key: s.key });
+    };
+    for (; this.queue.length; ) await Promise.all(Array.from({ length: e }, a));
+  }
+  /** A loaded JSON value. */
+  getJson(t) {
+    if (!this.data.has(t)) throw new Error(`AssetLoader: no JSON or text loaded as "${t}"`);
+    return this.data.get(t);
+  }
+  /** A loaded text file. */
+  getText(t) {
+    return this.getJson(t);
+  }
+  /** A loaded Tiled map. */
+  map(t) {
+    const e = this.maps.get(t);
+    if (!e) throw new Error(`AssetLoader: no tilemap loaded as "${t}"`);
+    return e;
+  }
+  add(t, e) {
+    return this.queue.push({ key: t, run: e }), this.total++, this;
+  }
+  async request(t) {
+    const e = c(t, this.options.baseUrl ?? "");
+    let a;
+    try {
+      a = await this.fetcher(e);
+    } catch (s) {
+      throw new Error(`AssetLoader: could not fetch ${e}: ${s instanceof Error ? s.message : String(s)}`);
+    }
+    if (!a.ok) throw new Error(`AssetLoader: ${e} answered ${a.status}`);
+    return a;
+  }
+  async blob(t) {
+    return (await this.request(t)).blob();
+  }
+  async bytes(t) {
+    const e = await this.request(t);
+    return typeof e.arrayBuffer == "function" ? e.arrayBuffer() : (await e.blob()).arrayBuffer();
+  }
+  async decode(t, e, a) {
+    try {
+      return await t.decodeAudioData(e.slice(0));
+    } catch (s) {
+      throw new Error(`AssetLoader: could not decode audio ${a}: ${s instanceof Error ? s.message : String(s)}`);
+    }
+  }
+}
+export {
+  $ as AssetLoader,
+  c as resolveUrl
+};

package/dist/assets/loadAseprite.js

@@ -0,0 +1,49 @@
+import { Texture as u, Rectangle as g } from "pixi.js";
+import { parseAseprite as l } from "../anim/parseAseprite.js";
+import { resolveUrl as h } from "./AssetLoader.js";
+function p(i, t, r, a) {
+  const o = i.addCanvas(t, r);
+  for (const e of a.frames) {
+    const { x: s, y: n, w: c, h: m } = e.rect;
+    if (!e.trimmed) {
+      o.add(String(e.index), 0, s, n, c, m);
+      continue;
+    }
+    o.frames.get(String(e.index))?.destroy(), o.frames.set(
+      String(e.index),
+      new u({
+        source: o.source,
+        frame: new g(s, n, c, m),
+        orig: new g(0, 0, e.sourceW, e.sourceH),
+        trim: new g(e.offsetX, e.offsetY, c, m)
+      })
+    );
+  }
+  return o;
+}
+async function A(i, t, r, a = {}) {
+  const o = a.fetch ?? ((f) => fetch(f)), e = async (f) => {
+    let w;
+    try {
+      w = await o(f);
+    } catch (d) {
+      throw new Error(`loadAseprite: could not fetch ${f}: ${d instanceof Error ? d.message : String(d)}`);
+    }
+    if (!w.ok) throw new Error(`loadAseprite: ${f} answered ${w.status}`);
+    return w;
+  }, s = h(r, a.baseUrl ?? ""), n = l(await (await e(s)).json());
+  if (!n.image) throw new Error(`loadAseprite: ${s} names no sheet image (meta.image)`);
+  const c = await (await e(h(n.image, s))).blob(), m = await (a.toCanvas ?? x)(c);
+  return p(i, t, m, n), n;
+}
+async function x(i) {
+  const t = await createImageBitmap(i), r = document.createElement("canvas");
+  r.width = t.width, r.height = t.height;
+  const a = r.getContext("2d");
+  if (!a) throw new Error("loadAseprite: no 2D context (out of canvas memory?)");
+  return a.drawImage(t, 0, 0), t.close(), r;
+}
+export {
+  p as addAsepriteTextures,
+  A as loadAseprite
+};

package/dist/assets/takeCleanerWorker-DTcI_Jqr.js

@@ -0,0 +1,30 @@
+function m(l, h) {
+  const a = l[0]?.length ?? 0, f = 1 / Math.max(1, l.length), e = new Float32Array(a);
+  for (const t of l) for (let n = 0; n < a; n++) e[n] += t[n] * f;
+  let r = 0;
+  for (let t = 0; t < a; t++) {
+    const n = Math.abs(e[t]);
+    n > r && (r = n);
+  }
+  if (r < 5e-3) return null;
+  const i = r * 0.01;
+  let s = 0;
+  for (; s < a && Math.abs(e[s]) < i; ) s++;
+  let c = a;
+  for (; c > s && Math.abs(e[c - 1]) < i; ) c--;
+  if (c <= s) return null;
+  s = Math.max(0, s - Math.round(2e-3 * h));
+  const o = e.slice(s, c);
+  let M = 0;
+  for (let t = 0; t < o.length; t++) M += o[t] * o[t];
+  const d = Math.sqrt(M / o.length), g = Math.min(0.16 / Math.max(d, 1e-6), 0.95 / r), E = Math.min(o.length, Math.round(0.01 * h));
+  for (let t = 0; t < o.length; t++) {
+    const n = o.length - t;
+    o[t] *= g * (n < E ? n / E : 1);
+  }
+  return o;
+}
+self.onmessage = (l) => {
+  const { id: h, channels: a, sampleRate: f } = l.data, e = m(a, f);
+  self.postMessage({ id: h, data: e }, e ? { transfer: [e.buffer] } : void 0);
+};

package/dist/assets/textureAtlas.js

@@ -0,0 +1,58 @@
+function m(n) {
+  const e = n;
+  return typeof e == "object" && e !== null && [e.x, e.y, e.w, e.h].every((t) => typeof t == "number" && Number.isFinite(t));
+}
+function u(n, e, t) {
+  if (!m(e.frame)) throw new Error(`${t}: frame "${n}" has no frame rect`);
+  const o = e.frame, i = e.rotated === !0, a = {
+    name: n,
+    x: Math.floor(o.x),
+    y: Math.floor(o.y),
+    w: Math.floor(i ? o.h : o.w),
+    h: Math.floor(i ? o.w : o.h),
+    rotated: i,
+    sourceW: Math.floor(e.trimmed && e.sourceSize ? e.sourceSize.w : o.w),
+    sourceH: Math.floor(e.trimmed && e.sourceSize ? e.sourceSize.h : o.h)
+  };
+  if (e.trimmed !== !1 && m(e.spriteSourceSize) && e.sourceSize) {
+    const f = e.spriteSourceSize;
+    f.x === 0 && f.y === 0 && o.w === e.sourceSize.w && o.h === e.sourceSize.h || (a.trim = { x: Math.floor(f.x), y: Math.floor(f.y), w: Math.floor(o.w), h: Math.floor(o.h) }, a.sourceW = Math.floor(e.sourceSize.w), a.sourceH = Math.floor(e.sourceSize.h));
+  }
+  const r = e.anchor ?? e.pivot;
+  return r && typeof r.x == "number" && typeof r.y == "number" && (a.anchor = { x: r.x, y: r.y }), a;
+}
+function h(n, e = "atlas") {
+  const t = n;
+  if (typeof t != "object" || t === null || typeof t.frames != "object" || t.frames === null)
+    throw new Error(`${e}: not a TexturePacker JSON atlas (no "frames")`);
+  const o = t.meta?.image;
+  if (typeof o != "string" || o === "") throw new Error(`${e}: no "meta.image"`);
+  const i = Array.isArray(t.frames) ? t.frames.map((s, c) => u(typeof s?.filename == "string" ? s.filename : String(c), s ?? {}, e)) : Object.entries(t.frames).map(([s, c]) => u(s, c ?? {}, e)), a = Array.isArray(t.meta?.related_multi_packs) ? t.meta.related_multi_packs.filter((s) => typeof s == "string" && s !== "") : [], r = {};
+  if (typeof t.animations == "object" && t.animations !== null)
+    for (const [s, c] of Object.entries(t.animations))
+      Array.isArray(c) && (r[s] = c.filter((l) => typeof l == "string"));
+  const f = Number(t.meta?.scale);
+  return { image: o, frames: i, animations: r, related: a, scale: Number.isFinite(f) && f > 0 ? f : 1 };
+}
+async function y(n, e, t) {
+  const o = /* @__PURE__ */ new Set([n]), i = [], a = [n];
+  for (let r = a.shift(); r !== void 0; r = a.shift()) {
+    const f = await e(r);
+    i.push({ url: r, page: f });
+    for (const s of f.related) {
+      const c = t(s, r);
+      o.has(c) || (o.add(c), a.push(c));
+    }
+  }
+  return i;
+}
+function p(n) {
+  const e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set();
+  for (const o of n) for (const i of o.frames) (e.has(i.name) ? t : e).add(i.name);
+  return [...t];
+}
+export {
+  y as collectAtlasPages,
+  p as duplicateFrames,
+  h as parseAtlas
+};

package/dist/audio/Footsteps.js

@@ -0,0 +1,25 @@
+import { sound as n } from "./SoundEngine.js";
+class u {
+  constructor(s) {
+    this.options = s;
+  }
+  options;
+  surfaceAt = () => {
+  };
+  /** Where the surface of a world point comes from; `undefined` is the fallback surface. */
+  setSurfaceAt(s) {
+    this.surfaceAt = s;
+  }
+  /** The surface at a world point. */
+  surface(s, o) {
+    return this.surfaceAt(s, o) ?? this.options.fallback;
+  }
+  /** One step (or a beat of hooves when `mounted`) at the feet, world x/y; `local` is the player's own. */
+  step(s, o, e, a = !1) {
+    const t = this.options, r = t.sounds[this.surface(s, o)] ?? t.sounds[t.fallback];
+    r && n.play(a ? r.hoof ?? r.step : r.step, { x: s, y: o, local: e, gain: t.gain ?? 0.5, range: t.range ?? 200, minor: !0 });
+  }
+}
+export {
+  u as Footsteps
+};

package/dist/audio/MusicPlayer.js

@@ -0,0 +1,77 @@
+import { engineSettings as n } from "../settings.js";
+import { isTouchUi as r } from "../platform/touch.js";
+import { ElementVoice as i } from "./music/ElementVoice.js";
+import { GraphVoice as o } from "./music/GraphVoice.js";
+import { MusicChannel as h } from "./music/MusicChannel.js";
+import { elementVolumeLocked as u } from "./music/musicVoice.js";
+class a {
+  channels = /* @__PURE__ */ new Map();
+  route = "auto";
+  graph = null;
+  graphLocked = null;
+  pauseInBackground = null;
+  installed = !1;
+  /** Picks the route and background behaviour; call before the first track for the route to apply to every track. */
+  configure(e) {
+    return e.route && (this.route = e.route), e.pauseInBackground !== void 0 && (this.pauseInBackground = e.pauseInBackground), this;
+  }
+  /** The channel named `name`, made on first use. */
+  channel(e = "music") {
+    let t = this.channels.get(e);
+    return t || (this.install(), t = new h(() => n.getState().musicVolume, (s) => this.voiceFor(s)), this.channels.set(e, t)), t;
+  }
+  /** The url the `'music'` channel plays, if any. */
+  get current() {
+    return this.channels.get("music")?.current ?? null;
+  }
+  /** Plays `url` on the `'music'` channel. */
+  play(e, t) {
+    this.channel().play(e, t);
+  }
+  /** Fades every channel out. */
+  stop(e = 1200) {
+    for (const t of this.channels.values()) t.stop(e);
+  }
+  pause() {
+    for (const e of this.channels.values()) e.pause();
+  }
+  resume() {
+    this.wake();
+  }
+  destroy() {
+    for (const e of this.channels.values()) e.dispose();
+    this.channels.clear(), this.graph?.close(), this.graph = null;
+  }
+  voiceFor(e) {
+    const t = this.throughGraph() ? this.context() : null;
+    return t ? new o(e, t) : new i(e);
+  }
+  throughGraph() {
+    return this.route !== "auto" ? this.route === "graph" : this.graphLocked ??= u();
+  }
+  context() {
+    if (this.graph) return this.graph;
+    const e = globalThis.AudioContext ?? globalThis.webkitAudioContext;
+    return e ? (this.graph = new e(), this.graph) : null;
+  }
+  /** Retries every refused start and follows the volume; the graph's context resumes inside the gesture that called it. */
+  wake() {
+    if (this.graph && this.graph.state !== "running" && this.graph.resume().catch(() => {
+    }), !(typeof document < "u" && document.hidden))
+      for (const e of this.channels.values()) e.refresh();
+  }
+  install() {
+    if (this.installed || typeof window > "u") return;
+    this.installed = !0;
+    const e = () => this.wake();
+    for (const t of ["pointerdown", "touchend", "keydown"]) window.addEventListener(t, e, { capture: !0 });
+    n.subscribe(e), document.addEventListener("visibilitychange", () => {
+      (this.pauseInBackground ?? r()) && (document.hidden ? this.pause() : e());
+    });
+  }
+}
+const w = new a();
+export {
+  a as MusicPlayer,
+  w as music
+};

package/dist/audio/SoundEngine.js

@@ -0,0 +1,125 @@
+import { engineSettings as m } from "../settings.js";
+import { SampleBank as E, hasTakes as y } from "./sampleBank.js";
+import { SOUNDS as u } from "./soundTable.js";
+import { renderRecipe as R, SYNTH_RATE as k } from "./synth.js";
+const p = 480, _ = 10, q = 6, B = 60, F = 0.45, C = 0.05, w = 80, g = [18e3, 1800], T = { freq: 3500, gainDb: -7 }, O = 11e3;
+class V {
+  ctx = null;
+  master = null;
+  buffers = /* @__PURE__ */ new Map();
+  samples = new E();
+  lastAt = /* @__PURE__ */ new Map();
+  voices = 0;
+  /** Where the local player stands, set by the world scene; null off the world screens. */
+  listener = () => null;
+  onRunning = () => {
+  };
+  constructor() {
+    if (typeof window > "u") return;
+    const t = () => {
+      const s = this.context();
+      if (!s || s.state === "running") return;
+      s.resume();
+      const r = s.createBufferSource();
+      r.buffer = s.createBuffer(1, 1, 22050), r.connect(s.destination), r.start();
+    }, n = ["pointerdown", "pointerup", "touchend", "keydown"], e = (s) => {
+      for (const r of n)
+        s ? window.addEventListener(r, t, { capture: !0 }) : window.removeEventListener(r, t, { capture: !0 });
+    };
+    this.onRunning = (s) => e(!s), e(!0);
+    const i = navigator.audioSession;
+    i && (i.type = "ambient"), m.subscribe((s) => {
+      this.ctx && this.master && this.master.gain.setTargetAtTime(this.level(s.sfxVolume), this.ctx.currentTime, 0.02);
+    });
+  }
+  /**
+   * The effects' audio context once something opened it (the first gesture does), else null: never created here, so
+   * asking does not open a context the browser would hold suspended. `AssetLoader.audio` decodes through it.
+   */
+  get audioContext() {
+    return this.ctx;
+  }
+  play(t, n = {}) {
+    if (!t || !u.recipes[t] && !y(t) || m.getState().sfxVolume <= 0) return;
+    const e = this.ctx;
+    if (!e || e.state !== "running" || this.voices >= (n.minor ? q : _)) return;
+    let i = (n.gain ?? 1) * (n.local ? 1 : F), s = 0, r = 0;
+    if (n.x !== void 0 && n.y !== void 0) {
+      const o = this.listener();
+      if (o) {
+        const M = n.x - o.x, d = Math.hypot(M, n.y - o.y), b = Math.min(p, n.range ?? p);
+        if (d >= b) return;
+        i *= Math.pow(1 - d / b, 1.5), r = d / p, s = Math.max(-0.7, Math.min(0.7, M / 320));
+      }
+    }
+    if (i < 0.03) return;
+    const x = performance.now();
+    if (x - (this.lastAt.get(t) ?? -1e9) < B) return;
+    const v = this.samples.take(e, t), l = v ?? this.buffer(e, t);
+    if (!l) return;
+    v && (i *= u.recipes[t]?.fileGain ?? 1), this.lastAt.set(t, x);
+    const c = e.createBufferSource();
+    c.buffer = l;
+    const S = u.recipes[t]?.jitter ?? C;
+    c.playbackRate.value = 1 + (Math.random() * 2 - 1) * S;
+    const a = e.createGain();
+    a.gain.value = Math.min(1, i);
+    const h = e.createStereoPanner();
+    h.pan.value = s;
+    const f = e.createBiquadFilter();
+    f.type = "lowpass", f.frequency.value = g[0] * Math.pow(g[1] / g[0], r), c.connect(f).connect(a).connect(h).connect(this.master), this.voices++, c.onended = () => {
+      this.voices--, c.disconnect(), f.disconnect(), a.disconnect(), h.disconnect();
+    }, c.start();
+    const A = l.duration / c.playbackRate.value * 1e3;
+    if (n.maxMs !== void 0 && A > n.maxMs) {
+      const o = e.currentTime + Math.max(w, n.maxMs) / 1e3;
+      a.gain.setValueAtTime(a.gain.value, o - w / 1e3), a.gain.linearRampToValueAtTime(0, o), c.stop(o);
+    }
+  }
+  level(t) {
+    return Math.max(0, Math.min(1, t)) * u.master;
+  }
+  context() {
+    if (this.ctx) return this.ctx;
+    if (typeof AudioContext > "u") return null;
+    this.ctx = new AudioContext(), this.master = this.ctx.createGain(), this.master.gain.value = this.level(m.getState().sfxVolume);
+    const t = this.ctx.createBiquadFilter();
+    t.type = "highshelf", t.frequency.value = T.freq, t.gain.value = T.gainDb;
+    const n = this.ctx.createBiquadFilter();
+    n.type = "lowpass", n.frequency.value = O, this.master.connect(t).connect(n).connect(this.ctx.destination);
+    const e = this.ctx, i = () => {
+      const s = e.state === "running";
+      this.onRunning(s), s && this.prerender(e);
+    };
+    return e.addEventListener("statechange", i), e.state === "running" && queueMicrotask(i), e;
+  }
+  /**
+   * Starts decoding every recorded take and renders every recipe not rendered yet, one per task, once the context
+   * first runs — so the first swing of a fight does not pay for its sound in that frame.
+   */
+  prerender(t) {
+    for (const i of this.samples.names()) this.samples.load(t, i);
+    const n = Object.keys(u.recipes).filter((i) => !this.buffers.has(i) && !y(i)), e = () => {
+      const i = n.shift();
+      i !== void 0 && (this.buffer(t, i), setTimeout(e, 0));
+    };
+    e();
+  }
+  /** Rendered on first use or by `prerender` (a few ms each), then kept. */
+  buffer(t, n) {
+    const e = this.buffers.get(n);
+    if (e !== void 0) return e;
+    const i = u.recipes[n];
+    let s = null;
+    if (i) {
+      const r = R(i);
+      s = t.createBuffer(1, r.length, k), s.getChannelData(0).set(r);
+    }
+    return this.buffers.set(n, s), s;
+  }
+}
+const H = new V();
+export {
+  V as SoundEngine,
+  H as sound
+};

package/dist/audio/cleanTake.js

@@ -0,0 +1,29 @@
+function L(c, h) {
+  const l = c[0]?.length ?? 0, E = 1 / Math.max(1, c.length), a = new Float32Array(l);
+  for (const t of c) for (let n = 0; n < l; n++) a[n] += t[n] * E;
+  let s = 0;
+  for (let t = 0; t < l; t++) {
+    const n = Math.abs(a[t]);
+    n > s && (s = n);
+  }
+  if (s < 5e-3) return null;
+  const f = s * 0.01;
+  let e = 0;
+  for (; e < l && Math.abs(a[e]) < f; ) e++;
+  let r = l;
+  for (; r > e && Math.abs(a[r - 1]) < f; ) r--;
+  if (r <= e) return null;
+  e = Math.max(0, e - Math.round(2e-3 * h));
+  const o = a.slice(e, r);
+  let i = 0;
+  for (let t = 0; t < o.length; t++) i += o[t] * o[t];
+  const A = Math.sqrt(i / o.length), u = Math.min(0.16 / Math.max(A, 1e-6), 0.95 / s), M = Math.min(o.length, Math.round(0.01 * h));
+  for (let t = 0; t < o.length; t++) {
+    const n = o.length - t;
+    o[t] *= u * (n < M ? n / M : 1);
+  }
+  return o;
+}
+export {
+  L as cleanSamples
+};

package/dist/audio/music/ElementVoice.js

@@ -0,0 +1,34 @@
+import { clamp01 as l } from "./musicVoice.js";
+class m {
+  constructor(e) {
+    this.el = e;
+  }
+  el;
+  fading = null;
+  level() {
+    return this.el.volume;
+  }
+  set(e) {
+    this.stopFade(), this.el.volume = l(e);
+  }
+  fade(e, t, o) {
+    this.stopFade();
+    const i = this.el.volume, a = performance.now(), s = () => {
+      const n = t > 0 ? Math.min(1, (performance.now() - a) / t) : 1;
+      this.el.volume = l(i + (e - i) * n), n < 1 ? this.fading = requestAnimationFrame(s) : (this.fading = null, o?.());
+    };
+    this.fading = requestAnimationFrame(s);
+  }
+  get busy() {
+    return this.fading !== null;
+  }
+  dispose() {
+    this.stopFade(), this.el.pause(), this.el.removeAttribute("src"), this.el.load();
+  }
+  stopFade() {
+    this.fading !== null && cancelAnimationFrame(this.fading), this.fading = null;
+  }
+}
+export {
+  m as ElementVoice
+};

package/dist/audio/music/GraphVoice.js

@@ -0,0 +1,38 @@
+import { clamp01 as a } from "./musicVoice.js";
+class h {
+  constructor(t, e) {
+    this.el = t, this.graph = e, this.source = e.createMediaElementSource(t), this.gain = e.createGain(), this.gain.gain.value = 0, this.source.connect(this.gain).connect(e.destination);
+  }
+  el;
+  graph;
+  gain;
+  source;
+  timer = null;
+  level() {
+    return this.gain.gain.value;
+  }
+  set(t) {
+    this.stopFade();
+    const e = this.gain.gain;
+    e.cancelScheduledValues(this.graph.currentTime), e.setValueAtTime(a(t), this.graph.currentTime);
+  }
+  fade(t, e, n) {
+    this.stopFade();
+    const i = this.gain.gain, s = this.graph.currentTime;
+    i.cancelScheduledValues(s), i.setValueAtTime(i.value, s), i.linearRampToValueAtTime(a(t), s + e / 1e3), this.timer = setTimeout(() => {
+      this.timer = null, n?.();
+    }, e);
+  }
+  get busy() {
+    return this.timer !== null;
+  }
+  dispose() {
+    this.stopFade(), this.el.pause(), this.source.disconnect(), this.gain.disconnect();
+  }
+  stopFade() {
+    this.timer && clearTimeout(this.timer), this.timer = null;
+  }
+}
+export {
+  h as GraphVoice
+};