@adatechnology/game-destruction-three 0.17.2 → 0.18.0

package/dist/index.js

@@ -764,7 +764,9 @@ var SLAM_MIN_SPEED = 2;
 var SLAM_BOUNCE = 0.2;
 var SLAM_FLOOR_NORMAL = 0.7;
 var SUB_DT = 1 / 120;
-var MU = 0.7;
+var MU_STATIC = 0.7;
+var MU_DYNAMIC = 0.6;
+var SLIP_SPEED = 0.02;
 var SLEEP_AFTER = 0.5;
 var CALM_DRIFT = 0.01;
 var CALM_TURN = 0.05;
@@ -783,6 +785,9 @@ var SIDE_BOUNCE = 0.1;
 var EDGE_POINTS = [-0.75, -0.5, -0.25, 0, 0.25, 0.5, 0.75];
 var SUPPORT_CHECKS2 = 16;
 var SUPPORT_GAP2 = 0.02;
+var WAKE_ABOVE_SPEED = 0.05;
+var WAKE_ABOVE_SPIN = 0.1;
+var topFace = 1;
 var boxTopAt = (s, x, z) => {
   const e = s.e;
   const dx = x - s.c[0], dz = z - s.c[2];
@@ -798,11 +803,24 @@ var boxTopAt = (s, x, z) => {
     let a = (-h - p) / d, b = (h - p) / d;
     if (a > b) [a, b] = [b, a];
     t0 = Math.max(t0, a);
-    t1 = Math.min(t1, b);
+    if (b < t1) {
+      t1 = b;
+      topFace = k;
+    }
     if (t0 > t1) return -Infinity;
   }
   return s.c[1] + t1;
 };
+var UP = [0, 1, 0];
+var faceNormal = (s, axis) => {
+  const e = s.e;
+  const sign = e[axis * 4 + 1] < 0 ? -1 : 1;
+  return [sign * e[axis * 4], sign * e[axis * 4 + 1], sign * e[axis * 4 + 2]];
+};
+var pairFriction = (a, b) => ({
+  static: Math.sqrt((a?.static ?? MU_STATIC) * (b?.static ?? MU_STATIC)),
+  dynamic: Math.sqrt((a?.dynamic ?? MU_DYNAMIC) * (b?.dynamic ?? MU_DYNAMIC))
+});
 var PieceSystem = class {
   constructor(THREE, o) {
     __publicField(this, "THREE", THREE);
@@ -816,6 +834,9 @@ var PieceSystem = class {
     __publicField(this, "ax");
     __publicField(this, "solids", []);
     __publicField(this, "supportTurn", 0);
+    /** The surface normal and the friction of what the last `supportAt` found under the point (the ground and fixed tops are level: up, and no piece). */
+    __publicField(this, "supportNormal", UP);
+    __publicField(this, "supportFriction", null);
     this.p = new THREE.Vector3();
     this.q = new THREE.Quaternion();
     this.dq = new THREE.Quaternion();
@@ -921,8 +942,9 @@ 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. */
+  /** 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; or the piece's own `contacts`. */
   samples(b, edges) {
+    if (b.contacts) return b.contacts;
     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]);
@@ -987,6 +1009,10 @@ var PieceSystem = class {
       }
       if (b.sleeping) continue;
       this.integrate(b, dt);
+      if (b.sleeping) continue;
+      const v = b.velocity;
+      const w = b.angularVelocity;
+      if (Math.hypot(v[0], v[1], v[2]) > WAKE_ABOVE_SPEED || Math.hypot(w[0], w[1], w[2]) > WAKE_ABOVE_SPIN) this.wakeAbove(b);
     }
     this.separate(dt);
   }
@@ -1017,15 +1043,48 @@ var PieceSystem = class {
     }
     return false;
   }
