@adatechnology/game-test-room 0.29.0 → 0.29.1

package/dist/index.global.js

@@ -3722,23 +3722,42 @@ var GameTestRoom = (() => {
     const v = table[mat.penetrationClass ?? mat.id] ?? table[mat.id];
     return v === void 0 ? void 0 : v * (mat.penetrationScale ?? 1);
   };
-  var capacityScale = (p) => {
+  var BURIED_BLAST_REACH = 0.5;
+  var GIVE_AT_CUT_HP = 0.5;
+  var capacityScale = (p, borne, through) => {
     const residual = p.spec.reinforcement?.residualCapacity ?? RESIDUAL_CAPACITY;
     if (p.st.stripped) return residual;
-    const kept = Math.min(p.rt.removed ? 1 - p.rt.removed / p.mass0 : 1, 1 - sectionLoss(p));
+    const kept = Math.min(p.rt.removed ? 1 - p.rt.removed / p.mass0 : 1, sectionKept(p, residual, borne, through));
     return Math.max(p.spec.reinforcement ? residual : 0.05, kept);
   };
-  var sectionLoss = (p) => {
+  var sectionKept = (p, residual, borne, through) => {
+    let kept = 1;
+    forEachSection(p, borne, (c, along, gone) => {
+      const share = through?.(c.center, along) ?? 1;
+      if (share <= 0) return;
+      kept = Math.min(kept, Math.max(p.spec.reinforcement ? residual : 0, 1 - gone) / share);
+    });
+    return kept;
+  };
+  var sectionLoss = (p, borne) => {
+    let worst = 0;
+    forEachSection(p, borne, (_c, _along, gone) => {
+      worst = Math.max(worst, gone);
+    });
+    return Math.min(1, worst);
+  };
+  var forEachSection = (p, borne, visit) => {
     const cells = p.st.chipped;
-    if (!cells?.length) return 0;
+    if (!cells?.length) return;
     const [u, v] = planeAxes(p.thin);
     const role = p.spec.structure?.role;
     const up = rotateVec(p.q, [0, 0, 0].map((_, k) => k === v ? 1 : 0));
     const upright = Math.abs(up[1]) > 0.7 ? v : Math.abs(rotateVec(p.q, [0, 0, 0].map((_, k) => k === u ? 1 : 0))[1]) > 0.7 ? u : -1;
     const along = (role === "wall" || role === "partition" || role === "column") && upright >= 0 ? upright : p.dims[u] >= p.dims[v] ? u : v;
     const across = along === u ? v : u;
-    let worst = 0;
+    const lying = along !== upright || upright < 0;
     for (const c of cells) {
+      if (lying && borne?.(c.center, along)) continue;
       const spans = [];
       for (const d of cells) if (Math.abs(d.center[along] - c.center[along]) < d.size[along] / 2 + 1e-6) spans.push([d.center[across] - d.size[across] / 2, d.center[across] + d.size[across] / 2]);
       spans.sort((a, b) => a[0] - b[0]);
@@ -3748,9 +3767,8 @@ var GameTestRoom = (() => {
         gone += b - Math.max(a, end3);
         end3 = b;
       }
-      worst = Math.max(worst, gone / Math.max(p.dims[across], 1e-6));
+      visit(c, along, Math.min(1, gone / Math.max(p.dims[across], 1e-6)));
     }
-    return Math.min(1, worst);
   };
   var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
   var clone = (v) => structuredClone(v);
@@ -4061,6 +4079,26 @@ var GameTestRoom = (() => {
       byTouching.set(support, { version: poseVersion, box: box2 });
       return box2;
     };
+    const throughOf = (p) => {
+      const load = p.st.load ?? 0;
+      if (load <= 0) return void 0;
+      const above2 = Math.max(0, load - p.st.mass);
+      const up = rotateVec(p.q, [0, 1, 0]);
+      return (local2, along) => {
+        const axis2 = [0, 0, 0];
+        axis2[along] = 1;
+        const sign = Math.sign(rotateVec(p.q, axis2)[1]);
+        if (Math.abs(up[1]) < 0.7 && Math.abs(rotateVec(p.q, axis2)[1]) < 0.7) return 1;
+        const half = p.dims[along] / 2;
+        const share = clamp2((half - sign * local2[along]) / Math.max(p.dims[along], 1e-6), 0, 1);
+        return (above2 + p.st.mass * share) / load;
+      };
+    };
+    const borneOn = (p, supports) => {
+      if (supports.length === 0) return void 0;
+      const boxes = supports.map((support) => contactBox(p, support));
+      return (local2, along) => boxes.some(([lo, hi]) => local2[along] >= lo[along] - SUPPORT_TOLERANCE && local2[along] <= hi[along] + SUPPORT_TOLERANCE);
+    };
     const measureContact = (p, support) => {
       const A = aabbOf(p.spec.shape, p.pos, p.q), B = aabbOf(support.spec.shape, support.pos, support.q);
       const lo = [0, 0, 0], hi = [0, 0, 0];
@@ -4268,7 +4306,7 @@ var GameTestRoom = (() => {
           o.unsup[i] = o.anyAnchor && !isLost(p) && !p.orphan;
           continue;
         }
-        p.st.stress = p.st.load * structureSafety / (p.cap * capacityScale(p));
+        p.st.stress = p.st.load * structureSafety / (p.cap * capacityScale(p, borneOn(p, (lowerOf.get(i) ?? []).map((k) => parts[k])), throughOf(p)));
         if (p.bend) {
           p.bendLoad = p.st.mass + bending[i];
           const bent = restFlexure(o, p, lowerOf.get(i) ?? []);
@@ -5358,6 +5396,27 @@ var GameTestRoom = (() => {
       debris3(o, p, p.mat.breakDebris, center, [0, -1, 0], 6, 1, src);
       return loose.length;
     };
+    const giveAtCut = (o, p, src) => {
+      if (!p.spec.reinforcement || !p.spec.units || !p.st.chipped?.length || sectionLoss(p) <= 0) return false;
+      const opened = [];
+      for (const j of o.byPart.get(p.spec.id) ?? []) {
+        if (j.st.open) continue;
+        const onIt = j.bears === "a_on_b" && j.spec.b === p.spec.id || j.bears === "b_on_a" && j.spec.a === p.spec.id;
+        if (!onIt) continue;
+        j.st.open = true;
+        j.st.openedBy = "break";
+        opened.push(j);
+      }
+      if (opened.length === 0) return false;
+      p.st.hp = Math.max(p.st.hp, p.st.maxHp * GIVE_AT_CUT_HP);
+      markDamaged(p);
+      solveStructure(o);
+      recomputeGroups(o);
+      detachEvents(o, opened, "break", src);
+      exposeRebar(o, p, src);
+      collapseCheck(o, src);
+      return true;
+    };
     const stripPart = (o, p, reinforcement, src) => {
       const bars = rebarBars(p.dims, p.thin, reinforcement.spacing);
       p.st.stripped = true;
@@ -5415,6 +5474,7 @@ var GameTestRoom = (() => {
         hingeDrop(o, p, src);
         return;
       }
+      if (!force && giveAtCut(o, p, src)) return;
       const ex = p.spec.explodes;
       const style = force ?? (p.snap ? "snap" : p.mat.fracture === "none" ? "snap" : p.mat.fracture);
       const { c, q } = partXf(o, p);
@@ -5761,7 +5821,9 @@ var GameTestRoom = (() => {
         const dx = local2[0] - p.pos[0];
         const dy = local2[1] - p.pos[1];
         const dz = local2[2] - p.pos[2];
-        if (dx * dx + dy * dy + dz * dz < reach * reach) near.push(p);
+        if (dx * dx + dy * dy + dz * dz >= reach * reach) continue;
+        if (p.spec.anchored && p.spec.structure?.role === "foundation" && distToPart(o, p, point) > BURIED_BLAST_REACH) continue;
+        near.push(p);
       }
       blastProbe.partsTested += o.parts.length;
       blastProbe.partsNear += near.length;
@@ -7270,7 +7332,7 @@ var GameTestRoom = (() => {
     return bank;
   }
 
-  // ../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 },
@@ -9665,6 +9727,8 @@ var GameTestRoom = (() => {
       ["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"],
@@ -17204,8 +17268,8 @@ var GameTestRoom = (() => {
       id: "dust",
       additive: false,
       life: [
-        1,
-        2
+        2,
+        5
       ],
       size: [
         0.08,
@@ -17272,8 +17336,8 @@ var GameTestRoom = (() => {
       id: "chips",
       additive: false,
       life: [
-        0.8,
-        1.5
+        2,
+        4
       ],
       size: [
         0.025,
@@ -19915,7 +19979,7 @@ var GameTestRoom = (() => {
     return sources;
   }
 
-  // ../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.);}`;
@@ -19962,10 +20026,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.;
@@ -22143,7 +22212,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;
@@ -22162,6 +22233,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];
@@ -22177,11 +22251,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) {
       __publicField3(this, "THREE", THREE);
@@ -22195,6 +22282,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField3(this, "ax");
       __publicField3(this, "solids", []);
       __publicField3(this, "supportTurn", 0);
+      __publicField3(this, "supportNormal", UP16);
+      __publicField3(this, "supportFriction", null);
       this.p = new THREE.Vector3();
       this.q = new THREE.Quaternion();
       this.dq = new THREE.Quaternion();
@@ -22300,8 +22389,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]);
@@ -22366,6 +22456,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);
     }
@@ -22396,15 +22490,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 fixed2 = this.o.staticTopAt?.(x, z, y, step) ?? -Infinity;
+      if (fixed2 >= top) on = null;
+      this.supportNormal = on ? faceNormal(on, face) : UP16;
+      this.supportFriction = on?.body.friction ?? null;
       return Math.max(top, fixed2);
     }
     /** 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. */
@@ -22487,7 +22614,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;
@@ -22505,6 +22635,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;
@@ -22525,12 +22657,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);
           }
         }
@@ -22543,7 +22682,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 impact22 = 0;
         for (const r of rs) impact22 = Math.max(impact22, -(v[1] + w[2] * r[0] - w[0] * r[2]));
         const restitution = impact22 > 2 ? 0.25 : 0;
@@ -22559,76 +22701,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 dot5 = (a, c2) => a[0] * c2[0] + a[1] * c2[1] + a[2] * c2[2];
+        const goal = rs.map((r, k) => {
+          const vn = dot5(pointV(r), ns[k]);
+          return vn < 0 ? -restitution * vn : 0;
+        });
+        const slipping = rs.map((r, k) => {
+          const pv = pointV(r);
+          const vn = dot5(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 = dot5(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;
+            if (j !== 0) push(r, [n[0] * j, n[1] * j, n[2] * j]);
+            const pv = pointV(r);
+            const pn = dot5(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 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;
-            }
-            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;
@@ -22637,9 +22775,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) {
@@ -22711,6 +22850,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;
@@ -22736,6 +22882,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;
@@ -24126,6 +24273,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",
@@ -24149,6 +24299,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;
@@ -24244,9 +24398,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField3(this, "staticAll", true);
       __publicField3(this, "staticRound", []);
       __publicField3(this, "pieceBoxes", /* @__PURE__ */ new WeakMap());
+      __publicField3(this, "broken", /* @__PURE__ */ new Set());
       __publicField3(this, "staticAt", 0);
       __publicField3(this, "queue", []);
       __publicField3(this, "coverWhenWentOff", /* @__PURE__ */ new WeakMap());
+      __publicField3(this, "trickles", []);
       __publicField3(this, "slices", []);
       __publicField3(this, "sliceDeadline", Infinity);
       __publicField3(this, "drainClock", () => performance.now());
@@ -24581,10 +24737,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);
@@ -24783,6 +24941,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);
@@ -25107,9 +25266,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.
@@ -25145,6 +25329,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         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;
@@ -25334,26 +25519,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);
@@ -25369,9 +25558,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 box2 = 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, box2);
+        if (!box2.isEmpty()) out.push([box2.min.x, box2.min.y, box2.min.z, box2.max.x, box2.max.y, box2.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.
@@ -25663,6 +25959,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.active.clear();
       for (const key2 of [...this.fires.keys()]) this.stopFire(key2);
       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) {
@@ -25924,6 +26221,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",
@@ -26111,7 +26423,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] };
   var IMPACT_SOUND_KEYS = {
     impact_metal_ballistic: { sound: "metal_bullet" },
     impact_metal_blunt: { sound: "metal_blunt" },
@@ -48938,6 +49250,8 @@ void main(){
   var SMOKE_PUFF_SPEED = 1.7;
   var SMOKE_PUFF_SIZE = 5;
   var SMOKE_PUFF_ALPHA = 1.5;
+  var SMOKE_HISS = { loop: "smoke_grenade_hiss", volume: 0.7, halfAt: 6, max: 1 };
+  var GRENADE_PIN_SOUND = "grenade_pin_pull";
   var CONE_BLAST_RADIUS = 0.5;
   var summarizeBlast = (results) => {
     const reports = results.flatMap((r) => r.blast ? [r.blast] : []);
@@ -48957,12 +49271,31 @@ void main(){
     const random = context.random ?? Math.random;
     const meshes = [];
     const up = new THREE.Vector3(0, 1, 0);
+    let smokeHiss = null;
+    const hissSmoke = () => {
+      if (!context.audio) return;
+      if (smokeSources.length === 0) {
+        smokeHiss?.stop();
+        smokeHiss = null;
+        return;
+      }
+      const at3 = camera2.position;
+      let level = 0;
+      for (const source of smokeSources) {
+        const distance4 = Math.hypot(source.point[0] - at3.x, source.point[1] - at3.y, source.point[2] - at3.z);
+        level += SMOKE_HISS.volume / (1 + (distance4 / SMOKE_HISS.halfAt) ** 2);
+      }
+      smokeHiss ?? (smokeHiss = context.audio.loop(SMOKE_HISS.loop));
+      smokeHiss.set({ volume: Math.min(SMOKE_HISS.max, level) });
+    };
     const drop = (objects) => {
       for (const object of objects) object.removeFromParent();
       releaseObject3D(objects, { keep: scene2 });
     };
     const clear = () => {
       smokeSources.length = 0;
+      smokeHiss?.stop();
+      smokeHiss = null;
       projectiles.length = 0;
       drop(meshes);
       meshes.length = 0;
@@ -49016,6 +49349,7 @@ void main(){
         age: 0,
         ...use.explosive !== void 0 ? { body: createExplosiveBody(use, arsenal.explosives, arsenal.rules.explosives), aligned: isRocket } : {}
       });
+      if (!isRocket && !isMolotov && use.explosive !== void 0) context.audio?.play(GRENADE_PIN_SOUND, { position: use.origin });
       const key2 = isRocket ? "act.launch" : isMolotov ? "act.throw.molotov" : "act.throw.grenade";
       action(isRocket ? "launch_projectile" : "throw_projectile", translate(key2, { weapon: context.toolName(), fuse: format(use.fuse, 1), arm: format(use.armDistance ?? 0, 0) }), {
         data: { weapon: context.toolId(), fuse: use.fuse, explosive: use.explosive }
@@ -49269,6 +49603,7 @@ void main(){
         }
         if (source.left <= 0) smokeSources.splice(index, 1);
       }
+      hissSmoke();
     };
     const update = (dt) => {
       burnSmoke(dt);
@@ -55687,6 +56022,7 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       "act.player_thrown_wounded": "The blast threw the player at {speed} m/s, {distance} m from it: badly wounded, stunned for {stun} s ({reach}% got through the cover)",
       "act.player_stunned": "The blast stunned the player for {stun} s, {distance} m from it: dizzy, ears ringing",
       "act.came_apart": "{name} came apart: what stayed is loose and falls",
+      "check.broken_floating": "ERROR: what was left of {name} stood on nothing after the break; it was let go to fall",
       "act.shoved": "{name} stands free: the shots moved it",
       "act.impact": "{name} hit {where} at {speed} m/s: {energy} J of blunt damage",
       "act.use_item": "{name}: {use}",
@@ -56065,6 +56401,7 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       "act.player_thrown_wounded": "A explos\xE3o arremessou o jogador a {speed} m/s, a {distance} m dela: ferido gravemente, atordoado por {stun} s ({reach}% passou pela cobertura)",
       "act.player_stunned": "A explos\xE3o atordoou o jogador por {stun} s, a {distance} m dela: tonto, com os ouvidos zumbindo",
       "act.came_apart": "{name} se desmontou: o que ficou est\xE1 solto e cai",
+      "check.broken_floating": "ERRO: o que sobrou de {name} ficou sem apoio depois de quebrar; foi solto para cair",
       "act.shoved": "{name} estava solto no ch\xE3o: os tiros o moveram",
       "act.impact": "{name} bateu em {where} a {speed} m/s: {energy} J de dano de impacto",
       "act.use_item": "{name}: {use}",
@@ -57795,6 +58132,14 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
         rendererPieces.set(objectId, piece);
         action("loosened", t(cause === "blast" ? "act.loosened" : "act.came_apart", { name: e.name }), { objectId, itemId: e.so.itemId });
       },
+      // after a break the collision of the object is measured again from what is still drawn; what stood on nothing was let go, which is a bug the room says aloud
+      onBrokenChecked: (objectId, released) => {
+        bodyBoxes.delete(objectId);
+        if (standingIds.includes(objectId)) leaveFootprint(objectId);
+        if (!released) return;
+        const e = entries2.get(objectId);
+        log.add({ channel: "check", type: "fail", text: t("check.broken_floating", { name: e?.name ?? objectId }), objectId, ...e ? { itemId: e.so.itemId } : {}, data: { invariant: "broken_floating" } });
+      },
       onPiece: (piece) => {
         rendererPieces.set(piece.objectId, piece);
         loose.push(piece);
@@ -58458,9 +58803,14 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
         bodyBoxes.delete(id);
         return null;
       }
-      bodyBounds.setFromObject(e.so.root);
-      if (bodyBounds.isEmpty()) return null;
-      const box2 = { minX: bodyBounds.min.x, maxX: bodyBounds.max.x, minZ: bodyBounds.min.z, maxZ: bodyBounds.max.z, base: bodyBounds.min.y, top: bodyBounds.max.y, stamp: frameStamp };
+      const parts = renderer.shownBoxes(id);
+      if (parts.length === 0) {
+        bodyBoxes.delete(id);
+        return null;
+      }
+      bodyBounds.makeEmpty();
+      for (const p of parts) bodyBounds.expandByPoint(tmpV2.set(p[0], p[1], p[2])).expandByPoint(tmpV2.set(p[3], p[4], p[5]));
+      const box2 = { minX: bodyBounds.min.x, maxX: bodyBounds.max.x, minZ: bodyBounds.min.z, maxZ: bodyBounds.max.z, base: bodyBounds.min.y, top: bodyBounds.max.y, stamp: frameStamp, parts };
       bodyBoxes.set(id, box2);
       return box2;
     };
@@ -58477,7 +58827,15 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
         const reach = c.radius + r;
         return (x - footPos.x) ** 2 + (z - footPos.z) ** 2 < reach * reach ? { ...b, top: Math.min(b.top, footPos.y + (c.height ?? b.top - footPos.y)) } : null;
       }
-      return x > b.minX - r && x < b.maxX + r && z > b.minZ - r && z < b.maxZ + r ? b : null;
+      if (!(x > b.minX - r && x < b.maxX + r && z > b.minZ - r && z < b.maxZ + r)) return null;
+      let base = Infinity;
+      let top = -Infinity;
+      for (const p of b.parts) {
+        if (!(x > p[0] - r && x < p[3] + r && z > p[2] - r && z < p[5] + r)) continue;
+        base = Math.min(base, p[1]);
+        top = Math.max(top, p[4]);
+      }
+      return top > base ? { ...b, base, top } : null;
     };
     blockers.add((x, z, r) => {
       for (const e of entries2.values()) {
@@ -59535,7 +59893,8 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       emitHost,
       startFire,
       say,
-      projectileModel: options.projectileModel
+      projectileModel: options.projectileModel,
+      audio
     });
     const toolOf = (hand) => hand === "L" ? offTool && offToolId ? { id: offToolId, state: offTool } : null : { id: toolId, state: tool };
     const dualReload = createDualReload(