@adatechnology/game-destruction-three 0.12.1 → 0.14.0

package/dist/index.js

@@ -2,8 +2,45 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// src/audio/impact-keys.ts
+var IMPACT_FAMILY_TAGS = [
+  ["metal", "metal"],
+  ["glass", "glass"],
+  ["ceramic", "ceramic"],
+  ["soil", "soil"],
+  ["masonry", "masonry"],
+  ["wood", "wood"],
+  ["plant", "plant"],
+  ["plastic", "plastic"],
+  ["rubber", "rubber"],
+  ["wax", "wax"],
+  ["fabric", "soft"]
+];
+function impactFamily(def) {
+  const tags = def?.tags ?? [];
+  for (const [tag, family] of IMPACT_FAMILY_TAGS) if (tags.includes(tag)) return family;
+  return void 0;
+}
+var ordered = (prefix, material, family, blow) => {
+  const keys = [];
+  if (material && blow) keys.push(`${prefix}_${material}_${blow}`);
+  if (material) keys.push(`${prefix}_${material}`);
+  if (family && blow) keys.push(`${prefix}_${family}_${blow}`);
+  if (family) keys.push(`${prefix}_${family}`);
+  return keys;
+};
+function impactSoundKeys(material, def, blow) {
+  return { keys: ordered("impact", material, impactFamily(def), blow) };
+}
+function breakSoundKeys(material, def, blow) {
+  return { keys: ordered("break", material, impactFamily(def), blow) };
+}
+function ricochetSoundKeys(material, def) {
+  return { keys: ordered("ricochet", material, impactFamily(def), void 0) };
+}
+
 // src/renderer.ts
-import { blastShove } from "@adatechnology/game-contracts";
+import { DEFERRED_QUEUE_ID, blastShove, warnOnce } from "@adatechnology/game-contracts";
 import { createVfx, effectForEvent, EVENT_EFFECTS_MAP } from "@adatechnology/game-vfx";
 import { createVfxRenderer } from "@adatechnology/game-vfx-three";
 
@@ -92,6 +129,7 @@ var SHEET_SWAY = 3;
 var BIG_LENGTH = 0.2;
 var BIG_WIDTH = 0.03;
 var FRAGMENT_SEED = 1374496523;