+  /** The highest top of a piece (other than `self`) under `(x, z)` that a point at height `y` stands on (at most `step` above it), -Infinity when none; the boxes of the last update. */
+  topAt(x, z, y, step, self) {
+    let top = -Infinity;
+    for (const s of this.solids) {
+      if (s.body.objectId === self || s.body.held || Math.abs(x - s.c[0]) > s.r || Math.abs(z - s.c[2]) > s.r) continue;
+      const t = boxTopAt(s, x, z);
+      if (t > top && t <= y + step) top = t;
+    }
+    return top;
+  }
+  /** What lay asleep on `b` (a box over its top) wakes at once when `b` moves: a can on a table that goes over goes with it. */
+  wakeAbove(b) {
+    const below = this.solids.find((s) => s.body === b);
+    if (!below) return;
+    const top = below.c[1] + below.half[0] * Math.abs(below.e[1]) + below.half[1] * Math.abs(below.e[5]) + below.half[2] * Math.abs(below.e[9]);
+    for (const s of this.solids) {
+      const o = s.body;
+      if (!o.sleeping || o.held || o === b) continue;
+      if (s.c[1] < below.c[1] || s.c[1] - s.r > top + STEP || Math.hypot(s.c[0] - below.c[0], s.c[2] - below.c[2]) > s.r + below.r) continue;
+      o.sleeping = false;
+      o.still = 0;
+      o.calmAt = null;
+    }
+  }
   /** Where a corner of `self` at `(x, y, z)` lands: the ground, the top of another piece or of something fixed under it. */
   supportAt(self, x, y, z, step) {
     let top = this.o.groundAt(x, z);
+    let on = null;
+    let face = 1;
     for (const s of this.solids) {
       if (s.body === self || s.body.held || Math.abs(x - s.c[0]) > s.r || Math.abs(z - s.c[2]) > s.r) continue;
       const t = boxTopAt(s, x, z);
-      if (t > top && t <= y + step) top = t;
+      if (t > top && t <= y + step) {
+        top = t;
+        on = s;
+        face = topFace;
+      }
     }
     const fixed = this.o.staticTopAt?.(x, z, y, step) ?? -Infinity;
+    if (fixed >= top) on = null;
+    this.supportNormal = on ? faceNormal(on, face) : UP;
+    this.supportFriction = on?.body.friction ?? null;
     return Math.max(top, fixed);
   }
   /** Stops a piece that ran into something on its way from `start` to `pos` (`sweep`): moves it back to where it met it and takes the speed into it. */
@@ -1108,7 +1167,10 @@ var PieceSystem = class {
       const e = this.m.elements;
       const rs = [];
       const ids = [];
+      const ns = [];
+      const mus = [];
       let maxPen = 0;
+      let penNormal = UP;
       const rise = STEP + Math.max(0, -v[1]) * h * 2;
       let side = null;
       let lowest = Infinity;
@@ -1126,6 +1188,8 @@ var PieceSystem = class {
             if (floor !== void 0 && floor - cy > -SLOP && floor < raw - STEP) {
               rs.push(r);
               ids.push(i);
+              ns.push(UP);
+              mus.push(pairFriction(b.friction, null));
               maxPen = Math.max(maxPen, floor - cy);
             }
             continue;
@@ -1146,12 +1210,19 @@ var PieceSystem = class {
           }
           continue;
         }
-        const gy = i < 8 ? this.supportAt(b, px, cy, pz, rise) : Math.max(raw, this.o.staticTopAt?.(px, pz, cy, rise) ?? -Infinity);
+        this.supportNormal = UP;
+        this.supportFriction = null;
+        const gy = i < 8 || b.contacts ? 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;
+          ns.push(this.supportNormal);
+          mus.push(pairFriction(b.friction, this.supportFriction));
+          if (pen > maxPen) {
+            maxPen = pen;
+            penNormal = this.supportNormal;
+          }
           lowest = Math.min(lowest, gy);
         }
       }
