@adatechnology/game-destruction-three 0.17.3 → 0.18.1

package/dist/index.global.js

@@ -43,10 +43,12 @@ var GameDestructionThree = (() => {
     FIRE_FALLOFF: () => FIRE_FALLOFF,
     FIRE_LOOP: () => FIRE_LOOP,
     FIRE_SOUNDS: () => FIRE_SOUNDS,
+    GRENADE_PIN_PULL: () => GRENADE_PIN_PULL,
     IMPACT_FAMILY_TAGS: () => IMPACT_FAMILY_TAGS,
     IMPACT_SOUNDS: () => IMPACT_SOUNDS,
     IMPACT_SOUND_KEYS: () => IMPACT_SOUND_KEYS,
     SCENE_SOUNDS: () => SCENE_SOUNDS,
+    SMOKE_HISS_LOOP: () => SMOKE_HISS_LOOP,
     blastFireSampleBank: () => blastFireSampleBank,
     breakSoundKeys: () => breakSoundKeys,
     createDestructionRenderer: () => createDestructionRenderer,
@@ -6222,8 +6224,8 @@ var GameDestructionThree = (() => {
       id: "dust",
       additive: false,
       life: [
-        1,
-        2
+        2,
+        5
       ],
       size: [
         0.08,
@@ -6290,8 +6292,8 @@ var GameDestructionThree = (() => {
       id: "chips",
       additive: false,
       life: [
-        0.8,
-        1.5
+        2,
+        4
       ],
       size: [
         0.025,
@@ -7738,7 +7740,7 @@ var GameDestructionThree = (() => {
   };
   var EFFECT_STEP_SECONDS = 1 / 50;
 
-  // ../game-vfx-three/dist/chunk-CPRCWTSQ.js
+  // ../game-vfx-three/dist/chunk-IOGYK5RO.js
   var GLOW_VERTEX = `attribute vec4 aP;attribute vec4 aC;varying vec2 vU;varying vec4 vC;
 void main(){vec3 R=vec3(viewMatrix[0][0],viewMatrix[1][0],viewMatrix[2][0]);vec3 Up=vec3(viewMatrix[0][1],viewMatrix[1][1],viewMatrix[2][1]);
 vec3 wp=aP.xyz+(R*position.x+Up*position.y)*aP.w;vU=position.xy;vC=aC;gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.);}`;
@@ -7785,10 +7787,15 @@ void main(){
   if(n<diss*1.08-.04)discard;
   float lam=max(dot(N,uLight),0.);
   float band=lam>.55?1.:lam>.15?.68:.42;
-  vec3 col=vC*(vec3(.5,.56,.7)*band*1.05+vec3(.2,.19,.18)+uGround*(.4-.4*N.y));
+  // soot: a dark smoke still scatters some light, so it never goes flat black, and its rim takes the sky so its volume reads (only the dark puffs; the rest as the Lab)
+  float dark=1.-smoothstep(.02,.12,dot(vC,vec3(.2126,.7152,.0722)));
+  vec3 alb=max(vC,vec3(.055)*dark);
+  vec3 col=alb*(vec3(.5,.56,.7)*band*1.05+vec3(.2,.19,.18)+uGround*(.4-.4*N.y));
+  float rim=pow(1.-clamp(abs(dot(N,normalize(cameraPosition-vWP))),0.,1.),2.);
+  col+=dark*rim*(uSky*.9+alb);
   vec3 tg=uGlowPos-vWP;float dg=length(tg)+.001;
   float gi=uGlowI/(1.+dg*dg*.05)*(.3+.7*max(dot(N,tg/dg),0.));
-  col+=uGlowCol*gi*vC*1.6;
+  col+=uGlowCol*gi*alb*1.6;
   float h=heat*(.72+.56*n)+heat*(-N.y)*.18;
   if(h>.05){
     float hq=floor(h*5.+.5)/5.;
@@ -9940,7 +9947,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   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;
@@ -9959,6 +9968,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   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];
@@ -9974,11 +9986,24 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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 UP16 = [0, 1, 0];
+  var faceNormal = (s, axis2) => {
+    const e = s.e;
+    const sign = e[axis2 * 4 + 1] < 0 ? -1 : 1;
+    return [sign * e[axis2 * 4], sign * e[axis2 * 4 + 1], sign * e[axis2 * 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);
@@ -9992,6 +10017,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __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", UP16);
+      __publicField(this, "supportFriction", null);
       this.p = new THREE.Vector3();
       this.q = new THREE.Quaternion();
       this.dq = new THREE.Quaternion();
@@ -10097,8 +10125,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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, hz2] = b.halfExtents;
       const out = [];
       for (let i = 0; i < 8; i++) out.push([i & 1 ? hx : -hx, i & 2 ? hy : -hy, i & 4 ? hz2 : -hz2]);
@@ -10163,6 +10192,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
         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);
     }
@@ -10193,15 +10226,48 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       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) : UP16;
+      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. */
@@ -10284,7 +10350,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const e = this.m.elements;
         const rs = [];
         const ids = [];
+        const ns = [];
+        const mus = [];
         let maxPen = 0;
+        let penNormal = UP16;
         const rise = STEP + Math.max(0, -v[1]) * h * 2;
         let side = null;
         let lowest = Infinity;
@@ -10302,6 +10371,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
               if (floor2 !== void 0 && floor2 - cy > -SLOP && floor2 < raw - STEP) {
                 rs.push(r);
                 ids.push(i);
+                ns.push(UP16);
+                mus.push(pairFriction(b.friction, null));
                 maxPen = Math.max(maxPen, floor2 - cy);
               }
               continue;
@@ -10322,12 +10393,19 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
             }
             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 = UP16;
+          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);
           }
         }
@@ -10340,7 +10418,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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 impact3 = 0;
         for (const r of rs) impact3 = Math.max(impact3, -(v[1] + w[2] * r[0] - w[0] * r[2]));
         const restitution = impact3 > 2 ? 0.25 : 0;
@@ -10356,76 +10437,72 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           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 vy2 = v[1] + (w[2] * r[0] - w[0] * r[2]);
-          return vy2 < 0 ? -restitution * vy2 : 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 vy2 = 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] - vy2) / 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 vx2 = v[0] + (w[1] * r[2] - w[2] * r[1]);
-            const vz2 = v[2] + (w[0] * r[1] - w[1] * r[0]);
-            const vt = Math.hypot(vx2, vz2);
-            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 = vx2 / vt;
-              const tz = vz2 / vt;
-              const at3 = this.mulInvInertiaWith(b, e, r[1] * tz, r[2] * tx - r[0] * tz, -r[1] * tx);
-              const cx = at3[1] * r[2] - at3[2] * r[1];
-              const cz = at3[0] * r[1] - at3[1] * r[0];
-              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;
+            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 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;
@@ -10434,9 +10511,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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) {
@@ -10508,6 +10586,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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;
@@ -10533,6 +10618,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           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;
@@ -13463,6 +13549,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   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",
@@ -13486,6 +13575,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   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;
@@ -13585,10 +13678,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __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. */
@@ -13931,10 +14028,12 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       dt = clamp6(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);
@@ -14133,6 +14232,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     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);
@@ -14457,9 +14557,34 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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.
@@ -14495,6 +14620,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const tone = 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, tone, 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;
@@ -14684,26 +14810,30 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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 floor2 = Math.min(...whole.map((one) => one.min.y));
       const feetOf = (boxes) => boxes.filter((one) => one.min.y < floor2 + FEET_BAND).reduce((feet, one) => feet.union(one), new this.THREE.Box3());
       const was = feetOf(whole);
@@ -14719,9 +14849,116 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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.
@@ -15013,6 +15250,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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) {
@@ -15148,7 +15386,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     return { id: options.id, samples };
   }
 
