@adatechnology/game-destruction-three 0.7.1 → 0.7.3

package/dist/index.global.js

@@ -1361,77 +1361,77 @@ var GameDestructionThree = (() => {
     }));
   }
   function spawnPuff(pool, random, init) {
-    const puff2 = pool.acquire();
-    puff2.x = init.x ?? 0;
-    puff2.y = init.y ?? 0;
-    puff2.z = init.z ?? 0;
-    puff2.vx = init.vx ?? 0;
-    puff2.vy = init.vy ?? 0;
-    puff2.vz = init.vz ?? 0;
-    puff2.s0 = init.s0 ?? 0.2;
-    puff2.s1 = init.s1 ?? 1;
-    puff2.sg = init.sg ?? 0.1;
-    puff2.gk = init.gk ?? 6;
-    puff2.life = init.life ?? 3;
-    puff2.t = 0;
-    puff2.h0 = init.h0 ?? 0;
-    puff2.hl = init.hl ?? 0.4;
-    puff2.drag = init.drag ?? 3;
-    puff2.buoy = init.buoy ?? 0.5;
-    puff2.grav = init.grav ?? 0;
-    puff2.kind = init.kind ?? 0;
-    puff2.seed = random.next();
-    puff2.wind = init.wind ?? 1;
-    puff2.color = init.color ?? SMOKE_COLORS.grey;
-    puff2.ring = init.ring ?? null;
-    puff2.ph = init.ph ?? 0;
-    puff2.th = init.th ?? 0;
-    puff2.rng = random;
-    puff2.age = 0;
-    puff2.heat = 0;
-    puff2.size = 0;
-    return puff2;
-  }
-  function ageOrKeep2(puff2, dt) {
-    puff2.t += dt;
-    return puff2.t < puff2.life;
-  }
-  function moveOnRing(puff2, ring2, wind) {
+    const puff3 = pool.acquire();
+    puff3.x = init.x ?? 0;
+    puff3.y = init.y ?? 0;
+    puff3.z = init.z ?? 0;
+    puff3.vx = init.vx ?? 0;
+    puff3.vy = init.vy ?? 0;
+    puff3.vz = init.vz ?? 0;
+    puff3.s0 = init.s0 ?? 0.2;
+    puff3.s1 = init.s1 ?? 1;
+    puff3.sg = init.sg ?? 0.1;
+    puff3.gk = init.gk ?? 6;
+    puff3.life = init.life ?? 3;
+    puff3.t = 0;
+    puff3.h0 = init.h0 ?? 0;
+    puff3.hl = init.hl ?? 0.4;
+    puff3.drag = init.drag ?? 3;
+    puff3.buoy = init.buoy ?? 0.5;
+    puff3.grav = init.grav ?? 0;
+    puff3.kind = init.kind ?? 0;
+    puff3.seed = random.next();
+    puff3.wind = init.wind ?? 1;
+    puff3.color = init.color ?? SMOKE_COLORS.grey;
+    puff3.ring = init.ring ?? null;
+    puff3.ph = init.ph ?? 0;
+    puff3.th = init.th ?? 0;
+    puff3.rng = random;
+    puff3.age = 0;
+    puff3.heat = 0;
+    puff3.size = 0;
+    return puff3;
+  }
+  function ageOrKeep2(puff3, dt) {
+    puff3.t += dt;
+    return puff3.t < puff3.life;
+  }
+  function moveOnRing(puff3, ring2, wind) {
     const ringTime = ring2.t;
     const centerY = ring2.y0 + ring2.rise * (1 - Math.exp(-ringTime * ring2.rk));
     const majorRadius = ring2.R0 + (ring2.R1 - ring2.R0) * (1 - Math.exp(-ringTime * 1.6));
-    const theta = puff2.th + ringTime * ring2.roll;
+    const theta = puff3.th + ringTime * ring2.roll;
     const minorRadius = ring2.r * (0.8 + 0.4 * Math.min(1, ringTime));
     const radius = majorRadius + minorRadius * Math.cos(theta);
-    puff2.x = ring2.x + Math.cos(puff2.ph) * radius + wind.x * ringTime * 0.6;
-    puff2.z = ring2.z + Math.sin(puff2.ph) * radius + wind.z * ringTime * 0.6;
-    puff2.y = centerY + minorRadius * Math.sin(theta);
-  }
-  function moveFree(puff2, dt, age, heat, wind) {
-    const damping = Math.exp(-puff2.drag * dt);
-    puff2.vx *= damping;
-    puff2.vy *= damping;
-    puff2.vz *= damping;
-    puff2.vy += (puff2.buoy * (heat > 0 ? 1.6 : 1) - puff2.grav) * dt;
-    puff2.x += (puff2.vx + wind.x * puff2.wind * age) * dt;
-    puff2.y += puff2.vy * dt;
-    puff2.z += (puff2.vz + wind.z * puff2.wind * age) * dt;
-    if (puff2.y < puff2.s0 * FLOOR_FRACTION) {
-      puff2.y = puff2.s0 * FLOOR_FRACTION;
-      if (puff2.vy < 0) puff2.vy *= FLOOR_BOUNCE;
+    puff3.x = ring2.x + Math.cos(puff3.ph) * radius + wind.x * ringTime * 0.6;
+    puff3.z = ring2.z + Math.sin(puff3.ph) * radius + wind.z * ringTime * 0.6;
+    puff3.y = centerY + minorRadius * Math.sin(theta);
+  }
+  function moveFree(puff3, dt, age, heat, wind) {
+    const damping = Math.exp(-puff3.drag * dt);
+    puff3.vx *= damping;
+    puff3.vy *= damping;
+    puff3.vz *= damping;
+    puff3.vy += (puff3.buoy * (heat > 0 ? 1.6 : 1) - puff3.grav) * dt;
+    puff3.x += (puff3.vx + wind.x * puff3.wind * age) * dt;
+    puff3.y += puff3.vy * dt;
+    puff3.z += (puff3.vz + wind.z * puff3.wind * age) * dt;
+    if (puff3.y < puff3.s0 * FLOOR_FRACTION) {
+      puff3.y = puff3.s0 * FLOOR_FRACTION;
+      if (puff3.vy < 0) puff3.vy *= FLOOR_BOUNCE;
     }
   }
   function updatePuffs(pool, dt, wind) {
     pool.compact(ageOrKeep2, dt);
-    for (const puff2 of pool.items) {
-      const age = puff2.t / puff2.life;
-      const heat = puff2.h0 > 0 ? puff2.h0 * Math.pow(Math.max(0, 1 - puff2.t / puff2.hl), 1.25) : 0;
-      if (puff2.ring) moveOnRing(puff2, puff2.ring, wind);
-      else moveFree(puff2, dt, age, heat, wind);
-      const size = puff2.s0 + (puff2.s1 - puff2.s0) * (1 - Math.exp(-puff2.t * puff2.gk)) + puff2.sg * Math.min(puff2.t, GROWTH_CAP_SECONDS);
-      puff2.size = size * Math.min(1, puff2.t * ARRIVAL_FRAME + ARRIVAL_BASE);
-      puff2.age = age;
-      puff2.heat = heat;
+    for (const puff3 of pool.items) {
+      const age = puff3.t / puff3.life;
+      const heat = puff3.h0 > 0 ? puff3.h0 * Math.pow(Math.max(0, 1 - puff3.t / puff3.hl), 1.25) : 0;
+      if (puff3.ring) moveOnRing(puff3, puff3.ring, wind);
+      else moveFree(puff3, dt, age, heat, wind);
+      const size = puff3.s0 + (puff3.s1 - puff3.s0) * (1 - Math.exp(-puff3.t * puff3.gk)) + puff3.sg * Math.min(puff3.t, GROWTH_CAP_SECONDS);
+      puff3.size = size * Math.min(1, puff3.t * ARRIVAL_FRAME + ARRIVAL_BASE);
+      puff3.age = age;
+      puff3.heat = heat;
     }
   }
   var GROUND_LIFT = 0.02;
@@ -1488,9 +1488,9 @@ var GameDestructionThree = (() => {
   var HOT_GLOW_COLOR = [1, 0.45, 0.12];
   function addPuff(core, random, init) {
     core.spawned.puffs++;
-    const puff2 = spawnPuff(core.puffs, random, init);
-    core.trace?.puff?.(puff2);
-    return puff2;
+    const puff3 = spawnPuff(core.puffs, random, init);
+    core.trace?.puff?.(puff3);
+    return puff3;
   }
   function addSpark(core, init) {
     core.spawned.sparks++;
@@ -1672,6 +1672,7 @@ var GameDestructionThree = (() => {
   var neg = call("neg");
   var abs = call("abs");
   var sqrt = call("sqrt");
+  var exp = call("exp");
   var sin = call("sin");
   var cos = call("cos");
   var atan2 = call("atan2");
@@ -1717,10 +1718,12 @@ var GameDestructionThree = (() => {
   var INDEX = { $: "index" };
   var QUALITY = { $: "quality" };
   var FRESH = { $: "fresh" };
+  var DIRECTION = { $: "direction" };
   var CAMERA_POSITION = { $: "cameraPosition" };
   var burst = (system, count, spawn2) => ({ op: "burst", system, count, spawn: spawn2 });
   var spawn = (system, options) => ({ op: "spawn", system, spawn: options });
   var emit = (key, system, rate, options) => ({ op: "emit", key, system, rate, spawn: options });
+  var mesh = (options) => ({ op: "mesh", spawn: options });
   var debris = (options) => ({ op: "debris", spawn: options });
   var decal = (...args) => ({ op: "decal", args });
   var ring = (...args) => ({ op: "ring", args });
@@ -2732,6 +2735,241 @@ var GameDestructionThree = (() => {
       )
     ]
   };
+  var SPOTS_X = [-3, 1, 5];
+  var SPOTS_Z = [-1, -2.4, 0.4];
+  var FOG_AND_ASH = {
+    id: "fog_and_ash",
+    pageId: "neblina",
+    team: "world",
+    budget: { particles: 120, lights: 1 },
+    loop: 0,
+    view: { eye: [3, 1.8, 7.5], target: [-3, 1.2, -1] },
+    setup: [
+      cue("fog", { density: 0.075 }),
+      cue("lamp_cone", { visible: true }),
+      cue("zombie_visible", { index: -1, visible: false }),
+      repeat(
+        SPOTS_X.length,
+        set("turn", rnd(-0.6, 0.6)),
+        behavior("walkers", "place", { index: INDEX, x: pick(SPOTS_X, INDEX), z: pick(SPOTS_Z, INDEX), facing: variable("turn") })
+      )
+    ],
+    timeline: [],
+    tick: [
+      emit("fog", "normal", 5, { p: [rnd(-14, 10), rnd(0.2, 1.1), rnd(-3, 8)], v: [rnd(0.15, 0.35), 0, rnd(-0.05, 0.05)], sp: 0, life: [9, 13], size: [3, 5], grow: 1.4, c0: 8227488, a: 0.13, fi: 0.35 }),
+      emit("ash", "normal", 14, { p: [rnd(-10, 8), rnd(4, 6), rnd(-3, 7)], v: [rnd(0.1, 0.4), -0.35, rnd(-0.1, 0.1)], sp: [0.05, 0.15], life: [8, 12], size: [0.025, 0.04], c0: 10525328, a: 0.75, fi: 0.1, gnd: 1 })
+    ]
+  };
+  var RAIN_CAPACITY = 4e3;
+  var FALL_SPEED = 15;
+  var WIND_PER_FALL = 0.07;
+  var STREAK_SLANT = 0.04;
+  var STREAK_LENGTH = 0.6;
+  var BOX_X = [-15, 15];
+  var BOX_Z = [-6, 16];
+  var START_HEIGHT = [0, 16];
+  var REENTRY_HEIGHT = [14, 17];
+  var SPLASH_CHANCE = 0.35;
+  var SPLASH_RANGE = 12;
+  var SPRITE_CHANCE = 0.5;
+  var UP9 = [0, 1, 0];
+  var WORKSHOP_PUDDLES = [
+    [-1.5, 2.2, 1.6, 0.9],
+    [3, 3.6, 1.1, 0.7],
+    [-6, 3.2, 1.3, 0.8],
+    [1.4, -2.2, 0.9, 0.5]
+  ];
+  var inPuddle = (puddles, x, z) => puddles.some((p) => ((x - p[0]) / p[2]) ** 2 + ((z - p[1]) / p[3]) ** 2 < 1);
+  var RainField = class {
+    constructor(engine) {
+      __publicField2(this, "engine", engine);
+      __publicField2(this, "positions", new Float32Array(RAIN_CAPACITY * 6));
+      __publicField2(this, "count", 0);
+      __publicField2(this, "wind", 1);
+      __publicField2(this, "on", false);
+      __publicField2(this, "centerX", 0);
+      __publicField2(this, "centerZ", 0);
+      __publicField2(this, "puddles", WORKSHOP_PUDDLES);
+      __publicField2(this, "puddleAt");
+    }
+    /** `initRain` (W321): `count` streaks (thinned by the quality), each drawn at a random place in the box. */
+    init(count, wind) {
+      const { random } = this.engine;
+      this.count = Math.min(RAIN_CAPACITY, Math.round(count * this.engine.context.quality.mult));
+      this.wind = wind;
+      this.on = true;
+      for (let index = 0; index < this.count; index++) {
+        const offset = index * 6;
+        const x = random.between(BOX_X[0], BOX_X[1]);
+        const y = random.between(START_HEIGHT[0], START_HEIGHT[1]);
+        const z = random.between(BOX_Z[0], BOX_Z[1]);
+        this.set(offset, x, y, z);
+      }
+    }
+    /**
+     * What a game does with the field every frame: the box follows the camera (`centerX`, `centerZ`), the streaks thin or thicken to `count` (a new streak
+     * starts at a random place of the box, as `init` draws it) and the wind slants them. The golden never calls it.
+     */
+    drive(count, wind, centerX, centerZ) {
+      const { random } = this.engine;
+      const target = Math.max(0, Math.min(RAIN_CAPACITY, Math.round(count * this.engine.context.quality.mult)));
+      this.wind = wind;
+      this.centerX = centerX;
+      this.centerZ = centerZ;
+      this.on = target > 0;
+      for (let index = this.count; index < target; index++) {
+        this.set(index * 6, random.between(BOX_X[0], BOX_X[1]) + centerX, random.between(START_HEIGHT[0], START_HEIGHT[1]), random.between(BOX_Z[0], BOX_Z[1]) + centerZ);
+      }
+      this.count = target;
+    }
+    /** `updateRain` (W322-329). `camera` is where the eye is; `splash` lets the drops that land leave a splash. */
+    update(dt, splash, camera2) {
+      if (!this.on) return;
+      const { random, context } = this.engine;
+      const positions = this.positions;
+      const fall = FALL_SPEED * dt;
+      const slant = this.wind * fall * WIND_PER_FALL;
+      const reach = SPLASH_RANGE / (1 + context.quality.level);
+      for (let index = 0; index < this.count; index++) {
+        const o = index * 6;
+        positions[o] += slant;
+        positions[o + 3] += slant;
+        positions[o + 1] -= fall;
+        positions[o + 4] -= fall;
+        const ground = context.groundAt(positions[o], positions[o + 2]);
+        if (positions[o + 4] < ground) {
+          const x = positions[o];
+          const z = positions[o + 2];
+          if (splash && random.next() < SPLASH_CHANCE) {
+            const distance = Math.hypot(x - camera2[0], z - camera2[2]);
+            if (distance < reach) {
+              if (random.next() < SPRITE_CHANCE) {
+                this.engine.spawn("normal", { p: [x, ground + 0.01, z], dir: UP9, cone: 0.6, sp: [0.6, 1.3], life: [0.18, 0.3], size: 0.035, c0: 12110044, a: 0.6, g: 9.8, fi: 0 });
+              }
+              if (this.puddleAt ? this.puddleAt(x, z) : inPuddle(this.puddles, x, z)) {
+                this.engine.ring([[x, ground + 0.012, z], 0.01, random.between(0.12, 0.25), random.between(0.4, 0.6), 6978192]);
+              }
+            }
+          }
+          const nx = random.between(BOX_X[0], BOX_X[1]) + this.centerX;
+          const ny = random.between(REENTRY_HEIGHT[0], REENTRY_HEIGHT[1]);
+          const nz = random.between(BOX_Z[0], BOX_Z[1]) + this.centerZ;
+          this.set(o, nx, ny, nz);
+        }
+      }
+    }
+    /** `rain.visible = false; RN.on = false` (W440): the field stops; the streaks stay where they were. */
+    clear() {
+      this.on = false;
+    }
+    set(offset, x, y, z) {
+      const positions = this.positions;
+      positions[offset] = x;
+      positions[offset + 1] = y;
+      positions[offset + 2] = z;
+      positions[offset + 3] = x + this.wind * STREAK_SLANT;
+      positions[offset + 4] = y - STREAK_LENGTH;
+      positions[offset + 5] = z;
+    }
+  };
+  var DROPS = [900, 2200, 4e3];
+  var SLANT = [0.3, 1.2, 4.5];
+  var STORM = 2;
+  var FLASH_STEPS = ite(lt(variable("flash"), 0.08), 1, ite(lt(variable("flash"), 0.16), 0.2, ite(lt(variable("flash"), 0.26), 0.8, 0)));
+  var RAIN_AND_PUDDLES = {
+    id: "rain_and_puddles",
+    pageId: "chuva",
+    team: "world",
+    params: { id: "intensity", options: ["drizzle", "rain", "storm"], default: 1 },
+    budget: { particles: 4e3, decals: 4 },
+    loop: 0,
+    view: { eye: [2, 2, 7], target: [-1, 0.6, 1] },
+    setup: [
+      cue("lamp_cone", { visible: true }),
+      ...WORKSHOP_PUDDLES.map(([x, z, radiusX, radiusZ]) => decal(x, 0, z, radiusX * 2, 790550, { grow: 0, life: 1e6, ar: radiusZ / radiusX }))
+    ],
+    timeline: [
+      behavior("rain", "init", { count: ite(eq(PARAM, 0), DROPS[0], ite(eq(PARAM, 1), DROPS[1], DROPS[2])), wind: ite(eq(PARAM, 0), SLANT[0], ite(eq(PARAM, 1), SLANT[1], SLANT[2])) }),
+      set("nextStrike", rnd(2, 4)),
+      set("flash", -1)
+    ],
+    tick: [
+      behavior("rain", "update", { dt: DELTA, splash: gt(PARAM, 0) }),
+      when(eq(PARAM, STORM), [
+        when(gt(TIME, variable("nextStrike")), [set("nextStrike", add(TIME, rnd(3.5, 6))), set("flash", 0)]),
+        when(ge(variable("flash"), 0), [
+          set("flash", add(variable("flash"), DELTA)),
+          set("light", FLASH_STEPS),
+          cue("lightning", { intensity: variable("light") }),
+          screen({ max: { white: mul(variable("light"), 0.12) } }),
+          when(gt(variable("flash"), 0.4), [set("flash", -1), cue("lightning", { intensity: 0 })])
+        ]),
+        emit("sheet", "normal", 2.5, { p: [-12, 2.5, rnd(-1, 8)], box: [0, 2, 0], v: [7, -0.5, 0], sp: 0, life: [3, 4], size: [3, 5], grow: 1.3, c0: 9083568, a: 0.06, fi: 0.3 })
+      ])
+    ]
+  };
+  var CAR_ORIGIN2 = [5.6, 0, 0.8];
+  var CAR_ROTATION2 = [0, -0.4, 0];
+  var carPoint = (x, y, z) => localToWorld(CAR_ORIGIN2, CAR_ROTATION2, [x, y, z]);
+  var carDirection = (from, to) => normalized([to[0] - from[0], to[1] - from[1], to[2] - from[2]]);
+  var BEAM_FROM = carPoint(0, 0.74, 2.15);
+  var BEAM_DIRECTION = carDirection(BEAM_FROM, carPoint(0, 0.74, 3.15));
+  var BEAM_SIDE = [BEAM_DIRECTION[2], 0, -BEAM_DIRECTION[0]];
+  var WALKERS = 6;
+  var WALK_SPEED2 = 0.7;
+  var DROPS2 = 1800;
+  var SLANT2 = 0.8;
+  var startWalking = [
+    set("spot", query("car", "point", rnd(-2, 2), 0, rnd(8, 18))),
+    set("goal", query("car", "point", rnd(-0.6, 0.6), 0, 2.6)),
+    behavior("walkers", "place", { index: INDEX, x: pick(variable("spot"), 0), z: pick(variable("spot"), 2), facing: 0 }),
+    behavior("walkers", "walk", { index: INDEX, to: variable("goal"), speed: WALK_SPEED2 })
+  ];
+  var HEADLIGHTS_IN_RAIN = {
+    id: "headlights_in_rain",
+    pageId: "farol",
+    team: "vehicles",
+    budget: { particles: 600, lights: 2 },
+    loop: 0,
+    view: { eye: [-2.5, 2, 5.5], target: [4, 1, 6] },
+    setup: [
+      cue("fog", { density: 0.05 }),
+      cue("headlights", { on: true, intensity: 2.4, color: 16773584 }),
+      behavior("rain", "init", { count: DROPS2, wind: SLANT2 }),
+      repeat(WALKERS, ...startWalking)
+    ],
+    timeline: [],
+    tick: [
+      behavior("rain", "update", { dt: DELTA, splash: true }),
+      emit(
+        "lit",
+        "streak",
+        600,
+        local(
+          "depth",
+          rnd(1, 13),
+          local(
+            "spread",
+            mul(variable("depth"), 0.33, sqrt(rand())),
+            local(
+              "turn",
+              rnd(0, 6.283),
+              local("base", vadd(BEAM_FROM, vscale(BEAM_DIRECTION, variable("depth")), vscale(BEAM_SIDE, mul(cos(variable("turn")), variable("spread")))), {
+                p: vwith(variable("base"), 1, add(vy(variable("base")), mul(sin(variable("turn")), variable("spread"), 0.6))),
+                v: [0.8, -14, 0],
+                sp: 0,
+                life: 0.06,
+                len: 0.035,
+                c0: 13622512,
+                a: 0.9
+              })
+            )
+          )
+        )
+      ),
+      repeat(WALKERS, when(not(query("walkers", "is_walking", INDEX)), startWalking))
+    ]
+  };
   var YAW = -Math.PI / 2;
   var COS = Math.cos(YAW);
   var SIN = Math.sin(YAW);
@@ -2759,10 +2997,6 @@ var GameDestructionThree = (() => {
       fireLight(0, [vx(variable("contact")), 0.34, vz(variable("contact"))], 1.6, mul(TIME, 3))
     ]
   };
-  var CAR_ORIGIN2 = [5.6, 0, 0.8];
-  var CAR_ROTATION2 = [0, -0.4, 0];
-  var carPoint = (x, y, z) => localToWorld(CAR_ORIGIN2, CAR_ROTATION2, [x, y, z]);
-  var carDirection = (from, to) => normalized([to[0] - from[0], to[1] - from[1], to[2] - from[2]]);
   var HOOD = carPoint(0, 1.02, 1.4);
   var EXHAUST = carPoint(0.5, 0.3, -2.2);
   var EXHAUST_DIRECTION = carDirection(EXHAUST, carPoint(0.5, 0.3, -3));
@@ -2796,7 +3030,7 @@ var GameDestructionThree = (() => {
       ], [fireLightOff(0)])
     ]
   };
-  var UP9 = [0, 1, 0];
+  var UP10 = [0, 1, 0];
   var doorVelocity = (side) => {
     const out = carPoint(side * 4, 3, 0.3);
     const centre = carPoint(0, 0, 0.3);
@@ -2806,7 +3040,7 @@ var GameDestructionThree = (() => {
     call2("explode", vadd(query("car", "position"), [0, 0.6, 0]), 1.8, 2759188),
     cue("car_burnt"),
     behavior("car", "launch", { rise: 4.5, spin: 0.9 }),
-    repeat(scaled(30), debris({ p: vadd(query("car", "position"), [0, 1.3, 0]), dir: UP9, cone: 1.3, sp: [2, 6], size: [0.06, 6e-3, 0.06], c: 11061464, life: 20 })),
+    repeat(scaled(30), debris({ p: vadd(query("car", "position"), [0, 1.3, 0]), dir: UP10, cone: 1.3, sp: [2, 6], size: [0.06, 6e-3, 0.06], c: 11061464, life: 20 })),
     debris({ p: carPoint(0, 1, 1.4), v: [rnd(-1, 1), 9, rnd(-1, 1)], sp: 0, size: [1.6, 0.06, 1.2], c: 3808536, spin: 6, life: 20, bounce: 0.2 }),
     ...[-1, 1].map((side) => debris({ p: carPoint(side * 0.95, 0.7, 0.3), v: doorVelocity(side), sp: 0, size: [0.06, 0.7, 1.1], c: 3808536, spin: 5, life: 20, bounce: 0.2 })),
     debris({ p: carPoint(0.95, 0.38, 1.35), v: [3, 4, 2], sp: 0, size: [0.3, 0.76, 0.76], c: 1118481, spin: 8, life: 20, bounce: 0.4 })
@@ -2976,7 +3210,7 @@ var GameDestructionThree = (() => {
       ])
     ]
   };
-  var WALKERS = 6;
+  var WALKERS2 = 6;
   var NEAR = 9;
   var RANGE = 7;
   var RESTING_BPM = 70;
@@ -2992,7 +3226,7 @@ var GameDestructionThree = (() => {
     setup: [
       cue("zombie_visible", { index: -1, visible: false }),
       repeat(
-        WALKERS,
+        WALKERS2,
         set("startX", rnd(-4, 4)),
         set("startZ", sub(rnd(-4, -2), mul(INDEX, 0.6))),
         behavior("walkers", "place", { index: INDEX, x: variable("startX"), z: variable("startZ"), facing: 0 }),
@@ -3002,7 +3236,7 @@ var GameDestructionThree = (() => {
     timeline: [],
     tick: [
       set("nearest", 99),
-      repeat(WALKERS, set("nearest", min(variable("nearest"), vdist(walkerPoint, CAMERA_POSITION)))),
+      repeat(WALKERS2, set("nearest", min(variable("nearest"), vdist(walkerPoint, CAMERA_POSITION)))),
       set("fear", clamp(div(sub(NEAR, variable("nearest")), RANGE), 0, 1)),
       set("bpm", add(RESTING_BPM, mul(BPM_RISE, variable("fear")))),
       when(lt(mod(div(mul(TIME, variable("bpm")), 60), 1), div(mul(DELTA, variable("bpm")), 60)), [screen({ set: { beat: add(0.4, mul(0.6, variable("fear"))) } })]),
@@ -3069,7 +3303,7 @@ var GameDestructionThree = (() => {
     ]
   };
   var FACING4 = [0, 0, 1];
-  var UP10 = [0, 1, 0];
+  var UP11 = [0, 1, 0];
   var ORIGIN = [0, 0, 0];
   var FORWARD4 = [0, 0, -1];
   var IMPACT_MATERIALS = ["concrete", "metal", "wood", "glass", "flesh", "water"];
@@ -3199,12 +3433,157 @@ var GameDestructionThree = (() => {
       team: "destruction",
       budget: { particles: 20, debris: 8 },
       loop: 2,
-      timeline: [call2("chips", ORIGIN, UP10, 8, 0.9), call2("rust_at", ORIGIN, 6)]
+      timeline: [call2("chips", ORIGIN, UP11, 8, 0.9), call2("rust_at", ORIGIN, 6)]
     }
   ];
-  var ALL_EFFECTS = [BLOOD_HIT, HEADSHOT, DISMEMBER, BLOATER_CLOUD, SCREAMER_SHRIEK, CORPSE_DECAY, REANIMATION, EYES_IN_FOG, MUZZLE_FLASH, IMPACT_BY_MATERIAL, PENETRATION, CASINGS_AND_MAGAZINE, MOLOTOV, GRENADE, EXPLOSIVE_BARREL, SHOPFRONT_GLASS, DOOR_STAGES, BUILDING_COLLAPSE, BLOCK_WALL, METAL_DOOR_EFFECT, IRON_RAILING, WOODEN_FENCE, HIT_POINT_BREAKAGE, PRESSURE_CYLINDERS, BUILDING_FIRE, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
+  var PI = Math.PI;
+  var SMOKE = { color: 9079430, width: 10, height: 8, gravity: -0.08, drag: 2.2, growth: 2.1 };
+  var FLASH_SECONDS = 0.055;
+  var FLASH_RAMP = [0.6, 0.9];
+  var FLASH_OPACITY = 0.95;
+  var FLAME_COLORS = [16742946, 16760896, 13121050, 16773296];
+  var FLAME_ADDITIVE = 3;
+  var ORIGIN2 = [0, 0, 0];
+  var SIZE = variable("size");
+  var wide = (width) => mul(sub(rand(), 0.5), width);
+  var puff2 = (point, velocity, world, radius, life, opacity) => mesh({
+    shape: "sphere",
+    p: point,
+    v: velocity,
+    wv: world,
+    r: radius,
+    seg: SMOKE.width,
+    seg2: SMOKE.height,
+    life,
+    c0: SMOKE.color,
+    a: opacity,
+    fade: true,
+    lit: true,
+    g: SMOKE.gravity,
+    drag: SMOKE.drag,
+    grow: SMOKE.growth
+  });
+  var flameBit = (point, velocity, world, radius, life) => [
+    set("bitPoint", point),
+    set("bitVelocity", velocity),
+    set("bitWorld", world),
+    set("bitRadius", radius),
+    set("bitLife", life),
+    set("bitColour", floor(mul(rand(), FLAME_COLORS.length))),
+    mesh({
+      shape: "icosahedron",
+      p: variable("bitPoint"),
+      v: variable("bitVelocity"),
+      wv: variable("bitWorld"),
+      r: variable("bitRadius"),
+      seg: 1,
+      rot: [mul(rand(), 3), mul(rand(), 3), 0],
+      spin: [3, 4, 2],
+      life: variable("bitLife"),
+      c0: pick(FLAME_COLORS, variable("bitColour")),
+      add: eq(variable("bitColour"), FLAME_ADDITIVE),
+      a: 0.9,
+      fade: true,
+      g: -1.4,
+      drag: 1.4,
+      grow: 2.2
+    })
+  ];
+  var flashPiece = (shape, radius, height, width, at3, rot, color) => mesh({ shape, r: radius, ...height === void 0 ? {} : { h: height }, seg: width, seg2: shape === "sphere" ? 8 : 1, p: ORIGIN2, at: at3, rot, roll: variable("roll"), ramp: FLASH_RAMP, life: FLASH_SECONDS, c0: color, a: FLASH_OPACITY, add: true });
+  var MUZZLE_FLASH2 = {
+    id: "viewmodel_muzzle_flash",
+    pageId: "event:viewmodel_muzzle_flash",
+    team: "weapons",
+    budget: { particles: 12, lights: 1 },
+    loop: 0.1,
+    timeline: [
+      set("angles", []),
+      repeat(4, append("angles", add(div(mul(INDEX, PI), 2), mul(rand(), 0.6)))),
+      set("roll", mul(rand(), PI)),
+      flash(ORIGIN2, 16756832, mul(4, SIZE), FLASH_SECONDS, mul(2, SIZE), true, true),
+      flashPiece("cone_open", mul(0.013, SIZE), mul(0.085, SIZE), 10, [mul(0.042, SIZE), 0, 0], [0, 0, -PI / 2], 16757575),
+      repeat(
+        4,
+        set("angle", pick(variable("angles"), INDEX)),
+        flashPiece(
+          "cone",
+          mul(5e-3, SIZE),
+          mul(0.04, SIZE),
+          6,
+          [mul(0.012, SIZE), mul(cos(variable("angle")), 0.016, SIZE), mul(sin(variable("angle")), 0.016, SIZE)],
+          [variable("angle"), 0, -PI / 2],
+          16757575
+        )
+      ),
+      flashPiece("sphere", mul(0.016, SIZE), void 0, 12, [mul(8e-3, SIZE), 0, 0], [0, 0, 0], 16773568),
+      repeat(
+        6,
+        puff2(
+          ORIGIN2,
+          [add(0.15, mul(rand(), 0.35)), add(0.03, mul(rand(), 0.12)), mul(sub(rand(), 0.5), 0.14)],
+          [0, 0, 0],
+          mul(0.013, SIZE),
+          add(1.3, mul(rand(), 0.6)),
+          0.45
+        )
+      )
+    ]
+  };
+  var SMOKE_PUFF = {
+    id: "weapon_smoke_puff",
+    pageId: "event:weapon_smoke_puff",
+    team: "weapons",
+    budget: { particles: 1 },
+    loop: 0.1,
+    timeline: [puff2(ORIGIN2, void 0, [variable("vx"), variable("vy"), variable("vz")], variable("radius"), variable("life"), variable("opacity"))]
+  };
+  var BACKBLAST = {
+    id: "launcher_backblast",
+    pageId: "event:launcher_backblast",
+    team: "weapons",
+    budget: { particles: 40 },
+    loop: 0.1,
+    timeline: [
+      repeat(26, puff2(ORIGIN2, [neg(add(1.5, mul(rand(), 3))), 0, 0], [wide(1.4), wide(0.8), wide(1.4)], add(0.03, mul(rand(), 0.03)), add(1.8, mul(rand(), 1.4)), 0.5)),
+      repeat(14, ...flameBit(ORIGIN2, [neg(add(2, mul(rand(), 2))), 0, 0], [wide(1), wide(0.6), wide(1)], 0.02, 0.25))
+    ]
+  };
+  var FLAME_JET = {
+    id: "flame_jet",
+    pageId: "event:flame_jet",
+    team: "weapons",
+    budget: { particles: 30 },
+    loop: 0.1,
+    timeline: [
+      repeat(
+        floor(mul(420, variable("dt"), variable("scale"))),
+        set("speed", mul(add(2.2, mul(rand(), 1.1)), variable("scale"))),
+        ...flameBit(
+          [mul(rand(), variable("speed"), min(variable("dt"), 0.3)), 0, 0],
+          [variable("speed"), 0, 0],
+          [wide(0.35), mul(sub(rand(), 0.3), 0.3), wide(0.35)],
+          add(0.02, mul(rand(), 0.022)),
+          add(0.4, mul(rand(), 0.35))
+        )
+      ),
+      when(lt(rand(), 0.5), [
+        puff2([add(mul(1.1, variable("scale")), mul(rand(), 0.4)), 0, 0], void 0, [mul(vx(DIRECTION), 0.6), 0.35, mul(vz(DIRECTION), 0.6)], 0.03, 1.6, 0.4)
+      ])
+    ]
+  };
+  var VIEWMODEL_EFFECTS = [MUZZLE_FLASH2, SMOKE_PUFF, BACKBLAST, FLAME_JET];
+  var aliasOf = (base, id, changes) => ({ ...base, id, pageId: `vehicle:${id}`, anchor: CAR_ORIGIN2, ...changes });
+  var VEHICLE_EFFECTS = [
+    /** The engine on fire: `engine_smoke` at its worst condition (black smoke, flames in the hood, a light). */
+    aliasOf(ENGINE_SMOKE, "vehicle_fire", { params: { id: "condition", options: ["100", "60", "30", "10"], default: 3 }, loop: 12 }),
+    /** The exhaust of a car under way: `engine_smoke` in the best condition, for half a second so a moving car asks again. */
+    aliasOf(ENGINE_SMOKE, "vehicle_exhaust", { params: { id: "condition", options: ["100", "60", "30", "10"], default: 0 }, loop: 0.5 }),
+    /** A hole in the tank: the page's own petrol leak (drips, pool, sparks, fire running to the tank). */
+    aliasOf(FUEL_LEAK, "vehicle_leak", {})
+  ];
+  var ALL_EFFECTS = [BLOOD_HIT, HEADSHOT, DISMEMBER, BLOATER_CLOUD, SCREAMER_SHRIEK, CORPSE_DECAY, REANIMATION, EYES_IN_FOG, MUZZLE_FLASH, IMPACT_BY_MATERIAL, PENETRATION, CASINGS_AND_MAGAZINE, MOLOTOV, GRENADE, EXPLOSIVE_BARREL, SHOPFRONT_GLASS, DOOR_STAGES, BUILDING_COLLAPSE, BLOCK_WALL, METAL_DOOR_EFFECT, IRON_RAILING, WOODEN_FENCE, HIT_POINT_BREAKAGE, PRESSURE_CYLINDERS, BUILDING_FIRE, RAIN_AND_PUDDLES, FOG_AND_ASH, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, HEADLIGHTS_IN_RAIN, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
   var WORKSHOP_EFFECTS = Object.fromEntries(ALL_EFFECTS.map((effect) => [effect.id, effect]));
-  var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries(EVENT_EFFECTS.map((effect) => [effect.id, effect])) };
+  var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS, ...VEHICLE_EFFECTS].map((effect) => [effect.id, effect])) };
   var LEHMER_MULTIPLIER = 16807;
   var LEHMER_MODULUS = 2147483647;
   var HASH_MIX = 2654435761;
@@ -3300,7 +3679,7 @@ var GameDestructionThree = (() => {
   }
   var COLUMNS = 6;
   var ROWS = 5;
-  var ORIGIN2 = [-2.2, 0, 2.6];
+  var ORIGIN3 = [-2.2, 0, 2.6];
   var BLOCK_SIZE = [0.5, 0.44, 0.25];
   var OBJECT_ID_DRAWS2 = 4;
   var FLOOR2 = 0.13;
@@ -3343,7 +3722,7 @@ var GameDestructionThree = (() => {
           const chipScale = random.between(0.8, 1.3) * scale;
           for (let draw = 0; draw < OBJECT_ID_DRAWS2; draw++) random.next();
           best.holes.push({ x: offsetX, y: offsetY, scale, chipTurn, chipScale });
-          impact(host.engine, "concrete", [ORIGIN2[0] + x, y, ORIGIN2[2] + 0.13], [0, 0, 1], 0.8);
+          impact(host.engine, "concrete", [ORIGIN3[0] + x, y, ORIGIN3[2] + 0.13], [0, 0, 1], 0.8);
         } else if (action === "collapse") {
           const { x, y } = args;
           for (const block of blocks) {
@@ -3393,7 +3772,7 @@ var GameDestructionThree = (() => {
       }
     };
   }
-  var ORIGIN3 = [5.6, 0, 0.8];
+  var ORIGIN4 = [5.6, 0, 0.8];
   var MAX_TILT = 0.25;
   function createCarBehavior() {
     let y = 0;
@@ -3425,8 +3804,13 @@ var GameDestructionThree = (() => {
           }
         }
       },
-      query(_host, name) {
-        if (name === "position") return [ORIGIN3[0], y, ORIGIN3[2]];
+      query(_host, name, args) {
+        if (name === "position") return [ORIGIN4[0], y, ORIGIN4[2]];
+        if (name === "point") {
+          const [x, py, z] = args;
+          const point = carPoint(x, py, z);
+          return [point[0], point[1] + y, point[2]];
+        }
         if (name === "roll") return roll;
         throw new Error(`car: unknown query ${name}`);
       },
@@ -3626,6 +4010,29 @@ var GameDestructionThree = (() => {
       }
     };
   }
+  function createRainBehavior() {
+    return {
+      reset() {
+      },
+      act(host, action, args) {
+        const { engine, camera: camera2 } = host;
+        if (action === "init") {
+          const { count, wind } = args;
+          engine.rain.init(count, wind);
+        } else if (action === "update") {
+          const { dt, splash } = args;
+          engine.rain.update(dt, splash, camera2.position);
+        }
+      },
+      query(host, name) {
+        if (name === "count") return host.engine.rain.count;
+        if (name === "on") return host.engine.rain.on;
+        throw new Error(`rain: unknown query ${name}`);
+      },
+      update() {
+      }
+    };
+  }
   var WALKER_COUNT = 10;
   var ARRIVAL_DISTANCE = 0.05;
   var SWAY_AMPLITUDE = 0.04;
@@ -3691,7 +4098,8 @@ var GameDestructionThree = (() => {
     blocks: () => createBlocksBehavior(),
     plate: () => createPlateBehavior(),
     cylinder: () => createCylinderBehavior(),
-    car: () => createCarBehavior()
+    car: () => createCarBehavior(),
+    rain: () => createRainBehavior()
   };
   var NOOP = () => {
   };
@@ -3762,6 +4170,8 @@ var GameDestructionThree = (() => {
         return Math.abs(asNumber(first));
       case "sqrt":
         return Math.sqrt(asNumber(first));
+      case "exp":
+        return Math.exp(asNumber(first));
       case "sin":
         return Math.sin(asNumber(first));
       case "cos":
@@ -3880,7 +4290,7 @@ var GameDestructionThree = (() => {
         return evaluateCall(value.$, args.map((entry) => resolve(entry, context)));
     }
   }
-  var UP11 = [0, 1, 0];
+  var UP12 = [0, 1, 0];
   var ZERO = [0, 0, 0];
   var FULL_TURN_DRAWN = 6.283;
   function scaledSizes(range, factor) {
@@ -3893,7 +4303,7 @@ var GameDestructionThree = (() => {
       p: centre,
       r: radius,
       flat: true,
-      dir: options.dir ?? UP11,
+      dir: options.dir ?? UP12,
       cone: 0.35,
       sp: [0.4, 1.4],
       v: wind,
@@ -3910,7 +4320,7 @@ var GameDestructionThree = (() => {
       p: centre,
       r: radius * 0.6,
       flat: true,
-      dir: UP11,
+      dir: UP12,
       cone: 0.3,
       sp: [0.3, 0.8],
       life: [0.2, 0.4],
@@ -3925,14 +4335,14 @@ var GameDestructionThree = (() => {
     if (engine.quality < 2) {
       engine.emit(`${key}e`, "streak", 10 * factor, dt, () => {
         const jitter = plus(wind, engine.random.between(-0.4, 0.4), 0, engine.random.between(-0.4, 0.4));
-        return { p: centre, box: [radius, 0, radius], dir: UP11, cone: 0.5, sp: [1.5, 3.5], v: jitter, life: [0.8, 1.8], len: 0.03, c0: 16756816, c1: 6295552, g: -0.6, drag: 0.4 };
+        return { p: centre, box: [radius, 0, radius], dir: UP12, cone: 0.5, sp: [1.5, 3.5], v: jitter, life: [0.8, 1.8], len: 0.03, c0: 16756816, c1: 6295552, g: -0.6, drag: 0.4 };
       });
     }
     if (options.noSmoke) return;
     engine.emit(`${key}s`, "normal", (options.smoke || 14) * factor, dt, () => ({
       p: plus(centre, 0, 0.8 * sqrtFactor, 0),
       r: radius * 0.7,
-      dir: UP11,
+      dir: UP12,
       cone: 0.35,
       sp: [0.6, 1.4],
       v: wind,
@@ -3972,15 +4382,15 @@ var GameDestructionThree = (() => {
     engine.screen.shake += 0.7 * scale;
     engine.screen.white += 0.18 * scale;
     engine.burst("add", 55 * scale, { p: point, r: 0.3 * scale, sp: [2, 7 * scale], drag: 4, life: [0.25, 0.6], size: [0.7 * scale, 1.4 * scale], grow: 1.7, c0: 16773296, c1: 10103304, fi: 0.04 });
-    engine.burst("add", 28 * scale, { p: plus(point, 0, 0.3, 0), r: 0.3, dir: UP11, cone: 0.7, sp: [2, 5 * scale], drag: 1.5, life: [0.6, 1.1], size: [0.6 * scale, 1 * scale], grow: 1.3, c0: 16760928, c1: 5902853, g: -2, fi: 0.05 });
+    engine.burst("add", 28 * scale, { p: plus(point, 0, 0.3, 0), r: 0.3, dir: UP12, cone: 0.7, sp: [2, 5 * scale], drag: 1.5, life: [0.6, 1.1], size: [0.6 * scale, 1 * scale], grow: 1.3, c0: 16760928, c1: 5902853, g: -2, fi: 0.05 });
     engine.ring([plus(point, 0, 0.05, 0), 0.3, 7 * scale, 0.55, 16767136]);
     const toCamera = normalized([cameraPosition[0] - point[0], cameraPosition[1] - point[1], cameraPosition[2] - point[2]]);
     engine.ring([plus(point, 0, 1, 0), 0.3, 5 * scale, 0.35, 16773328, toCamera]);
-    engine.burst("normal", 32 * scale, { p: plus(point, 0, 0.6, 0), r: 0.8 * scale, dir: UP11, cone: 1.1, sp: [1, 3], drag: 1.2, life: [3, 6], size: [1 * scale, 1.8 * scale], grow: 2.6, c0: 2828068, c1: 987155, a: 0.6, fi: 0.18, g: -0.35 });
+    engine.burst("normal", 32 * scale, { p: plus(point, 0, 0.6, 0), r: 0.8 * scale, dir: UP12, cone: 1.1, sp: [1, 3], drag: 1.2, life: [3, 6], size: [1 * scale, 1.8 * scale], grow: 2.6, c0: 2828068, c1: 987155, a: 0.6, fi: 0.18, g: -0.35 });
     ringOfDust(engine, point, scale);
-    if (engine.quality < 2) engine.burst("streak", 44 * scale, { p: point, dir: UP11, cone: 1.45, sp: [10, 26], life: [0.3, 0.7], len: 0.03, c0: 16760944, c1: 8396800, g: 9.8, gnd: 2 });
+    if (engine.quality < 2) engine.burst("streak", 44 * scale, { p: point, dir: UP12, cone: 1.45, sp: [10, 26], life: [0.3, 0.7], len: 0.03, c0: 16760944, c1: 8396800, g: 9.8, gnd: 2 });
     for (let index = 0; index < engine.scaled(16 * scale); index++) {
-      engine.debrisPiece({ p: point, dir: UP11, cone: 1.2, sp: [3, 9], size: [0.12, 0.06, 0.1], k: [0.6, 1.6], c: chipColor || 2762274, life: 9 });
+      engine.debrisPiece({ p: point, dir: UP12, cone: 1.2, sp: [3, 9], size: [0.12, 0.06, 0.1], k: [0.6, 1.6], c: chipColor || 2762274, life: 9 });
     }
     engine.decal([point[0], engine.context.groundAt(point[0], point[2]), point[2], 3 * scale, 657930, { grow: 0.15, life: 60 }]);
   }
@@ -4123,6 +4533,7 @@ var GameDestructionThree = (() => {
       if (!def) return;
       this.schedule.clear();
       this.variables.clear();
+      for (const [name, value] of Object.entries(this.setup.values ?? {})) this.variables.set(name, value);
       for (const behavior2 of this.deps.behaviors()) behavior2.reset(this.host);
       this.time = 0;
       this.within(() => {
@@ -4181,6 +4592,10 @@ var GameDestructionThree = (() => {
           return engine.spawn(step.system, this.value(step.spawn));
         case "emit":
           return engine.emit(step.key, step.system, this.value(step.rate), this.dt, () => this.value(step.spawn));
+        case "mesh": {
+          engine.mesh(this.value(step.spawn));
+          return;
+        }
         case "debris":
           return engine.debrisPiece(this.value(step.spawn));
         case "decal":
@@ -4262,7 +4677,7 @@ var GameDestructionThree = (() => {
       this.index = previous;
     }
   };
-  var ORIGIN4 = [0, 0, 0];
+  var ORIGIN5 = [0, 0, 0];
   var DEFAULT_HEADING = [0, 0, -1];
   var DEFAULT_MAX_INSTANCES = 48;
   var ENDLESS_SECONDS = 60;
@@ -4307,7 +4722,7 @@ var GameDestructionThree = (() => {
     }
     function placementOf(entry) {
       const origin = entry.follow ? [entry.origin[0] + positionOf2(entry.follow)[0], entry.origin[1] + positionOf2(entry.follow)[1], entry.origin[2] + positionOf2(entry.follow)[2]] : entry.origin;
-      return { origin, anchor: entry.anchor, yaw: entry.yaw };
+      return { origin, anchor: entry.anchor, yaw: entry.yaw, ...entry.orientation ? { orientation: entry.orientation } : {} };
     }
     function drawing(entry, action) {
       const context = engine.context;
@@ -4331,8 +4746,9 @@ var GameDestructionThree = (() => {
           random: playOptions.seed !== void 0 ? streamOf(playOptions.seed) : void 0,
           follow: playOptions.follow,
           origin: point,
-          anchor: def.anchor ?? ORIGIN4,
+          anchor: def.anchor ?? ORIGIN5,
           yaw: yawOf(heading, playOptions.direction),
+          orientation: playOptions.orientation,
           seconds: playOptions.seconds ?? (def.loop && def.loop > 0 ? def.loop : ENDLESS_SECONDS)
         };
         playing.push(entry);
@@ -4341,7 +4757,8 @@ var GameDestructionThree = (() => {
           () => instance.begin(def, paramIndex(def, playOptions.param), {
             placement: placementOf(entry),
             ...playOptions.direction ? { direction: playOptions.direction } : {},
-            ...playOptions.normal ? { normal: playOptions.normal } : {}
+            ...playOptions.normal ? { normal: playOptions.normal } : {},
+            ...playOptions.values ? { values: playOptions.values } : {}
           })
         );
         return entry.handle;
@@ -4601,15 +5018,15 @@ var GameDestructionThree = (() => {
     return shock;
   }
   function pushPuffs(puffs, shock, reach, dt, age) {
-    for (const puff2 of puffs) {
-      if (puff2.ring || puff2.t > PUSH_AGE_LIMIT) continue;
-      const dx = puff2.x - shock.x;
-      const dz = puff2.z - shock.z;
+    for (const puff3 of puffs) {
+      if (puff3.ring || puff3.t > PUSH_AGE_LIMIT) continue;
+      const dx = puff3.x - shock.x;
+      const dz = puff3.z - shock.z;
       const distance = Math.hypot(dx, dz) + 1e-3;
-      if (Math.abs(distance - reach) < PUSH_BAND && puff2.y < PUSH_CEILING) {
+      if (Math.abs(distance - reach) < PUSH_BAND && puff3.y < PUSH_CEILING) {
         const strength = 4 * dt * (1 - age);
-        puff2.vx += dx / distance * strength * 6;
-        puff2.vz += dz / distance * strength * 6;
+        puff3.vx += dx / distance * strength * 6;
+        puff3.vz += dz / distance * strength * 6;
       }
     }
   }
@@ -4909,10 +5326,10 @@ var GameDestructionThree = (() => {
       const life = random.between(ring2.life * 0.75, ring2.life);
       const h0 = random.between(1, 1.25);
       const hl = random.between(0.9, 1.6);
-      const puff2 = addPuff(core, random, { x, y, z, s0: spec.radius * 0.2, s1, sg: spec.radius * 0.06, gk: 3, life, h0, hl, color, kind: 0 });
-      puff2.ring = ring2;
-      puff2.ph = random.next() * Math.PI * 2;
-      puff2.th = random.next() * Math.PI * 2;
+      const puff3 = addPuff(core, random, { x, y, z, s0: spec.radius * 0.2, s1, sg: spec.radius * 0.06, gk: 3, life, h0, hl, color, kind: 0 });
+      puff3.ring = ring2;
+      puff3.ph = random.next() * Math.PI * 2;
+      puff3.th = random.next() * Math.PI * 2;
     }
     const stemCount = Math.round((spec.stem || 18) * Math.max(lod, 0.4));
     for (let index = 0; index < stemCount; index++) {
@@ -5713,7 +6130,7 @@ var GameDestructionThree = (() => {
   };
   var TWO_PI_ROUNDED = 6.2832;
   var WIDE_CONE = 3.1;
-  var UP12 = [0, 1, 0];
+  var UP13 = [0, 1, 0];
   function drawRange(random, range) {
     if (Array.isArray(range)) return random.between(range[0], range[1]);
     return range || 0;
@@ -5741,7 +6158,7 @@ var GameDestructionThree = (() => {
   }
   function coneDirection(random, direction, cone, out) {
     if (cone >= WIDE_CONE) return randomUnit(random, out);
-    const [dx, dy, dz] = direction ?? UP12;
+    const [dx, dy, dz] = direction ?? UP13;
     const cosTilt = 1 - random.next() * (1 - Math.cos(cone));
     const sinTilt = Math.sqrt(1 - cosTilt * cosTilt);
     const phase = random.next() * TWO_PI_ROUNDED;
@@ -5861,12 +6278,12 @@ var GameDestructionThree = (() => {
     }
   };
   var CAPACITY2 = 400;
-  var UP13 = [0, 1, 0];
+  var UP14 = [0, 1, 0];
   var DEFAULT_LIFE2 = 60;
   var DEFAULT_GROW = 1.2;
   var EVAPORATION = { fuel: [6, 5], water: [40, 20] };
   function createDecal() {
-    return { on: false, x: 0, y: 0, z: 0, sx: 0, sy: 0, t: 0, life: 0, grow: 0, color: 0, normal: UP13, fluid: void 0, dryColor: -1, dryAt: 0, dryTime: 0 };
+    return { on: false, x: 0, y: 0, z: 0, sx: 0, sy: 0, t: 0, life: 0, grow: 0, color: 0, normal: UP14, fluid: void 0, dryColor: -1, dryAt: 0, dryTime: 0 };
   }
   var DecalPool = class {
     constructor(context) {
@@ -5879,7 +6296,7 @@ var GameDestructionThree = (() => {
       const random = this.context.random;
       const index = this.next++ % CAPACITY2;
       const decal2 = this.decals[index];
-      const normal = options.n ?? UP13;
+      const normal = options.n ?? UP14;
       random.between(0, 6.28);
       const offset = 4e-3 + index % 40 * 4e-4;
       decal2.on = true;
@@ -5920,6 +6337,94 @@ var GameDestructionThree = (() => {
       }
     }
   };
+  var CAPACITY3 = 400;
+  var IDENTITY = [0, 0, 0, 1];
+  function multiply(a, b) {
+    const [ax, ay, az, aw] = a;
+    const [bx, by, bz, bw] = b;
+    return [aw * bx + ax * bw + ay * bz - az * by, aw * by - ax * bz + ay * bw + az * bx, aw * bz + ax * by - ay * bx + az * bw, aw * bw - ax * bx - ay * by - az * bz];
+  }
+  var aboutX = (angle) => [Math.sin(angle / 2), 0, 0, Math.cos(angle / 2)];
+  var MeshPool = class {
+    constructor(capacity = CAPACITY3) {
+      __publicField2(this, "capacity", capacity);
+      __publicField2(this, "particles", []);
+      __publicField2(this, "serial", 0);
+    }
+    get count() {
+      return this.particles.length;
+    }
+    spawn(options, frame = IDENTITY) {
+      const velocity = options.v ?? [0, 0, 0];
+      const world = options.wv ?? [0, 0, 0];
+      const particle = {
+        id: ++this.serial,
+        shape: options.shape,
+        radius: options.r,
+        height: options.h ?? 0,
+        segments: options.seg ?? 0,
+        segments2: options.seg2 ?? 0,
+        color: options.c0,
+        additive: options.add === true,
+        lit: options.lit === true,
+        x: options.p[0],
+        y: options.p[1],
+        z: options.p[2],
+        frame: options.roll ? multiply(frame, aboutX(options.roll)) : frame,
+        at: options.at ?? [0, 0, 0],
+        rx: options.rot?.[0] ?? 0,
+        ry: options.rot?.[1] ?? 0,
+        rz: options.rot?.[2] ?? 0,
+        scale: 1,
+        opacity: options.a,
+        age: 0,
+        life: options.life,
+        vx: velocity[0] + world[0],
+        vy: velocity[1] + world[1],
+        vz: velocity[2] + world[2],
+        spin: options.spin ?? [0, 0, 0],
+        gravity: options.g ?? 0,
+        drag: options.drag ?? 0,
+        grow: options.grow ?? 0,
+        ramp: options.ramp,
+        fade: options.fade === true,
+        startOpacity: options.a
+      };
+      this.particles.push(particle);
+      if (this.particles.length > this.capacity) this.particles.shift();
+      return particle;
+    }
+    update(dt) {
+      const live = this.particles;
+      for (let index = 0; index < live.length; index++) {
+        const particle = live[index];
+        particle.age += dt;
+        if (particle.ramp ? particle.age >= particle.life : particle.age > particle.life) {
+          live.splice(index--, 1);
+          continue;
+        }
+        if (particle.fade) particle.opacity = Math.max(0, particle.startOpacity * (1 - particle.age / particle.life));
+        particle.vy -= particle.gravity * dt;
+        if (particle.drag) {
+          const keep = Math.max(0, 1 - particle.drag * dt);
+          particle.vx *= keep;
+          particle.vy *= keep;
+          particle.vz *= keep;
+        }
+        particle.x += particle.vx * dt;
+        particle.y += particle.vy * dt;
+        particle.z += particle.vz * dt;
+        particle.rx += particle.spin[0] * dt;
+        particle.ry += particle.spin[1] * dt;
+        particle.rz += particle.spin[2] * dt;
+        if (particle.grow) particle.scale *= 1 + particle.grow * dt;
+        if (particle.ramp) particle.scale = particle.ramp[0] + Math.min(1, particle.age / particle.life) * particle.ramp[1];
+      }
+    }
+    clear() {
+      this.particles.length = 0;
+    }
+  };
   var DEFAULT_FADE_IN = 0.1;
   var FLOATS_PER_VECTOR = 3;
   var BYTE_MAX2 = 255;
@@ -6209,11 +6714,11 @@ var GameDestructionThree = (() => {
   };
   var RING_CAPACITY = 120;
   var LIGHT_CAPACITY = 4;
-  var UP14 = [0, 1, 0];
+  var UP15 = [0, 1, 0];
   var DEFAULT_LIGHT_DISTANCE = 14;
   var WaveRingPool = class {
     constructor() {
-      __publicField2(this, "rings", Array.from({ length: RING_CAPACITY }, () => ({ on: false, point: UP14, from: 0, to: 0, t: 0, duration: 1, color: 0, normal: UP14, hold: 0 })));
+      __publicField2(this, "rings", Array.from({ length: RING_CAPACITY }, () => ({ on: false, point: UP15, from: 0, to: 0, t: 0, duration: 1, color: 0, normal: UP15, hold: 0 })));
       __publicField2(this, "count", 0);
       __publicField2(this, "next", 0);
     }
@@ -6226,7 +6731,7 @@ var GameDestructionThree = (() => {
       ring2.t = 0;
       ring2.duration = duration;
       ring2.color = color;
-      ring2.normal = normal ?? UP14;
+      ring2.normal = normal ?? UP15;
       ring2.hold = hold || 0;
     }
     clear() {
@@ -6246,7 +6751,7 @@ var GameDestructionThree = (() => {
   var FlashLightPool = class {
     constructor(context) {
       __publicField2(this, "context", context);
-      __publicField2(this, "lights", Array.from({ length: LIGHT_CAPACITY }, () => ({ x: 0, y: 0, z: 0, color: 16760944, distance: DEFAULT_LIGHT_DISTANCE, peak: 0, duration: 1, t: 0, intensity: 0 })));
+      __publicField2(this, "lights", Array.from({ length: LIGHT_CAPACITY }, () => ({ x: 0, y: 0, z: 0, color: 16760944, distance: DEFAULT_LIGHT_DISTANCE, peak: 0, duration: 1, t: 0, intensity: 0, steady: false })));
       __publicField2(this, "fire", [
         { x: 0, y: 0, z: 0, intensity: 0 },
         { x: 0, y: 0, z: 0, intensity: 0 }
@@ -6256,7 +6761,7 @@ var GameDestructionThree = (() => {
     get lit() {
       return this.lights.filter((light) => light.intensity > 0).length;
     }
-    flash(point, color, intensity, duration, distance, force) {
+    flash(point, color, intensity, duration, distance, force, steady) {
       const { level } = this.context.quality;
       if (level >= 1 && !force) return;
       if (level >= 2 && force !== "boom") return;
@@ -6269,6 +6774,7 @@ var GameDestructionThree = (() => {
       light.peak = intensity;
       light.duration = duration;
       light.t = 0;
+      light.steady = steady === true;
       light.intensity = intensity;
     }
     clear() {
@@ -6280,7 +6786,7 @@ var GameDestructionThree = (() => {
         if (light.intensity <= 0) continue;
         light.t += dt;
         const age = light.t / light.duration;
-        light.intensity = age >= 1 ? 0 : light.peak * (1 - age) * (1 - age);
+        light.intensity = age >= 1 ? 0 : light.steady ? light.peak : light.peak * (1 - age) * (1 - age);
       }
     }
   };
@@ -6288,6 +6794,14 @@ var GameDestructionThree = (() => {
   var FIRE_FLICKER_SWAY = 0.25;
   var FIRE_FLICKER_JITTER = 0.08;
   var LENS_FADE = 0.16;
+  function rotate(q, v) {
+    const [qx, qy, qz, qw] = q;
+    const ix = qw * v[0] + qy * v[2] - qz * v[1];
+    const iy = qw * v[1] + qz * v[0] - qx * v[2];
+    const iz = qw * v[2] + qx * v[1] - qy * v[0];
+    const iw = -qx * v[0] - qy * v[1] - qz * v[2];
+    return [ix * qw + iw * -qx + iy * -qz - iz * -qy, iy * qw + iw * -qy + iz * -qx - ix * -qz, iz * qw + iw * -qz + ix * -qy - iy * -qx];
+  }
   function workshopGround(x, z) {
     return z < -2.9 && z > -4.5 && Math.abs(x) < 13 ? 0.12 : 0;
   }
@@ -6301,6 +6815,8 @@ var GameDestructionThree = (() => {
       __publicField2(this, "decals");
       __publicField2(this, "rings", new WaveRingPool());
       __publicField2(this, "lights");
+      __publicField2(this, "rain", new RainField(this));
+      __publicField2(this, "meshes", new MeshPool());
       __publicField2(this, "screen", createScreenState());
       __publicField2(this, "lens", []);
       __publicField2(this, "post", {});
@@ -6333,7 +6849,11 @@ var GameDestructionThree = (() => {
     place(point) {
       const placement = this.placement;
       if (!placement) return point;
-      const { anchor, origin, yaw } = placement;
+      const { anchor, origin, yaw, orientation } = placement;
+      if (orientation) {
+        const turned = rotate(orientation, [point[0] - anchor[0], point[1] - anchor[1], point[2] - anchor[2]]);
+        return [origin[0] + turned[0], origin[1] + turned[1], origin[2] + turned[2]];
+      }
       const x = point[0] - anchor[0];
       const z = point[2] - anchor[2];
       const cos2 = Math.cos(yaw);
@@ -6344,6 +6864,7 @@ var GameDestructionThree = (() => {
     turn(vector) {
       const placement = this.placement;
       if (!placement) return vector;
+      if (placement.orientation) return rotate(placement.orientation, vector);
       const cos2 = Math.cos(placement.yaw);
       const sin2 = Math.sin(placement.yaw);
       return [cos2 * vector[0] + sin2 * vector[2], vector[1], -sin2 * vector[0] + cos2 * vector[2]];
@@ -6372,6 +6893,14 @@ var GameDestructionThree = (() => {
       }
       this.accumulators.set(key, carried);
     }
+    /** A solid particle (a cone, a sphere): the group sits at `p` turned by the placement, `v` is turned with it and `wv` is not. */
+    mesh(recipe) {
+      const placement = this.placement;
+      const options = placement ? { ...recipe, p: this.place(recipe.p), ...recipe.v ? { v: this.turn(recipe.v) } : {} } : recipe;
+      this.context.trace?.("mesh", [options]);
+      const grouped = recipe.at !== void 0 || recipe.roll !== void 0;
+      return this.meshes.spawn(options, placement && grouped ? placement.orientation ?? [0, Math.sin(placement.yaw / 2), 0, Math.cos(placement.yaw / 2)] : void 0);
+    }
     debrisPiece(recipe) {
       const options = this.placed(recipe);
       this.context.trace?.("debris", [options]);
@@ -6392,10 +6921,11 @@ var GameDestructionThree = (() => {
       this.context.trace?.("ring", args);
       this.rings.add(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
     }
+    /** `steady` (a seventh number): the light holds its intensity for its duration and goes out, where the Workshop's fades with the square of its age. */
     flash(recipe) {
-      const args = this.placement ? [this.place(recipe[0]), recipe[1], recipe[2], recipe[3], recipe[4], recipe[5]] : recipe;
-      this.context.trace?.("flash", args);
-      this.lights.flash(args[0], args[1], args[2], args[3], args[4], args[5]);
+      const args = this.placement ? [this.place(recipe[0]), recipe[1], recipe[2], recipe[3], recipe[4], recipe[5], recipe[6]] : recipe;
+      this.context.trace?.("flash", args.slice(0, 6));
+      this.lights.flash(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
     }
     /** `fireLight` (W400): sways with the clock and flickers with one draw. */
     fireLight(slot, recipe, intensity, time) {
@@ -6420,6 +6950,7 @@ var GameDestructionThree = (() => {
       this.debris.update(dt);
       this.decals.update(dt);
       this.rings.update(dt);
+      this.meshes.update(dt);
       this.lights.update(dt);
       updateScreen(this.screen, dt);
       for (let index = this.lens.length - 1; index >= 0; index--) {
@@ -6436,7 +6967,9 @@ var GameDestructionThree = (() => {
       this.debris.clear();
       this.decals.clear();
       this.rings.clear();
+      this.meshes.clear();
       this.lights.clear();
+      this.rain.clear();
       this.accumulators.clear();
       resetScreenState(this.screen);
       this.lens.length = 0;
@@ -6582,16 +7115,16 @@ var GameDestructionThree = (() => {
       },
       push(point, radius, speed) {
         spriteSystem.push(point, radius, speed);
-        for (const puff2 of core.puffs.items) {
-          const dx = puff2.x - point[0];
-          const dy = puff2.y - point[1];
-          const dz = puff2.z - point[2];
+        for (const puff3 of core.puffs.items) {
+          const dx = puff3.x - point[0];
+          const dy = puff3.y - point[1];
+          const dz = puff3.z - point[2];
           const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
           if (distance >= radius) continue;
           const strength = speed * (1 - distance / radius) / (distance + 1e-3);
-          puff2.vx += dx * strength;
-          puff2.vy += dy * strength;
-          puff2.vz += dz * strength;
+          puff3.vx += dx * strength;
+          puff3.vy += dy * strength;
+          puff3.vz += dz * strength;
         }
       },
       stop(handle) {
@@ -6608,6 +7141,12 @@ var GameDestructionThree = (() => {
         camera2.y = position[1];
         camera2.z = position[2];
       },
+      setWind(next) {
+        wind.x = next[0];
+        wind.y = next[1];
+        wind.z = next[2];
+      },
+      wind: () => [wind.x, wind.y, wind.z],
       forceLod(scale) {
         core.clock.forcedLod = scale;
       },
@@ -6805,11 +7344,11 @@ void main(){
     geometry.setAttribute("aC", attributes[2]);
     geometry.instanceCount = 0;
     const material = new THREE.ShaderMaterial({ uniforms, vertexShader: PUFF_VERTEX, fragmentShader: PUFF_FRAGMENT });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = "vfx-puffs";
-    mesh.frustumCulled = false;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "vfx-puffs";
+    mesh2.frustumCulled = false;
     return {
-      mesh,
+      mesh: mesh2,
       sync() {
         let n = 0;
         for (const p of pool.items) {
@@ -6850,12 +7389,12 @@ void main(){
     geometry.setAttribute("aE", attributes[2]);
     geometry.instanceCount = 0;
     const material = new THREE.ShaderMaterial({ transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, vertexShader: SPARK_VERTEX, fragmentShader: SPARK_FRAGMENT });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = "vfx-sparks";
-    mesh.frustumCulled = false;
-    mesh.renderOrder = 5;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "vfx-sparks";
+    mesh2.frustumCulled = false;
+    mesh2.renderOrder = 5;
     return {
-      mesh,
+      mesh: mesh2,
       sync() {
         let n = 0;
         for (const s of pool.items) {
@@ -6893,12 +7432,12 @@ void main(){
     geometry.setAttribute("aC", attributes[1]);
     geometry.instanceCount = 0;
     const material = new THREE.ShaderMaterial({ transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, vertexShader: GLOW_VERTEX, fragmentShader: GLOW_FRAGMENT });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = "vfx-glows";
-    mesh.frustumCulled = false;
-    mesh.renderOrder = 6;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "vfx-glows";
+    mesh2.frustumCulled = false;
+    mesh2.renderOrder = 6;
     return {
-      mesh,
+      mesh: mesh2,
       sync() {
         let n = 0;
         for (const g of pool.items) {
@@ -6927,14 +7466,14 @@ void main(){
     const rockMaterial = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.85, flatShading: true });
     const plateMaterial = rockMaterial.clone();
     const make = (geometry, material) => {
-      const mesh = new THREE.InstancedMesh(geometry, material, capacity);
-      mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-      mesh.castShadow = true;
-      mesh.receiveShadow = true;
-      mesh.frustumCulled = false;
-      mesh.count = 0;
-      mesh.setColorAt(0, new THREE.Color(1, 1, 1));
-      return mesh;
+      const mesh2 = new THREE.InstancedMesh(geometry, material, capacity);
+      mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+      mesh2.castShadow = true;
+      mesh2.receiveShadow = true;
+      mesh2.frustumCulled = false;
+      mesh2.count = 0;
+      mesh2.setColorAt(0, new THREE.Color(1, 1, 1));
+      return mesh2;
     };
     const rocks = make(shapes.rock, rockMaterial);
     const plates = make(shapes.plate, plateMaterial);
@@ -6953,20 +7492,20 @@ void main(){
           euler.set(chunk.rx, chunk.ry, chunk.rz);
           quaternion.setFromEuler(euler);
           matrix.compose(position.set(chunk.x, chunk.y, chunk.z), quaternion, scale.set(chunk.sx, chunk.sy, chunk.sz));
-          const mesh = chunk.plate ? plates : rocks;
+          const mesh2 = chunk.plate ? plates : rocks;
           const index = chunk.plate ? plateCount++ : rockCount++;
-          mesh.setMatrixAt(index, matrix);
+          mesh2.setMatrixAt(index, matrix);
           const color = colorOf2(chunk);
-          const colors = mesh.instanceColor.array;
+          const colors = mesh2.instanceColor.array;
           colors[index * 3] = color[0];
           colors[index * 3 + 1] = color[1];
           colors[index * 3 + 2] = color[2];
         }
         rocks.count = rockCount;
         plates.count = plateCount;
-        for (const mesh of [rocks, plates]) {
-          mesh.instanceMatrix.needsUpdate = true;
-          mesh.instanceColor.needsUpdate = true;
+        for (const mesh2 of [rocks, plates]) {
+          mesh2.instanceMatrix.needsUpdate = true;
+          mesh2.instanceColor.needsUpdate = true;
         }
         return rockCount + plateCount;
       },
@@ -7150,28 +7689,28 @@ void main(){
         position.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
       }
       geometry.computeVertexNormals();
-      const mesh = new THREE.Mesh(geometry, material);
-      mesh.receiveShadow = true;
-      return mesh;
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.receiveShadow = true;
+      return mesh2;
     }
     function addRock(mark) {
-      const mesh = new THREE.Mesh(mark.plate ? options.plateGeometry : options.rockGeometry, rockMaterial(mark.color));
-      mesh.position.set(mark.x, mark.y, mark.z);
-      mesh.scale.set(mark.scale[0], mark.scale[1], mark.scale[2]);
-      mesh.rotation.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]);
-      mesh.castShadow = true;
-      mesh.receiveShadow = true;
-      return mesh;
+      const mesh2 = new THREE.Mesh(mark.plate ? options.plateGeometry : options.rockGeometry, rockMaterial(mark.color));
+      mesh2.position.set(mark.x, mark.y, mark.z);
+      mesh2.scale.set(mark.scale[0], mark.scale[1], mark.scale[2]);
+      mesh2.rotation.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]);
+      mesh2.castShadow = true;
+      mesh2.receiveShadow = true;
+      return mesh2;
     }
     function addBlood(mark) {
-      const mesh = new THREE.Mesh(bloodGeometry, bloodMaterial);
-      mesh.position.set(mark.x, mark.y, mark.z);
-      mesh.scale.set(mark.scaleX, 1, mark.scaleZ);
-      mesh.rotation.y = mark.rotation;
-      mesh.receiveShadow = true;
-      mesh.scale.multiplyScalar(0.05);
-      blood.push({ mesh, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 });
-      return mesh;
+      const mesh2 = new THREE.Mesh(bloodGeometry, bloodMaterial);
+      mesh2.position.set(mark.x, mark.y, mark.z);
+      mesh2.scale.set(mark.scaleX, 1, mark.scaleZ);
+      mesh2.rotation.y = mark.rotation;
+      mesh2.receiveShadow = true;
+      mesh2.scale.multiplyScalar(0.05);
+      blood.push({ mesh: mesh2, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 });
+      return mesh2;
     }
     function build(mark) {
       if (mark.kind === "scorch") return conform(mark, scorchMaterials[mark.variant]);
@@ -7382,6 +7921,73 @@ void main() {
       }
     };
   }
+  var SPHERE_DEFAULT_WIDTH = 8;
+  var SPHERE_DEFAULT_HEIGHT = 6;
+  function geometryOf(THREE, particle) {
+    switch (particle.shape) {
+      case "cone":
+        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
+      case "cone_open":
+        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
+      case "sphere":
+        return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
+      case "icosahedron":
+        return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
+    }
+  }
+  function materialOf(THREE, particle) {
+    if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
+    return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
+  }
+  function createMeshLayer(THREE, pool) {
+    const group = new THREE.Group();
+    group.name = "workshop-meshes";
+    const drawn = /* @__PURE__ */ new Map();
+    const frame = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const turn = new THREE.Quaternion();
+    const offset = new THREE.Vector3();
+    function release(mesh2) {
+      mesh2.removeFromParent();
+      mesh2.geometry.dispose();
+      mesh2.material.dispose();
+    }
+    return {
+      group,
+      sync() {
+        const live = /* @__PURE__ */ new Set();
+        for (const particle of pool.particles) {
+          live.add(particle.id);
+          let mesh2 = drawn.get(particle.id);
+          if (!mesh2) {
+            mesh2 = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
+            mesh2.frustumCulled = false;
+            mesh2.renderOrder = particle.additive ? 5 : 3;
+            drawn.set(particle.id, mesh2);
+            group.add(mesh2);
+          }
+          frame.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
+          offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame);
+          mesh2.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
+          turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
+          mesh2.quaternion.copy(frame).multiply(turn);
+          mesh2.scale.setScalar(particle.scale);
+          mesh2.material.opacity = particle.opacity;
+        }
+        for (const [id, mesh2] of drawn) {
+          if (live.has(id)) continue;
+          release(mesh2);
+          drawn.delete(id);
+        }
+        return pool.count;
+      },
+      dispose() {
+        for (const mesh2 of drawn.values()) release(mesh2);
+        drawn.clear();
+        group.removeFromParent();
+      }
+    };
+  }
   var WORKSHOP_SPRITE_VERTEX = `attribute float size;attribute float alpha;attribute vec3 pcol;varying vec3 vC;varying float vA;uniform float uScale;
 void main(){vC=pcol;vA=alpha;vec4 mv=modelViewMatrix*vec4(position,1.);gl_PointSize=clamp(size*uScale/-mv.z,1.,512.);gl_Position=projectionMatrix*mv;}`;
   var WORKSHOP_SPRITE_FRAGMENT = `uniform float uSoft;varying vec3 vC;varying float vA;
@@ -7457,13 +8063,37 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     };
   }
+  function rainLayer(THREE, rain) {
+    const geometry = new THREE.BufferGeometry();
+    const position = new THREE.BufferAttribute(rain.positions, 3).setUsage(THREE.DynamicDrawUsage);
+    geometry.setAttribute("position", position);
+    geometry.setDrawRange(0, 0);
+    const material = new THREE.LineBasicMaterial({ color: 10466255, transparent: true, opacity: 0.35, depthWrite: false });
+    const lines = new THREE.LineSegments(geometry, material);
+    lines.frustumCulled = false;
+    lines.name = "workshop-rain";
+    return {
+      object: lines,
+      sync() {
+        const drawn = rain.on && rain.count > 0;
+        lines.visible = drawn;
+        geometry.setDrawRange(0, drawn ? rain.count * 2 : 0);
+        position.needsUpdate = true;
+        return drawn;
+      },
+      dispose() {
+        geometry.dispose();
+        material.dispose();
+      }
+    };
+  }
   function debrisLayer(THREE, pool) {
     const geometry = new THREE.BoxGeometry(1, 1, 1);
     const material = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.45, metalness: 0.25, flatShading: true });
-    const mesh = new THREE.InstancedMesh(geometry, material, DEBRIS_CAPACITY);
-    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-    mesh.frustumCulled = false;
-    mesh.name = "workshop-debris";
+    const mesh2 = new THREE.InstancedMesh(geometry, material, DEBRIS_CAPACITY);
+    mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    mesh2.frustumCulled = false;
+    mesh2.name = "workshop-debris";
     const euler = new THREE.Euler();
     const quaternion = new THREE.Quaternion();
     const position = new THREE.Vector3();
@@ -7471,16 +8101,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const matrix = new THREE.Matrix4();
     const colour = new THREE.Color();
     const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
-    for (let index = 0; index < DEBRIS_CAPACITY; index++) mesh.setMatrixAt(index, hidden);
-    mesh.setColorAt(0, colour.setHex(16777215));
+    for (let index = 0; index < DEBRIS_CAPACITY; index++) mesh2.setMatrixAt(index, hidden);
+    mesh2.setColorAt(0, colour.setHex(16777215));
     return {
-      object: mesh,
+      object: mesh2,
       sync() {
         let drawn = false;
         for (let index = 0; index < DEBRIS_CAPACITY; index++) {
           const piece = pool.pieces[index];
           if (!piece.on) {
-            mesh.setMatrixAt(index, hidden);
+            mesh2.setMatrixAt(index, hidden);
             continue;
           }
           drawn = true;
@@ -7488,11 +8118,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           euler.set(piece.rx, piece.ry, piece.rz);
           quaternion.setFromEuler(euler);
           matrix.compose(position.set(piece.x, piece.y, piece.z), quaternion, scale.set(piece.sx * shrink, piece.sy * shrink, piece.sz * shrink));
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, colour.setHex(piece.color));
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, colour.setHex(piece.color));
         }
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        mesh2.instanceMatrix.needsUpdate = true;
+        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
         return drawn;
       },
       dispose() {
@@ -7549,11 +8179,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const dryMesh = new THREE.InstancedMesh(geometry, dry, DECAL_CAPACITY);
     const group = new THREE.Group();
     group.name = "workshop-decals";
-    for (const mesh of [wetMesh, dryMesh]) {
-      mesh.frustumCulled = false;
-      mesh.renderOrder = 1;
-      mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-      group.add(mesh);
+    for (const mesh2 of [wetMesh, dryMesh]) {
+      mesh2.frustumCulled = false;
+      mesh2.renderOrder = 1;
+      mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+      group.add(mesh2);
     }
     const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
     const colour = new THREE.Color();
@@ -7590,13 +8220,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           quaternion.multiply(turn.setFromAxisAngle(forward, index * 2.399963));
           const offset = 4e-3 + index % 40 * 4e-4;
           matrix.compose(position.set(decal2.x + normal.x * offset, decal2.y + normal.y * offset, decal2.z + normal.z * offset), quaternion, scale.set(look.sx, look.sy, 1));
-          const mesh = look.dried ? dryMesh : wetMesh;
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, colour);
+          const mesh2 = look.dried ? dryMesh : wetMesh;
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, colour);
         }
-        for (const mesh of [wetMesh, dryMesh]) {
-          mesh.instanceMatrix.needsUpdate = true;
-          if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        for (const mesh2 of [wetMesh, dryMesh]) {
+          mesh2.instanceMatrix.needsUpdate = true;
+          if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
         }
         return drawn;
       },
@@ -7610,10 +8240,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   function ringLayer(THREE, pool) {
     const geometry = new THREE.RingGeometry(0.86, 1, 40);
     const material = new THREE.MeshBasicMaterial({ color: 16777215, transparent: true, blending: THREE.AdditiveBlending, depthWrite: false, side: THREE.DoubleSide });
-    const mesh = new THREE.InstancedMesh(geometry, material, RING_CAPACITY3);
-    mesh.frustumCulled = false;
-    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-    mesh.name = "workshop-rings";
+    const mesh2 = new THREE.InstancedMesh(geometry, material, RING_CAPACITY3);
+    mesh2.frustumCulled = false;
+    mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    mesh2.name = "workshop-rings";
     const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
     const colour = new THREE.Color();
     const normal = new THREE.Vector3();
@@ -7622,16 +8252,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const position = new THREE.Vector3();
     const scale = new THREE.Vector3();
     const matrix = new THREE.Matrix4();
-    mesh.setColorAt(0, colour.setHex(0));
-    for (let index = 0; index < RING_CAPACITY3; index++) mesh.setMatrixAt(index, hidden);
+    mesh2.setColorAt(0, colour.setHex(0));
+    for (let index = 0; index < RING_CAPACITY3; index++) mesh2.setMatrixAt(index, hidden);
     return {
-      object: mesh,
+      object: mesh2,
       sync() {
         let drawn = false;
         for (let index = 0; index < RING_CAPACITY3; index++) {
           const ring2 = pool.rings[index];
           if (!ring2.on) {
-            mesh.setMatrixAt(index, hidden);
+            mesh2.setMatrixAt(index, hidden);
             continue;
           }
           drawn = true;
@@ -7639,11 +8269,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const radius = ring2.from + (ring2.to - ring2.from) * (1 - Math.pow(1 - k, 2));
           quaternion.setFromUnitVectors(forward, normal.set(ring2.normal[0], ring2.normal[1], ring2.normal[2]));
           matrix.compose(position.set(ring2.point[0], ring2.point[1], ring2.point[2]), quaternion, scale.set(radius, radius, 1));
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, colour.setHex(ring2.color).multiplyScalar(ring2.hold ? ring2.hold : 1 - k));
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, colour.setHex(ring2.color).multiplyScalar(ring2.hold ? ring2.hold : 1 - k));
         }
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        mesh2.instanceMatrix.needsUpdate = true;
+        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
         return drawn;
       },
       dispose() {
@@ -7659,11 +8289,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       spriteLayer(THREE, engine.add, true, 1, pointScale),
       spriteLayer(THREE, engine.normal, false, 0.55, pointScale),
       streakLayer(THREE, engine.streaks),
+      rainLayer(THREE, engine.rain),
       debrisLayer(THREE, engine.debris),
       decalLayer(THREE, engine.decals),
       ringLayer(THREE, engine.rings)
     ];
     for (const layer2 of layers) group.add(layer2.object);
+    const meshes = createMeshLayer(THREE, engine.meshes);
+    group.add(meshes.group);
     const flashLights = engine.lights.lights.map(() => new THREE.PointLight(16760944, 0, 14));
     const fireLights = engine.lights.fire.map(() => new THREE.PointLight(FIRE_LIGHT_COLOR, 0, FIRE_LIGHT_DISTANCE));
     for (const light of [...flashLights, ...fireLights]) group.add(light);
@@ -7672,6 +8305,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       sync() {
         let drawCalls = 0;
         for (const layer2 of layers) if (layer2.sync()) drawCalls++;
+        drawCalls += meshes.sync();
         engine.lights.lights.forEach((source, index) => {
           const light = flashLights[index];
           light.position.set(source.x, source.y, source.z);
@@ -7688,6 +8322,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       },
       dispose() {
         for (const layer2 of layers) layer2.dispose();
+        meshes.dispose();
         group.clear();
       }
     };
@@ -7803,8 +8438,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         return world.play(request.effect, request.point, {
           ...request.direction ? { direction: request.direction } : {},
           ...request.normal ? { normal: request.normal } : {},
+          ...request.orientation ? { orientation: request.orientation } : {},
           ...request.seed !== void 0 ? { seed: request.seed } : {},
-          ...request.param !== void 0 ? { param: request.param } : {}
+          ...request.param !== void 0 ? { param: request.param } : {},
+          ...request.values ? { values: request.values } : {}
         });
       },
       stop: (handle) => world.stop(handle),
@@ -7965,11 +8602,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
      * 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) {
+    addMarks(mesh2, 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 sc = mesh.scale;
+      const sc = mesh2.scale;
       for (const mark of f.marks) {
         const disc = new this.THREE.Mesh(this.markGeometry, this.markMaterial);
         const radius = Math.max(4e-3, mark.diameter) * 0.6;
@@ -7977,22 +8614,22 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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);
         disc.quaternion.setFromUnitVectors(this.w.set(0, 0, 1), n);
         disc.scale.set(radius / sc.x, radius / sc.y, radius / sc.z);
-        mesh.add(disc);
+        mesh2.add(disc);
       }
     }
     /** Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget. */
     spawn(f, material, home, maxAllowed) {
       const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
-      const mesh = new this.THREE.Mesh(geo, material);
-      mesh.position.set(f.center[0], f.center[1], f.center[2]);
-      mesh.quaternion.set(f.rotation[0], f.rotation[1], f.rotation[2], f.rotation[3]).normalize();
+      const mesh2 = new this.THREE.Mesh(geo, material);
+      mesh2.position.set(f.center[0], f.center[1], f.center[2]);
+      mesh2.quaternion.set(f.rotation[0], f.rotation[1], f.rotation[2], f.rotation[3]).normalize();
       const sz = f.size;
       const sc = new this.THREE.Vector3(Math.max(5e-3, sz[0]), Math.max(5e-3, sz[1]), Math.max(3e-3, sz[2]));
-      mesh.scale.copy(sc);
-      mesh.castShadow = true;
-      this.o.scene.add(mesh);
+      mesh2.scale.copy(sc);
+      mesh2.castShadow = true;
+      this.o.scene.add(mesh2);
       const live = {
-        mesh,
+        mesh: mesh2,
         home,
         vel: new this.THREE.Vector3(f.velocity[0], f.velocity[1], f.velocity[2]),
         ang: new this.THREE.Vector3(f.angularVelocity[0], f.angularVelocity[1], f.angularVelocity[2]),
@@ -8013,8 +8650,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           alive--;
         }
       }
-      this.addMarks(mesh, f);
-      return mesh;
+      this.addMarks(mesh2, f);
+      return mesh2;
     }
     /** Add velocity to every fragment within `radius` of a point (blasts). */
     blast(point, radius, speed) {
@@ -8053,24 +8690,24 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     }
     step(f, dt, g) {
-      const mesh = f.mesh;
+      const mesh2 = f.mesh;
       f.vel.y -= g * dt;
-      mesh.position.addScaledVector(f.vel, dt);
+      mesh2.position.addScaledVector(f.vel, dt);
       const w = f.ang.length();
       if (w > 1e-5) {
         this.dq.setFromAxisAngle(this.v.copy(f.ang).multiplyScalar(1 / w), w * dt);
-        mesh.quaternion.premultiply(this.dq).normalize();
+        mesh2.quaternion.premultiply(this.dq).normalize();
       }
-      this.m.makeRotationFromQuaternion(mesh.quaternion);
+      this.m.makeRotationFromQuaternion(mesh2.quaternion);
       const e = this.m.elements;
       const h = f.half;
       const sc = f.dying ? f.fade : 1;
       const ext = (Math.abs(e[1]) * h.x + Math.abs(e[5]) * h.y + Math.abs(e[9]) * h.z) * sc;
-      const gy = this.o.groundAt(mesh.position.x, mesh.position.z);
+      const gy = this.o.groundAt(mesh2.position.x, mesh2.position.z);
       let contact = false;
-      if (mesh.position.y - ext < gy) {
+      if (mesh2.position.y - ext < gy) {
         contact = true;
-        mesh.position.y = gy + ext;
+        mesh2.position.y = gy + ext;
         if (f.vel.y < -0.6) {
           f.vel.y = -f.vel.y * 0.25;
           f.vel.x *= 0.7;
@@ -8103,8 +8740,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     /** Tip the fragment towards lying on its flattest face. */
     settle(f, dt) {
-      const mesh = f.mesh;
-      this.m.makeRotationFromQuaternion(mesh.quaternion);
+      const mesh2 = f.mesh;
+      this.m.makeRotationFromQuaternion(mesh2.quaternion);
       const e = this.m.elements;
       const up = [e[1], e[5], e[9]];
       const half = [f.half.x, f.half.y, f.half.z];
@@ -8119,8 +8756,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.v.set(e[axis2 * 4], e[axis2 * 4 + 1], e[axis2 * 4 + 2]).multiplyScalar(sign);
       this.w.set(0, 1, 0);
       this.dq.setFromUnitVectors(this.v, this.w);
-      this.q.copy(this.dq).multiply(mesh.quaternion);
-      mesh.quaternion.slerp(this.q, clamp6(dt * 7, 0, 1));
+      this.q.copy(this.dq).multiply(mesh2.quaternion);
+      mesh2.quaternion.slerp(this.q, clamp6(dt * 7, 0, 1));
     }
     /** Remove the fragments of one object (after `restore`). */
     removeHome(home) {
@@ -8192,13 +8829,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
       }
       while (this.spots.length >= this.cap) this.remove(this.spots[0]);
-      const mesh = new this.THREE.Mesh(this.geometry, this.material(kind, color));
+      const mesh2 = new this.THREE.Mesh(this.geometry, this.material(kind, color));
       const y = this.groundAt(x, z) + 4e-3 + this.spots.length % 8 * 4e-4;
-      mesh.position.set(x, y, z);
-      mesh.scale.setScalar(1e-3);
-      mesh.renderOrder = 1;
-      this.scene.add(mesh);
-      this.spots.push({ mesh, kind, home, x, z, radius: 1e-3, target: Math.min(MAX_RADIUS, radius) });
+      mesh2.position.set(x, y, z);
+      mesh2.scale.setScalar(1e-3);
+      mesh2.renderOrder = 1;
+      this.scene.add(mesh2);
+      this.spots.push({ mesh: mesh2, kind, home, x, z, radius: 1e-3, target: Math.min(MAX_RADIUS, radius) });
     }
     remove(s) {
       const i = this.spots.indexOf(s);
@@ -8578,7 +9215,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     /** Bars drawn now, over every part. */
     get count() {
       let n = 0;
-      for (const mesh of this.cages.values()) n += mesh.count;
+      for (const mesh2 of this.cages.values()) n += mesh2.count;
       return n;
     }
     /** Meshes of the live cages (tests and picking). */
@@ -8589,25 +9226,25 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     set(key, bars) {
       this.remove(key);
       if (bars.length === 0) return;
-      const mesh = new this.THREE.InstancedMesh(this.geometry, this.material, bars.length);
+      const mesh2 = new this.THREE.InstancedMesh(this.geometry, this.material, bars.length);
       bars.forEach(([a, b], i) => {
         this.dir.set(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
         const length = this.dir.length();
         this.mid.set((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2);
         this.q.setFromUnitVectors(this.up, length > 1e-9 ? this.dir.divideScalar(length) : this.up);
         this.m.compose(this.mid, this.q, this.scale.set(1, Math.max(length, 1e-4), 1));
-        mesh.setMatrixAt(i, this.m);
+        mesh2.setMatrixAt(i, this.m);
       });
-      mesh.instanceMatrix.needsUpdate = true;
-      mesh.castShadow = true;
-      this.scene.add(mesh);
-      this.cages.set(key, mesh);
+      mesh2.instanceMatrix.needsUpdate = true;
+      mesh2.castShadow = true;
+      this.scene.add(mesh2);
+      this.cages.set(key, mesh2);
     }
     remove(key) {
-      const mesh = this.cages.get(key);
-      if (!mesh) return;
-      this.scene.remove(mesh);
-      mesh.dispose();
+      const mesh2 = this.cages.get(key);
+      if (!mesh2) return;
+      this.scene.remove(mesh2);
+      mesh2.dispose();
       this.cages.delete(key);
     }
     /** Remove the cages of every part of `object` (keys are `object|part`). */
@@ -8626,9 +9263,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
 
   // ../game-destruction/dist/index.js
   var EPS = 1e-9;
-  var IDENTITY = [0, 0, 0, 1];
+  var IDENTITY2 = [0, 0, 0, 1];
   var quat = {
-    identity: () => [IDENTITY[0], IDENTITY[1], IDENTITY[2], IDENTITY[3]],
+    identity: () => [IDENTITY2[0], IDENTITY2[1], IDENTITY2[2], IDENTITY2[3]],
     /** Hamilton product `a * b` (apply `b` first, then `a`). */
     mul: (a, b) => [
       a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
@@ -9951,25 +10588,25 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     /**
      * @param range vertex range `[v0, v1)` of a merged mesh this part is drawn by (see `MeshRange`); `hosts` caches the shared state per mesh for one `bind`.
      */
-    makeMeshVis(mesh, home, range, hosts) {
+    makeMeshVis(mesh2, home, range, hosts) {
       let host = null;
       if (range) {
-        host = hosts?.get(mesh) ?? null;
+        host = hosts?.get(mesh2) ?? null;
         if (!host) {
-          host = { mesh, origGeometry: mesh.geometry, origMaterial: mesh.material, ownGeo: false, work: null, ownMat: false, sharers: [] };
-          hosts?.set(mesh, host);
+          host = { mesh: mesh2, origGeometry: mesh2.geometry, origMaterial: mesh2.material, ownGeo: false, work: null, ownMat: false, sharers: [] };
+          hosts?.set(mesh2, host);
         }
       }
       const mv = {
-        mesh,
+        mesh: mesh2,
         home,
-        origGeometry: mesh.geometry,
-        origMaterial: mesh.material,
-        origVisible: mesh.visible,
-        origParent: mesh.parent,
-        origPosition: mesh.position.clone(),
-        origQuaternion: mesh.quaternion.clone(),
-        origScale: mesh.scale.clone(),
+        origGeometry: mesh2.geometry,
+        origMaterial: mesh2.material,
+        origVisible: mesh2.visible,
+        origParent: mesh2.parent,
+        origPosition: mesh2.position.clone(),
+        origQuaternion: mesh2.quaternion.clone(),
+        origScale: mesh2.scale.clone(),
         ownMat: false,
         ownGeo: false,
         work: null,
@@ -10094,15 +10731,15 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
      * Returns false when nothing was changed (too far, low quality on a heavy mesh, or no editable positions).
      */
     applyDent(mv, worldPoint, worldNormal, dent) {
-      const mesh = mv.mesh;
+      const mesh2 = mv.mesh;
       if (this.lowQuality && this.vertexCount(mv) > 2e4) return false;
-      mesh.updateWorldMatrix(true, false);
-      const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
-      const lp = mesh.worldToLocal(this.a.copy(worldPoint));
-      const ln = this.b.copy(worldNormal).transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
+      mesh2.updateWorldMatrix(true, false);
+      const s = mesh2.matrixWorld.getMaxScaleOnAxis() || 1;
+      const lp = mesh2.worldToLocal(this.a.copy(worldPoint));
+      const ln = this.b.copy(worldNormal).transformDirection(this.m4.copy(mesh2.matrixWorld).invert()).normalize();
       const r = dent.radius / s;
       const depth = dent.depth / s;
-      const geo = mesh.geometry;
+      const geo = mesh2.geometry;
       let bb;
       if (mv.host) bb = this.localBox(mv, this.lbox);
       else {
@@ -10112,7 +10749,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (bb && !bb.isEmpty() && bb.distanceToPoint(lp) > r) return false;
       if (!this.ownGeometry(mv)) return false;
       const work = mv.host ? mv.host.work : mv.work;
-      const pos = positionAttr(mesh.geometry);
+      const pos = positionAttr(mesh2.geometry);
       const r2 = r * r;
       let touched = false;
       const px = lp.x;
@@ -10178,11 +10815,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     // Decals
     // ------------------------------------------------------------------------------------------------------------------------------------
     /** Decal pose in mesh space: position and a rotation taking +Z to the surface normal. */
-    decalPose(mesh, worldPoint, worldNormal, lift) {
-      mesh.updateWorldMatrix(true, false);
-      const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
-      const ln = worldNormal.clone().transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
-      const pos = mesh.worldToLocal(worldPoint.clone()).addScaledVector(ln, lift / s);
+    decalPose(mesh2, worldPoint, worldNormal, lift) {
+      mesh2.updateWorldMatrix(true, false);
+      const s = mesh2.matrixWorld.getMaxScaleOnAxis() || 1;
+      const ln = worldNormal.clone().transformDirection(this.m4.copy(mesh2.matrixWorld).invert()).normalize();
+      const pos = mesh2.worldToLocal(worldPoint.clone()).addScaledVector(ln, lift / s);
       const quat2 = new this.THREE.Quaternion().setFromUnitVectors(new this.THREE.Vector3(0, 0, 1), ln);
       return { s, pos, quat: quat2 };
     }
@@ -10318,7 +10955,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (Math.abs(m - pv.meltApplied) < 0.01) return;
       pv.meltApplied = m;
       for (const mv of pv.meshes) {
-        const mesh = mv.mesh;
+        const mesh2 = mv.mesh;
         if (mv.host) {
           mv.meltApplied = m;
           mv.touched = true;
@@ -10326,27 +10963,27 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           continue;
         }
         if (mv.meltApplied === 0 && m > 0) {
-          mesh.updateWorldMatrix(true, false);
-          mv.bottomY = this.box.setFromObject(mesh).min.y;
+          mesh2.updateWorldMatrix(true, false);
+          mv.bottomY = this.box.setFromObject(mesh2).min.y;
         }
         mv.meltApplied = m;
         mv.moved = true;
         const sy = lerp5(1, 0.25, m);
         const sxz = 1 + 0.18 * m;
-        mesh.scale.set(mv.origScale.x * sxz, mv.origScale.y * sy, mv.origScale.z * sxz);
-        mesh.position.copy(mv.origPosition);
-        mesh.updateWorldMatrix(true, false);
-        const bottom = this.box.setFromObject(mesh).min.y;
+        mesh2.scale.set(mv.origScale.x * sxz, mv.origScale.y * sy, mv.origScale.z * sxz);
+        mesh2.position.copy(mv.origPosition);
+        mesh2.updateWorldMatrix(true, false);
+        const bottom = this.box.setFromObject(mesh2).min.y;
         const dy = mv.bottomY - bottom;
-        if (Math.abs(dy) > 1e-6 && mesh.parent) {
-          mesh.parent.updateWorldMatrix(true, false);
-          const inv = this.m4.copy(mesh.parent.matrixWorld).invert();
+        if (Math.abs(dy) > 1e-6 && mesh2.parent) {
+          mesh2.parent.updateWorldMatrix(true, false);
+          const inv = this.m4.copy(mesh2.parent.matrixWorld).invert();
           this.a.set(0, dy, 0).applyMatrix4(inv);
           this.b.set(0, 0, 0).applyMatrix4(inv);
-          mesh.position.copy(mv.origPosition).add(this.a.sub(this.b));
+          mesh2.position.copy(mv.origPosition).add(this.a.sub(this.b));
         }
         if (!(this.lowQuality && this.vertexCount(mv) > 2e4) && this.ownGeometry(mv)) {
-          this.writePositions(mv, positionAttr(mesh.geometry));
+          this.writePositions(mv, positionAttr(mesh2.geometry));
         }
       }
     }
@@ -10424,10 +11061,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 noise2 = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
+        const noise = (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 - noise * 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. */
@@ -10619,30 +11256,30 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.restoreRanged(mv);
         return;
       }
-      const mesh = mv.mesh;
+      const mesh2 = mv.mesh;
       for (const d of mv.decals) this.disposeDecal(d);
       mv.decals.length = 0;
       if (mv.ownGeo) {
-        mesh.geometry.dispose();
-        mesh.geometry = mv.origGeometry;
+        mesh2.geometry.dispose();
+        mesh2.geometry = mv.origGeometry;
         mv.ownGeo = false;
         mv.work = null;
       }
       if (mv.ownMat) {
-        for (const m of materialsOf(mesh.material)) m.dispose();
-        mesh.material = mv.origMaterial;
+        for (const m of materialsOf(mesh2.material)) m.dispose();
+        mesh2.material = mv.origMaterial;
         mv.ownMat = false;
         mv.baseColors = null;
       }
-      mesh.visible = mv.origVisible;
-      if (mv.origParent && mesh.parent !== mv.origParent) {
-        mv.origParent.add(mesh);
+      mesh2.visible = mv.origVisible;
+      if (mv.origParent && mesh2.parent !== mv.origParent) {
+        mv.origParent.add(mesh2);
         mv.moved = true;
       }
       if (mv.moved) {
-        mesh.position.copy(mv.origPosition);
-        mesh.quaternion.copy(mv.origQuaternion);
-        mesh.scale.copy(mv.origScale);
+        mesh2.position.copy(mv.origPosition);
+        mesh2.quaternion.copy(mv.origQuaternion);
+        mesh2.scale.copy(mv.origScale);
         mv.moved = false;
       }
       mv.meltApplied = 0;
@@ -11780,6 +12417,56 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     };
   }
   var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
+  var ATTACK = 2e-3;
+  function 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 sceneNoise(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 sceneTone(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 sceneMany = (count, make) => Array.from({ length: count }, make);
+  function sceneRecipe(id, layers, line, options = {}) {
+    return {
+      id,
+      bus: options.bus ?? "world",
+      pan: true,
+      layers,
+      falloff: DISTANCE_CURVES.art_scene,
+      ...options.vars ? { vars: options.vars } : {},
+      ...options.group ? { group: options.group } : {},
+      sources: [`cena:${line}`]
+    };
+  }
   var BENCH_BANK = {
     id: "audio_bench",
     sounds: [
@@ -11827,88 +12514,42 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   };
 
   // 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 scene = (id, layers, line, vars) => sceneRecipe(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] }))
+    sceneNoise({ f: 1200, f2: 120, d: 1.8, vol: 2, wet: 1.2 }),
+    sceneTone({ f: 65, f2: 24, d: 1, vol: 1.8 }),
+    sceneNoise({ type: "highpass", f: 1500, d: 0.2, vol: 0.8 }),
+    ...big ? [sceneNoise({ f: 500, f2: 90, a: 0.2, d: 2.4, vol: 1.2, wet: 1, delay: 0.15 })] : [],
+    ...sceneMany(8, () => sceneTone({ 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] }))],
+      [sceneNoise({ type: "highpass", f: 2800, d: 0.45, vol: 0.9, wet: 0.5 }), ...sceneMany(12, () => sceneTone({ 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 })],
+      [sceneNoise({ type: "bandpass", f: 850, q: 1, d: 0.25, vol: 0.9, wet: 0.3 }), sceneTone({ f: 210, f2: 90, d: 0.1, vol: 0.6 }), sceneNoise({ 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", [sceneNoise({ type: "bandpass", f: 700, q: 2, d: 0.07, vol: 0.4 })], "L1361 thunk"),
+    scene("ping", [sceneTone({ f: [2600, 3500], f2: 1400, d: 0.14, vol: 0.18, wet: 0.3 })], "L1362 ping"),
+    scene("clang", [sceneTone({ f: [520, 720], f2: 480, d: 0.5, vol: 0.35, wet: 0.4 }), sceneTone({ f: 1370, f2: 1300, d: 0.3, vol: 0.15 }), sceneNoise({ type: "highpass", f: 2e3, d: 0.05, vol: 0.5 })], "L1363 clang"),
+    scene("chip", [sceneNoise({ 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] }))],
+      [sceneNoise({ f: 900, f2: 200, d: 0.6, vol: 0.9, wet: 0.3 }), ...sceneMany(5, () => sceneNoise({ 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", [sceneTone({ f: 75, f2: 38, d: 0.22, vol: { param: "scale", scale: 0.6 } }), sceneNoise({ 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", [sceneNoise({ 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", [sceneNoise({ f: 700, f2: 120, d: 0.7, vol: 1.4, wet: 0.5 }), sceneNoise({ type: "highpass", f: 3e3, a: 0.05, d: 1.2, vol: 0.4, delay: 0.1 })], "L1357 burst"),
+    scene("crack", [sceneNoise({ type: "highpass", f: 1800, d: 0.05, vol: 0.8 }), sceneTone({ f: 420, f2: 180, d: 0.06, vol: 0.4 })], "L1354 crack")
   ];
   var EXPLOSION_BOOM = {
     id: "explosion_boom",