@@ -1164,7 +1235,10 @@ var PieceSystem = class {
       contactedLast = rs.length > 0;
       if (contactedLast) touched = true;
       if (!contactedLast) continue;
-      pos[1] += Math.max(0, maxPen - SLOP * 0.5);
+      const out = Math.max(0, maxPen - SLOP * 0.5) * penNormal[1];
+      pos[0] += penNormal[0] * out;
+      pos[1] += penNormal[1] * out;
+      pos[2] += penNormal[2] * out;
       let impact2 = 0;
       for (const r of rs) impact2 = Math.max(impact2, -(v[1] + w[2] * r[0] - w[0] * r[2]));
       const restitution = impact2 > 2 ? 0.25 : 0;
@@ -1180,76 +1254,72 @@ var PieceSystem = class {
         const lz = pos[2] + sz / rs.length;
         landPoint = [lx, pos[1] - Math.max(...rs.map((r) => -r[1])), lz];
       }
-      const goal = rs.map((r) => {
-        const vy = v[1] + (w[2] * r[0] - w[0] * r[2]);
-        return vy < 0 ? -restitution * vy : 0;
+      const pointV = (r) => [v[0] + w[1] * r[2] - w[2] * r[1], v[1] + w[2] * r[0] - w[0] * r[2], v[2] + w[0] * r[1] - w[1] * r[0]];
+      const dot = (a, c2) => a[0] * c2[0] + a[1] * c2[1] + a[2] * c2[2];
+      const goal = rs.map((r, k) => {
+        const vn = dot(pointV(r), ns[k]);
+        return vn < 0 ? -restitution * vn : 0;
+      });
+      const slipping = rs.map((r, k) => {
+        const pv = pointV(r);
+        const vn = dot(pv, ns[k]);
+        return Math.hypot(pv[0] - vn * ns[k][0], pv[1] - vn * ns[k][1], pv[2] - vn * ns[k][2]) > SLIP_SPEED;
       });
       const vx0 = v[0];
       const vz0 = v[2];
-      if (!b.warm || b.warm.length !== WARM_SLOTS * 3) b.warm = new Float64Array(WARM_SLOTS * 3);
+      if (!b.warm || b.warm.length !== WARM_SLOTS * 4) b.warm = new Float64Array(WARM_SLOTS * 4);
       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);
+      const accN = ids.map((id) => id < WARM_SLOTS ? warm[id * 4] : 0);
+      const accT = ids.map((id) => id < WARM_SLOTS ? [warm[id * 4 + 1], warm[id * 4 + 2], warm[id * 4 + 3]] : [0, 0, 0]);
+      const push = (r, j) => {
+        v[0] += j[0] * invM;
+        v[1] += j[1] * invM;
+        v[2] += j[2] * invM;
+        const dw = this.mulInvInertiaWith(b, e, r[1] * j[2] - r[2] * j[1], r[2] * j[0] - r[0] * j[2], r[0] * j[1] - r[1] * j[0]);
         w[0] += dw[0];
         w[1] += dw[1];
         w[2] += dw[2];
+      };
+      const reach = (r, d) => {
+        const a = this.mulInvInertiaWith(b, e, r[1] * d[2] - r[2] * d[1], r[2] * d[0] - r[0] * d[2], r[0] * d[1] - r[1] * d[0]);
+        return invM + (a[1] * r[2] - a[2] * r[1]) * d[0] + (a[2] * r[0] - a[0] * r[2]) * d[1] + (a[0] * r[1] - a[1] * r[0]) * d[2];
+      };
+      for (let k = 0; k < rs.length; k++) {
+        const n = ns[k];
+        const t = accT[k];
+        if (accN[k] !== 0 || t[0] !== 0 || t[1] !== 0 || t[2] !== 0) push(rs[k], [n[0] * accN[k] + t[0], n[1] * accN[k] + t[1], n[2] * accN[k] + t[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 total = Math.max(0, accN[k] + (goal[k] - vy) / denom);
+          const n = ns[k];
+          const vn = dot(pointV(r), n);
+          const total = Math.max(0, accN[k] + (goal[k] - vn) / reach(r, n));
           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-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 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 jt = vt / (invM + cx * tx + cz * tz);
-            fx -= tx * jt;
-            fz -= tz * jt;
+          if (j !== 0) push(r, [n[0] * j, n[1] * j, n[2] * j]);
+          const pv = pointV(r);
+          const pn = dot(pv, n);
+          const vt = [pv[0] - pn * n[0], pv[1] - pn * n[1], pv[2] - pn * n[2]];
+          const speed = Math.hypot(vt[0], vt[1], vt[2]);
+          const f = [accT[k][0], accT[k][1], accT[k][2]];
+          if (speed > 1e-6) {
+            const d = [vt[0] / speed, vt[1] / speed, vt[2] / speed];
+            const jt = speed / reach(r, d);
+            f[0] -= d[0] * jt;
+            f[1] -= d[1] * jt;
+            f[2] -= d[2] * jt;
+          } else if (f[0] === 0 && f[1] === 0 && f[2] === 0) continue;
+          const most = (slipping[k] ? mus[k].dynamic : mus[k].static) * accN[k];
+          const fl = Math.hypot(f[0], f[1], f[2]);
+          if (fl > most) {
+            f[0] *= most / fl;
+            f[1] *= most / fl;
+            f[2] *= most / fl;
           }
-          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];
+          const dj = [f[0] - accT[k][0], f[1] - accT[k][1], f[2] - accT[k][2]];
+          accT[k] = f;
+          if (dj[0] !== 0 || dj[1] !== 0 || dj[2] !== 0) push(r, dj);
         }
       }
       pos[0] += (v[0] - vx0) * h;
@@ -1258,9 +1328,10 @@ var PieceSystem = class {
       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];
+        warm[id * 4] = accN[k];
+        warm[id * 4 + 1] = accT[k][0];
+        warm[id * 4 + 2] = accT[k][1];
+        warm[id * 4 + 3] = accT[k][2];
       }
       let x0 = Infinity, x1 = -Infinity, z0 = Infinity, z1 = -Infinity, low = 0;
       for (const r of rs) {
@@ -1332,6 +1403,13 @@ var PieceSystem = class {
     b.calm += dt;
     return b.calm >= CALM_SLEEP_AFTER;
   }
+  /** Whether the centre `c` of `upper` is over the top of `lower`'s box (as it was at the start of the update). */
+  onTopOf(upper, lower, c) {
+    const s = this.solids.find((one) => one.body === lower);
+    if (!s) return false;
+    const top = boxTopAt(s, c.x, c.z);
+    return top > -Infinity && c.y >= top - 0.01;
+  }
   /** Half the height of the box of a piece as it is turned now. */
   halfHeight(b) {
     const e = this.m.makeRotationFromQuaternion(b.root.quaternion).elements;
@@ -1357,6 +1435,7 @@ var PieceSystem = class {
         this.centerOf(b, cb);
         if (Math.abs(ca.y - cb.y) > ra + rb) continue;
         if (Math.abs(ca.y - cb.y) >= (this.halfHeight(a) + this.halfHeight(b)) * 0.9) continue;
+        if (this.onTopOf(b, a, cb) || this.onTopOf(a, b, ca)) continue;
         const rh = (Math.max(a.halfExtents[0], a.halfExtents[2]) + Math.max(b.halfExtents[0], b.halfExtents[2])) * 0.8;
         let dx = cb.x - ca.x;
         let dz = cb.z - ca.z;
@@ -2764,6 +2843,9 @@ var WOOD_RIM = 1.5;
 var IMPACT_TAGS = ["metal", "glass", "wood"];
 var GLOW_FROM_C = 430;
 var QUEUE_CAP = 4e3;
+var TRICKLE_SECONDS = [2, 5];
+var TRICKLE_EVERY = 0.25;
+var TRICKLE_MAX = 24;
 var STRUCTURAL_EVENTS = /* @__PURE__ */ new Set([
   "fracture",
   "detach",
@@ -2787,6 +2869,10 @@ var STATIC_SPAN = 3;
 var FEET_BAND = 0.03;
 var TIP_MIN_HEIGHT = 0.3;
 var TIP_NARROW = 0.3;
+var CONTACT_MESHES = 12;
+var BROKEN_GAP = 0.03;
+var BROKEN_SAMPLES = [[0.5, 0.5], [0.1, 0.1], [0.9, 0.1], [0.1, 0.9], [0.9, 0.9]];
+var UNCHECKED_KINDS = /* @__PURE__ */ new Set(["structure", "room", "ground"]);
 var FIRE_CEILING_SECONDS = 3600;
 var GENERIC_REFERENCE_RADIUS = 15;
 var SWEEP_CORE = 0.15;
@@ -2886,10 +2972,14 @@ var Renderer = class {
     __publicField(this, "staticRound", []);
     /** Boxes of the pieces' meshes (as `staticBoxes`), with the time they were measured. */
     __publicField(this, "pieceBoxes", /* @__PURE__ */ new WeakMap());
+    /** Objects broken since the last update: `checkBroken` looks at what is left of them. */
+    __publicField(this, "broken", /* @__PURE__ */ new Set());
     __publicField(this, "staticAt", 0);
     __publicField(this, "queue", []);
     /** The cover of each body around a part of the world that went off, read as the event is emitted: before the blast tore or moved anything. */
     __publicField(this, "coverWhenWentOff", /* @__PURE__ */ new WeakMap());
+    /** Places a blow broke a hard face at: grit and dust keep coming off them for a few seconds, less and less (`TRICKLE_SECONDS`). */
+    __publicField(this, "trickles", []);
     /** 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 a drain, where a call finishes what it started. */
@@ -3232,10 +3322,12 @@ var Renderer = class {
     dt = clamp(dt, 0, 0.1);
     this.time += dt;
     if (!this.attached) this.drainQueue();
+    this.checkBroken();
     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);
+    this.updateTrickles(dt);
     this.pieceSys.update(dt);
     this.fragments.update(dt);
     this.ground.update(dt);
@@ -3434,6 +3526,7 @@ var Renderer = class {
   }
   apply(ev) {
     this.staticDirty.add(ev.object);
+    if (ev.type === "fracture" || ev.type === "detach" || ev.type === "collapse" || ev.type === "burnout" || ev.type === "destroyed") this.broken.add(ev.object);
     switch (ev.type) {
       case "damage":
         if (ev.damageType === "heat" || ev.damageType === "fire" || ev.damageType === "explosive") this.activate(ev.object, ev.part);
@@ -3758,9 +3851,34 @@ var Renderer = class {
     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 (core !== void 0) this.trickleFrom(ev.point, [normal.x, normal.y, normal.z], core);
     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));
   }
+  /** Grit and dust go on falling from where a blow broke a hard face (masonry, concrete) for `TRICKLE_SECONDS`, a pinch at a time and less and less. */
+  trickleFrom(point, normal, color) {
+    if (this.trickles.length >= TRICKLE_MAX) this.trickles.shift();
+    const total = TRICKLE_SECONDS[0] + (TRICKLE_SECONDS[1] - TRICKLE_SECONDS[0]) * this.rng();
+    this.trickles.push({ point: [point[0], point[1], point[2]], normal, color, left: total, total, next: TRICKLE_EVERY });
+  }
+  updateTrickles(dt) {
+    for (let i = this.trickles.length - 1; i >= 0; i--) {
+      const t = this.trickles[i];
+      t.left -= dt;
+      t.next -= dt;
+      if (t.left <= 0) {
+        this.trickles.splice(i, 1);
+        continue;
+      }
+      if (t.next > 0) continue;
+      const share = t.left / t.total;
+      t.next = TRICKLE_EVERY / Math.max(share, 0.25);
+      const out = [t.normal[0] * 0.2, -1, t.normal[2] * 0.2];
+      const options = t.color !== void 0 ? { color: t.color } : void 0;
+      this.vfx.burst("chips", t.point, out, this.low ? 1 : 2, 0.3, options);
+      if (this.rng() < 0.5) this.vfx.burst("dust", t.point, out, 1, 0.2, options);
+    }
+  }
   /**
    * 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
    * (cutting the wall's faces) is not drawn yet: it needs the per-vertex binding of the house renderer.
@@ -3796,6 +3914,7 @@ var Renderer = class {
       const tone3 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === def ? color : fallbackColor(fr.material, fdef);
       this.fragments.spawn(fr, this.fragments.materialFor(fr.material, tone3, false), ev.object, maxAlive);
     }
+    if (def?.visual?.innerColor !== void 0 || pv?.material === "concrete" || pv?.material === "brick") this.trickleFrom(ev.center, [0, 0, 0], color);
     if (ev.torn) {
       this.impactSound(pv?.material ?? "", ev.center, 0.5, ev.blow);
       return;
@@ -3985,26 +4104,30 @@ var Renderer = class {
     this.o.onPiece?.(piece);
   }
   /**
-   * Furniture that lost what it stood on falls: with every leg of a table broken the top is loose, and with the legs of one side gone what is left topples. Feet are the
-   * meshes at the bottom of the object as it was whole; while the ones left still span the same floor (a cupboard with a broken door, a table missing one leg) it stands.
+   * What lost what it stood on falls (furniture, a stand, a crate, a car; not a structure): with every leg of a table broken the top is loose, and with the legs of one side
+   * gone what is left topples. Feet are the meshes at the bottom of the object as it was whole; while the ones left still span the same floor (a cupboard with a broken door,
+   * a table missing one leg) it stands. A piece that lost a part is the box of what is left, touching the ground by the corners of each part (`setContacts`).
    */
   loosenIfFootless(objectId) {
     const b = this.bounds.get(objectId);
     if (!b || !this.autoSplit) return;
     const left = this.meshesOf(b).filter((mv) => this.visuals.shown(mv));
     if (left.length === 0) return;
+    const structural = UNCHECKED_KINDS.has(this.kindOf(b));
     const body = b.piece ?? this.pieceSys.get(objectId);
     if (body) {
       const { half, center } = this.measure(b.root, left);
       body.halfExtents = half;
       this.pieceSys.setCenter(body, center);
       body.mass = Math.max(0.05, this.massOf(objectId));
+      if (!structural) this.setContacts(b, body, left);
       body.sleeping = false;
       return;
     }
-    if (kitOriginOf(b.root)?.kind !== "furniture") return;
+    if (structural) return;
     const boxOf = (mv) => this.visuals.worldBox(mv, new this.THREE.Box3());
     const whole = [...b.parts.values()].flatMap((pv) => pv.meshes).map(boxOf).filter((one) => !one.isEmpty());
+    if (!this.standsOn(objectId, whole.map((one) => [one.min.x, one.min.y, one.min.z, one.max.x, one.max.y, one.max.z]))) return;
     const floor = Math.min(...whole.map((one) => one.min.y));
     const feetOf = (boxes) => boxes.filter((one) => one.min.y < floor + FEET_BAND).reduce((feet, one) => feet.union(one), new this.THREE.Box3());
     const was = feetOf(whole);
@@ -4020,9 +4143,116 @@ var Renderer = class {
       if (!narrow && centreX > now.min.x && centreX < now.max.x && centreZ > now.min.z && centreZ < now.max.z) return;
     }
     const piece = this.makePiece(objectId);
+    this.setContacts(b, b.piece ?? piece, left);
     this.tipIfTopHeavy(b);
     this.o.onLoosened?.(objectId, piece, "apart");
   }
+  shownBoxes(objectId, partId) {
+    const b = this.bounds.get(objectId);
+    if (!b) return [];
+    const box = new this.THREE.Box3();
+    const out = [];
+    const pv = partId === void 0 ? null : b.parts.get(partId);
+    if (partId !== void 0 && (!pv || pv.gone !== "none")) return out;
+    for (const mv of pv ? pv.meshes : this.meshesOf(b)) {
+      if (!this.visuals.shown(mv)) continue;
+      this.visuals.worldBox(mv, box);
+      if (!box.isEmpty()) out.push([box.min.x, box.min.y, box.min.z, box.max.x, box.max.y, box.max.z]);
+    }
+    return out;
+  }
+  /**
+   * What is left of each object broken since the last update stands on something, or falls: an object that is not a piece whose lowest drawn box has neither the ground, a
+   * fixed top nor a piece within `BROKEN_GAP` under it is made a piece on the spot (see `onBrokenChecked`).
+   */
+  checkBroken() {
+    if (this.broken.size === 0) return;
+    const ids = [...this.broken];
+    this.broken.clear();
+    for (const id of ids) {
+      const released = this.releaseIfFloating(id);
+      this.o.onBrokenChecked?.(id, released);
+    }
+  }
+  releaseIfFloating(objectId) {
+    const b = this.bounds.get(objectId);
+    if (!b || b.piece || this.pieceSys.get(objectId) || !this.autoSplit || UNCHECKED_KINDS.has(this.kindOf(b))) return false;
+    const boxes = this.shownBoxes(objectId);
+    if (boxes.length === 0) return false;
+    const whole = new this.THREE.Box3();
+    const wholeBoxes = [];
+    for (const pv of b.parts.values()) {
+      for (const mv of pv.meshes) {
+        this.visuals.worldBox(mv, whole);
+        if (!whole.isEmpty()) wholeBoxes.push([whole.min.x, whole.min.y, whole.min.z, whole.max.x, whole.max.y, whole.max.z]);
+      }
+    }
+    if (!this.standsOn(objectId, wholeBoxes) || this.standsOn(objectId, boxes)) return false;
+    const piece = this.makePiece(objectId);
+    this.setContacts(b, b.piece ?? piece, this.meshesOf(b).filter((mv) => this.visuals.shown(mv)));
+    this.tipIfTopHeavy(b);
+    this.o.onLoosened?.(objectId, piece, "apart");
+    return true;
+  }
+  /** Whether the lowest of `boxes` (world boxes of the object `objectId`) has the ground, a fixed top or a piece within `BROKEN_GAP` under it. */
+  standsOn(objectId, boxes) {
+    if (boxes.length === 0) return false;
+    const low = Math.min(...boxes.map((one) => one[1]));
+    for (const [x0, y0, z0, x1, , z1] of boxes) {
+      if (y0 > low + FEET_BAND) continue;
+      for (const [fx, fz] of BROKEN_SAMPLES) {
+        const x = x0 + (x1 - x0) * fx;
+        const z = z0 + (z1 - z0) * fz;
+        const under = Math.max(this.groundAt(x, z), this.staticTopAtBut(objectId, x, z, y0, BROKEN_GAP), this.pieceSys.topAt(x, z, y0, BROKEN_GAP, objectId));
+        if (under >= y0 - BROKEN_GAP) return true;
+      }
+    }
+    return false;
+  }
+  /** The kind of kit piece a bound object is, by the mark on its root or the nearest one above it (a house binds a group inside its marked root); '' when unmarked. */
+  kindOf(b) {
+    for (let o = b.root; o; o = o.parent) {
+      const kind = kitOriginOf(o)?.kind;
+      if (kind) return kind;
+    }
+    return "";
+  }
+  /** `staticTopAt` without the boxes of `objectId` itself. */
+  staticTopAtBut(objectId, x, z, y, step) {
+    let top = -Infinity;
+    for (const [id, a] of this.staticNow()) {
+      if (id === objectId || a.length === 0 || x < a[0] || x > a[3] || z < a[2] || z > a[5]) continue;
+      for (let i = 6; i < a.length; i += 6) {
+        if (x < a[i] || x > a[i + 3] || z < a[i + 2] || z > a[i + 5]) continue;
+        const t = a[i + 4];
+        if (t > top && t <= y + step) top = t;
+      }
+    }
+    return top;
+  }
+  /**
+   * The piece touches the ground by the corners of each part left of it, not by the box around them all: on one leg, or on the legs of one side, its centre of mass is off
+   * what holds it and it goes over until the top meets the floor. Past `CONTACT_MESHES` meshes it keeps the corners of its box.
+   */
+  setContacts(b, body, meshes) {
+    if (meshes.length > CONTACT_MESHES) {
+      body.contacts = void 0;
+      return;
+    }
+    const inv = specFrameInverse(this.THREE, b.root);
+    const m4 = new this.THREE.Matrix4();
+    const lb = new this.THREE.Box3();
+    const [cx, cy, cz] = body.localCenter;
+    const points = [];
+    for (const mv of meshes) {
+      mv.mesh.updateWorldMatrix(true, false);
+      this.visuals.localBox(mv, lb);
+      if (lb.isEmpty()) continue;
+      lb.applyMatrix4(m4.multiplyMatrices(inv, mv.mesh.matrixWorld));
+      for (let i = 0; i < 8; i++) points.push([(i & 1 ? lb.max.x : lb.min.x) - cx, (i & 2 ? lb.max.y : lb.min.y) - cy, (i & 4 ? lb.max.z : lb.min.z) - cz]);
+    }
+    body.contacts = points.length > 0 ? points : void 0;
+  }
   /**
    * A piece of furniture standing on feet too close for its height (a board on two legs in a line, a lone leg) does not stay up: the box of a piece hides that its weight is up
    * high and its feet are thin, so it gets the start of the fall, across the line of its feet.
@@ -4314,6 +4544,7 @@ var Renderer = class {
     this.active.clear();
     for (const key of [...this.fires.keys()]) this.stopFire(key);
     this.leaks.length = 0;
+    this.trickles.length = 0;
     for (const id of [...this.bounds.keys()]) if (this.bounds.has(id)) this.restore(id);
     for (const b of [...this.bounds.values()]) {
       if (b.isSplit) {
@@ -4582,6 +4813,21 @@ var FIRE_LOOP = {
   volume: 0,
   sources: ["sdk: the roar under the crackles of a fire"]
 };
+var SMOKE_HISS_LOOP = {
+  id: "smoke_grenade_hiss",
+  bus: "world",
+  order: "chain_loop",
+  source: { kind: "noise", loop: true },
+  filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 1400 }, q: 0.7 }, { type: "lowpass", frequency: { set: 7e3 }, q: 0.5 }] },
+  volume: 0,
+  sources: ["sdk: a smoke canister venting (the gas through its holes, steady for its whole burn)"]
+};
+var GRENADE_PIN_PULL = blast(
+  "grenade_pin_pull",
+  [noise({ type: "highpass", f: [3200, 4200], d: 0.025, vol: 0.5 }), noise({ type: "bandpass", f: [2200, 2800], q: 2, d: 0.04, vol: 0.4, delay: 0.18 })],
+  ["sdk: the ring pulled from the fuse, then the spoon flying off"],
+  FIRE_FALLOFF
+);
 var FIRE_FUEL_OF = {
   wood_soft: "wood",
   wood_hard: "wood",
@@ -4771,7 +5017,7 @@ var IMPACT_SOUNDS = [
   impact("plastic_crack", [noise2({ type: "bandpass", f: 1800, q: 2, d: 0.06, vol: 0.75 }), tone2({ f: [450, 550], f2: 250, d: 0.05, vol: 0.22 })]),
   impact("mdf_crumble", [noise2({ type: "lowpass", f: 700, d: 0.25, vol: 0.75, wet: 0.2 }), ...many2(4, () => noise2({ type: "lowpass", f: 500, d: 0.05, vol: 0.32, delay: [0.05, 0.3] }))])
 ];
-var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, ...LEAF_SOUNDS, ...IMPACT_SOUNDS, EXPLOSION_BOOM, ...BLAST_SOUNDS, ...FIRE_SOUNDS], loops: [BURN_LOOP, FIRE_LOOP, ...FIRE_FUEL_LOOPS] };
+var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, ...LEAF_SOUNDS, ...IMPACT_SOUNDS, EXPLOSION_BOOM, ...BLAST_SOUNDS, ...FIRE_SOUNDS, GRENADE_PIN_PULL], loops: [BURN_LOOP, FIRE_LOOP, ...FIRE_FUEL_LOOPS, SMOKE_HISS_LOOP] };
 
 // src/audio/sound.ts
 import { FOLEY_BANK, GAME_SFX_BANK } from "@adatechnology/game-audio";
@@ -5106,10 +5352,12 @@ export {
   FIRE_FALLOFF,
   FIRE_LOOP,
   FIRE_SOUNDS,
+  GRENADE_PIN_PULL,
   IMPACT_FAMILY_TAGS,
   IMPACT_SOUNDS,
   IMPACT_SOUND_KEYS,
   SCENE_SOUNDS,
+  SMOKE_HISS_LOOP,
   blastFireSampleBank,
   breakSoundKeys,
   createDestructionRenderer,