@adatechnology/game-destruction-three 0.5.0 → 0.6.0

package/README.md

@@ -7,7 +7,7 @@ physics, loose pieces after a part comes off, and pooled particles (fire, smoke,
 - Nothing is changed in place: geometry and materials are cloned on the first visual change of a mesh, and `restore` / `clear` give the originals back.
 - Blasts and the fires of burning parts are drawn by the effects world of [`@adatechnology/game-vfx`](../game-vfx) (an `explode` event plays `ev.effect ?? 'generic'`, scaled by the radius when it names none). Pass the world the host shares in `vfx`; without it the renderer makes its own world and its own `game-vfx-three` layer and steps them in `update`. Debris, sparks, drips and leaks still use two pooled `THREE.Points` (additive and normal blending), with a soft sprite computed in the shader (no texture asset); they move to the shared sprite pool when `game-vfx` gets one.
 - `three` is a peer dependency used for types only: you pass your own `THREE` instance at runtime.
-- Sounds are not played: you get keys (`impact_metal`, `shatter_glass`, ...) through `onSound`.
+- The renderer plays nothing: you get keys (`impact_metal`, `shatter_glass`, `burn_loop`, `burn_end`, ...) through `onSound`. `createDestructionSound(engine)` is the sound bank for them on a [`@adatechnology/game-audio`](../game-audio) engine: the Cena de Arte's material sounds (clang, wood, glass, crumble, thud, boom...) and the game's explosion thump, a fire loop that follows how many parts burn, and a key table (`style: 'art_scene' | 'game'`, `keys` to replace) so a game changes what each key plays.
 
 Contracts live in [`@adatechnology/game-contracts`](../game-contracts); the types are re-exported here, so existing imports keep working.
 
@@ -155,7 +155,7 @@ heatColor(temperatureC: number): number // 0xRRGGBB, 0 below ~450 C, dark red ~5
 Renderizador three.js para o `@adatechnology/game-destruction`. O núcleo decide o que cada golpe faz e devolve eventos; este pacote desenha: amassados
 nos vértices, furos de bala e rachaduras, carbonização e brilho de calor, derretimento e poças, fragmentos com física leve, peças soltas e partículas
 em pool (fogo, fumaça, faíscas, poeira, cacos, lascas). Geometria e materiais só são clonados na primeira mudança visual de uma malha, e `restore` /
-`clear` devolvem os originais. Os sons não são tocados: o jogo recebe chaves (`impact_metal`, `shatter_glass`, ...) em `onSound`.
+`clear` devolvem os originais. O renderer não toca nada: o jogo recebe chaves (`impact_metal`, `shatter_glass`, `burn_loop`, `burn_end`, ...) em `onSound`; `createDestructionSound(engine)` é o banco de sons delas no `game-audio` (sons dos materiais da Cena de Arte, o estouro do jogo, o laço de fogo e a tabela chave → som, trocável).
 
 Uso: `specFromObject3D(THREE, modelo)` gera a especificação e o mapa parte -> malhas; registre no mundo com `world.add(spec)`, ligue com
 `renderer.bind(id, modelo, { parts })` e chame `world.update(dt)` e `renderer.update(dt)` a cada quadro. Com `quality: 'low'` os orçamentos de

package/dist/index.d.ts

@@ -2,6 +2,8 @@ import * as THREE_NS from 'three';
 import { Vec3, DebrisKind, DestructionWorld, MaterialId, DestructibleSpec } from '@adatechnology/game-destruction';
 export { Quat, Vec3 } from '@adatechnology/game-destruction';
 import { VfxWorld, SpriteKind } from '@adatechnology/game-vfx';
+import { LoopRecipe, SoundBank, SoundRecipe, AudioEngine } from '@adatechnology/game-audio';
+import { Vec3 as Vec3$1 } from '@adatechnology/game-contracts';
 
 /**
  * Public types of @adatechnology/game-destruction-three.
@@ -34,7 +36,7 @@ interface RendererOptions {
     autoSplit?: boolean;
     /** Called when a loose piece is created (the bench registers it as grabbable). */
     onPiece?: (piece: Piece) => void;
-    /** Called when a sound should play; the host maps keys to audio (e.g. `impact_metal`, `shatter_glass`, `ignite`, `explode`). */
+    /** Called when a sound should play; the host maps keys to audio (e.g. `impact_metal`, `shatter_glass`, `ignite`, `explode`). `burn_loop` is sent when a part starts to burn and `burn_end` when it burns out or is put out. */
     onSound?: (key: string, point: Vec3, volume: number) => void;
     /**
      * The effects world that draws blasts and fires. Pass the one the host shares with the other renderers (and step it, through its
@@ -187,7 +189,70 @@ declare function specFromObject3D(THREE: ThreeNamespace, root: Object3D, options
  */
 declare function heatColor(temperatureC: number): number;
 
+/** The art scene's destruction sounds, each with the team name in its `sources`. */
+declare const SCENE_SOUNDS: readonly SoundRecipe[];
+/** The game's explosion thump: a sine from 70 to 28 Hz over 1.2 s, `1.4 / (1 + d² × 0.002)` (jogo L68278). */
+declare const EXPLOSION_BOOM: SoundRecipe;
+/**
+ * The fire loop of the art scene (cena L1316): noise through a 1800 Hz bandpass (Q 0.6) into a gain that starts at 0. The page never raises it, so it is
+ * silent there; here `createDestructionSound` raises it while something burns (the level is the kit's, in `fire`).
+ */
+declare const BURN_LOOP: LoopRecipe;
+declare const DESTRUCTION_SOUND_BANK: SoundBank;
+
+/**
+ * What a sound key plays: the recipe, its params, a scale on the volume the renderer gives, and (optionally) a louder recipe above a volume
+ * (a big blast gets the long boom).
+ */
+type SoundKeyRule = {
+    readonly sound: string;
+    readonly params?: Readonly<Record<string, number>>;
+    readonly volumeScale?: number;
+    readonly above?: {
+        readonly volume: number;
+        readonly sound: string;
+    };
+};
+type DestructionSoundStyle = 'art_scene' | 'game';
+/**
+ * The keys `createDestructionRenderer` sends to `onSound`, mapped to the sounds the teams delivered. The Cena de Arte has a sound for every material
+ * (clang, wood, glass, crumble, thud...); the game has four classes (impact, glass, wood, explosion) and its own explosion thump. Which team sound answers
+ * which key is the kit's choice (the teams call the sounds, not the renderer's keys), so it is data: `keys` replaces any entry.
+ */
+declare const DESTRUCTION_SOUND_KEYS: Readonly<Record<DestructionSoundStyle, Readonly<Record<string, SoundKeyRule>>>>;
+type DestructionSoundOptions = {
+    /** Which team answers the keys (default `art_scene`, the kit mix). `game` falls back to the art scene for the keys the game has no sound for. */
+    readonly style?: DestructionSoundStyle;
+    /** Replaces or adds a key's rule; `null` silences it. */
+    readonly keys?: Readonly<Record<string, SoundKeyRule | null>>;
+    /** The fire loop: the volume each burning part adds and the most it reaches (the page never raises it, so these are the kit's). */
+    readonly fire?: {
+        readonly perFire?: number;
+        readonly max?: number;
+    };
+    /** Burn loop on or off (default on). */
+    readonly burnLoop?: boolean;
+};
+type DestructionSound = {
+    /** Pass to `createDestructionRenderer({ onSound })`. */
+    readonly onSound: (key: string, point: Vec3$1, volume: number) => void;
+    /** The rule a key resolves to, if any. */
+    rule(key: string): SoundKeyRule | undefined;
+    /** Parts burning now. */
+    readonly burning: () => number;
+    dispose(): void;
+};
+declare const DEFAULT_FIRE: {
+    readonly perFire: 0.05;
+    readonly max: 0.2;
+};
+/**
+ * Plays the renderer's sound keys on a game-audio engine: the bank is registered in the engine, a key becomes a positional sound at the point, and
+ * `burn_loop` / `burn_end` (a part starts to burn, a part burns out or is put out) drive one fire loop whose volume follows how many parts burn.
+ */
+declare function createDestructionSound(engine: AudioEngine, options?: DestructionSoundOptions): DestructionSound;
+
 /** Every particle kind the renderer can emit (the game's sprite kinds, see `@adatechnology/game-vfx`). */
 type ParticleKind = SpriteKind;
 
-export { type BindOptions, type DestructionRenderer, type ExplodeOptions, type Mesh, type MeshRange, type Object3D, type PartHint, type ParticleKind, type Piece, type Quality, type RendererOptions, type SpecFromObjectOptions, type SpecFromObjectResult, type ThreeNamespace, createDestructionRenderer, heatColor, specFromObject3D };
+export { BURN_LOOP, type BindOptions, DEFAULT_FIRE, DESTRUCTION_SOUND_BANK, DESTRUCTION_SOUND_KEYS, type DestructionRenderer, type DestructionSound, type DestructionSoundOptions, type DestructionSoundStyle, EXPLOSION_BOOM, type ExplodeOptions, type Mesh, type MeshRange, type Object3D, type PartHint, type ParticleKind, type Piece, type Quality, type RendererOptions, SCENE_SOUNDS, type SoundKeyRule, type SpecFromObjectOptions, type SpecFromObjectResult, type ThreeNamespace, createDestructionRenderer, createDestructionSound, heatColor, specFromObject3D };

package/dist/index.global.js

@@ -23,7 +23,14 @@ var GameDestructionThree = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    BURN_LOOP: () => BURN_LOOP,
+    DEFAULT_FIRE: () => DEFAULT_FIRE,
+    DESTRUCTION_SOUND_BANK: () => DESTRUCTION_SOUND_BANK,
+    DESTRUCTION_SOUND_KEYS: () => DESTRUCTION_SOUND_KEYS,
+    EXPLOSION_BOOM: () => EXPLOSION_BOOM,
+    SCENE_SOUNDS: () => SCENE_SOUNDS,
     createDestructionRenderer: () => createDestructionRenderer,
+    createDestructionSound: () => createDestructionSound,
     heatColor: () => heatColor,
     specFromObject3D: () => specFromObject3D
   });