-  // ../game-audio/dist/chunk-UUWKSG4J.js
+  // ../game-audio/dist/chunk-BUYBYP4L.js
   var DISTANCE_CURVES = {
     /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
     game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
@@ -15326,6 +15564,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ["revolver_38_357", 2, "sfx_pistol"],
       ["revolver_44_50ae", 3, "sfx_pistol"],
       ["smg_9mm_auto", 1, "sfx_pistol"],
+      ["launcher_40mm", 2],
+      ["rocket_launch", 2],
       ["shotgun_12", 1, "sfx_shotgun"],
       ["rifle_5_56", 1, "sfx_rifle"],
       ["rifle_7_62x39", 1, "sfx_rifle"],
@@ -16791,6 +17031,21 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     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",
+    [sceneNoise({ type: "highpass", f: [3200, 4200], d: 0.025, vol: 0.5 }), sceneNoise({ 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",
@@ -16980,7 +17235,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     impact2("plastic_crack", [sceneNoise({ type: "bandpass", f: 1800, q: 2, d: 0.06, vol: 0.75 }), sceneTone({ f: [450, 550], f2: 250, d: 0.05, vol: 0.22 })]),
     impact2("mdf_crumble", [sceneNoise({ type: "lowpass", f: 700, d: 0.25, vol: 0.75, wet: 0.2 }), ...sceneMany(4, () => sceneNoise({ 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
   var IMPACT_SOUND_KEYS = {
@@ -17281,7 +17536,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     // each fuel has its own roar: a gas jet (burners and torches), a pool of fuel, plastic and rubber sizzling under the flames
     fire_loop_gas: { bus: "world", gain: 6, loop: { crossfade: 1 } },
     fire_loop_liquid: { bus: "world", gain: 3.5, loop: { crossfade: 1 } },
-    fire_loop_plastic: { bus: "world", gain: 1, loop: { crossfade: 0.6 } }
+    fire_loop_plastic: { bus: "world", gain: 1, loop: { crossfade: 0.6 } },
+    // a smoke canister venting: a gas hiss chained like the fire roar (the level comes from the room, by how near the burning canisters are)
+    smoke_grenade_hiss: { bus: "world", gain: 1, loop: { crossfade: 0.8 } },
+    // the ring and the spoon of a hand grenade: a small metal latch
+    grenade_pin_pull: fire(0.5)
   };
   function blastFireSampleBank(manifest, options = {}) {
     const sounds = options.sounds ?? BLAST_FIRE_SAMPLES;