@adatechnology/game-destruction-three 0.11.0 → 0.12.0

package/dist/index.js

@@ -7,6 +7,9 @@ import { blastShove } from "@adatechnology/game-contracts";
 import { createVfx, effectForEvent, EVENT_EFFECTS_MAP } from "@adatechnology/game-vfx";
 import { createVfxRenderer } from "@adatechnology/game-vfx-three";
 
+// src/fragments.ts
+import { markKitOrigin } from "@adatechnology/game-contracts";
+
 // src/fitted-boxes.ts
 var SLICE_LENGTH = 0.12;
 var MAX_SLICES = 12;
@@ -88,6 +91,7 @@ var SHEET_AIR = 2.5;
 var SHEET_SWAY = 3;
 var BIG_LENGTH = 0.2;
 var BIG_WIDTH = 0.03;
+var FRAGMENT_SEED = 1374496523;
 var isBig = (size) => {
   const [, middle, longest] = [...size].sort((a, b) => a - b);
   return longest >= BIG_LENGTH && middle >= BIG_WIDTH;
@@ -107,7 +111,7 @@ var FragmentSystem = class {
     __publicField(this, "m");
     __publicField(this, "v");
     __publicField(this, "w");
-    __publicField(this, "rng", createRng(1374496523));
+    __publicField(this, "rng", createRng(FRAGMENT_SEED));
     /** Count of `update` calls: what makes the fragments of one burst tell apart from older ones. */
     __publicField(this, "tick", 0);
     __publicField(this, "markGeometry", null);
@@ -208,6 +212,8 @@ var FragmentSystem = class {
     mesh.scale.copy(sc);
     mesh.castShadow = true;
     mesh.userData.destructionDebris = true;
+    mesh.name = "fragment";
+    markKitOrigin(mesh, { owner: "game-destruction-three", kind: "fragment", id: f.material });
     this.o.scene.add(mesh);
     const live = {
       mesh,
@@ -224,7 +230,8 @@ var FragmentSystem = class {
       dying: false,
       air: f.shape === "scrap" && sz[2] <= SHEET_MAX ? SHEET_AIR : 0,
       body: null,
-      born: this.tick
+      born: this.tick,
+      life: Math.max(0, typeof this.o.life === "function" ? this.o.life(f, home) : this.o.life)
     };
     if (f.shape !== "shard" && isBig(f.size)) {
       live.body = {
@@ -233,8 +240,7 @@ var FragmentSystem = class {
           live.vel.x = x;
           live.vel.z = z;
           live.vel.y = Math.max(live.vel.y, 0.3);
-          live.asleep = false;
-          live.rest = 0;
+          this.rouse(live);
         }
       };
     }
@@ -269,16 +275,20 @@ var FragmentSystem = class {
       d.y += k * 0.4;
       f.vel.add(d);
       f.ang.add(this.w.set(this.rng() - 0.5, this.rng() - 0.5, this.rng() - 0.5).multiplyScalar(k));
-      f.asleep = false;
-      f.rest = 0;
+      this.rouse(f);
     }
   }
+  /** A fragment that came to rest stops having its matrix recomputed on every frame; whatever moves it again calls this first. */
+  rouse(f) {
+    f.asleep = false;
+    f.rest = 0;
+    f.mesh.matrixAutoUpdate = true;
+  }
   /** What lies inside the disc looks at the ground again: it was dug or heaped under it. */
   wakeRegion(x, z, radius) {
     for (const f of this.list) {
       if (!f.asleep || Math.hypot(f.mesh.position.x - x, f.mesh.position.z - z) > radius) continue;
-      f.asleep = false;
-      f.rest = 0;
+      this.rouse(f);
     }
   }
   update(dt) {
@@ -287,6 +297,7 @@ var FragmentSystem = class {
     for (let i = this.list.length - 1; i >= 0; i--) {
       const f = this.list[i];
       if (f.dying) {
+        f.mesh.matrixAutoUpdate = true;
         f.fade -= dt / 0.6;
         if (f.fade <= 0) {
           this.o.scene.remove(f.mesh);
@@ -297,7 +308,10 @@ var FragmentSystem = class {
       }
       if (f.asleep) {
         f.rest += dt;
-        if (this.o.life > 0 && f.rest > this.o.life && !f.body) f.dying = true;
+        if (f.life > 0 && f.rest > f.life && !f.body) {
+          f.dying = true;
+          f.mesh.matrixAutoUpdate = true;
+        }
         continue;
       }
       this.step(f, dt, g);
@@ -346,6 +360,8 @@ var FragmentSystem = class {
       f.still += dt;
       if (f.still > 0.4) {
         f.asleep = true;
+        f.mesh.updateMatrix();
+        f.mesh.matrixAutoUpdate = false;
         f.vel.set(0, 0, 0);
         f.ang.set(0, 0, 0);
       }
@@ -395,6 +411,12 @@ var FragmentSystem = class {
     for (const f of this.list) this.o.scene.remove(f.mesh);
     this.list.length = 0;
   }
+  /** `clear`, the random stream back to its seed and the tick to 0: what comes next flies as on a new system. */
+  reset() {
+    this.clear();
+    this.rng = createRng(FRAGMENT_SEED);
+    this.tick = 0;
+  }
   dispose() {
     this.clear();
     this.box.dispose();
@@ -493,6 +515,9 @@ var GroundSpots = class {
 var SUB_DT = 1 / 120;
 var MU = 0.7;
 var SLEEP_AFTER = 0.5;
+var CALM_DRIFT = 0.01;
+var CALM_TURN = 0.05;
+var CALM_SLEEP_AFTER = 1.5;
 var HARD_LANDING = 3;
 var SLOP = 2e-3;
 var NARROW = 0.3;
@@ -501,6 +526,10 @@ var TIP_ACCELERATION = 30;
 var TIP_LYING = 0.25;
 var TIP_SECONDS = 3;
 var STEP = 0.03;
+var WARM_SLOTS = 8 + 12 * 7;
+var SOLVER_PASSES = 10;
+var SIDE_BOUNCE = 0.1;
+var EDGE_POINTS = [-0.75, -0.5, -0.25, 0, 0.25, 0.5, 0.75];
 var boxTopAt = (s, x, z) => {
   const e = s.e;
   const dx = x - s.c[0], dz = z - s.c[2];
@@ -571,6 +600,8 @@ var PieceSystem = class {
       localCenter: [localCenter.x, localCenter.y, localCenter.z],
       centerV: localCenter.clone(),
       still: 0,
+      calmAt: null,
+      calm: 0,
       lastHit: -1,
       onGround: false
     };
@@ -589,6 +620,11 @@ var PieceSystem = class {
   clear() {
     this.list.length = 0;
   }
+  /** `clear` and the clock back to 0. */
+  reset() {
+    this.clear();
+    this.time = 0;
+  }
   /** World position of the centre of mass. */
   centerOf(b, out) {
     return out.copy(b.centerV).applyQuaternion(b.root.quaternion).add(b.root.position);
@@ -613,6 +649,7 @@ var PieceSystem = class {
     }
     b.sleeping = false;
     b.still = 0;
+    b.calmAt = null;
   }
   /** I^-1 * (x, y, z) in world space for a box with the body's half extents and mass (needs `this.m` to hold the body's rotation). */
   mulInvInertia(b, x, y, z) {
@@ -630,12 +667,51 @@ var PieceSystem = class {
     const lz = (e[8] * x + e[9] * y + e[10] * z) * iz;
     return [e[0] * lx + e[4] * ly + e[8] * lz, e[1] * lx + e[5] * ly + e[9] * lz, e[2] * lx + e[6] * ly + e[10] * lz];
   }
+  /** The points of the box that touch the ground, in its own frame: the 8 corners, then (with `edges`) `EDGE_POINTS` along each of its 12 edges. */
+  samples(b, edges) {
+    const [hx, hy, hz] = b.halfExtents;
+    const out = [];
+    for (let i = 0; i < 8; i++) out.push([i & 1 ? hx : -hx, i & 2 ? hy : -hy, i & 4 ? hz : -hz]);
+    if (!edges) return out;
+    const h = [hx, hy, hz];
+    for (let axis = 0; axis < 3; axis++) {
+      const a1 = (axis + 1) % 3;
+      const a2 = (axis + 2) % 3;
+      for (let k = 0; k < 4; k++) {
+        for (const f of EDGE_POINTS) {
+          const p = [0, 0, 0];
+          p[axis] = f * h[axis];
+          p[a1] = k & 1 ? h[a1] : -h[a1];
+          p[a2] = k & 2 ? h[a2] : -h[a2];
+          out.push(p);
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * An impulse along the unit normal `n` at `r` (from the centre of mass, world) that stops the point closing in along `n` (with `bounce`); `e` holds the body's rotation.
+   */
+  contactImpulse(b, e, r, n, bounce) {
+    const v = b.velocity;
+    const w = b.angularVelocity;
+    const vn = (v[0] + w[1] * r[2] - w[2] * r[1]) * n[0] + (v[1] + w[2] * r[0] - w[0] * r[2]) * n[1] + (v[2] + w[0] * r[1] - w[1] * r[0]) * n[2];
+    if (vn >= 0) return;
+    const a = this.mulInvInertiaWith(b, e, r[1] * n[2] - r[2] * n[1], r[2] * n[0] - r[0] * n[2], r[0] * n[1] - r[1] * n[0]);
+    const k = (a[1] * r[2] - a[2] * r[1]) * n[0] + (a[2] * r[0] - a[0] * r[2]) * n[1] + (a[0] * r[1] - a[1] * r[0]) * n[2];
+    const j = -(1 + bounce) * vn / (1 / b.mass + k);
+    for (let i = 0; i < 3; i++) {
+      v[i] += j * n[i] / b.mass;
+      w[i] += a[i] * j;
+    }
+  }
   /** What lies inside the disc looks at the ground again: it was dug or heaped under it. */
   wakeRegion(x, z, radius) {
     for (const b of this.list) {
       if (!b.sleeping || b.held || Math.hypot(b.root.position.x - x, b.root.position.z - z) > radius) continue;
       b.sleeping = false;
       b.still = 0;
+      b.calmAt = null;
     }
   }
   update(dt) {
@@ -651,6 +727,7 @@ var PieceSystem = class {
         b.angularVelocity = [0, 0, 0];
         b.sleeping = false;
         b.still = 0;
+        b.calmAt = null;
         continue;
       }
       if (b.sleeping) continue;
@@ -675,7 +752,6 @@ var PieceSystem = class {
     const q = this.q.copy(b.root.quaternion);
     const v = b.velocity;
     const w = b.angularVelocity;
-    const [hx, hy, hz] = b.halfExtents;
     const invM = 1 / b.mass;
     const steps = clamp(Math.ceil(dt / SUB_DT), 1, 8);
     const h = dt / steps;
@@ -684,7 +760,30 @@ var PieceSystem = class {
     let contactedLast = false;
     let touched = false;
     let unstable = false;
+    const corners = this.samples(b, false);
+    this.m.makeRotationFromQuaternion(q);
+    let gLow = Infinity;
+    let gHigh = -Infinity;
+    for (const [sx, sy, sz] of corners) {
+      const e0 = this.m.elements;
+      const y = pos[1] + e0[1] * sx + e0[5] * sy + e0[9] * sz;
+      const x = pos[0] + e0[0] * sx + e0[4] * sy + e0[8] * sz;
+      const z = pos[2] + e0[2] * sx + e0[6] * sy + e0[10] * sz;
+      const g = Math.max(this.o.groundAt(x, z), this.o.staticTopAt?.(x, z, y, STEP) ?? -Infinity);
+      gLow = Math.min(gLow, g);
+      gHigh = Math.max(gHigh, g);
+    }
+    const local = gHigh - gLow > STEP ? this.samples(b, true) : corners;
+    const prev = local.map(() => [0, 0, 0]);
     for (let s = 0; s < steps; s++) {
+      this.m.makeRotationFromQuaternion(q);
+      const e0 = this.m.elements;
+      for (let i = 0; i < local.length; i++) {
+        const [sx, sy, sz] = local[i];
+        prev[i][0] = pos[0] + e0[0] * sx + e0[4] * sy + e0[8] * sz;
+        prev[i][1] = pos[1] + e0[1] * sx + e0[5] * sy + e0[9] * sz;
+        prev[i][2] = pos[2] + e0[2] * sx + e0[6] * sy + e0[10] * sz;
+      }
       v[1] -= this.o.gravity * h;
       pos[0] += v[0] * h;
       pos[1] += v[1] * h;
@@ -701,20 +800,60 @@ var PieceSystem = class {
       this.m.makeRotationFromQuaternion(q);
       const e = this.m.elements;
       const rs = [];
+      const ids = [];
       let maxPen = 0;
-      for (let i = 0; i < 8; i++) {
-        const sx = i & 1 ? hx : -hx;
-        const sy = i & 2 ? hy : -hy;
-        const sz = i & 4 ? hz : -hz;
+      const rise = STEP + Math.max(0, -v[1]) * h * 2;
+      let side = null;
+      let lowest = Infinity;
+      for (let i = 0; i < local.length; i++) {
+        const [sx, sy, sz] = local[i];
         const r = [e[0] * sx + e[4] * sy + e[8] * sz, e[1] * sx + e[5] * sy + e[9] * sz, e[2] * sx + e[6] * sy + e[10] * sz];
+        const px = pos[0] + r[0];
+        const pz = pos[2] + r[2];
         const cy = pos[1] + r[1];
-        const gy = this.supportAt(b, pos[0] + r[0], cy, pos[2] + r[2], STEP + Math.max(0, -v[1]) * h * 2);
+        const was = prev[i];
+        const raw = this.o.groundAt(px, pz);
+        if (raw > cy - SLOP && was[1] < raw - STEP) {
+          if (this.o.groundAt(was[0], was[2]) >= raw - STEP) {
+            const floor = b.floor;
+            if (floor !== void 0 && floor - cy > -SLOP && floor < raw - STEP) {
+              rs.push(r);
+              ids.push(i);
+              maxPen = Math.max(maxPen, floor - cy);
+            }
+            continue;
+          }
+          const dx = px - was[0];
+          const dz = pz - was[2];
+          const len = Math.hypot(dx, dz);
+          if (len > 1e-6) {
+            let lo = 0;
+            let hi = 1;
+            for (let it = 0; it < 6; it++) {
+              const mid = (lo + hi) / 2;
+              if (this.o.groundAt(was[0] + dx * mid, was[2] + dz * mid) >= raw - STEP) hi = mid;
+              else lo = mid;
+            }
+            const back = (1 - lo) * len + 1e-3;
+            if (!side || back > side.back) side = { back, dir: [dx / len, dz / len], r };
+          }
+          continue;
+        }
+        const gy = i < 8 ? this.supportAt(b, px, cy, pz, rise) : Math.max(raw, this.o.staticTopAt?.(px, pz, cy, rise) ?? -Infinity);
         const pen = gy - cy;
         if (pen > -SLOP) {
           rs.push(r);
+          ids.push(i);
           if (pen > maxPen) maxPen = pen;
+          lowest = Math.min(lowest, gy);
         }
       }
+      if (lowest < Infinity) b.floor = lowest;
+      if (side) {
+        pos[0] -= side.dir[0] * side.back;
+        pos[2] -= side.dir[1] * side.back;
+        this.contactImpulse(b, e, side.r, [-side.dir[0], 0, -side.dir[1]], SIDE_BOUNCE);
+      }
       contactedLast = rs.length > 0;
       if (contactedLast) touched = true;
       if (!contactedLast) continue;
@@ -734,45 +873,88 @@ var PieceSystem = class {
         const lz = pos[2] + sz / rs.length;
         landPoint = [lx, pos[1] - Math.max(...rs.map((r) => -r[1])), lz];
       }
-      for (let it = 0; it < 4; it++) {
-        for (const r of rs) {
-          let vx = v[0] + (w[1] * r[2] - w[2] * r[1]);
-          let vy = v[1] + (w[2] * r[0] - w[0] * r[2]);
-          let vz = v[2] + (w[0] * r[1] - w[1] * r[0]);
-          const vn = vy;
-          if (vn >= 0) continue;
+      const goal = rs.map((r) => {
+        const vy = v[1] + (w[2] * r[0] - w[0] * r[2]);
+        return vy < 0 ? -restitution * vy : 0;
+      });
+      const vx0 = v[0];
+      const vz0 = v[2];
+      if (!b.warm || b.warm.length !== WARM_SLOTS * 3) b.warm = new Float64Array(WARM_SLOTS * 3);
+      const warm = b.warm;
+      const accN = ids.map((id) => id < WARM_SLOTS ? warm[id * 3] : 0);
+      const accT = ids.map((id) => id < WARM_SLOTS ? [warm[id * 3 + 1], warm[id * 3 + 2]] : [0, 0]);
+      for (let k = 0; k < rs.length; k++) {
+        const r = rs[k];
+        const jn = accN[k];
+        const [fx, fz] = accT[k];
+        if (jn === 0 && fx === 0 && fz === 0) continue;
+        v[0] += fx * invM;
+        v[1] += jn * invM;
+        v[2] += fz * invM;
+        const dw = this.mulInvInertiaWith(b, e, r[1] * fz - r[2] * jn, r[2] * fx - r[0] * fz, r[0] * jn - r[1] * fx);
+        w[0] += dw[0];
+        w[1] += dw[1];
+        w[2] += dw[2];
+      }
+      for (let it = 0; it < SOLVER_PASSES; it++) {
+        for (let k = 0; k < rs.length; k++) {
+          const r = rs[k];
+          const vy = v[1] + (w[2] * r[0] - w[0] * r[2]);
           const a = this.mulInvInertiaWith(b, e, -r[2], 0, r[0]);
           const denom = invM + (a[2] * r[0] - a[0] * r[2]);
-          const j = -(1 + (it === 0 ? restitution : 0)) * vn / denom;
-          v[1] += j * invM;
-          const dw = this.mulInvInertiaWith(b, e, -r[2] * j, 0, r[0] * j);
-          w[0] += dw[0];
-          w[1] += dw[1];
-          w[2] += dw[2];
-          vx = v[0] + (w[1] * r[2] - w[2] * r[1]);
-          vy = v[1] + (w[2] * r[0] - w[0] * r[2]);
-          vz = v[2] + (w[0] * r[1] - w[1] * r[0]);
+          const total = Math.max(0, accN[k] + (goal[k] - vy) / denom);
+          const j = total - accN[k];
+          accN[k] = total;
+          if (j !== 0) {
+            v[1] += j * invM;
+            w[0] += a[0] * j;
+            w[1] += a[1] * j;
+            w[2] += a[2] * j;
+          }
+          const vx = v[0] + (w[1] * r[2] - w[2] * r[1]);
+          const vz = v[2] + (w[0] * r[1] - w[1] * r[0]);
           const vt = Math.hypot(vx, vz);
-          if (vt > 1e-5) {
+          if (vt < 1e-6 && accT[k][0] === 0 && accT[k][1] === 0) continue;
+          let fx = accT[k][0];
+          let fz = accT[k][1];
+          if (vt > 1e-6) {
             const tx = vx / vt;
             const tz = vz / vt;
-            const rx = r[1] * tz;
-            const ry = r[2] * tx - r[0] * tz;
-            const rz = -r[1] * tx;
-            const at = this.mulInvInertiaWith(b, e, rx, ry, rz);
+            const at = this.mulInvInertiaWith(b, e, r[1] * tz, r[2] * tx - r[0] * tz, -r[1] * tx);
             const cx = at[1] * r[2] - at[2] * r[1];
             const cz = at[0] * r[1] - at[1] * r[0];
-            const denomT = invM + cx * tx + cz * tz;
-            const jt = Math.min(vt / denomT, MU * j);
-            v[0] -= tx * jt * invM;
-            v[2] -= tz * jt * invM;
-            const dwt = this.mulInvInertiaWith(b, e, rx * jt, ry * jt, rz * jt);
-            w[0] -= dwt[0];
-            w[1] -= dwt[1];
-            w[2] -= dwt[2];
+            const jt = vt / (invM + cx * tx + cz * tz);
+            fx -= tx * jt;
+            fz -= tz * jt;
           }
+          const most = MU * accN[k];
+          const f = Math.hypot(fx, fz);
+          if (f > most) {
+            fx *= most / f;
+            fz *= most / f;
+          }
+          const dx = fx - accT[k][0];
+          const dz = fz - accT[k][1];
+          accT[k] = [fx, fz];
+          if (dx === 0 && dz === 0) continue;
+          v[0] += dx * invM;
+          v[2] += dz * invM;
+          const dw = this.mulInvInertiaWith(b, e, r[1] * dz, r[2] * dx - r[0] * dz, -r[1] * dx);
+          w[0] += dw[0];
+          w[1] += dw[1];
+          w[2] += dw[2];
         }
       }
+      pos[0] += (v[0] - vx0) * h;
+      pos[2] += (v[2] - vz0) * h;
+      warm.fill(0);
+      for (let k = 0; k < rs.length; k++) {
+        const id = ids[k];
+        if (id >= WARM_SLOTS) continue;
+        warm[id * 3] = accN[k];
+        warm[id * 3 + 1] = accT[k][0];
+        warm[id * 3 + 2] = accT[k][1];
+      }
       let x0 = Infinity, x1 = -Infinity, z0 = Infinity, z1 = -Infinity, low = 0;
       for (const r of rs) {
         x0 = Math.min(x0, r[0]);
@@ -787,7 +969,9 @@ var PieceSystem = class {
       unstable = Math.min(wx, wz) < NARROW * height || x0 > 0 || x1 < 0 || z0 > 0 || z1 < 0;
       if (b.tipping) {
         b.tipping.seconds -= h;
-        if (height < TIP_LYING || b.tipping.seconds <= 0) b.tipping = null;
+        const [hx, hy, hz] = b.halfExtents;
+        const upHalf = Math.abs(e[1]) * hx + Math.abs(e[5]) * hy + Math.abs(e[9]) * hz;
+        if (upHalf < TIP_LYING || b.tipping.seconds <= 0) b.tipping = null;
         else {
           w[0] += b.tipping.x * TIP_ACCELERATION * h;
           w[2] += b.tipping.z * TIP_ACCELERATION * h;
@@ -819,16 +1003,26 @@ var PieceSystem = class {
       this.o.onHardLanding(b, landPoint, landing);
     }
     const still = touched && !unstable && Math.hypot(v[0], v[1], v[2]) < 0.12 && Math.hypot(w[0], w[1], w[2]) < 0.45;
-    if (still) {
-      b.still += dt;
-      if (b.still >= SLEEP_AFTER) {
-        b.sleeping = true;
-        v[0] = v[1] = v[2] = 0;
-        w[0] = w[1] = w[2] = 0;
-      }
-    } else {
-      b.still = 0;
-    }
+    if (still) b.still += dt;
+    else b.still = 0;
+    if (b.still >= SLEEP_AFTER || this.staysInPlace(b, touched && !b.tipping, pos, q, dt)) {
+      b.sleeping = true;
+      b.calmAt = null;
+      v[0] = v[1] = v[2] = 0;
+      w[0] = w[1] = w[2] = 0;
+    }
+  }
+  /** Whether the piece has kept to the same spot on the ground for `CALM_SLEEP_AFTER` (see `CALM_DRIFT`). */
+  staysInPlace(b, touched, center, q, dt) {
+    const at = b.calmAt;
+    const turned = at ? 2 * Math.acos(Math.min(1, Math.abs(at.quaternion[0] * q.x + at.quaternion[1] * q.y + at.quaternion[2] * q.z + at.quaternion[3] * q.w))) : Infinity;
+    if (!touched || !at || Math.hypot(center[0] - at.center[0], center[1] - at.center[1], center[2] - at.center[2]) > CALM_DRIFT || turned > CALM_TURN) {
+      b.calmAt = touched ? { center: [center[0], center[1], center[2]], quaternion: [q.x, q.y, q.z, q.w] } : null;
+      b.calm = 0;
+      return false;
+    }
+    b.calm += dt;
+    return b.calm >= CALM_SLEEP_AFTER;
   }
   /** Half the height of the box of a piece as it is turned now. */
   halfHeight(b) {
@@ -846,8 +1040,9 @@ var PieceSystem = class {
       const a = this.list[i];
       for (let j = i + 1; j < n; j++) {
         const b = this.list[j];
-        if (a.held && b.held) continue;
-        if (a.sleeping && b.sleeping) continue;
+        const fixedA = a.held || a.sleeping;
+        const fixedB = b.held || b.sleeping;
+        if (fixedA && fixedB) continue;
         const ra = Math.hypot(a.halfExtents[0], a.halfExtents[1], a.halfExtents[2]);
         const rb = Math.hypot(b.halfExtents[0], b.halfExtents[1], b.halfExtents[2]);
         this.centerOf(a, ca);
@@ -865,19 +1060,17 @@ var PieceSystem = class {
           d = 1;
         }
         const push = Math.min(maxMove, (rh - d) * 0.5);
-        const wa = a.held ? 0 : b.held ? 1 : b.mass / (a.mass + b.mass);
-        const wb = b.held ? 0 : a.held ? 1 : a.mass / (a.mass + b.mass);
+        const wa = fixedA ? 0 : fixedB ? 1 : b.mass / (a.mass + b.mass);
+        const wb = fixedB ? 0 : fixedA ? 1 : a.mass / (a.mass + b.mass);
         const ux = dx / (d || 1);
         const uz = dz / (d || 1);
-        if (!a.held) {
+        if (!fixedA) {
           a.root.position.x -= ux * push * 2 * wa;
           a.root.position.z -= uz * push * 2 * wa;
-          a.sleeping = false;
         }
-        if (!b.held) {
+        if (!fixedB) {
           b.root.position.x += ux * push * 2 * wb;
           b.root.position.z += uz * push * 2 * wb;
-          b.sleeping = false;
         }
       }
     }
@@ -1014,6 +1207,7 @@ function specFromObject3D(THREE, root, options = {}) {
         const fill = options.fillOf?.(o, material);
         const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
         const contains = containsOf(ud.destructionContains);
+        const powder = typeof ud.destructionPowder?.color === "number" ? { color: ud.destructionPowder.color } : void 0;
         const thickness = typeof ud.destructionThickness === "number" && ud.destructionThickness > 0 ? ud.destructionThickness : void 0;
         const existing = explicit ? byKey.get(explicit) : void 0;
         if (existing) {
@@ -1027,9 +1221,10 @@ function specFromObject3D(THREE, root, options = {}) {
           existing.skin = existing.skin && skin;
           if (fill !== void 0) existing.fill = fill;
           if (contains) existing.contains = contains;
+          if (powder) existing.powder = powder;
           if (thickness !== void 0) existing.thickness = Math.min(existing.thickness ?? thickness, thickness);
         } else {
-          const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, skin, tags, fixedId: !!explicit, ...contains ? { contains } : {}, ...thickness !== void 0 ? { thickness } : {}, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
+          const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, skin, tags, fixedId: !!explicit, ...contains ? { contains } : {}, ...powder ? { powder } : {}, ...thickness !== void 0 ? { thickness } : {}, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
           entries.push(e);
           if (explicit) byKey.set(explicit, e);
         }
@@ -1104,6 +1299,7 @@ function specFromObject3D(THREE, root, options = {}) {
     }
     if (e.tags) part.tags = [...e.tags];
     if (e.contains) part.contains = { ...e.contains };
+    if (e.powder) part.powder = { ...e.powder };
     const ao = options.anchorBelow ?? -1;
     if (ao >= 0 && e.box.min.y <= ao) part.anchored = true;
     parts.push(part);
@@ -1284,6 +1480,22 @@ var SKIN_FOLLOW = 0.85;
 var SKIN_SLACK = 5e-4;
 var SKIN_LAYER_SLACK = 4;
 var NEAREST_MARGIN = 1.5;
+var basePositions = (host) => {
+  const p0 = host.mesh.userData._p0;
+  if (p0) return p0;
+  const op = positionAttr(host.origGeometry);
+  return op ? op.array : null;
+};
+var collapseForeign = (mesh, arr) => {
+  for (const [v0, v1] of mesh.userData.collapsedRanges ?? []) {
+    for (let k = v0 + 1; k < v1; k++) {
+      arr[k * 3] = arr[v0 * 3];
+      arr[k * 3 + 1] = arr[v0 * 3 + 1];
+      arr[k * 3 + 2] = arr[v0 * 3 + 2];
+    }
+  }
+};
+var DECAL_SNAP = 0.03;
 var Visuals = class {
   constructor(THREE, lowQuality, decalCap) {
     __publicField(this, "THREE", THREE);
@@ -1293,6 +1505,7 @@ var Visuals = class {
     __publicField(this, "a");
     __publicField(this, "b");
     __publicField(this, "m4");
+    __publicField(this, "ray");
     __publicField(this, "box");
     __publicField(this, "t");
     __publicField(this, "lbox");
@@ -1303,6 +1516,7 @@ var Visuals = class {
     this.a = tmpV(THREE);
     this.b = tmpV(THREE);
     this.m4 = new THREE.Matrix4();
+    this.ray = new THREE.Raycaster();
     this.box = new THREE.Box3();
     this.t = tmpV(THREE);
     this.lbox = new THREE.Box3();
@@ -1456,7 +1670,7 @@ var Visuals = class {
     host.ownGeo = true;
     const g = host.mesh.geometry.clone();
     host.mesh.geometry = g;
-    host.work = new Float32Array(positionAttr(g).array);
+    host.work = new Float32Array(basePositions(host) ?? positionAttr(g).array);
     return true;
   }
   // ------------------------------------------------------------------------------------------------------------------------------------
@@ -1626,12 +1840,38 @@ var Visuals = class {
   // ------------------------------------------------------------------------------------------------------------------------------------
   // Decals
   // ------------------------------------------------------------------------------------------------------------------------------------
+  /**
+   * The point on the drawn face of `mesh` under a world point, within `DECAL_SNAP` metres along the normal: the world's box of a part and the face
+   * the renderer drew (a coat of plaster, a merged house mesh) can be a few millimetres apart, and a mark behind the drawn face does not show.
+   */
+  onFace(mesh, worldPoint, worldNormal) {
+    if (!mesh.isMesh || !mesh.geometry?.attributes?.position) return worldPoint;
+    const n = worldNormal.clone().normalize();
+    this.ray.set(worldPoint.clone().addScaledVector(n, DECAL_SNAP), n.clone().negate());
+    this.ray.near = 0;
+    this.ray.far = 2 * DECAL_SNAP;
+    const hits = [];
+    mesh.raycast(this.ray, hits);
+    for (const c of mesh.parent?.children ?? []) {
+      if (c === mesh || c.name !== "breach-shell") continue;
+      c.raycast(this.ray, hits);
+      const behind = c.userData.behind?.();
+      if (behind) behind.raycast(this.ray, hits);
+    }
+    let best = null;
+    for (const h of hits) {
+      if (h.object.userData.cutAt?.(h.point)) continue;
+      if (h.face && h.face.normal.clone().transformDirection(h.object.matrixWorld).dot(n) <= 0.3) continue;
+      if (!best || Math.abs(h.distance - DECAL_SNAP) < Math.abs(best.distance - DECAL_SNAP)) best = h;
+    }
+    return best ? best.point : worldPoint;
+  }
   /** 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);
+    const pos = mesh.worldToLocal(this.onFace(mesh, worldPoint, worldNormal).clone()).addScaledVector(ln, lift / s);
     const quat = new this.THREE.Quaternion().setFromUnitVectors(new this.THREE.Vector3(0, 0, 1), ln);
     return { s, pos, quat };
   }
@@ -1651,6 +1891,21 @@ var Visuals = class {
     d.geometry?.dispose();
     this.decalCount = Math.max(0, this.decalCount - 1);
   }
+  /**
+   * Takes away the decals of a mesh that sit inside a box (world `center`, `half` extents along the axes of the world `rotation`): the surface they
+   * marked is gone (a unit came out of the wall with its bullet holes and spalls).
+   */
+  clearDecals(mv, center, half, rotation) {
+    const inv = rotation.clone().invert();
+    const p = new this.THREE.Vector3();
+    for (let i = mv.decals.length - 1; i >= 0; i--) {
+      const d = mv.decals[i];
+      d.obj.getWorldPosition(p).sub(center).applyQuaternion(inv);
+      if (Math.abs(p.x) > half.x || Math.abs(p.y) > half.y || Math.abs(p.z) > half.z) continue;
+      this.disposeDecal(d);
+      mv.decals.splice(i, 1);
+    }
+  }
   addHole(mv, worldPoint, worldNormal, diameter) {
     const { s, pos, quat } = this.decalPose(mv.mesh, worldPoint, worldNormal, 25e-4);
     const work = mv.host ? mv.host.work : mv.work;
@@ -1855,6 +2110,7 @@ var Visuals = class {
     if (!pos || !work) return;
     const arr = pos.array;
     arr.set(work);
+    collapseForeign(host.mesh, arr);
     for (const s of host.sharers) {
       if (s.merged && s.merged.host === host) {
         if (s.collapsed) this.collapseRange(arr, s.merged.range);
@@ -2059,9 +2315,9 @@ var Visuals = class {
     mv.touched = false;
     if (!host.ownGeo) return;
     const work = host.work;
-    const op = positionAttr(host.origGeometry);
+    const op = basePositions(host);
     const [v0, v1] = merged.range;
-    if (op) work.set(op.array.subarray(v0 * 3, v1 * 3), v0 * 3);
+    if (op) work.set(op.subarray(v0 * 3, v1 * 3), v0 * 3);
     const attr = host.mesh.geometry.getAttribute("color");
     if (attr) {
       const orig = host.origGeometry.getAttribute("color");
@@ -2075,6 +2331,13 @@ var Visuals = class {
     if (host.sharers.every((s) => !s.touched)) {
       host.mesh.geometry.dispose();
       host.mesh.geometry = host.origGeometry;
+      const base = basePositions(host), back = positionAttr(host.origGeometry);
+      if (base && back) {
+        const arr = back.array;
+        arr.set(base);
+        collapseForeign(host.mesh, arr);
+        back.needsUpdate = true;
+      }
       host.work = null;
       host.ownGeo = false;
       if (host.ownMat) {
@@ -2133,9 +2396,13 @@ var Visuals = class {
 // src/renderer.ts
 var rendererCount = 0;
 var COLLAPSE_CLOUD_KG = 1e3;
+var CHIP_DECAL_EDGE = 0.05;
+var OPAQUE_CRACK = 0.1;
+var WOOD_RIM = 1.5;
 var IMPACT_TAGS = ["metal", "glass", "wood"];
 var GLOW_FROM_C = 430;
 var QUEUE_CAP = 4e3;
+var MIN_FRAGMENTS_PER_SLICE = 8;
 var STATIC_REFRESH = 0.5;
 var STATIC_SPAN = 3;
 var FEET_BAND = 0.03;
@@ -2211,6 +2478,7 @@ function isMeshRange(v) {
   const r = v;
   return !!r.mesh && Array.isArray(r.range);
 }
+var RNG_SEED = 12648430;
 function createDestructionRenderer(THREE, options) {
   return new Renderer(THREE, options);
 }
@@ -2226,6 +2494,7 @@ var Renderer = class {
     __publicField(this, "gravity");
     __publicField(this, "autoSplit");
     __publicField(this, "maxFragments");
+    __publicField(this, "eventBudgetMs");
     __publicField(this, "bounds", /* @__PURE__ */ new Map());
     /** World boxes (min xyz, max xyz) of the drawn meshes of the bound objects that are not pieces, for the pieces to land on. */
     __publicField(this, "staticBoxes", /* @__PURE__ */ new Map());
@@ -2236,6 +2505,10 @@ var Renderer = class {
     __publicField(this, "pieceBoxes", /* @__PURE__ */ new WeakMap());
     __publicField(this, "staticAt", 0);
     __publicField(this, "queue", []);
+    /** Presentation work an event left for later frames (fragments still to spawn, loose groups still to split), run in order within the frame budget. */
+    __publicField(this, "slices", []);
+    /** When the work of this frame must stop; `Infinity` outside `drainQueue`, where a call finishes what it started. */
+    __publicField(this, "sliceDeadline", Infinity);
     __publicField(this, "unsubscribe");
     __publicField(this, "visuals");
     __publicField(this, "fragments");
@@ -2249,7 +2522,7 @@ var Renderer = class {
     __publicField(this, "leaks", []);
     __publicField(this, "homeTags", []);
     __publicField(this, "throttles", /* @__PURE__ */ new Map());
-    __publicField(this, "rng", createRng(12648430));
+    __publicField(this, "rng", createRng(RNG_SEED));
     __publicField(this, "vfx");
     /** Names this renderer to the world's drips, so a shared world tells each renderer where its own landed. */
     __publicField(this, "owner", `destruction-${++rendererCount}`);
@@ -2273,6 +2546,7 @@ var Renderer = class {
     this.gravity = o.gravity ?? 9.81;
     this.autoSplit = o.autoSplit !== false;
     this.maxFragments = o.maxFragments ?? 160;
+    this.eventBudgetMs = o.eventBudgetMs ?? Infinity;
     this.box = new THREE.Box3();
     this.tmpQ = new THREE.Quaternion();
     this.v1 = new THREE.Vector3();
@@ -2358,6 +2632,7 @@ var Renderer = class {
       if (leftovers.length) this.matchByBox(objectId, root, leftovers, add);
     }
     const bound = { id: objectId, root, sync: options.syncTransform !== false, parts: /* @__PURE__ */ new Map(), lastPos: null, lastQuat: null, piece: null, isSplit: false };
+    if (options.onFrame) bound.onFrame = options.onFrame;
     const hosts = /* @__PURE__ */ new Map();
     for (const pid of partIds) bound.parts.set(pid, this.makePartVis(objectId, pid, state?.parts.find((p) => p.id === pid)?.material ?? "", byPart.get(pid) ?? [], hosts));
     for (const [pid, meshes] of byPart) {
@@ -2517,6 +2792,7 @@ var Renderer = class {
     dt = clamp(dt, 0, 0.1);
     this.time += dt;
     this.drainQueue();
+    for (const b of this.bounds.values()) b.onFrame?.(dt);
     for (const b of this.bounds.values()) if (b.soilNode && this.world.state(b.id)?.soil?.status === "yielding") this.onSettle(b.id);
     this.updateActive(dt);
     this.updateLeaks(dt);
@@ -2528,11 +2804,32 @@ var Renderer = class {
   }
   drainQueue() {
     const batch = this.queue.splice(0, this.queue.length);
-    for (const ev of batch) {
+    const deadline = performance.now() + this.eventBudgetMs;
+    this.sliceDeadline = deadline;
+    try {
+      this.runSlices(deadline);
+      for (let i = 0; i < batch.length; i++) {
+        if (i > 0 && performance.now() >= deadline) {
+          this.queue.unshift(...batch.slice(i));
+          return;
+        }
+        try {
+          this.apply(batch[i]);
+        } catch (err) {
+          if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", batch[i].type, err);
+        }
+      }
+    } finally {
+      this.sliceDeadline = Infinity;
+    }
+  }
+  /** Runs the work left by earlier frames until the deadline; at least one piece per frame, so it always finishes. */
+  runSlices(deadline) {
+    for (let ran = 0; this.slices.length > 0 && (ran === 0 || performance.now() < deadline); ran++) {
       try {
-        this.apply(ev);
+        this.slices.shift()();
       } catch (err) {
-        if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", ev.type, err);
+        if (typeof console !== "undefined") console.error("game-destruction-three: failed to run deferred work", err);
       }
     }
   }
@@ -2696,7 +2993,7 @@ var Renderer = class {
         break;
       }
       case "debris":
-        this.vfx.burst(ev.kind, ev.point, ev.normal, ev.count, ev.speed > 0 ? ev.speed : DEFAULT_SPEED[ev.kind] ?? 1, this.debrisOptions(ev.kind, ev.object, ev.part));
+        this.vfx.burst(ev.kind, ev.point, ev.normal, ev.count, ev.speed > 0 ? ev.speed : DEFAULT_SPEED[ev.kind] ?? 1, this.debrisOptions(ev.kind, ev.object, ev.part, ev.material));
         break;
       case "fracture":
         this.onFracture(ev);
@@ -2869,10 +3166,11 @@ var Renderer = class {
     }
     return def ? fallbackColor(def.id, def) : null;
   }
-  debrisOptions(kind, objectId, partId) {
+  debrisOptions(kind, objectId, partId, material) {
     const pv = this.partVis(objectId, partId);
-    const def = pv ? this.world.materials.get(pv.material) : void 0;
+    const def = this.world.materials.get(material ?? pv?.material ?? "");
     if (kind === "smoke") return { color: SMOKE_TONES[def?.thermal.smoke ?? "grey"] };
+    if ((kind === "dust" || kind === "chips") && def?.visual?.innerColor !== void 0) return { color: def.visual.innerColor };
     if (kind === "fibers" || kind === "leaves") {
       if (def?.visual?.innerColor !== void 0) return { color: def.visual.innerColor };
       const c = pv ? this.visuals.baseColorHex(pv.meshes[0] ?? {}) : -1;
@@ -2929,12 +3227,19 @@ var Renderer = class {
         const seed = hashNumbers(ev.time, point[0], point[1], point[2]);
         this.visuals.addCrack(mv, wp, normal, 7, Math.max(0.05, ev.hole.diameter * 5), 15267071, seed);
       } else {
+        const fresh = def?.penetrationClass === "wood" ? def.visual?.innerColor : void 0;
+        if (fresh !== void 0) this.visuals.addSpall(mv, wp, normal, Math.max(6e-3, ev.hole.diameter * WOOD_RIM), fresh);
         this.visuals.addHole(mv, wp, normal, ev.hole.diameter);
       }
     };
     draw(ev.worldPoint, n);
     if (ev.hole.through && ev.exitPoint) draw(ev.exitPoint, n.clone().negate());
     if (def?.tags?.includes("metal")) this.vfx.burst("sparks", ev.worldPoint, [n.x, n.y, n.z], 6, 3.5);
+    if (ev.powder) {
+      const puff = { color: ev.powder.color, size: 0.6, life: 1.6, alpha: 1.3 };
+      this.vfx.burst("dust", ev.worldPoint, [n.x, n.y, n.z], this.low ? 5 : 10, 0.7, puff);
+      if (ev.hole.through && ev.exitPoint) this.vfx.burst("dust", ev.exitPoint, [-n.x, -n.y, -n.z], this.low ? 10 : 20, 1.3, puff);
+    }
     this.sound(impactKey(def), ev.worldPoint, 0.6);
   }
   onCrack(ev) {
@@ -2945,8 +3250,11 @@ var Renderer = class {
     const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
     const mv = this.nearestMesh(pv, wp);
     if (mv) {
-      const color = def?.visual?.transparent ? 15267071 : 2762532;
-      this.visuals.addCrack(mv, wp, this.worldDir(b, ev.crack.normal), ev.crack.rays, ev.crack.length, color, hashNumbers(ev.time, ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]));
+      const glass = !!def?.visual?.transparent;
+      const own = this.partColor(pv, def) ?? fallbackColor(pv.material, def);
+      const color = glass ? 15267071 : new this.THREE.Color(own).multiplyScalar(0.45).getHex();
+      const length = glass ? ev.crack.length : Math.min(ev.crack.length, OPAQUE_CRACK);
+      this.visuals.addCrack(mv, wp, this.worldDir(b, ev.crack.normal), ev.crack.rays, length, color, hashNumbers(ev.time, ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]));
     }
     this.sound(impactKey(def), ev.worldPoint, 0.5);
   }
@@ -2980,8 +3288,12 @@ var Renderer = class {
     const mv = this.nearestMesh(pv, wp);
     if (!mv) return;
     const def = this.world.materials.get(pv.material);
-    this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.point);
-    this.visuals.addSpall(mv, wp, this.faceNormal(mv, wp), Math.sqrt(ev.area / Math.PI), fallbackColor(pv.material, def));
+    const normal = this.faceNormal(mv, wp);
+    const core = def?.visual?.innerColor;
+    if (core !== void 0) this.vfx.burst("chips", ev.point, [normal.x, normal.y, normal.z], 5, 2.5, { color: core });
+    else this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.point);
+    if (mv.mesh.userData.drawnSpalls?.includes(ev.part)) return;
+    this.visuals.addSpall(mv, wp, normal, Math.sqrt(ev.area / Math.PI), core ?? fallbackColor(pv.material, def));
   }
   /**
    * Stage 2 of a staged part: the unit-sized fragments come out and the part stays drawn (hiding it is what `fracture` does). The opening itself
@@ -3004,8 +3316,9 @@ var Renderer = class {
     this.sound(impactKey(def), ev.opening.center, 0.8);
   }
   /**
-   * A unit came out of a wall of units: the unit flies as a fragment with a puff of its dust. The gap itself is the drawing's (the house renderer redraws
-   * the wall as its courses without that unit); a part drawn as one box keeps its box.
+   * A unit came out of a wall of units: the unit flies as a fragment with a puff of its dust, and the marks drawn on it (bullet holes, spalls, the impact
+   * marks of the effects) go with it. The gap itself is the drawing's (the house renderer cuts the wall where the unit was); a part drawn as one box
+   * keeps its box.
    */
   onChip(ev) {
     const pv = this.partVis(ev.object, ev.part);
@@ -3017,7 +3330,17 @@ var Renderer = class {
       const tone2 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === def ? color : fallbackColor(fr.material, fdef);
       this.fragments.spawn(fr, this.fragments.materialFor(fr.material, tone2, false), ev.object, maxAlive);
     }
-    if (!this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.center)) this.vfx.burst("dust", ev.center, [0, 1, 0], 6, 0.8, { color });
+    if (ev.torn) {
+      this.sound(impactKey(def), ev.center, 0.5);
+      return;
+    }
+    const T = this.THREE;
+    const center = new T.Vector3(ev.center[0], ev.center[1], ev.center[2]);
+    const half = new T.Vector3(ev.size[0] / 2 + CHIP_DECAL_EDGE, ev.size[1] / 2 + CHIP_DECAL_EDGE, ev.size[2] / 2 + CHIP_DECAL_EDGE);
+    const rotation = new T.Quaternion(ev.rotation[0], ev.rotation[1], ev.rotation[2], ev.rotation[3]);
+    for (const part of this.bounds.get(ev.object)?.parts.values() ?? []) for (const mv of part.meshes) this.visuals.clearDecals(mv, center, half, rotation);
+    this.vfx.peekWorkshop()?.decals.clearInside(ev.center, [half.x, half.y, half.z], ev.rotation);
+    this.vfx.burst("dust", ev.center, [0, 1, 0], 8, 0.8, { color });
     this.sound(impactKey(def), ev.center, 0.7);
   }
   onFracture(ev) {
@@ -3035,15 +3358,7 @@ var Renderer = class {
       if (m && m.transparent) opacity = clamp(m.opacity, 0.2, 0.8);
       this.visuals.hide(pv, "broken");
     }
-    const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
-    const step = this.low ? 2 : 1;
-    for (let i = 0; i < ev.fragments.length; i += step) {
-      const fr = ev.fragments[i];
-      const fdef = this.world.materials.get(fr.material);
-      const tone2 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === def || !fdef ? color : fallbackColor(fr.material, fdef);
-      const mat = this.fragments.materialFor(fr.material, tone2, transparent || fdef?.visual?.transparent === true, opacity);
-      this.fragments.spawn(fr, mat, ev.object, maxAlive);
-    }
+    this.spawnFragments(ev, 0, { def, color, opacity, transparent });
     const up = [0, 1, 0];
     const sizeK = clamp(ev.fragments.length / 10, 0.5, 2);
     switch (ev.style) {
@@ -3069,6 +3384,22 @@ var Renderer = class {
     }
     this.sound(fractureKey(def, ev.style), ev.point, clamp(0.4 + ev.fragments.length * 0.03, 0.4, 1));
   }
+  /** Spawns the fragments of a fracture from index `from`; what does not fit in this frame's budget is spawned by the next frames. */
+  spawnFragments(ev, from, look) {
+    const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
+    const step = this.low ? 2 : 1;
+    for (let i = from; i < ev.fragments.length; i += step) {
+      if (i - from >= MIN_FRAGMENTS_PER_SLICE * step && performance.now() >= this.sliceDeadline) {
+        this.slices.push(() => this.spawnFragments(ev, i, look));
+        return;
+      }
+      const fr = ev.fragments[i];
+      const fdef = this.world.materials.get(fr.material);
+      const tone2 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === look.def || !fdef ? look.color : fallbackColor(fr.material, fdef);
+      const mat = this.fragments.materialFor(fr.material, tone2, look.transparent || fdef?.visual?.transparent === true, look.opacity);
+      this.fragments.spawn(fr, mat, ev.object, maxAlive);
+    }
+  }
   onDetach(ev) {
     this.sound("detach", this.rootPoint(ev.object), 0.5);
     this.splitLoose(ev.object);
@@ -3082,6 +3413,13 @@ var Renderer = class {
     if (!st || st.groups.length < 2) return;
     const loose = st.groups.length - 1;
     for (let i = 0; i < loose; i++) {
+      if (i > 0 && performance.now() >= this.sliceDeadline) {
+        this.slices.push(() => {
+          this.staticDirty.add(objectId);
+          this.splitLoose(objectId);
+        });
+        return;
+      }
       let newId;
       try {
         newId = this.world.splitGroup(objectId, 1);
@@ -3098,8 +3436,9 @@ var Renderer = class {
       old.mass = Math.max(0.05, this.massOf(objectId));
       old.sleeping = false;
     } else if (kitOriginOf(b.root)?.kind === "furniture") {
-      this.makePiece(objectId);
+      const piece = this.makePiece(objectId);
       this.tipIfTopHeavy(b);
+      this.o.onLoosened?.(objectId, piece, "apart");
     }
   }
   /** The renderer side of `splitGroup`: a new group holding the meshes of the new object, made a piece. */
@@ -3208,7 +3547,7 @@ var Renderer = class {
       const piece = this.makePiece(b.id, { mass });
       const body = this.pieceSys.get(b.id);
       if (!body) continue;
-      this.o.onLoosened?.(b.id, piece);
+      this.o.onLoosened?.(b.id, piece, "blast");
       const spread = half[0];
       const momentum = hit.speed * mass;
       this.pieceSys.impulse(body, [hit.direction[0] * momentum, hit.direction[1] * momentum, hit.direction[2] * momentum], [world.x + (this.rng() - 0.5) * spread, world.y + spread * 0.5, world.z + (this.rng() - 0.5) * spread]);
@@ -3403,6 +3742,7 @@ var Renderer = class {
   }
   clear() {
     this.queue.length = 0;
+    this.slices.length = 0;
     this.active.clear();
     for (const key of [...this.fires.keys()]) this.stopFire(key);
     this.leaks.length = 0;
@@ -3422,6 +3762,15 @@ var Renderer = class {
     this.vfx.sprites().clear();
     this.ownVfx?.world.clear();
   }
+  reset() {
+    this.clear();
+    this.rng = createRng(RNG_SEED);
+    this.time = 0;
+    this.staticAt = 0;
+    this.throttles.clear();
+    this.fragments.reset();
+    this.pieceSys.reset();
+  }
   wakeRegion(x, z, radius) {
     this.fragments.wakeRegion(x, z, radius);
     this.pieceSys.wakeRegion(x, z, radius);
@@ -3547,7 +3896,18 @@ var DRAG_SOUNDS = [
   drag("drag_masonry", [noise({ type: "bandpass", f: 260, q: 0.9, d: 0.3, vol: 0.62 }), ...many(3, () => noise({ type: "bandpass", f: [600, 1200], q: 2, d: 0.04, vol: 0.14, delay: [0, 0.2] }))]),
   drag("drag_soft", [noise({ type: "lowpass", f: 420, d: 0.28, vol: 0.3 })])
 ];
-var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
+var leaf = (id, layers) => ({ ...sceneRecipe(id, layers, ""), sources: ["sdk: a door, lid or drawer worked by hand"] });
+var LEAF_SOUNDS = [
+  leaf("latch", [noise({ type: "bandpass", f: 2400, q: 4, d: 0.03, vol: 0.35 }), tone({ f: 1900, f2: 1500, d: 0.025, vol: 0.06, delay: 0.035 })]),
+  leaf("creak_wood", [tone({ f: [190, 240], f2: 310, d: 0.5, vol: 0.05 }), noise({ type: "bandpass", f: 520, q: 6, a: 0.05, d: 0.45, vol: 0.12 })]),
+  leaf("creak_metal", [tone({ f: [620, 760], f2: 900, d: 0.35, vol: 0.035 }), noise({ type: "bandpass", f: 1400, q: 8, a: 0.04, d: 0.3, vol: 0.08 })]),
+  leaf("shut_wood", [tone({ f: 120, f2: 60, d: 0.14, vol: 0.5 }), noise({ type: "bandpass", f: 600, q: 1.2, d: 0.1, vol: 0.55, wet: 0.25 }), noise({ type: "bandpass", f: 2400, q: 4, d: 0.03, vol: 0.25, delay: 0.02 })]),
+  leaf("shut_metal", [tone({ f: 160, f2: 85, d: 0.18, vol: 0.55 }), noise({ type: "bandpass", f: 900, q: 1.6, d: 0.12, vol: 0.45, wet: 0.3 }), tone({ f: 1250, f2: 1150, d: 0.12, vol: 0.06 })]),
+  leaf("shut_soft", [tone({ f: 95, f2: 55, d: 0.12, vol: 0.35 }), noise({ type: "lowpass", f: 500, d: 0.1, vol: 0.3 })]),
+  leaf("rattle", many(5, () => noise({ type: "bandpass", f: [1600, 2600], q: 3, d: 0.035, vol: 0.32, delay: [0, 0.45] }))),
+  leaf("slide", [noise({ type: "bandpass", f: 700, q: 2, a: 0.04, d: 0.35, vol: 0.22 }), noise({ type: "bandpass", f: 2200, q: 5, d: 0.3, vol: 0.05 })])
+];
+var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, ...LEAF_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
 
 // src/audio/sound.ts
 import { GAME_SFX_BANK } from "@adatechnology/game-audio";
@@ -3563,6 +3923,32 @@ var DESTRUCTION_SOUND_KEYS = {
     drag_glass: { sound: "drag_glass" },
     drag_masonry: { sound: "drag_masonry" },
     drag_soft: { sound: "drag_soft" },
+    // a leaf worked by hand (doors, lids, drawers): the latch, the hinge turning, the leaf meeting the frame, a locked one shaken
+    leaf_latch: { sound: "latch" },
+    leaf_creak_wood: { sound: "creak_wood" },
+    leaf_creak_metal: { sound: "creak_metal" },
+    leaf_shut_wood: { sound: "shut_wood" },
+    leaf_shut_metal: { sound: "shut_metal" },
+    leaf_shut_glass: { sound: "shut_metal", volumeScale: 0.6 },
+    leaf_shut_masonry: { sound: "shut_wood" },
+    leaf_shut_soft: { sound: "shut_soft" },
+    leaf_rattle: { sound: "rattle" },
+    leaf_slide: { sound: "slide" },
+    // the keys of the item clips (furniture and vehicle doors, hoods, trunks, drawers)
+    door_latch: { sound: "latch" },
+    hood_latch: { sound: "latch" },
+    trunk_latch: { sound: "latch" },
+    door_open: { sound: "latch" },
+    door_shut: { sound: "shut_metal" },
+    hood_shut: { sound: "shut_metal" },
+    trunk_shut: { sound: "shut_metal" },
+    door_close: { sound: "shut_wood", volumeScale: 0.7 },
+    drawer_open: { sound: "slide" },
+    drawer_close: { sound: "slide" },
+    lid_open: { sound: "latch" },
+    lid_close: { sound: "shut_soft" },
+    flap_open: { sound: "latch" },
+    flap_close: { sound: "shut_soft" },
     shatter_glass: { sound: "glass_shatter" },
     crumble: { sound: "crumble" },
     splinter: { sound: "crack" },