@@ -5284,9 +5291,9 @@ var GameDestructionThree = (() => {
         this.color[i3] = lerp4(this.rgbStart[i3], this.rgbEnd[i3], t);
         this.color[i3 + 1] = lerp4(this.rgbStart[i3 + 1], this.rgbEnd[i3 + 1], t);
         this.color[i3 + 2] = lerp4(this.rgbStart[i3 + 2], this.rgbEnd[i3 + 2], t);
-        let envelope = t < def.fadeIn ? t / def.fadeIn : 1 - (t - def.fadeIn) / (1 - def.fadeIn);
-        if (def.flicker) envelope *= 1 - def.flicker * (0.5 + 0.5 * Math.sin(age * 38 + this.seed[i] * 50));
-        this.alpha[i] = clamp4(envelope, 0, 1) * def.alpha * this.alphaMul[i];
+        let envelope2 = t < def.fadeIn ? t / def.fadeIn : 1 - (t - def.fadeIn) / (1 - def.fadeIn);
+        if (def.flicker) envelope2 *= 1 - def.flicker * (0.5 + 0.5 * Math.sin(age * 38 + this.seed[i] * 50));
+        this.alpha[i] = clamp4(envelope2, 0, 1) * def.alpha * this.alphaMul[i];
         top = i + 1;
       }
       this.high = top;
@@ -8143,9 +8150,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   // src/ground.ts
   var MAX_RADIUS = 1.2;
   var GroundSpots = class {
-    constructor(THREE, scene, groundAt, cap) {
+    constructor(THREE, scene2, groundAt, cap) {
       __publicField(this, "THREE", THREE);
-      __publicField(this, "scene", scene);
+      __publicField(this, "scene", scene2);
       __publicField(this, "groundAt", groundAt);
       __publicField(this, "cap", cap);
       __publicField(this, "spots", []);
@@ -8547,9 +8554,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
 
   // src/rebar.ts
   var RebarCages = class {
-    constructor(THREE, scene, radius = 4e-3) {
+    constructor(THREE, scene2, radius = 4e-3) {
       __publicField(this, "THREE", THREE);
-      __publicField(this, "scene", scene);
+      __publicField(this, "scene", scene2);
       __publicField(this, "cages", /* @__PURE__ */ new Map());
       __publicField(this, "geometry");
       __publicField(this, "material");
@@ -10413,10 +10420,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const sy = lerp5(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 noise = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
+        const noise2 = (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 - noise * melt * h * 0.04);
+        arr[i + 1] = Math.max(minY, minY + (work[i + 1] - minY) * sy - noise2 * 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. */
@@ -10741,6 +10748,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "cages");
       __publicField(this, "active", /* @__PURE__ */ new Map());
       __publicField(this, "fires", /* @__PURE__ */ new Map());
+      /** Primed parts burning in the effects world until they go off: their burn loop ends when they are put out. */
+      __publicField(this, "primedBurning", /* @__PURE__ */ new Set());
       __publicField(this, "leaks", []);
       __publicField(this, "homeTags", []);
       __publicField(this, "throttles", /* @__PURE__ */ new Map());
@@ -11082,8 +11091,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         case "primed":
           if (ev.trigger !== "explosion") {
             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("burn_loop", ev.point, 0.5);
           }
           break;
         case "spall":
@@ -11101,16 +11112,20 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           break;
         case "extinguish": {
           const f = this.fires.get(`${ev.object}|${ev.part}`);
+          const primed = this.primedBurning.delete(`${ev.object}|${ev.part}`);
           if (f) {
             this.stopFire(`${ev.object}|${ev.part}`);
             this.vfx.burst("steam", f.point, [0, 1, 0], 14, 1.2);
           }
+          if (f || primed) this.sound("burn_end", f?.point ?? this.rootPoint(ev.object), 0.5);
           this.activate(ev.object, ev.part);
           this.sound("extinguish", f?.point ?? this.rootPoint(ev.object), 0.6);
           break;
         }
         case "burnout": {
           this.stopFire(`${ev.object}|${ev.part}`);
+          this.primedBurning.delete(`${ev.object}|${ev.part}`);
+          this.sound("burn_end", ev.point, 0.5);
           this.vfx.burst("ash", ev.point, [0, 1, 0], 16, 1);
           this.vfx.burst("smoke", ev.point, [0, 1, 0], 6, 0.8, { color: SMOKE_TONES.grey });
           const pv = this.partVis(ev.object, ev.part);
@@ -11152,6 +11167,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           break;
         }
         case "explode":
+          this.primedBurning.delete(`${ev.object}|${ev.part}`);
           this.onExplode(ev);
           break;
         case "destroyed":
@@ -11642,6 +11658,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.fragments.clear();
       this.ground.clear();
       this.cages.clear();
+      this.primedBurning.clear();
       this.vfx.sprites().clear();
       this.ownVfx?.world.clear();
     }
@@ -11670,6 +11687,325 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.disposed = true;
     }
   };
+
+  // ../game-audio/dist/index.js
+  var DISTANCE_CURVES = {
+    /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
+    game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
+    /** The game's `grito`: `1 / (1 + d² × 0.006)`, silent below 0.02 (jogo L62129–62130). */
+    game_scream: { model: "inverse_square", k: 6e-3, minGain: 0.02 },
+    /** The game's `voz`: `1 / (1 + d² × 0.01)`, silent below 0.02 (jogo L62146–62147). */
+    game_voice: { model: "inverse_square", k: 0.01, minGain: 0.02 },
+    /** The game's `boom`: `1.4 / (1 + d² × 0.002)`, never silent (jogo L68280). */
+    game_boom: { model: "inverse_square", k: 2e-3, scale: 1.4 },
+    /** The art scene's `outAt`: `vol / (1 + d² × 0.008)` (cena L1320). */
+    art_scene: { model: "inverse_square", k: 8e-3 },
+    /** The game's animal calls: `max(0, 1 − d / 70) × 0.25`, silent at or below 0.005 (jogo L66627–66628). */
+    animals: { model: "linear", range: 70, scale: 0.25, minGain: 5e-3 }
+  };
+  var mix_profiles_default = [
+    {
+      id: "game",
+      master: 0.5,
+      noise: { seconds: 1.5, create: "lazy" },
+      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
+    },
+    {
+      id: "art_scene",
+      master: 0.85,
+      compressor: { threshold: -12, ratio: 5 },
+      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
+      noise: { seconds: 2, create: "eager" },
+      sources: [
+        "cena:L1308 compressor -12 dB, ratio 5",
+        "cena:L1309 master 0.85",
+        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
+        "cena:L1311 wet 0.4",
+        "cena:L1312 noise 2 s made with the chain"
+      ]
+    }
+  ];
+  var MIX_PROFILES = Object.fromEntries(
+    mix_profiles_default.map((profile) => [profile.id, profile])
+  );
+  var game_sfx_default = {
+    sources: ["jogo:L62089-62107"],
+    note: "The game's sfx table P: [lowpass cutoff Hz, peak gain, seconds]. Played as a noise burst with the game's distance curve (falloff game_sfx) and a 0.05 s tail. Team names in `team`.",
+    classes: [
+      { id: "pistol", team: "pistola", bus: "weapons", cutoff: 1800, gain: 0.9, seconds: 0.18 },
+      { id: "shotgun", team: "escopeta", bus: "weapons", cutoff: 900, gain: 1.2, seconds: 0.35 },
+      { id: "rifle", team: "fuzil", bus: "weapons", cutoff: 1400, gain: 1.1, seconds: 0.28 },
+      { id: "long_rifle", team: "rifle", bus: "weapons", cutoff: 1100, gain: 1.3, seconds: 0.45 },
+      { id: "impact", team: "impacto", bus: "world", cutoff: 2500, gain: 0.25, seconds: 0.05 },
+      { id: "flesh", team: "carne", bus: "world", cutoff: 600, gain: 0.35, seconds: 0.08 },
+      { id: "step", team: "passo", bus: "world", cutoff: 400, gain: 0.08, seconds: 0.05 },
+      { id: "glass", team: "vidro", bus: "world", cutoff: 5e3, gain: 0.5, seconds: 0.3 },
+      { id: "wood", team: "madeira", bus: "world", cutoff: 700, gain: 0.5, seconds: 0.2 },
+      { id: "reload", team: "recarga", bus: "weapons", cutoff: 3e3, gain: 0.15, seconds: 0.06 },
+      { id: "empty", team: "vazio", bus: "weapons", cutoff: 4e3, gain: 0.12, seconds: 0.03 },
+      { id: "explosion", team: "explosao", bus: "world", cutoff: 200, gain: 1.6, seconds: 1.4 }
+    ],
+    fallback: { id: "unknown", team: "(any other name)", bus: "world", cutoff: 1e3, gain: 0.5, seconds: 0.1 }
+  };
+  var GAME_SFX = game_sfx_default;
+  var GAME_SFX_CLASSES = GAME_SFX.classes;
+  var GAME_SFX_FALLBACK = GAME_SFX.fallback;
+  function noiseClassRecipe(row, id = `sfx_${row.id}`) {
+    return {
+      id,
+      bus: row.bus,
+      order: "burst",
+      duration: row.seconds,
+      tail: 0.05,
+      layers: [
+        {
+          source: { kind: "noise", offset: "random" },
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: row.cutoff } }] },
+          envelope: [
+            [0, row.gain, "set"],
+            ["1d", 1e-3, "exp", "fixed"]
+          ]
+        }
+      ],
+      falloff: DISTANCE_CURVES.game_sfx,
+      sources: [...GAME_SFX.sources.map((source) => `${source} ${row.team}`)]
+    };
+  }
+  var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
+  var BENCH_BANK = {
+    id: "audio_bench",
+    sounds: [
+      {
+        id: "bench_ping",
+        bus: "ui",
+        pan: true,
+        duration: 0.25,
+        layers: [
+          {
+            gain: 0.5,
+            wet: 0.3,
+            source: { kind: "osc", wave: "sine", frequency: { from: 880 } },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a 880 Hz ping through the art scene output stage"]
+      },
+      {
+        id: "bench_hiss",
+        bus: "ui",
+        pan: true,
+        duration: [0.3, 0.9],
+        layers: [
+          {
+            gain: 0.4,
+            source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+            filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 3e3 }, q: 0.7 }] },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a highpass hiss of random length"]
+      }
+    ]
+  };
+
+  // src/audio/recipes.ts
+  var ATTACK = 2e-3;
+  var lengthOf = (d, attack) => {
+    if (typeof d === "number") return attack + d;
+    if (Array.isArray(d)) return [attack + d[0], attack + d[1]];
+    return { ...d, add: (d.add ?? 0) + attack };
+  };
+  var envelope = (attack) => [
+    [0, 1e-4, "set", "fixed"],
+    [attack, 1, "exp"],
+    ["1d", 1e-4, "exp", "fixed"]
+  ];
+  function noise(o) {
+    const a = o.a ?? ATTACK;
+    const over = typeof o.d === "number" ? o.d : 0;
+    return {
+      filters: {
+        mode: "serial",
+        bank: [{ type: o.type ?? "lowpass", frequency: o.f2 === void 0 ? { set: o.f } : { set: o.f, to: o.f2, curve: "exp", over }, q: o.q ?? 0.7 }]
+      },
+      duration: lengthOf(o.d, a),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+      envelope: envelope(a)
+    };
+  }
+  function tone(o) {
+    return {
+      source: { kind: "osc", wave: o.wave ?? "sine", frequency: { from: o.f, to: o.f2 ?? "from", curve: "exp", over: "duration" } },
+      duration: lengthOf(o.d, ATTACK),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      envelope: envelope(ATTACK)
+    };
+  }
+  var many = (count, make) => Array.from({ length: count }, make);
+  var scene = (id, layers, line, vars) => ({
+    id,
+    bus: "world",
+    pan: true,
+    layers,
+    falloff: DISTANCE_CURVES.art_scene,
+    ...vars ? { vars } : {},
+    sources: [`cena:${line}`]
+  });
+  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] }))
+  ];
+  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] }))],
+      "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 })],
+      "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(
+      "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] }))],
+      "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 }),
+    // `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("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")
+  ];
+  var EXPLOSION_BOOM = {
+    id: "explosion_boom",
+    bus: "world",
+    order: "boom",
+    duration: 1.6,
+    tail: 0.1,
+    layers: [
+      {
+        source: { kind: "osc", wave: "sine", frequency: { from: 70, to: 28, curve: "exp", over: 1.2 } },
+        envelope: [
+          [0, 1, "set"],
+          ["1d", 1e-3, "exp", "fixed"]
+        ]
+      }
+    ],
+    falloff: DISTANCE_CURVES.game_boom,
+    sources: ["jogo:L68278-68285 boom"]
+  };
+  var BURN_LOOP = {
+    id: "burn_loop",
+    bus: "world",
+    order: "chain_loop",
+    source: { kind: "noise", loop: true },
+    filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: 1800 }, q: 0.6 }] },
+    volume: 0,
+    sources: ["cena:L1316 fire loop (silent in the page: its gain is never raised)", "sdk: the level while burning"]
+  };
+  var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
+
+  // src/audio/sound.ts
+  var DESTRUCTION_SOUND_KEYS = {
+    art_scene: {
+      impact_metal: { sound: "clang" },
+      impact_wood: { sound: "wood_hit" },
+      impact_glass: { sound: "ping" },
+      impact_masonry: { sound: "chip" },
+      impact_soft: { sound: "thud" },
+      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" },
+      melt_sizzle: { sound: "hiss", params: { seconds: 0.6 } },
+      explode: { sound: "boom", above: { volume: 0.9, sound: "boom_big" } }
+    },
+    game: {
+      impact_metal: { sound: "sfx_impact" },
+      impact_wood: { sound: "sfx_wood" },
+      impact_glass: { sound: "sfx_glass" },
+      impact_masonry: { sound: "sfx_impact" },
+      impact_soft: { sound: "sfx_flesh" },
+      shatter_glass: { sound: "sfx_glass" },
+      crumble: { sound: "sfx_impact" },
+      splinter: { sound: "sfx_wood" },
+      explode: { sound: "explosion_boom" }
+    }
+  };
+  var DEFAULT_FIRE = { perFire: 0.05, max: 0.2 };
+  function createDestructionSound(engine, options = {}) {
+    engine.register(DESTRUCTION_SOUND_BANK);
+    engine.register(GAME_SFX_BANK);
+    const fire = { ...DEFAULT_FIRE, ...options.fire };
+    const rules = { ...DESTRUCTION_SOUND_KEYS.art_scene, ...options.style === "game" ? DESTRUCTION_SOUND_KEYS.game : {}, ...options.keys };
+    let loop;
+    let burning = 0;
+    const setFire = () => {
+      if (options.burnLoop === false) return;
+      if (burning <= 0) {
+        loop?.stop();
+        loop = void 0;
+        return;
+      }
+      loop ?? (loop = engine.loop("burn_loop"));
+      loop.set({ volume: Math.min(fire.max, fire.perFire * burning) });
+    };
+    return {
+      onSound(key, point, volume) {
+        if (key === "burn_loop") {
+          burning += 1;
+          setFire();
+          return;
+        }
+        if (key === "burn_end") {
+          if (burning > 0) burning -= 1;
+          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 } : {} });
+      },
+      rule: (key) => rules[key] ?? void 0,
+      burning: () => burning,
+      dispose() {
+        loop?.stop();
+        loop = void 0;
+        burning = 0;
+      }
+    };
+  }
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map