+var SHARD_SHAPES = 6;
 var isBig = (size) => {
   const [, middle, longest] = [...size].sort((a, b) => a - b);
   return longest >= BIG_LENGTH && middle >= BIG_WIDTH;
@@ -141,7 +179,7 @@ var FragmentSystem = class {
     return m;
   }
   shardGeometry(seed) {
-    const idx = seed % 6;
+    const idx = seed % SHARD_SHAPES;
     let g = this.shardGeos[idx];
     if (!g) {
       const r = createRng(1e3 + idx);
@@ -162,17 +200,32 @@ var FragmentSystem = class {
     }
     return g;
   }
+  markParts() {
+    this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
+    this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
+    return { geometry: this.markGeometry, material: this.markMaterial };
+  }
+  /**
+   * Meshes, never put in a scene by this class, that draw every shared piece of a fragment once: the box, the six shards, the bullet-hole disc, and the opaque and
+   * glass materials. A host draws them at load so the first blast does not upload these buffers in the middle of a frame.
+   */
+  warmMeshes() {
+    const opaque = this.materialFor("warm", 8421504, false);
+    const glass2 = this.materialFor("warm", 8421504, true);
+    const geometries = [this.box, ...Array.from({ length: SHARD_SHAPES }, (_, index) => this.shardGeometry(index))];
+    const { geometry, material } = this.markParts();
+    return [...geometries.flatMap((shared) => [new this.THREE.Mesh(shared, opaque), new this.THREE.Mesh(shared, glass2)]), new this.THREE.Mesh(geometry, material)];
+  }
   /**
    * Bullet holes that stay on a fragment (`Fragment.marks`): dark discs that are children of its mesh, so they fall, spin and settle with it. The mesh is
    * a unit box scaled to the fragment, so each disc is scaled back; exact for a mark on a face, which is where a bullet hole is.
    */
   addMarks(mesh, f) {
     if (!f.marks?.length) return;
-    this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
-    this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
+    const { geometry, material } = this.markParts();
     const sc = mesh.scale;
     for (const mark of f.marks) {
-      const disc = new this.THREE.Mesh(this.markGeometry, this.markMaterial);
+      const disc = new this.THREE.Mesh(geometry, material);
       const radius = Math.max(4e-3, mark.diameter) * 0.6;
       const n = this.v.set(mark.normal[0], mark.normal[1], mark.normal[2]).normalize();
       disc.position.set(mark.point[0] / sc.x + n.x * 2e-3 / sc.x, mark.point[1] / sc.y + n.y * 2e-3 / sc.y, mark.point[2] / sc.z + n.z * 2e-3 / sc.z);
@@ -512,6 +565,9 @@ var GroundSpots = class {
 };
 
 // src/pieces.ts
+var SLAM_MIN_SPEED = 2;
+var SLAM_BOUNCE = 0.2;
+var SLAM_FLOOR_NORMAL = 0.7;
 var SUB_DT = 1 / 120;
 var MU = 0.7;
 var SLEEP_AFTER = 0.5;
@@ -746,9 +802,34 @@ var PieceSystem = class {
     const fixed = this.o.staticTopAt?.(x, z, y, step) ?? -Infinity;
     return Math.max(top, fixed);
   }
+  /** Stops a piece that ran into something on its way from `start` to `pos` (`sweep`): moves it back to where it met it and takes the speed into it. */
+  sweepOn(b, start, pos) {
+    const travel = Math.hypot(pos[0] - start[0], pos[1] - start[1], pos[2] - start[2]);
+    if (travel < 1e-3) return;
+    const hit = this.o.sweep?.(b, start, pos);
+    if (!hit || hit.normal[1] > SLAM_FLOOR_NORMAL) return;
+    const v = b.velocity;
+    const n = hit.normal;
+    const into = -(v[0] * n[0] + v[1] * n[1] + v[2] * n[2]);
+    if (into <= 0) return;
+    const k = Math.min(1, hit.distance / travel);
+    for (let i = 0; i < 3; i++) {
+      pos[i] = start[i] + (pos[i] - start[i]) * k;
+      v[i] += (1 + SLAM_BOUNCE) * into * n[i];
+    }
+    const w = b.angularVelocity;
+    w[0] *= 0.5;
+    w[1] *= 0.5;
+    w[2] *= 0.5;
+    if (into >= SLAM_MIN_SPEED && this.time - b.lastHit > 0.15) {
+      b.lastHit = this.time;
+      this.o.onSlam?.(b, hit, into);
+    }
+  }
   integrate(b, dt) {
     const c = this.centerOf(b, this.p);
     const pos = [c.x, c.y, c.z];
+    const start = [c.x, c.y, c.z];
     const q = this.q.copy(b.root.quaternion);
     const v = b.velocity;
     const w = b.angularVelocity;
@@ -858,11 +939,11 @@ var PieceSystem = class {
       if (contactedLast) touched = true;
       if (!contactedLast) continue;
       pos[1] += Math.max(0, maxPen - SLOP * 0.5);
-      let impact = 0;
-      for (const r of rs) impact = Math.max(impact, -(v[1] + w[2] * r[0] - w[0] * r[2]));
-      const restitution = impact > 2 ? 0.25 : 0;
-      if (impact > landing) {
-        landing = impact;
+      let impact2 = 0;
+      for (const r of rs) impact2 = Math.max(impact2, -(v[1] + w[2] * r[0] - w[0] * r[2]));
+      const restitution = impact2 > 2 ? 0.25 : 0;
+      if (impact2 > landing) {
+        landing = impact2;
         let sx = 0;
         let sz = 0;
         for (const r of rs) {
@@ -993,6 +1074,7 @@ var PieceSystem = class {
       v[0] *= fd;
       v[2] *= fd;
     }
+    if (this.o.sweep && !b.held) this.sweepOn(b, start, pos);
     b.root.quaternion.copy(q);
     const off = this.ax.copy(b.centerV).applyQuaternion(q);
     b.root.position.set(pos[0] - off.x, pos[1] - off.y, pos[2] - off.z);
@@ -1517,6 +1599,7 @@ var Visuals = class {
     this.b = tmpV(THREE);
     this.m4 = new THREE.Matrix4();
     this.ray = new THREE.Raycaster();
+    this.ray.layers.enableAll();
     this.box = new THREE.Box3();
     this.t = tmpV(THREE);
     this.lbox = new THREE.Box3();
@@ -2151,10 +2234,10 @@ var Visuals = class {
     const sy = lerp(1, 0.25, melt);
     const sxz = 1 + 0.18 * melt;
     for (let i = range[0] * 3, v = 0; i < range[1] * 3; i += 3, v++) {
-      const noise2 = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
+      const noise3 = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
       arr[i] = cx + (work[i] - cx) * sxz;
       arr[i + 2] = cz + (work[i + 2] - cz) * sxz;
-      arr[i + 1] = Math.max(minY, minY + (work[i + 1] - minY) * sy - noise2 * melt * h * 0.04);
+      arr[i + 1] = Math.max(minY, minY + (work[i + 1] - minY) * sy - noise3 * melt * h * 0.04);
     }
   }
   /** The colour attribute of the host's current geometry (created white when there is none) with vertex colours switched on in its material. */
@@ -2404,12 +2487,14 @@ var GLOW_FROM_C = 430;
 var QUEUE_CAP = 4e3;
 var MIN_FRAGMENTS_PER_SLICE = 8;
 var STATIC_REFRESH = 0.5;
+var STATIC_REFRESH_SLICE_MS = 1;
 var STATIC_SPAN = 3;
 var FEET_BAND = 0.03;
 var TIP_MIN_HEIGHT = 0.3;
 var TIP_NARROW = 0.3;
 var FIRE_CEILING_SECONDS = 3600;
 var GENERIC_REFERENCE_RADIUS = 15;
+var SWEEP_CORE = 0.15;
 var PRIMED_FIRE_RADIUS = 0.2;
 var FLUID_COLORS = {
   water: 9226495,
@@ -2452,6 +2537,7 @@ function impactKey(def) {
   if (def.fracture === "tear") return "impact_soft";
   return def.fracture === "none" ? "impact_metal" : "impact_wood";
 }
+var shotKey = (def) => impactKey(def).replace("impact_", "shot_");
 var dragSoundKey = (def) => impactKey(def).replace("impact_", "drag_");
 function fractureKey(def, style) {
   switch (style) {
@@ -2501,14 +2587,34 @@ var Renderer = class {
     /** Objects to measure again; `staticAll` measures every one. */
     __publicField(this, "staticDirty", /* @__PURE__ */ new Set());
     __publicField(this, "staticAll", true);
+    /** The periodic refresh: the objects still to measure again in this round, a slice per call. */
+    __publicField(this, "staticRound", []);
     /** Boxes of the pieces' meshes (as `staticBoxes`), with the time they were measured. */
     __publicField(this, "pieceBoxes", /* @__PURE__ */ new WeakMap());
     __publicField(this, "staticAt", 0);
     __publicField(this, "queue", []);
     /** Presentation work an event left for later frames (fragments still to spawn, loose groups still to split), run in order within the frame budget. */
     __publicField(this, "slices", []);
-    /** When the work of this frame must stop; `Infinity` outside `drainQueue`, where a call finishes what it started. */
+    /** When the work of this frame must stop; `Infinity` outside a drain, where a call finishes what it started. */
     __publicField(this, "sliceDeadline", Infinity);
+    /** The clock the drain reads; a budget lends its own while it runs the queue. */
+    __publicField(this, "drainClock", () => performance.now());
+    /** true once a frame budget owns the draining: `update` no longer drains by itself. */
+    __publicField(this, "attached", false);
+    __publicField(this, "eventQueue", {
+      id: DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS,
+      pending: () => this.queue.length + this.slices.length,
+      run: (deadline, clock) => this.runBudgeted(deadline, clock),
+      flush: () => {
+        for (let guard = 0; guard < 16 && this.queue.length + this.slices.length > 0; guard++) this.runBudgeted(Infinity, () => 0);
+      },
+      attach: () => {
+        this.attached = true;
+      },
+      detach: () => {
+        this.attached = false;
+      }
+    });
     __publicField(this, "unsubscribe");
     __publicField(this, "visuals");
     __publicField(this, "fragments");
@@ -2554,6 +2660,7 @@ var Renderer = class {
     const maxParticles = Math.max(8, Math.floor((o.maxParticles ?? 2500) * (this.low ? 0.5 : 1)));
     this.visuals = new Visuals(THREE, this.low, 600);
     this.ground = new GroundSpots(THREE, o.scene, this.groundAt, 48);
+    if (!o.vfx) warnOnce("game-destruction-three.own-effects-world", "game-destruction-three made an effects world of its own because the host lent none (options.vfx); pass the host effects so the effects share one budget");
     this.vfx = o.vfx ?? createVfx({ profile: this.quality, gravity: this.gravity, groundAt: this.groundAt, sprites: { capacity: maxParticles, density: this.low ? 0.6 : 1 } });
     this.ownVfx = o.vfx ? void 0 : createVfxRenderer(THREE, { scene: o.scene, camera: o.camera ?? new THREE.PerspectiveCamera(), vfx: this.vfx, pointScale: o.pointScale ?? 700 });
     this.stopLanding = this.vfx.onLand(this.owner, (x, _y, z, color, tag) => {
@@ -2573,7 +2680,9 @@ var Renderer = class {
       staticTopAt: (x, z, y, step) => this.staticTopAt(x, z, y, step),
       gravity: this.gravity,
       scene: o.scene,
-      onHardLanding: (p, point, speed) => this.hardLanding(p, point, speed)
+      onHardLanding: (p, point, speed) => this.hardLanding(p, point, speed),
+      sweep: (p, from, to) => this.sweepPiece(p, from, to),
+      onSlam: (p, hit, speed) => this.slam(p, hit, speed)
     });
     this.unsubscribe = this.world.on("*", (ev) => {
       if (this.queue.length < QUEUE_CAP) this.queue.push(ev);
@@ -2763,26 +2872,58 @@ var Renderer = class {
     const p = this.pieceSys.get(objectId);
     if (p) this.pieceSys.impulse(p, impulse, point);
   }
+  /**
+   * What a piece moving from `from` to `to` runs into: the core of its box (its thinnest half each way, at most `SWEEP_CORE`) swept through the world, the piece itself left out,
+   * so a crate thrown by a blast stops at the wall instead of passing through it. Null for a world that cannot sweep.
+   */
+  sweepPiece(p, from, to) {
+    if (typeof this.world.sweepBox !== "function") return null;
+    const d = [to[0] - from[0], to[1] - from[1], to[2] - from[2]];
+    const travel = Math.hypot(d[0], d[1], d[2]);
+    if (travel < 1e-4) return null;
+    const core = Math.min(SWEEP_CORE, ...p.halfExtents);
+    const box = { min: [from[0] - core, from[1] - core, from[2] - core], max: [from[0] + core, from[1] + core, from[2] + core] };
+    const hit = this.world.sweepBox(box, d, travel, { ignore: p.objectId, spacing: Math.max(0.05, core) });
+    if (!hit) return null;
+    return { object: hit.object, part: hit.part, distance: hit.distance, point: hit.point, normal: hit.normal };
+  }
+  /** A piece thrown into a wall: the wall takes the blow of its weight where it met it, the piece takes it too, and each sounds as its material does. */
+  slam(p, hit, speed) {
+    const energy = 0.5 * p.mass * speed * speed;
+    const direction = [-hit.normal[0], -hit.normal[1], -hit.normal[2]];
+    this.landingSound(hit.object, hit.point, clamp(speed / 10, 0.2, 1));
+    this.syncBound(p.objectId);
+    try {
+      this.world.hitPart(hit.object, hit.part, { type: "blunt", point: hit.point, energy, radius: 0.1, direction, normal: hit.normal, source: p.objectId });
+      this.world.hit(p.objectId, { type: "blunt", point: hit.point, energy, radius: 0.08, direction: hit.normal, source: "slam" });
+    } catch {
+    }
+  }
   hardLanding(p, point, speed) {
-    const key = this.impactSoundOf(p.objectId);
-    this.sound(key, point, clamp(speed / 10, 0.2, 1));
+    this.landingSound(p.objectId, point, clamp(speed / 10, 0.2, 1));
     this.syncBound(p.objectId);
     try {
       this.world.hit(p.objectId, { type: "blunt", point, energy: 0.5 * p.mass * speed * speed, radius: 0.08, direction: [0, -1, 0], source: "fall" });
     } catch {
     }
   }
-  impactSoundOf(objectId) {
+  /** The impact of the heaviest part of an object (a piece landing): its material and the blunt blow of the fall. */
+  landingSound(objectId, point, volume) {
     const st = this.world.state(objectId);
-    let best;
+    let best = "";
     let mass = -1;
     for (const p of st?.parts ?? []) {
       if (p.mass > mass) {
         mass = p.mass;
-        best = this.world.materials.get(p.material);
+        best = p.material;
       }
     }
-    return impactKey(best);
+    this.impactSound(best, point, volume, "blunt");
+  }
+  /** The impact on a material by a blow: the legacy family key (`impactKey`) with the more specific keys to try first (`impactSoundKeys`). */
+  impactSound(material, point, volume, blow) {
+    const def = this.world.materials.get(material);
+    this.sound(impactKey(def), point, volume, impactSoundKeys(material, def, blow));
   }
   // ----------------------------------------------------------------------------------------------------------------------------------
   // Update
@@ -2791,7 +2932,7 @@ var Renderer = class {
     if (this.disposed) return;
     dt = clamp(dt, 0, 0.1);
     this.time += dt;
-    this.drainQueue();
+    if (!this.attached) this.drainQueue();
     for (const b of this.bounds.values()) b.onFrame?.(dt);
     for (const b of this.bounds.values()) if (b.soilNode && this.world.state(b.id)?.soil?.status === "yielding") this.onSettle(b.id);
     this.updateActive(dt);
@@ -2802,36 +2943,50 @@ var Renderer = class {
     this.ownVfx?.update(dt);
     this.syncTransforms();
   }
+  deferredQueue() {
+    return this.eventQueue;
+  }
   drainQueue() {
+    this.runBudgeted(performance.now() + this.eventBudgetMs, () => performance.now());
+  }
+  /** Applies the waiting events in order until the deadline, after the slices earlier events left; always at least one unit when something waits. Returns the units run. */
+  runBudgeted(deadline, clock) {
     const batch = this.queue.splice(0, this.queue.length);
-    const deadline = performance.now() + this.eventBudgetMs;
+    const outerClock = this.drainClock;
+    this.drainClock = clock;
     this.sliceDeadline = deadline;
+    let ran = 0;
     try {
-      this.runSlices(deadline);
+      ran = this.runSlices(deadline);
       for (let i = 0; i < batch.length; i++) {
-        if (i > 0 && performance.now() >= deadline) {
+        if ((i > 0 || ran > 0 && this.attached) && clock() >= deadline) {
           this.queue.unshift(...batch.slice(i));
-          return;
+          return ran;
         }
         try {
           this.apply(batch[i]);
         } catch (err) {
           if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", batch[i].type, err);
         }
+        ran++;
       }
     } finally {
       this.sliceDeadline = Infinity;
+      this.drainClock = outerClock;
     }
+    return ran;
   }
   /** Runs the work left by earlier frames until the deadline; at least one piece per frame, so it always finishes. */
   runSlices(deadline) {
-    for (let ran = 0; this.slices.length > 0 && (ran === 0 || performance.now() < deadline); ran++) {
+    let ran = 0;
+    for (; this.slices.length > 0 && (ran === 0 || this.drainClock() < deadline); ran++) {
       try {
         this.slices.shift()();
       } catch (err) {
         if (typeof console !== "undefined") console.error("game-destruction-three: failed to run deferred work", err);
       }
     }
+    return ran;
   }
   /**
    * The ground under an object settled or tilted: its parts are drawn under a node with the soil's offset (`ObjectState.soil.offset`), so the host's
@@ -2900,9 +3055,9 @@ var Renderer = class {
   staticNow() {
     if (this.time - this.staticAt > STATIC_REFRESH) {
       this.staticAt = this.time;
-      this.staticAll = true;
+      if (this.staticRound.length === 0) this.staticRound = [...this.bounds.keys()].reverse();
     }
-    if (!this.staticAll && this.staticDirty.size === 0) return this.staticBoxes;
+    if (!this.staticAll && this.staticDirty.size === 0 && this.staticRound.length === 0) return this.staticBoxes;
     const box = new this.THREE.Box3();
     const measure = (b) => {
       if (b.piece || this.pieceSys.get(b.id)) {
@@ -2922,14 +3077,21 @@ var Renderer = class {
       }
       this.staticBoxes.set(b.id, out.length > 6 ? out : []);
     };
+    const measureId = (id) => {
+      const b = this.bounds.get(id);
+      if (b) measure(b);
+      else this.staticBoxes.delete(id);
+    };
     if (this.staticAll) {
       this.staticBoxes.clear();
       for (const b of this.bounds.values()) measure(b);
+      this.staticRound = [];
     } else {
-      for (const id of this.staticDirty) {
-        const b = this.bounds.get(id);
-        if (b) measure(b);
-        else this.staticBoxes.delete(id);
+      for (const id of this.staticDirty) measureId(id);
+      const until = performance.now() + STATIC_REFRESH_SLICE_MS;
+      while (this.staticRound.length > 0) {
+        measureId(this.staticRound.pop());
+        if (performance.now() >= until) break;
       }
     }
     this.staticAll = false;
@@ -2989,7 +3151,8 @@ var Renderer = class {
       case "ricochet": {
         const d = ev.direction;
         this.vfx.burst("sparks", ev.point, d, 4 + Math.min(10, ev.energy / 150), 4);
-        this.sound("ricochet", ev.point, 0.7);
+        const glanced = this.partVis(ev.object, ev.part)?.material ?? "";
+        this.sound("ricochet", ev.point, 0.7, ricochetSoundKeys(glanced, this.world.materials.get(glanced)));
         break;
       }
       case "debris":
@@ -3031,7 +3194,7 @@ var Renderer = class {
           this.vfx.fire({ point: ev.point, radius: PRIMED_FIRE_RADIUS, life: ev.delay });
           this.primedBurning.add(`${ev.object}|${ev.part}`);
           this.activate(ev.object, ev.part);
-          this.sound("ignite", ev.point, 0.7);
+          this.sound("primed", ev.point, 0.7, { seconds: ev.delay });
           this.sound("burn_loop", ev.point, 0.5);
         }
         break;
@@ -3145,8 +3308,9 @@ var Renderer = class {
     const b = this.bounds.get(objectId);
     return b ? [b.root.position.x, b.root.position.y, b.root.position.z] : [0, 0, 0];
   }
-  sound(key, point, volume) {
-    this.o.onSound?.(key, point, volume);
+  sound(key, point, volume, detail) {
+    if (detail) this.o.onSound?.(key, point, volume, detail);
+    else this.o.onSound?.(key, point, volume);
   }
   partVis(objectId, partId) {
     return this.bounds.get(objectId)?.parts.get(partId) ?? null;
@@ -3211,7 +3375,7 @@ var Renderer = class {
     const reach = shown.reduce((widest, mv) => Math.max(widest, this.visuals.dentReach(mv, wp, ev.dent)), ev.dent.radius);
     this.visuals.applyPartDent(shown, wp, wn, ev.dent, reach);
     if (def?.tags?.includes("metal")) this.vfx.burst("sparks", ev.worldPoint, [wn.x, wn.y, wn.z], 4 + Math.min(8, ev.dent.depth * 150), 3.2);
-    this.sound(impactKey(def), ev.worldPoint, clamp(0.3 + ev.dent.depth * 12, 0.3, 1));
+    this.impactSound(pv.material, ev.worldPoint, clamp(0.3 + ev.dent.depth * 12, 0.3, 1), ev.blow);
   }
   onHole(ev) {
     const b = this.bounds.get(ev.object);
@@ -3240,7 +3404,7 @@ var Renderer = class {
       this.vfx.burst("dust", ev.worldPoint, [n.x, n.y, n.z], this.low ? 5 : 10, 0.7, puff);
       if (ev.hole.through && ev.exitPoint) this.vfx.burst("dust", ev.exitPoint, [-n.x, -n.y, -n.z], this.low ? 10 : 20, 1.3, puff);
     }
-    this.sound(impactKey(def), ev.worldPoint, 0.6);
+    this.sound(shotKey(def), ev.worldPoint, 0.6, impactSoundKeys(pv.material, def, ev.blow));
   }
   onCrack(ev) {
     const b = this.bounds.get(ev.object);
@@ -3250,13 +3414,13 @@ var Renderer = class {
     const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
     const mv = this.nearestMesh(pv, wp);
     if (mv) {
-      const glass = !!def?.visual?.transparent;
+      const glass2 = !!def?.visual?.transparent;
       const own = this.partColor(pv, def) ?? fallbackColor(pv.material, def);
-      const color = glass ? 15267071 : new this.THREE.Color(own).multiplyScalar(0.45).getHex();
-      const length = glass ? ev.crack.length : Math.min(ev.crack.length, OPAQUE_CRACK);
+      const color = glass2 ? 15267071 : new this.THREE.Color(own).multiplyScalar(0.45).getHex();
+      const length = glass2 ? ev.crack.length : Math.min(ev.crack.length, OPAQUE_CRACK);
       this.visuals.addCrack(mv, wp, this.worldDir(b, ev.crack.normal), ev.crack.rays, length, color, hashNumbers(ev.time, ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]));
     }
-    this.sound(impactKey(def), ev.worldPoint, 0.5);
+    this.impactSound(pv.material, ev.worldPoint, 0.5, ev.blow);
   }
   /** Outward normal of the face of `mv` nearest to a world point: the thin axis of its world box (right for a wall; a sloped face is left to the vertex-range binding). */
   faceNormal(mv, point) {
@@ -3313,7 +3477,7 @@ var Renderer = class {
       this.fragments.spawn(fr, this.fragments.materialFor(fr.material, fdef === def || !fdef ? color : fallbackColor(fr.material, fdef), false), ev.object, maxAlive);
     }
     if (!played) this.vfx.burst("dust", ev.opening.center, [0, 1, 0], 14, 1.2, { color });
-    this.sound(impactKey(def), ev.opening.center, 0.8);
+    this.impactSound(pv?.material ?? "", ev.opening.center, 0.8, ev.blow);
   }
   /**
    * A unit came out of a wall of units: the unit flies as a fragment with a puff of its dust, and the marks drawn on it (bullet holes, spalls, the impact
@@ -3327,11 +3491,11 @@ var Renderer = class {
     const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
     for (const fr of ev.fragments) {
       const fdef = this.world.materials.get(fr.material);
-      const tone2 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === def ? color : fallbackColor(fr.material, fdef);
-      this.fragments.spawn(fr, this.fragments.materialFor(fr.material, tone2, false), ev.object, maxAlive);
+      const tone3 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === def ? color : fallbackColor(fr.material, fdef);
+      this.fragments.spawn(fr, this.fragments.materialFor(fr.material, tone3, false), ev.object, maxAlive);
     }
     if (ev.torn) {
-      this.sound(impactKey(def), ev.center, 0.5);
+      this.impactSound(pv?.material ?? "", ev.center, 0.5, ev.blow);
       return;
     }
     const T = this.THREE;
@@ -3341,7 +3505,7 @@ var Renderer = class {
     for (const part of this.bounds.get(ev.object)?.parts.values() ?? []) for (const mv of part.meshes) this.visuals.clearDecals(mv, center, half, rotation);
     this.vfx.peekWorkshop()?.decals.clearInside(ev.center, [half.x, half.y, half.z], ev.rotation);
     this.vfx.burst("dust", ev.center, [0, 1, 0], 8, 0.8, { color });
-    this.sound(impactKey(def), ev.center, 0.7);
+    this.impactSound(pv?.material ?? "", ev.center, 0.7, ev.blow);
   }
   onFracture(ev) {
     const b = this.bounds.get(ev.object);
@@ -3382,21 +3546,21 @@ var Renderer = class {
       default:
         this.vfx.burst("sparks", ev.point, up, 10, 4);
     }
-    this.sound(fractureKey(def, ev.style), ev.point, clamp(0.4 + ev.fragments.length * 0.03, 0.4, 1));
+    this.sound(fractureKey(def, ev.style), ev.point, clamp(0.4 + ev.fragments.length * 0.03, 0.4, 1), breakSoundKeys(matId, def, ev.blow));
   }
   /** Spawns the fragments of a fracture from index `from`; what does not fit in this frame's budget is spawned by the next frames. */
   spawnFragments(ev, from, look) {
     const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
     const step = this.low ? 2 : 1;
     for (let i = from; i < ev.fragments.length; i += step) {
-      if (i - from >= MIN_FRAGMENTS_PER_SLICE * step && performance.now() >= this.sliceDeadline) {
+      if (i - from >= MIN_FRAGMENTS_PER_SLICE * step && this.drainClock() >= this.sliceDeadline) {
         this.slices.push(() => this.spawnFragments(ev, i, look));
         return;
       }
       const fr = ev.fragments[i];
       const fdef = this.world.materials.get(fr.material);
-      const tone2 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === look.def || !fdef ? look.color : fallbackColor(fr.material, fdef);
-      const mat = this.fragments.materialFor(fr.material, tone2, look.transparent || fdef?.visual?.transparent === true, look.opacity);
+      const tone3 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === look.def || !fdef ? look.color : fallbackColor(fr.material, fdef);
+      const mat = this.fragments.materialFor(fr.material, tone3, look.transparent || fdef?.visual?.transparent === true, look.opacity);
       this.fragments.spawn(fr, mat, ev.object, maxAlive);
     }
   }
@@ -3413,7 +3577,7 @@ var Renderer = class {
     if (!st || st.groups.length < 2) return;
     const loose = st.groups.length - 1;
     for (let i = 0; i < loose; i++) {
-      if (i > 0 && performance.now() >= this.sliceDeadline) {
+      if (i > 0 && this.drainClock() >= this.sliceDeadline) {
         this.slices.push(() => {
           this.staticDirty.add(objectId);
           this.splitLoose(objectId);
@@ -3519,10 +3683,11 @@ var Renderer = class {
     const report = options.report;
     const confinement = report?.find((r) => r.blast !== void 0)?.blast?.confinement ?? 1;
     const energy = ev.energy * confinement;
-    const reachOf = (objectId) => report?.find((r) => r.object === objectId)?.blast?.shelter ?? 1;
+    const reachOf = (objectId, at) => report?.find((r) => r.object === objectId)?.blast?.shelter ?? this.world.blastReach?.(p, at, { ignore: ev.object ? [ev.object, objectId] : [objectId] }) ?? 1;
     const shove = (pc) => {
       this.pieceSys.centerOf(pc, c);
-      const hit = blastShove({ point: p, energy, radius: ev.radius, reach: reachOf(pc.objectId) }, { position: [c.x, c.y, c.z], mass: pc.mass }, this.o.blastShove);
+      if (c.distanceTo(this.v2.set(p[0], p[1], p[2])) > ev.radius) return;
+      const hit = blastShove({ point: p, energy, radius: ev.radius, reach: reachOf(pc.objectId, [c.x, c.y, c.z]) }, { position: [c.x, c.y, c.z], mass: pc.mass }, this.o.blastShove);
       if (!hit) return;
       const spread = pc.halfExtents[0];
       const momentum = hit.speed * pc.mass;
@@ -3531,7 +3696,12 @@ var Renderer = class {
     for (const pc of [...this.pieceSys.list]) shove(pc);
     if (this.o.shoveable) this.loosen(p, ev.radius, energy, reachOf);
     this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(energy) * 0.08));
-    this.sound("explode", p, clamp(0.5 + ev.radius / 10, 0.5, 1));
+    this.sound("explode", p, clamp(0.5 + ev.radius / 10, 0.5, 1), {
+      radius: ev.radius,
+      ...ev.effect !== void 0 ? { effect: ev.effect } : {},
+      ...options.effect !== void 0 ? { effect: options.effect } : {},
+      ...report ? { confinement } : {}
+    });
   }
   /** The bound objects without a piece that the host lets a blast move (`shoveable`): the ones it reaches with enough speed become pieces and get the shove. */
   loosen(point, radius, energy, reachOf) {
@@ -3542,7 +3712,8 @@ var Renderer = class {
       const { half, center } = this.measure(b.root, this.meshesOf(b));
       const world = center.clone().applyQuaternion(b.root.quaternion).add(b.root.position);
       const mass = this.massOf(b.id);
-      const hit = blastShove({ point, energy, radius, reach: reachOf(b.id) }, { position: [world.x, world.y, world.z], mass }, this.o.blastShove);
+      if (world.distanceTo(this.v2.set(point[0], point[1], point[2])) > radius) continue;
+      const hit = blastShove({ point, energy, radius, reach: reachOf(b.id, [world.x, world.y, world.z]) }, { position: [world.x, world.y, world.z], mass }, this.o.blastShove);
       if (!hit) continue;
       const piece = this.makePiece(b.id, { mass });
       const body = this.pieceSys.get(b.id);
@@ -3566,9 +3737,9 @@ var Renderer = class {
     this.fires.set(key, { object: ev.object, part: ev.part, point: ev.point, follow: { x: ev.point[0], y: ev.point[1], z: ev.point[2] } });
   }
   stopFire(key) {
-    const fire = this.fires.get(key);
-    if (!fire) return;
-    if (fire.handle !== void 0) this.vfx.stop(fire.handle);
+    const fire2 = this.fires.get(key);
+    if (!fire2) return;
+    if (fire2.handle !== void 0) this.vfx.stop(fire2.handle);
     this.fires.delete(key);
   }
   // ----------------------------------------------------------------------------------------------------------------------------------
@@ -3605,9 +3776,9 @@ var Renderer = class {
         if (ps.status === "melted") this.onGone(a.object, pv, "melted", def);
         else if (ps.status === "ashes") this.onGone(a.object, pv, "ashes", def);
       }
-      const fire = this.fires.get(key);
-      if (fire) {
-        if (ps.burning && ps.status !== "broken" && ps.status !== "ashes" && ps.status !== "melted") this.emitFire(fire, pv, def);
+      const fire2 = this.fires.get(key);
+      if (fire2) {
+        if (ps.burning && ps.status !== "broken" && ps.status !== "ashes" && ps.status !== "melted") this.emitFire(fire2, pv, def);
         else this.stopFire(key);
       }
       const hot = def?.visual?.glows === true && ps.temperature > GLOW_FROM_C;
@@ -3737,10 +3908,12 @@ var Renderer = class {
         this.scene.remove(b.root);
         this.pieceSys.remove(b.id);
         this.bounds.delete(b.id);
+        this.staticDirty.add(b.id);
       }
     }
   }
   clear() {
+    this.staticAll = true;
     this.queue.length = 0;
     this.slices.length = 0;
     this.active.clear();
@@ -3767,6 +3940,8 @@ var Renderer = class {
     this.rng = createRng(RNG_SEED);
     this.time = 0;
     this.staticAt = 0;
+    this.staticRound = [];
+    this.staticAll = true;
     this.throttles.clear();
     this.fragments.reset();
     this.pieceSys.reset();
@@ -3792,6 +3967,7 @@ var Renderer = class {
     const materials = [kit.discMaterial().clone(), kit.patchMaterial(8421504).clone(), kit.lineMaterial(0).clone()];
     const group = new T.Group();
     group.add(new T.Mesh(kit.discGeometry(), materials[0]), new T.Mesh(kit.discGeometry(), materials[1]), new T.LineSegments(geometry, materials[2]));
+    group.add(...this.fragments.warmMeshes());
     for (const probe of group.children) probe.frustumCulled = false;
     this.warmProbes = { group, geometry, materials };
     return { group, dispose: () => {
@@ -3823,43 +3999,242 @@ var Renderer = class {
 };
 
 // src/audio/recipes.ts
-import { DISTANCE_CURVES, sceneMany as many, sceneNoise as noise, sceneRecipe, sceneTone as tone } from "@adatechnology/game-audio";
-var scene = (id, layers, line, vars) => sceneRecipe(id, layers, line, vars ? { vars } : {});
+import { DISTANCE_CURVES, sceneMany as many2, sceneNoise as noise2, sceneRecipe as sceneRecipe2, sceneTone as tone2 } from "@adatechnology/game-audio";
+
+// src/audio/blast-fire.ts
+import { sceneMany as many, sceneNoise as noise, sceneRecipe, sceneTone as tone } from "@adatechnology/game-audio";
+var BLAST_FALLOFF = { model: "inverse_square", k: 12e-4, cutoffK: 6e-3, minGain: 2e-3 };
+var BLAST_FAR_FALLOFF = { model: "inverse_square", k: 8e-5, scale: 0.3, minGain: 1e-3 };
+var FIRE_FALLOFF = { model: "inverse_square", k: 0.01, cutoffK: 0.01, minGain: 5e-3 };
+var BLAST_FAR_DISTANCE = 60;
+var BLAST_KINDS = ["grenade", "big", "fuel", "car", "pipe_bomb", "rocket", "flashbang", "molotov"];
+var BLAST_KIND_OF = {
+  m67: "grenade",
+  vog_25: "grenade",
+  m79_40mm: "grenade",
+  claymore: "grenade",
+  generic: "grenade",
+  c4: "big",
+  dynamite: "big",
+  fuel_station_tank: "big",
+  propane_p13: "fuel",
+  fuel_barrel: "fuel",
+  fuel_pump: "fuel",
+  car_fuel_tank: "car",
+  pipe_bomb: "pipe_bomb",
+  m72_66mm: "rocket",
+  at4_84mm: "rocket",
+  carl_gustaf_84mm: "rocket",
+  pg7v: "rocket",
+  flashbang: "flashbang",
+  molotov: "molotov"
+};
+var BIG_BLAST_RADIUS = 8;
+var blast = (id, layers, sources, falloff = BLAST_FALLOFF) => ({
+  ...sceneRecipe(id, layers, ""),
+  falloff,
+  sources
+});
+var crack = (f, d, vol) => noise({ type: "highpass", f, a: 1e-3, d, vol });
+var debris = (count, from, to, vol) => [
+  ...many(count, () => noise({ type: "bandpass", f: [300, 1400], q: 2.5, d: [0.03, 0.09], vol, delay: [from, to] })),
+  ...many(Math.ceil(count / 3), () => noise({ type: "bandpass", f: [1800, 3600], q: 5, d: [0.02, 0.04], vol: [vol[0] * 0.6, vol[1] * 0.6], delay: [from + 0.1, to] }))
+];
+var shrapnel = (count, to) => many(count, () => noise({ type: "bandpass", f: [2500, 6e3], q: 6, d: [0.015, 0.045], vol: [0.08, 0.16], delay: [0.02, to] }));
+var glass = (count, from) => [
+  noise({ type: "highpass", f: [2600, 3e3], d: 0.4, vol: 0.7, wet: 0.5, delay: from }),
+  ...many(count, () => tone({ f: [3e3, 7500], d: [0.05, 0.13], vol: 0.12, delay: [from, from + 0.7] }))
+];
+var BLAST_SOUNDS = [
+  blast(
+    "explosion_grenade",
+    [
+      crack([2300, 2700], 0.06, 2.4),
+      noise({ f: [2500, 3e3], f2: 160, d: 0.7, vol: 2, wet: 0.35 }),
+      tone({ f: [80, 92], f2: 32, d: 0.5, vol: 1.6 }),
+      noise({ type: "bandpass", f: [620, 760], q: 0.8, d: 0.18, vol: 1.1 }),
+      ...shrapnel(14, 0.7),
+      ...debris(10, 0.35, 1.8, [0.1, 0.2])
+    ],
+    ["sdk: frag grenade (M67, VOG-25, 40 mm): sharp crack, short body, fragments striking, a little debris"]
+  ),
+  blast(
+    "explosion_big",
+    [
+      crack([1900, 2300], 0.08, 2.4),
+      noise({ f: [2200, 2600], f2: 90, d: 1.6, vol: 2.2, wet: 0.45 }),
+      tone({ f: [52, 60], f2: 22, d: 1.6, vol: 1.9 }),
+      noise({ f: [280, 330], f2: 60, a: 0.25, d: 2.8, vol: 0.8, wet: 0.6, delay: 0.05 }),
+      ...debris(24, 0.5, 3.6, [0.12, 0.25])
+    ],
+    ["sdk: big charge (C4, dynamite, a fuel station tank): crack, long deep roar, debris falling for 2 to 4 s"]
+  ),
+  blast(
+    "explosion_fuel",
+    [
+      noise({ type: "highpass", f: [1700, 2e3], a: 1e-3, d: 0.05, vol: 1 }),
+      tone({ f: [380, 450], f2: 300, d: 0.4, vol: 0.3 }),
+      noise({ f: [1700, 2e3], f2: 150, a: 0.03, d: 1.4, vol: 2.1, wet: 0.4 }),
+      tone({ f: [48, 56], f2: 25, d: 1.2, vol: 1.7 }),
+      noise({ type: "bandpass", f: [450, 560], q: 0.6, a: 0.15, d: 2.2, vol: 0.85, wet: 0.5, delay: 0.1 }),
+      ...debris(10, 0.5, 2.6, [0.08, 0.16])
+    ],
+    ['sdk: a fuel vessel bursting (propane P13, fuel barrel, pump): the shell tearing, a fireball "whoomp" and its roar']
+  ),
+  blast(
+    "explosion_car",
+    [
+      noise({ type: "highpass", f: [1700, 2e3], a: 1e-3, d: 0.06, vol: 1.1 }),
+      noise({ f: [1600, 1900], f2: 140, a: 0.03, d: 1.6, vol: 2.1, wet: 0.4 }),
+      tone({ f: [44, 52], f2: 24, d: 1.4, vol: 1.8 }),
+      noise({ type: "bandpass", f: [420, 520], q: 0.6, a: 0.15, d: 2.6, vol: 0.9, wet: 0.5, delay: 0.1 }),
+      ...glass(10, 0.04),
+      tone({ f: [130, 150], f2: 85, d: 1.1, vol: 0.18, delay: [0.3, 0.5] }),
+      ...debris(16, 0.6, 3.2, [0.1, 0.2])
+    ],
+    ["sdk: a car going up: the fuel tank fireball, every window breaking, the body groaning, parts falling"]
+  ),
+  blast(
+    "explosion_pipe_bomb",
+    [
+      crack([2e3, 2400], 0.07, 2.2),
+      noise({ f: [2e3, 2400], f2: 150, d: 0.8, vol: 1.9, wet: 0.35 }),
+      tone({ f: [70, 82], f2: 30, d: 0.6, vol: 1.5 }),
+      ...many(6, () => tone({ f: [1800, 3200], f2: 1200, d: [0.06, 0.12], vol: 0.06, delay: [0.05, 0.6] })),
+      ...shrapnel(18, 0.9),
+      ...debris(8, 0.4, 1.8, [0.08, 0.16])
+    ],
+    ["sdk: pipe bomb: crack, body, the steel pipe flying apart in ringing pieces"]
+  ),
+  blast(
+    "explosion_rocket",
+    [
+      crack([2100, 2500], 0.08, 2.4),
+      noise({ f: [2400, 2800], f2: 120, d: 1.1, vol: 2.1, wet: 0.4 }),
+      tone({ f: [60, 70], f2: 26, d: 0.9, vol: 1.8 }),
+      noise({ f: [350, 420], f2: 80, a: 0.08, d: 1.8, vol: 0.9, wet: 0.6, delay: 0.05 }),
+      ...shrapnel(10, 0.8),
+      ...debris(16, 0.4, 2.6, [0.1, 0.2])
+    ],
+    ["sdk: rocket or anti-tank warhead (M72, AT4, RPG): hard crack, heavy body, debris"]
+  ),
+  blast(
+    "explosion_flashbang",
+    [crack([1400, 1700], 0.12, 2.8), noise({ f: [1900, 2200], f2: 300, d: 0.35, vol: 1.3, wet: 0.3 }), tone({ f: [110, 130], f2: 60, d: 0.2, vol: 0.8 })],
+    ["sdk: flashbang: a deafening crack with almost no body and no fragments"]
+  ),
+  blast(
+    "molotov_break_ignite",
+    [
+      ...glass(8, 0),
+      noise({ f: [280, 340], f2: 2200, a: 0.12, d: 0.9, vol: 1.5, wet: 0.6, delay: 0.05 }),
+      tone({ f: [85, 95], f2: 55, d: 0.4, vol: 0.5, delay: 0.08 })
+    ],
+    ['sdk: molotov: the bottle breaking and the fuel catching with a "fuuush"'],
+    FIRE_FALLOFF
+  ),
+  blast(
+    "explosion_far",
+    [
+      noise({ f: [550, 650], f2: 80, a: 0.03, d: 2.5, vol: 2, wet: 1.4 }),
+      tone({ f: [42, 48], f2: 25, d: 1.8, vol: 1.2 }),
+      noise({ f: [350, 420], f2: 70, a: 0.1, d: 1.6, vol: 0.6, wet: 1.5, delay: [0.6, 1] })
+    ],
+    ["sdk: any blast far away: no crack left, a dull thud and the echo rolling back"],
+    BLAST_FAR_FALLOFF
+  ),
+  blast(
+    "explosion_indoor_tail",
+    [
+      ...many(3, () => noise({ f: [650, 800], d: 0.12, vol: 0.5, delay: [0.04, 0.2] })),
+      noise({ f: [850, 950], f2: 120, a: 0.05, d: 2.6, vol: 0.9, wet: 1.6, delay: 0.08 })
+    ],
+    ["sdk: the room answering a blast inside it: slaps off the walls and a boomy tail"]
+  )
+];
+var FIRE_SOUNDS = [
+  {
+    ...blast(
+      "fire_ignite",
+      [noise({ f: [230, 270], f2: 1500, a: 0.07, d: 0.5, vol: 1.6 }), tone({ f: [80, 90], f2: 55, d: 0.3, vol: 0.45 }), noise({ type: "highpass", f: 3e3, d: 0.3, vol: 0.1, delay: 0.1 })],
+      ['sdk: fire catching, a soft "fuuump"'],
+      FIRE_FALLOFF
+    ),
+    group: "fire_ignite"
+  },
+  {
+    ...blast("gas_leak", [noise({ type: "bandpass", f: [3200, 3800], q: 0.7, a: 0.08, d: { param: "seconds" }, vol: 0.3 })], ["sdk: gas jetting from a punctured vessel"], FIRE_FALLOFF),
+    vars: { seconds: 2 }
+  },
+  {
+    ...blast(
+      "fire_extinguish",
+      [noise({ type: "highpass", f: [2300, 2700], a: 0.03, d: { param: "seconds" }, vol: 0.3 }), noise({ type: "bandpass", f: [800, 1e3], q: 0.5, d: 0.5, vol: 0.25 })],
+      ["sdk: water or foam on a fire: a steam puff and a sizzle"],
+      FIRE_FALLOFF
+    ),
+    vars: { seconds: 1.2 }
+  },
+  { ...blast("fire_crackle", [noise({ type: "highpass", f: [1500, 3e3], d: [0.01, 0.025], vol: [1.2, 2.2] })], ["sdk: a crackle of the fire"], FIRE_FALLOFF), group: "fire_crackle" },
+  { ...blast("fire_pop", [noise({ type: "bandpass", f: [500, 1100], q: 1, d: [0.03, 0.06], vol: [3, 4.5] })], ["sdk: a log or a resin pocket popping"], FIRE_FALLOFF), group: "fire_crackle" }
+];
+var FIRE_LOOP = {
+  id: "fire_loop",
+  bus: "world",
+  order: "chain_loop",
+  source: { kind: "noise", loop: true },
+  filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 950 }, q: 0.5 }] },
+  volume: 0,
+  sources: ["sdk: the roar under the crackles of a fire"]
+};
+var BLAST_SOUND_OF = {
+  grenade: "explosion_grenade",
+  big: "explosion_big",
+  fuel: "explosion_fuel",
+  car: "explosion_car",
+  pipe_bomb: "explosion_pipe_bomb",
+  rocket: "explosion_rocket",
+  flashbang: "explosion_flashbang",
+  molotov: "molotov_break_ignite"
+};
+
+// src/audio/recipes.ts
+var scene = (id, layers, line, vars) => sceneRecipe2(id, layers, line, vars ? { vars } : {});
 var boomLayers = (big) => [
-  noise({ f: 1200, f2: 120, d: 1.8, vol: 2, wet: 1.2 }),
-  tone({ f: 65, f2: 24, d: 1, vol: 1.8 }),
-  noise({ type: "highpass", f: 1500, d: 0.2, vol: 0.8 }),
-  ...big ? [noise({ f: 500, f2: 90, a: 0.2, d: 2.4, vol: 1.2, wet: 1, delay: 0.15 })] : [],
-  ...many(8, () => tone({ f: [2600, 5600], d: 0.05, vol: 0.08, delay: [0.4, 1.6] }))
+  noise2({ f: 1200, f2: 120, d: 1.8, vol: 2, wet: 1.2 }),
+  tone2({ f: 65, f2: 24, d: 1, vol: 1.8 }),
+  noise2({ type: "highpass", f: 1500, d: 0.2, vol: 0.8 }),
+  ...big ? [noise2({ f: 500, f2: 90, a: 0.2, d: 2.4, vol: 1.2, wet: 1, delay: 0.15 })] : [],
+  ...many2(8, () => tone2({ f: [2600, 5600], d: 0.05, vol: 0.08, delay: [0.4, 1.6] }))
 ];
 var SCENE_SOUNDS = [
   scene(
     "glass_shatter",
-    [noise({ type: "highpass", f: 2800, d: 0.45, vol: 0.9, wet: 0.5 }), ...many(12, () => tone({ f: [3e3, 7500], d: [0.06, 0.14], vol: 0.18, delay: [0, 0.55] }))],
+    [noise2({ type: "highpass", f: 2800, d: 0.45, vol: 0.9, wet: 0.5 }), ...many2(12, () => tone2({ f: [3e3, 7500], d: [0.06, 0.14], vol: 0.18, delay: [0, 0.55] }))],
     "L1359 glass"
   ),
   scene(
     "wood_hit",
-    [noise({ type: "bandpass", f: 850, q: 1, d: 0.25, vol: 0.9, wet: 0.3 }), tone({ f: 210, f2: 90, d: 0.1, vol: 0.6 }), noise({ type: "highpass", f: 2e3, d: 0.04, vol: 0.5 })],
+    [noise2({ type: "bandpass", f: 850, q: 1, d: 0.25, vol: 0.9, wet: 0.3 }), tone2({ f: 210, f2: 90, d: 0.1, vol: 0.6 }), noise2({ type: "highpass", f: 2e3, d: 0.04, vol: 0.5 })],
     "L1360 wood"
   ),
-  scene("thunk", [noise({ type: "bandpass", f: 700, q: 2, d: 0.07, vol: 0.4 })], "L1361 thunk"),
-  scene("ping", [tone({ f: [2600, 3500], f2: 1400, d: 0.14, vol: 0.18, wet: 0.3 })], "L1362 ping"),
-  scene("clang", [tone({ f: [520, 720], f2: 480, d: 0.5, vol: 0.35, wet: 0.4 }), tone({ f: 1370, f2: 1300, d: 0.3, vol: 0.15 }), noise({ type: "highpass", f: 2e3, d: 0.05, vol: 0.5 })], "L1363 clang"),
-  scene("chip", [noise({ type: "bandpass", f: 1600, q: 1.2, d: 0.06, vol: 0.5 })], "L1364 chip"),
+  scene("thunk", [noise2({ type: "bandpass", f: 700, q: 2, d: 0.07, vol: 0.4 })], "L1361 thunk"),
+  scene("ping", [tone2({ f: [2600, 3500], f2: 1400, d: 0.14, vol: 0.18, wet: 0.3 })], "L1362 ping"),
+  scene("clang", [tone2({ f: [520, 720], f2: 480, d: 0.5, vol: 0.35, wet: 0.4 }), tone2({ f: 1370, f2: 1300, d: 0.3, vol: 0.15 }), noise2({ type: "highpass", f: 2e3, d: 0.05, vol: 0.5 })], "L1363 clang"),
+  scene("chip", [noise2({ type: "bandpass", f: 1600, q: 1.2, d: 0.06, vol: 0.5 })], "L1364 chip"),
   scene(
     "crumble",
-    [noise({ f: 900, f2: 200, d: 0.6, vol: 0.9, wet: 0.3 }), ...many(5, () => noise({ type: "bandpass", f: [500, 1400], q: 2, d: 0.05, vol: 0.4, delay: [0.1, 0.5] }))],
+    [noise2({ f: 900, f2: 200, d: 0.6, vol: 0.9, wet: 0.3 }), ...many2(5, () => noise2({ type: "bandpass", f: [500, 1400], q: 2, d: 0.05, vol: 0.4, delay: [0.1, 0.5] }))],
     "L1365 crumble"
   ),
   // `thud(x, z, v)`: `v` is the `scale` param (default 1)
-  scene("thud", [tone({ f: 75, f2: 38, d: 0.22, vol: { param: "scale", scale: 0.6 } }), noise({ f: 420, d: 0.16, vol: { param: "scale", scale: 0.45 } })], "L1358 thud", { scale: 1 }),
+  scene("thud", [tone2({ f: 75, f2: 38, d: 0.22, vol: { param: "scale", scale: 0.6 } }), noise2({ f: 420, d: 0.16, vol: { param: "scale", scale: 0.45 } })], "L1358 thud", { scale: 1 }),
   // `hiss(x, z, d)`: `seconds` is the param `d` (default 1.2)
-  scene("hiss", [noise({ type: "highpass", f: 3500, a: 0.05, d: { param: "seconds" }, vol: 0.35 })], "L1366 hiss", { seconds: 1.2 }),
+  scene("hiss", [noise2({ type: "highpass", f: 3500, a: 0.05, d: { param: "seconds" }, vol: 0.35 })], "L1366 hiss", { seconds: 1.2 }),
   scene("boom", boomLayers(false), "L1367 boom"),
   scene("boom_big", boomLayers(true), "L1367 boom (big)"),
-  scene("burst", [noise({ f: 700, f2: 120, d: 0.7, vol: 1.4, wet: 0.5 }), noise({ type: "highpass", f: 3e3, a: 0.05, d: 1.2, vol: 0.4, delay: 0.1 })], "L1357 burst"),
-  scene("crack", [noise({ type: "highpass", f: 1800, d: 0.05, vol: 0.8 }), tone({ f: 420, f2: 180, d: 0.06, vol: 0.4 })], "L1354 crack")
+  scene("burst", [noise2({ f: 700, f2: 120, d: 0.7, vol: 1.4, wet: 0.5 }), noise2({ type: "highpass", f: 3e3, a: 0.05, d: 1.2, vol: 0.4, delay: 0.1 })], "L1357 burst"),
+  scene("crack", [noise2({ type: "highpass", f: 1800, d: 0.05, vol: 0.8 }), tone2({ f: 420, f2: 180, d: 0.06, vol: 0.4 })], "L1354 crack")
 ];
 var EXPLOSION_BOOM = {
   id: "explosion_boom",
@@ -3888,29 +4263,129 @@ var BURN_LOOP = {
   volume: 0,
   sources: ["cena:L1316 fire loop (silent in the page: its gain is never raised)", "sdk: the level while burning"]
 };
-var drag = (id, layers) => ({ ...sceneRecipe(id, layers, ""), sources: ["sdk: a base dragged on a floor, one grain per stretch"] });
+var drag = (id, layers) => ({ ...sceneRecipe2(id, layers, ""), sources: ["sdk: a base dragged on a floor, one grain per stretch"] });
 var DRAG_SOUNDS = [
-  drag("drag_wood", [noise({ type: "bandpass", f: 380, q: 1.4, d: 0.28, vol: 0.5 }), noise({ type: "bandpass", f: [900, 1300], q: 3, d: 0.08, vol: 0.14 })]),
-  drag("drag_metal", [noise({ type: "bandpass", f: 1500, q: 4, d: 0.26, vol: 0.32 }), tone({ f: [880, 1240], f2: 760, d: 0.18, vol: 0.05 })]),
-  drag("drag_glass", [noise({ type: "bandpass", f: 2600, q: 5, d: 0.2, vol: 0.22 })]),
-  drag("drag_masonry", [noise({ type: "bandpass", f: 260, q: 0.9, d: 0.3, vol: 0.62 }), ...many(3, () => noise({ type: "bandpass", f: [600, 1200], q: 2, d: 0.04, vol: 0.14, delay: [0, 0.2] }))]),
-  drag("drag_soft", [noise({ type: "lowpass", f: 420, d: 0.28, vol: 0.3 })])
+  drag("drag_wood", [noise2({ type: "bandpass", f: 380, q: 1.4, d: 0.28, vol: 0.5 }), noise2({ type: "bandpass", f: [900, 1300], q: 3, d: 0.08, vol: 0.14 })]),
+  drag("drag_metal", [noise2({ type: "bandpass", f: 1500, q: 4, d: 0.26, vol: 0.32 }), tone2({ f: [880, 1240], f2: 760, d: 0.18, vol: 0.05 })]),
+  drag("drag_glass", [noise2({ type: "bandpass", f: 2600, q: 5, d: 0.2, vol: 0.22 })]),
+  drag("drag_masonry", [noise2({ type: "bandpass", f: 260, q: 0.9, d: 0.3, vol: 0.62 }), ...many2(3, () => noise2({ type: "bandpass", f: [600, 1200], q: 2, d: 0.04, vol: 0.14, delay: [0, 0.2] }))]),
+  drag("drag_soft", [noise2({ type: "lowpass", f: 420, d: 0.28, vol: 0.3 })])
 ];
-var leaf = (id, layers) => ({ ...sceneRecipe(id, layers, ""), sources: ["sdk: a door, lid or drawer worked by hand"] });
+var leaf = (id, layers) => ({ ...sceneRecipe2(id, layers, ""), sources: ["sdk: a door, lid or drawer worked by hand"] });
 var LEAF_SOUNDS = [
-  leaf("latch", [noise({ type: "bandpass", f: 2400, q: 4, d: 0.03, vol: 0.35 }), tone({ f: 1900, f2: 1500, d: 0.025, vol: 0.06, delay: 0.035 })]),
-  leaf("creak_wood", [tone({ f: [190, 240], f2: 310, d: 0.5, vol: 0.05 }), noise({ type: "bandpass", f: 520, q: 6, a: 0.05, d: 0.45, vol: 0.12 })]),
-  leaf("creak_metal", [tone({ f: [620, 760], f2: 900, d: 0.35, vol: 0.035 }), noise({ type: "bandpass", f: 1400, q: 8, a: 0.04, d: 0.3, vol: 0.08 })]),
-  leaf("shut_wood", [tone({ f: 120, f2: 60, d: 0.14, vol: 0.5 }), noise({ type: "bandpass", f: 600, q: 1.2, d: 0.1, vol: 0.55, wet: 0.25 }), noise({ type: "bandpass", f: 2400, q: 4, d: 0.03, vol: 0.25, delay: 0.02 })]),
-  leaf("shut_metal", [tone({ f: 160, f2: 85, d: 0.18, vol: 0.55 }), noise({ type: "bandpass", f: 900, q: 1.6, d: 0.12, vol: 0.45, wet: 0.3 }), tone({ f: 1250, f2: 1150, d: 0.12, vol: 0.06 })]),
-  leaf("shut_soft", [tone({ f: 95, f2: 55, d: 0.12, vol: 0.35 }), noise({ type: "lowpass", f: 500, d: 0.1, vol: 0.3 })]),
-  leaf("rattle", many(5, () => noise({ type: "bandpass", f: [1600, 2600], q: 3, d: 0.035, vol: 0.32, delay: [0, 0.45] }))),
-  leaf("slide", [noise({ type: "bandpass", f: 700, q: 2, a: 0.04, d: 0.35, vol: 0.22 }), noise({ type: "bandpass", f: 2200, q: 5, d: 0.3, vol: 0.05 })])
+  leaf("latch", [noise2({ type: "bandpass", f: 2400, q: 4, d: 0.03, vol: 0.35 }), tone2({ f: 1900, f2: 1500, d: 0.025, vol: 0.06, delay: 0.035 })]),
+  leaf("creak_wood", [tone2({ f: [190, 240], f2: 310, d: 0.5, vol: 0.05 }), noise2({ type: "bandpass", f: 520, q: 6, a: 0.05, d: 0.45, vol: 0.12 })]),
+  leaf("creak_metal", [tone2({ f: [620, 760], f2: 900, d: 0.35, vol: 0.035 }), noise2({ type: "bandpass", f: 1400, q: 8, a: 0.04, d: 0.3, vol: 0.08 })]),
+  leaf("shut_wood", [tone2({ f: 120, f2: 60, d: 0.14, vol: 0.5 }), noise2({ type: "bandpass", f: 600, q: 1.2, d: 0.1, vol: 0.55, wet: 0.25 }), noise2({ type: "bandpass", f: 2400, q: 4, d: 0.03, vol: 0.25, delay: 0.02 })]),
+  leaf("shut_metal", [tone2({ f: 160, f2: 85, d: 0.18, vol: 0.55 }), noise2({ type: "bandpass", f: 900, q: 1.6, d: 0.12, vol: 0.45, wet: 0.3 }), tone2({ f: 1250, f2: 1150, d: 0.12, vol: 0.06 })]),
+  leaf("shut_soft", [tone2({ f: 95, f2: 55, d: 0.12, vol: 0.35 }), noise2({ type: "lowpass", f: 500, d: 0.1, vol: 0.3 })]),
+  leaf("rattle", many2(5, () => noise2({ type: "bandpass", f: [1600, 2600], q: 3, d: 0.035, vol: 0.32, delay: [0, 0.45] }))),
+  leaf("slide", [noise2({ type: "bandpass", f: 700, q: 2, a: 0.04, d: 0.35, vol: 0.22 }), noise2({ type: "bandpass", f: 2200, q: 5, d: 0.3, vol: 0.05 })]),
+  // an item taken in the hand: the fingers on a hard surface and the sleeve moving, or a soft thing gathered up (the kit's recordings answer these ids)
+  leaf("grab_hard", [noise2({ type: "bandpass", f: 1800, q: 3, d: 0.03, vol: 0.18 }), noise2({ type: "bandpass", f: 900, q: 1.2, a: 0.02, d: 0.14, vol: 0.08 })]),
+  leaf("grab_soft", [noise2({ type: "lowpass", f: 1400, a: 0.02, d: 0.16, vol: 0.14 })])
+];
+var impact = (id, layers) => ({ ...sceneRecipe2(id, layers, ""), sources: ["sdk: a blow on a material, by material and kind of blow (synthesised until the recorded samples arrive)"] });
+var IMPACT_SOUNDS = [
+  // metal
+  impact("metal_bullet", [noise2({ type: "highpass", f: 3e3, d: 0.03, vol: 0.8 }), tone2({ f: [2600, 3400], f2: 1800, d: 0.14, vol: 0.28, wet: 0.35 }), tone2({ f: [520, 720], f2: 480, d: 0.35, vol: 0.22, wet: 0.35 })]),
+  impact("metal_blunt", [noise2({ type: "bandpass", f: 800, q: 1, d: 0.05, vol: 0.5 }), tone2({ f: [150, 210], f2: 120, d: 0.6, vol: 0.5, wet: 0.4 }), tone2({ f: [420, 520], f2: 400, d: 0.4, vol: 0.12 })]),
+  impact("metal_blade", [noise2({ type: "bandpass", f: [3500, 4500], q: 6, a: 0.01, d: 0.18, vol: 0.45 }), tone2({ f: [2200, 2800], f2: 3e3, d: 0.15, vol: 0.06 })]),
+  impact("metal_thin", [noise2({ type: "highpass", f: 2500, d: 0.04, vol: 0.6 }), tone2({ f: [900, 1300], f2: 700, d: 0.25, vol: 0.22, wet: 0.3 }), noise2({ type: "bandpass", f: 1200, q: 2, d: 0.08, vol: 0.3 })]),
+  // wood (the bullet keeps the art scene's `wood_hit`)
+  impact("wood_blunt", [tone2({ f: [110, 150], f2: 70, d: 0.14, vol: 0.6 }), noise2({ type: "bandpass", f: 500, q: 1.2, d: 0.12, vol: 0.55, wet: 0.2 })]),
+  impact("wood_blade", [noise2({ type: "bandpass", f: [1800, 2400], q: 2, a: 0.01, d: 0.12, vol: 0.5 }), ...many2(3, () => noise2({ type: "bandpass", f: [2500, 4e3], q: 3, d: 0.02, vol: 0.22, delay: [0.02, 0.1] }))]),
+  impact("mdf_puff", [noise2({ type: "lowpass", f: 900, d: 0.08, vol: 1 }), tone2({ f: [180, 230], f2: 110, d: 0.06, vol: 0.3 }), noise2({ type: "highpass", f: 3e3, a: 0.01, d: 0.2, vol: 0.1 })]),
+  // glass and ceramic
+  impact("glass_bullet", [noise2({ type: "highpass", f: 4e3, d: 0.05, vol: 0.7 }), tone2({ f: [3200, 4200], f2: 2600, d: 0.2, vol: 0.14, wet: 0.3 }), ...many2(4, () => tone2({ f: [4e3, 7e3], d: 0.05, vol: 0.07, delay: [0.02, 0.2] }))]),
+  impact("glass_blunt", [noise2({ type: "bandpass", f: 2200, q: 3, d: 0.05, vol: 0.8 }), tone2({ f: [1400, 1800], f2: 1300, d: 0.2, vol: 0.16, wet: 0.3 })]),
+  impact("glass_blade", [noise2({ type: "bandpass", f: 5e3, q: 8, a: 0.02, d: 0.25, vol: 0.3 })]),
+  impact("ceramic_hit", [noise2({ type: "bandpass", f: 3e3, q: 2, d: 0.03, vol: 0.6 }), tone2({ f: [1800, 2400], f2: 1600, d: 0.1, vol: 0.2 })]),
+  impact("ceramic_bullet", [noise2({ type: "highpass", f: 2500, d: 0.06, vol: 0.85 }), ...many2(5, () => tone2({ f: [2500, 5e3], d: 0.04, vol: 0.09, delay: [0, 0.15] }))]),
+  // masonry and the ground
+  impact("masonry_bullet", [noise2({ type: "bandpass", f: [1600, 2e3], q: 1, d: 0.05, vol: 1.8 }), noise2({ type: "lowpass", f: 600, d: 0.12, vol: 0.9, wet: 0.2 }), ...many2(4, () => noise2({ type: "bandpass", f: [2e3, 4e3], q: 3, d: 0.02, vol: 0.28, delay: [0.03, 0.3] }))]),
+  impact("masonry_blunt", [tone2({ f: [70, 95], f2: 45, d: 0.12, vol: 0.55 }), noise2({ type: "lowpass", f: 400, d: 0.1, vol: 0.5 })]),
+  impact("masonry_blade", [noise2({ type: "bandpass", f: [2500, 3500], q: 4, a: 0.01, d: 0.15, vol: 0.4 })]),
+  impact("plaster_puff", [noise2({ type: "lowpass", f: 900, d: 0.09, vol: 0.7 }), noise2({ type: "highpass", f: 3e3, a: 0.01, d: 0.2, vol: 0.14 })]),
+  impact("soil_bullet", [noise2({ type: "lowpass", f: 700, d: 0.08, vol: 2.2 }), ...many2(3, () => noise2({ type: "bandpass", f: [1200, 2200], q: 2, d: 0.03, vol: 0.18, delay: [0.02, 0.2] }))]),
+  impact("soil_blunt", [tone2({ f: [55, 70], f2: 40, d: 0.1, vol: 0.45 }), noise2({ type: "lowpass", f: 300, d: 0.08, vol: 0.4 })]),
+  impact("sand_hit", [noise2({ type: "bandpass", f: 3500, q: 0.8, a: 5e-3, d: 0.15, vol: 0.45 }), noise2({ type: "lowpass", f: 500, d: 0.06, vol: 0.45 })]),
+  impact("gravel_hit", [noise2({ type: "lowpass", f: 500, d: 0.06, vol: 0.45 }), ...many2(6, () => noise2({ type: "bandpass", f: [1500, 3500], q: 3, d: 0.025, vol: 0.28, delay: [0, 0.18] }))]),
+  // plastic, rubber, wax
+  impact("plastic_hit", [noise2({ type: "bandpass", f: 1600, q: 3, d: 0.04, vol: 0.5 }), tone2({ f: [380, 520], f2: 300, d: 0.08, vol: 0.32 })]),
+  impact("plastic_bullet", [noise2({ type: "bandpass", f: 2500, q: 2, d: 0.03, vol: 1.3 }), tone2({ f: [600, 800], f2: 450, d: 0.06, vol: 0.4 })]),
+  impact("rubber_hit", [tone2({ f: [90, 130], f2: 60, d: 0.1, vol: 0.45 }), noise2({ type: "lowpass", f: 350, d: 0.06, vol: 0.28 })]),
+  impact("wax_hit", [noise2({ type: "lowpass", f: 800, d: 0.05, vol: 0.45 }), tone2({ f: [240, 280], f2: 180, d: 0.05, vol: 0.22 })]),
+  // soft things, paper, plants
+  impact("soft_bullet", [noise2({ type: "lowpass", f: 450, a: 3e-3, d: 0.1, vol: 1.8 }), noise2({ type: "bandpass", f: 900, q: 1, d: 0.05, vol: 0.5 })]),
+  impact("fabric_rip", [noise2({ type: "bandpass", f: [2e3, 2800], q: 1.5, a: 0.02, d: 0.25, vol: 0.4 }), ...many2(4, () => noise2({ type: "bandpass", f: [3e3, 5e3], q: 4, d: 0.02, vol: 0.14, delay: [0, 0.22] }))]),
+  impact("paper_hit", [noise2({ type: "bandpass", f: 2200, q: 1, d: 0.05, vol: 0.45 })]),
+  impact("paper_tear", [noise2({ type: "highpass", f: 2500, a: 0.02, d: 0.3, vol: 0.15 })]),
+  impact("leaf_rustle", many2(6, () => noise2({ type: "bandpass", f: [2500, 6e3], q: 2, d: 0.05, vol: 0.16, delay: [0, 0.3] }))),
+  impact("branch_cut", [noise2({ type: "bandpass", f: 1500, q: 2, d: 0.04, vol: 0.55 }), tone2({ f: [260, 340], f2: 150, d: 0.05, vol: 0.22 })]),
+  impact("fruit_splat", [noise2({ type: "lowpass", f: 1200, d: 0.12, vol: 0.55 }), noise2({ type: "bandpass", f: 600, q: 0.7, d: 0.2, vol: 0.32 })]),
+  // a round glancing off: steel whines down in pitch ("piiuu"), stone and concrete give a short crack with grit
+  impact("ricochet_metal", [noise2({ type: "highpass", f: 3e3, d: 0.02, vol: 0.6 }), tone2({ f: [2800, 3600], f2: 900, d: 0.38, vol: 0.2, wet: 0.4 }), tone2({ f: [5200, 6400], f2: 2e3, d: 0.2, vol: 0.05 })]),
+  impact("ricochet_stone", [noise2({ type: "bandpass", f: [2200, 2800], q: 2, d: 0.04, vol: 0.8 }), tone2({ f: [1800, 2400], f2: 1200, d: 0.08, vol: 0.1 }), ...many2(3, () => noise2({ type: "bandpass", f: [2500, 4500], q: 3, d: 0.015, vol: 0.2, delay: [0.02, 0.12] }))]),
+  // breaks a material has of its own (the rest keep the art scene's shatter, crumble and splinter)
+  impact("ceramic_break", [noise2({ type: "highpass", f: 1800, d: 0.3, vol: 0.85, wet: 0.4 }), ...many2(8, () => tone2({ f: [1800, 4500], d: [0.04, 0.1], vol: 0.15, delay: [0, 0.4] }))]),
+  impact("tempered_burst", [noise2({ type: "highpass", f: 3500, d: 0.6, vol: 0.9, wet: 0.4 }), ...many2(16, () => tone2({ f: [4e3, 8e3], d: 0.04, vol: 0.08, delay: [0, 0.8] }))]),
+  impact("plastic_crack", [noise2({ type: "bandpass", f: 1800, q: 2, d: 0.06, vol: 0.75 }), tone2({ f: [450, 550], f2: 250, d: 0.05, vol: 0.22 })]),
+  impact("mdf_crumble", [noise2({ type: "lowpass", f: 700, d: 0.25, vol: 0.75, wet: 0.2 }), ...many2(4, () => noise2({ type: "lowpass", f: 500, d: 0.05, vol: 0.32, delay: [0.05, 0.3] }))])
 ];
-var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, ...LEAF_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
+var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, ...LEAF_SOUNDS, ...IMPACT_SOUNDS, EXPLOSION_BOOM, ...BLAST_SOUNDS, ...FIRE_SOUNDS], loops: [BURN_LOOP, FIRE_LOOP] };
 
 // src/audio/sound.ts
-import { GAME_SFX_BANK } from "@adatechnology/game-audio";
+import { FOLEY_BANK, GAME_SFX_BANK } from "@adatechnology/game-audio";
+var IMPACT_SOUND_KEYS = {
+  impact_metal_ballistic: { sound: "metal_bullet" },
+  impact_metal_blunt: { sound: "metal_blunt" },
+  impact_metal_slash: { sound: "metal_blade" },
+  impact_aluminium_ballistic: { sound: "metal_thin" },
+  impact_aluminium_blunt: { sound: "metal_thin" },
+  impact_copper_ballistic: { sound: "metal_thin" },
+  impact_copper_blunt: { sound: "metal_thin" },
+  impact_wood_ballistic: { sound: "wood_hit" },
+  impact_wood_blunt: { sound: "wood_blunt" },
+  impact_wood_slash: { sound: "wood_blade" },
+  impact_mdf_ballistic: { sound: "mdf_puff" },
+  impact_mdf_blunt: { sound: "mdf_puff", volumeScale: 0.8 },
+  impact_glass_ballistic: { sound: "glass_bullet" },
+  impact_glass_blunt: { sound: "glass_blunt" },
+  impact_glass_slash: { sound: "glass_blade" },
+  impact_ceramic: { sound: "ceramic_hit" },
+  impact_ceramic_ballistic: { sound: "ceramic_bullet" },
+  impact_masonry_ballistic: { sound: "masonry_bullet" },
+  impact_masonry_blunt: { sound: "masonry_blunt" },
+  impact_masonry_slash: { sound: "masonry_blade" },
+  impact_plaster: { sound: "plaster_puff" },
+  impact_soil: { sound: "soil_blunt" },
+  impact_soil_ballistic: { sound: "soil_bullet" },
+  impact_sand: { sound: "sand_hit" },
+  impact_gravel: { sound: "gravel_hit" },
+  impact_plastic: { sound: "plastic_hit" },
+  impact_plastic_ballistic: { sound: "plastic_bullet" },
+  impact_rubber: { sound: "rubber_hit" },
+  impact_wax: { sound: "wax_hit" },
+  impact_soft_ballistic: { sound: "soft_bullet" },
+  impact_soft_slash: { sound: "fabric_rip" },
+  impact_paper: { sound: "paper_hit" },
+  impact_paper_slash: { sound: "paper_tear" },
+  impact_plant: { sound: "leaf_rustle" },
+  impact_plant_slash: { sound: "branch_cut" },
+  impact_flesh_fruit: { sound: "fruit_splat" },
+  ricochet_metal: { sound: "ricochet_metal" },
+  ricochet_masonry: { sound: "ricochet_stone" },
+  ricochet_soil: { sound: "ricochet_stone" },
+  ricochet_ceramic: { sound: "ricochet_stone" },
+  break_ceramic: { sound: "ceramic_break" },
+  break_tempered_glass: { sound: "tempered_burst" },
+  break_plastic: { sound: "plastic_crack" },
+  break_mdf: { sound: "mdf_crumble" },
+  break_soft: { sound: "fabric_rip" },
+  break_paper: { sound: "paper_tear" },
+  break_plant: { sound: "branch_cut" }
+};
 var DESTRUCTION_SOUND_KEYS = {
   art_scene: {
     impact_metal: { sound: "clang" },
@@ -3918,6 +4393,12 @@ var DESTRUCTION_SOUND_KEYS = {
     impact_glass: { sound: "ping" },
     impact_masonry: { sound: "chip" },
     impact_soft: { sound: "thud" },
+    // a round strikes: the steel rings high, glass cracks, wood and masonry chip, a soft part takes a dull thunk
+    shot_metal: { sound: "ping" },
+    shot_wood: { sound: "chip" },
+    shot_glass: { sound: "crack" },
+    shot_masonry: { sound: "chip" },
+    shot_soft: { sound: "thunk" },
     drag_wood: { sound: "drag_wood" },
     drag_metal: { sound: "drag_metal" },
     drag_glass: { sound: "drag_glass" },
@@ -3943,22 +4424,38 @@ var DESTRUCTION_SOUND_KEYS = {
     hood_shut: { sound: "shut_metal" },
     trunk_shut: { sound: "shut_metal" },
     door_close: { sound: "shut_wood", volumeScale: 0.7 },
+    // a vehicle's leaves (the vehicle bank of game-vehicles-three): a car door shuts with a padded thump and a latch, not like a fridge
+    vehicle_door_open: { sound: "car_door_open", fallback: "latch" },
+    vehicle_door_shut: { sound: "car_door_close", fallback: "shut_metal" },
+    vehicle_trunk_open: { sound: "car_door_open", fallback: "latch" },
+    vehicle_trunk_shut: { sound: "car_trunk_close", fallback: "shut_metal" },
+    vehicle_hood_open: { sound: "car_door_open", fallback: "latch" },
+    vehicle_hood_shut: { sound: "car_hood_close", fallback: "shut_metal" },
     drawer_open: { sound: "slide" },
     drawer_close: { sound: "slide" },
     lid_open: { sound: "latch" },
     lid_close: { sound: "shut_soft" },
     flap_open: { sound: "latch" },
     flap_close: { sound: "shut_soft" },
+    // an item taken in the hand, by what it is made of (game-audio's KIT_SAMPLE_ALIASES puts recordings on these ids)
+    grab_metal: { sound: "grab_hard" },
+    grab_wood: { sound: "grab_hard" },
+    grab_glass: { sound: "grab_hard", volumeScale: 0.7 },
+    grab_masonry: { sound: "grab_hard" },
+    grab_soft: { sound: "grab_soft" },
     shatter_glass: { sound: "glass_shatter" },
     crumble: { sound: "crumble" },
     splinter: { sound: "crack" },
     ricochet: { sound: "ping" },
     unscrew: { sound: "chip" },
     detach: { sound: "thunk" },
-    ignite: { sound: "hiss", params: { seconds: 0.5 } },
-    extinguish: { sound: "hiss" },
+    ignite: { sound: "fire_ignite" },
+    primed: { sound: "gas_leak" },
+    extinguish: { sound: "fire_extinguish" },
     melt_sizzle: { sound: "hiss", params: { seconds: 0.6 } },
-    explode: { sound: "boom", above: { volume: 0.9, sound: "boom_big" } }
+    // the blast family comes from the explosion's effect (`BLAST_KIND_OF`); this rule answers only an explosion the kit cannot place
+    explode: { sound: "explosion_grenade", above: { volume: 0.9, sound: "explosion_big" } },
+    ...IMPACT_SOUND_KEYS
   },
   game: {
     impact_metal: { sound: "sfx_impact" },
@@ -3972,14 +4469,26 @@ var DESTRUCTION_SOUND_KEYS = {
     explode: { sound: "explosion_boom" }
   }
 };
-var DEFAULT_FIRE = { perFire: 0.05, max: 0.2 };
+var DEFAULT_FIRE = { perFire: 0.08, max: 0.45 };
+var DEFAULT_CRACKLES = { base: 2, perSqrtFire: 3, max: 14, volume: 0.5 };
+var DEFAULT_INDOOR_CONFINEMENT = 1.3;
 function createDestructionSound(engine, options = {}) {
   engine.register(DESTRUCTION_SOUND_BANK);
   engine.register(GAME_SFX_BANK);
-  const fire = { ...DEFAULT_FIRE, ...options.fire };
+  engine.register(FOLEY_BANK);
+  const fire2 = { ...DEFAULT_FIRE, ...options.fire };
+  const crackles = options.crackles === false ? null : { ...DEFAULT_CRACKLES, ...options.crackles };
+  const fireLoop = options.fireLoop ?? "fire_loop";
+  const kinds = { ...BLAST_KIND_OF, ...options.blastKinds };
+  const farDistance = options.blastFarDistance ?? BLAST_FAR_DISTANCE;
+  const indoorFrom = options.indoorConfinement ?? DEFAULT_INDOOR_CONFINEMENT;
   const rules = { ...DESTRUCTION_SOUND_KEYS.art_scene, ...options.style === "game" ? DESTRUCTION_SOUND_KEYS.game : {}, ...options.keys };
+  const blastByKind = options.style !== "game" && !(options.keys && "explode" in options.keys);
+  const channel = engine.channel({ seed: options.seed ?? 1 });
   let loop;
   let burning = 0;
+  const fires = [];
+  let nextCrackle = 0;
   const setFire = () => {
     if (options.burnLoop === false) return;
     if (burning <= 0) {
@@ -3987,48 +4496,157 @@ function createDestructionSound(engine, options = {}) {
       loop = void 0;
       return;
     }
-    loop ?? (loop = engine.loop("burn_loop"));
-    loop.set({ volume: Math.min(fire.max, fire.perFire * burning) });
+    loop ?? (loop = engine.loop(fireLoop));
+    loop.set({ volume: Math.min(fire2.max, fire2.perFire * burning) });
+  };
+  const forget = (point) => {
+    let best = -1;
+    let bestD = Infinity;
+    fires.forEach((f, i) => {
+      const d = (f[0] - point[0]) ** 2 + (f[1] - point[1]) ** 2 + (f[2] - point[2]) ** 2;
+      if (d < bestD) {
+        bestD = d;
+        best = i;
+      }
+    });
+    if (best >= 0) fires.splice(best, 1);
+  };
+  const blastSound = (point, volume, detail) => {
+    const named = detail?.effect === void 0 ? void 0 : kinds[detail.effect];
+    const kind = named ?? ((detail?.radius ?? 0) >= BIG_BLAST_RADIUS || volume >= 0.9 ? "big" : "grenade");
+    const sound = BLAST_SOUND_OF[kind];
+    const distance = engine.plan(sound, { position: point, seed: 1 })?.distance ?? 0;
+    return kind !== "molotov" && distance > farDistance ? "explosion_far" : sound;
   };
   return {
-    onSound(key, point, volume) {
+    onSound(key, point, volume, detail) {
       if (key === "burn_loop") {
         burning += 1;
+        fires.push(point);
         setFire();
         return;
       }
       if (key === "burn_end") {
         if (burning > 0) burning -= 1;
+        forget(point);
         setFire();
         return;
       }
-      const rule = rules[key];
-      if (!rule) return;
-      const sound = rule.above && volume >= rule.above.volume ? rule.above.sound : rule.sound;
-      engine.play(sound, { position: point, volume: volume * (rule.volumeScale ?? 1), ...rule.params ? { params: rule.params } : {} });
+      if (key === "explode" && blastByKind) {
+        const sound2 = blastSound(point, volume, detail);
+        engine.play(sound2, { position: point, volume });
+        if (sound2 !== "explosion_far" && sound2 !== "molotov_break_ignite" && (detail?.confinement ?? 1) >= indoorFrom) engine.play("explosion_indoor_tail", { position: point, volume });
+        return;
+      }
+      let rule;
+      for (const k of detail?.keys ?? []) {
+        if (k in rules) {
+          rule = rules[k];
+          break;
+        }
+      }
+      if (rule === void 0) rule = key in rules ? rules[key] : rules[key.replace(/^shot_/, "impact_")];
+      if (rule === null) return;
+      if (!rule) {
+        if (engine.registry.sound(key)) engine.play(key, { position: point, volume });
+        return;
+      }
+      const wanted = rule.above && volume >= rule.above.volume ? rule.above.sound : rule.sound;
+      const sound = rule.fallback && !engine.registry.sound(wanted) ? rule.fallback : wanted;
+      const params = detail?.seconds === void 0 ? rule.params : { ...rule.params, seconds: detail.seconds };
+      engine.play(sound, { position: point, volume: volume * (rule.volumeScale ?? 1), ...params ? { params } : {} });
+    },
+    update(dt) {
+      if (!crackles || fires.length === 0 || options.burnLoop === false) return;
+      nextCrackle -= dt;
+      for (let i = 0; i < 4 && nextCrackle <= 0; i++) {
+        const rate = Math.min(crackles.max, crackles.base + crackles.perSqrtFire * Math.sqrt(fires.length));
+        nextCrackle += (0.4 + channel.random() * 1.2) / rate;
+        const at = fires[Math.floor(channel.random() * fires.length)];
+        engine.play(channel.random() < 0.18 ? "fire_pop" : "fire_crackle", { position: at, volume: crackles.volume });
+      }
+      if (nextCrackle < 0) nextCrackle = 0;
+    },
+    blastSound,
+    rule(key, detail) {
+      for (const k of detail?.keys ?? []) if (k in rules) return rules[k] ?? void 0;
+      return rules[key] ?? void 0;
     },
-    rule: (key) => rules[key] ?? void 0,
     burning: () => burning,
     dispose() {
       loop?.stop();
       loop = void 0;
       burning = 0;
+      fires.length = 0;
     }
   };
 }
+
+// src/audio/samples.ts
+import { sampleBankFromManifest } from "@adatechnology/game-audio";
+var blast2 = (gain) => ({ bus: "world", gain, falloff: BLAST_FALLOFF, cutoffK: 6e-3, priority: 3 });
+var fire = (gain, group) => ({ bus: "world", gain, falloff: FIRE_FALLOFF, cutoffK: 0.01, ...group ? { group } : {} });
+var BLAST_FIRE_SAMPLES = {
+  explosion_grenade: blast2(1),
+  explosion_big: blast2(1),
+  explosion_car: blast2(1),
+  explosion_flashbang: blast2(1),
+  molotov_break_ignite: blast2(0.8),
+  // the far takes are already muffled: no extra distance lowpass
+  explosion_far: { bus: "world", gain: 1, falloff: BLAST_FAR_FALLOFF, cutoffK: 0, priority: 2 },
+  fire_ignite: fire(0.8, "fire_ignite"),
+  fire_crackle: fire(0.8, "fire_crackle"),
+  fire_pop: fire(0.6, "fire_crackle"),
+  fire_extinguish: fire(0.7),
+  gas_leak: fire(0.5),
+  // the roar: recorded fires chained with a crossfade (the level comes from `createDestructionSound`, by how much burns)
+  fire_loop: { bus: "world", gain: 4, loop: { crossfade: 1 } }
+};
+function blastFireSampleBank(manifest, options = {}) {
+  const sounds = options.sounds ?? BLAST_FIRE_SAMPLES;
+  const bank = sampleBankFromManifest(manifest, { id: options.id ?? "destruction-samples", ...options.baseUrl === void 0 ? {} : { baseUrl: options.baseUrl }, sounds });
+  const samples = (bank.samples ?? []).map((sample) => {
+    const loop = sounds[sample.id]?.loop;
+    return loop === void 0 ? sample : { ...sample, loop };
+  });
+  return { ...bank, samples };
+}
 export {
+  BIG_BLAST_RADIUS,
+  BLAST_FALLOFF,
+  BLAST_FAR_DISTANCE,
+  BLAST_FAR_FALLOFF,
+  BLAST_FIRE_SAMPLES,
+  BLAST_KINDS,
+  BLAST_KIND_OF,
+  BLAST_SOUNDS,
+  BLAST_SOUND_OF,
   BURN_LOOP,
+  DEFAULT_CRACKLES,
   DEFAULT_FIRE,
+  DEFAULT_INDOOR_CONFINEMENT,
   DESTRUCTION_SOUND_BANK,
   DESTRUCTION_SOUND_KEYS,
   DRAG_SOUNDS,
   EXPLOSION_BOOM,
+  FIRE_FALLOFF,
+  FIRE_LOOP,
+  FIRE_SOUNDS,
+  IMPACT_FAMILY_TAGS,
+  IMPACT_SOUNDS,
+  IMPACT_SOUND_KEYS,
   SCENE_SOUNDS,
+  blastFireSampleBank,
+  breakSoundKeys,
   createDestructionRenderer,
   createDestructionSound,
   dragSoundKey,
   heatColor,
+  impactFamily,
   impactKey,
+  impactSoundKeys,
+  ricochetSoundKeys,
+  shotKey,
   specFromObject3D
 };
 //# sourceMappingURL=index.js.map