@adatechnology/game-destruction-three 0.10.0 → 0.11.0

package/dist/index.global.js

@@ -27,11 +27,14 @@ var GameDestructionThree = (() => {
     DEFAULT_FIRE: () => DEFAULT_FIRE,
     DESTRUCTION_SOUND_BANK: () => DESTRUCTION_SOUND_BANK,
     DESTRUCTION_SOUND_KEYS: () => DESTRUCTION_SOUND_KEYS,
+    DRAG_SOUNDS: () => DRAG_SOUNDS,
     EXPLOSION_BOOM: () => EXPLOSION_BOOM,
     SCENE_SOUNDS: () => SCENE_SOUNDS,
     createDestructionRenderer: () => createDestructionRenderer,
     createDestructionSound: () => createDestructionSound,
+    dragSoundKey: () => dragSoundKey,
     heatColor: () => heatColor,
+    impactKey: () => impactKey,
     specFromObject3D: () => specFromObject3D
   });
 
@@ -8589,6 +8592,44 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   }
   var LIGHT_BUDGET = EVENT_BUDGET.blastLights + EVENT_BUDGET.fireLights;
 
+  // src/fitted-boxes.ts
+  var SLICE_LENGTH = 0.12;
+  var MAX_SLICES = 12;
+  var SNUG_RATIO = 1.1;
+  function pushFittedBoxes(local2, matrix, out) {
+    const e = matrix.elements;
+    const sizes = [0, 1, 2].map((k) => k === 0 ? local2.max.x - local2.min.x : k === 1 ? local2.max.y - local2.min.y : local2.max.z - local2.min.z);
+    const lengths = [0, 1, 2].map((k) => sizes[k] * Math.hypot(e[k * 4], e[k * 4 + 1], e[k * 4 + 2]));
+    const longest = lengths.indexOf(Math.max(...lengths));
+    const whole = worldBoxOf(local2, matrix, longest, 0, 1);
+    const span = (whole[3] - whole[0]) * (whole[4] - whole[1]) * (whole[5] - whole[2]);
+    const volume = lengths[0] * lengths[1] * lengths[2];
+    const slices = span <= volume * SNUG_RATIO ? 1 : Math.min(MAX_SLICES, Math.ceil(lengths[longest] / SLICE_LENGTH));
+    if (slices <= 1) {
+      out.push(...whole);
+      return;
+    }
+    for (let i = 0; i < slices; i++) out.push(...worldBoxOf(local2, matrix, longest, i / slices, (i + 1) / slices));
+  }
+  function worldBoxOf(local2, matrix, axis2, from, to) {
+    const e = matrix.elements;
+    const low = [local2.min.x, local2.min.y, local2.min.z];
+    const high = [local2.max.x, local2.max.y, local2.max.z];
+    const start = low[axis2];
+    const size = high[axis2] - start;
+    low[axis2] = start + size * from;
+    high[axis2] = start + size * to;
+    const box = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+    for (const x of [low[0], high[0]]) for (const y of [low[1], high[1]]) for (const z of [low[2], high[2]]) {
+      for (let k = 0; k < 3; k++) {
+        const v = e[k] * x + e[k + 4] * y + e[k + 8] * z + e[k + 12];
+        box[k] = Math.min(box[k], v);
+        box[k + 3] = Math.max(box[k + 3], v);
+      }
+    }
+    return box;
+  }
+
   // src/math.ts
   function createRng(seed) {
     let a = seed >>> 0;
@@ -8630,12 +8671,20 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var SHEET_MAX = 4e-3;
   var SHEET_AIR = 2.5;
   var SHEET_SWAY = 3;
+  var BIG_LENGTH = 0.2;
+  var BIG_WIDTH = 0.03;
+  var isBig = (size) => {
+    const [, middle, longest] = [...size].sort((a, b) => a - b);
+    return longest >= BIG_LENGTH && middle >= BIG_WIDTH;
+  };
   var FragmentSystem = class {
     constructor(THREE, o) {
       __publicField(this, "THREE", THREE);
       __publicField(this, "o", o);
       __publicField(this, "list", []);
       __publicField(this, "box");
+      /** The mesh box of a fragment before its scale. */
+      __publicField(this, "unitBox", { min: { x: -0.5, y: -0.5, z: -0.5 }, max: { x: 0.5, y: 0.5, z: 0.5 } });
       __publicField(this, "shardGeos", []);
       __publicField(this, "materials", /* @__PURE__ */ new Map());
       __publicField(this, "q");
@@ -8644,6 +8693,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "v");
       __publicField(this, "w");
       __publicField(this, "rng", createRng(1374496523));
+      /** Count of `update` calls: what makes the fragments of one burst tell apart from older ones. */
+      __publicField(this, "tick", 0);
       __publicField(this, "markGeometry", null);
       __publicField(this, "markMaterial", null);
       this.box = new THREE.BoxGeometry(1, 1, 1);
@@ -8711,8 +8762,28 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         mesh2.add(disc);
       }
     }
-    /** Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget. */
+    /**
+     * Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget: over it the oldest fragment still showing fades out to make room, and a burst
+     * bigger than the budget (every live fragment was made in this same frame) does not make the rest at all, so a blast never builds a thousand meshes only to fade them
+     * out. Returns null when the fragment was not made.
+     */
     spawn(f, material, home, maxAllowed) {
+      if (this.list.length >= maxAllowed) {
+        let alive = 0;
+        let oldest;
+        let oldestSmall;
+        for (const l of this.list) {
+          if (l.dying) continue;
+          alive++;
+          oldest ?? (oldest = l);
+          if (!l.body) oldestSmall ?? (oldestSmall = l);
+        }
+        oldest = oldestSmall ?? oldest;
+        if (alive >= maxAllowed) {
+          if (!oldest || oldest.born === this.tick) return null;
+          oldest.dying = true;
+        }
+      }
       const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
       const mesh2 = new this.THREE.Mesh(geo, material);
       mesh2.position.set(f.center[0], f.center[1], f.center[2]);
@@ -8736,19 +8807,42 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         rest: 0,
         fade: 1,
         dying: false,
-        air: f.shape === "scrap" && sz[2] <= SHEET_MAX ? SHEET_AIR : 0
+        air: f.shape === "scrap" && sz[2] <= SHEET_MAX ? SHEET_AIR : 0,
+        body: null,
+        born: this.tick
       };
-      this.list.push(live);
-      let alive = this.list.reduce((n, l) => n + (l.dying ? 0 : 1), 0);
-      for (let i = 0; i < this.list.length && alive > maxAllowed; i++) {
-        if (!this.list[i].dying) {
-          this.list[i].dying = true;
-          alive--;
-        }
+      if (f.shape !== "shard" && isBig(f.size)) {
+        live.body = {
+          mass: f.mass,
+          push: (x, z) => {
+            live.vel.x = x;
+            live.vel.z = z;
+            live.vel.y = Math.max(live.vel.y, 0.3);
+            live.asleep = false;
+            live.rest = 0;
+          }
+        };
       }
+      this.list.push(live);
       this.addMarks(mesh2, f);
       return mesh2;
     }
+    /** The boxes of the big fragments around (x, z). */
+    solidsNear(x, z, radius, found) {
+      const boxes = [];
+      for (const f of this.list) {
+        if (!f.body || f.dying) continue;
+        const reach = f.half.length() + radius;
+        if (Math.abs(f.mesh.position.x - x) > reach || Math.abs(f.mesh.position.z - z) > reach) continue;
+        f.mesh.updateMatrixWorld();
+        boxes.length = 0;
+        pushFittedBoxes(this.unitBox, f.mesh.matrixWorld, boxes);
+        for (let i = 0; i < boxes.length; i += 6) {
+          if (x < boxes[i] - radius || x > boxes[i + 3] + radius || z < boxes[i + 2] - radius || z > boxes[i + 5] + radius) continue;
+          found(f.home, [boxes[i], boxes[i + 1], boxes[i + 2]], [boxes[i + 3], boxes[i + 4], boxes[i + 5]], f.body);
+        }
+      }
+    }
     /** Add velocity to every fragment within `radius` of a point (blasts). */
     blast(point, radius, speed) {
       for (const f of this.list) {
@@ -8764,7 +8858,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         f.rest = 0;
       }
     }
+    /** What lies inside the disc looks at the ground again: it was dug or heaped under it. */
+    wakeRegion(x, z, radius) {
+      for (const f of this.list) {
+        if (!f.asleep || Math.hypot(f.mesh.position.x - x, f.mesh.position.z - z) > radius) continue;
+        f.asleep = false;
+        f.rest = 0;
+      }
+    }
     update(dt) {
+      this.tick++;
       const g = this.o.gravity;
       for (let i = this.list.length - 1; i >= 0; i--) {
         const f = this.list[i];
@@ -8779,7 +8882,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
         if (f.asleep) {
           f.rest += dt;
-          if (this.o.life > 0 && f.rest > this.o.life) f.dying = true;
+          if (this.o.life > 0 && f.rest > this.o.life && !f.body) f.dying = true;
           continue;
         }
         this.step(f, dt, g);
@@ -8853,7 +8956,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       let small = 0;
       for (let i = 1; i < 3; i++) if (half[i] < half[small]) small = i;
       let axis2 = small;
-      if (Math.abs(up[small]) < 0.35) {
+      if (Math.abs(up[small]) < 0.35 && !f.body) {
         axis2 = 0;
         for (let i = 1; i < 3; i++) if (Math.abs(up[i]) > Math.abs(up[axis2])) axis2 = i;
       }
@@ -8979,6 +9082,30 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var SLOP = 2e-3;
   var NARROW = 0.3;
   var TOPPLE = 3;
+  var TIP_ACCELERATION = 30;
+  var TIP_LYING = 0.25;
+  var TIP_SECONDS = 3;
+  var STEP = 0.03;
+  var boxTopAt = (s, x, z) => {
+    const e = s.e;
+    const dx = x - s.c[0], dz = z - s.c[2];
+    let t0 = -Infinity, t1 = Infinity;
+    for (let k = 0; k < 3; k++) {
+      const p = e[k * 4] * dx + e[k * 4 + 2] * dz;
+      const d = e[k * 4 + 1];
+      const h = s.half[k];
+      if (Math.abs(d) < 1e-9) {
+        if (Math.abs(p) > h) return -Infinity;
+        continue;
+      }
+      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 (t0 > t1) return -Infinity;
+    }
+    return s.c[1] + t1;
+  };
   var PieceSystem = class {
     constructor(THREE, o) {
       __publicField(this, "THREE", THREE);
@@ -8990,6 +9117,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "dq");
       __publicField(this, "m");
       __publicField(this, "ax");
+      __publicField(this, "solids", []);
       this.p = new THREE.Vector3();
       this.q = new THREE.Quaternion();
       this.dq = new THREE.Quaternion();
@@ -8999,6 +9127,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     get(objectId) {
       return this.list.find((b) => b.objectId === objectId) ?? null;
     }
+    /** Sets a piece falling over, about the world axes x and z (a unit axis): its feet are thinner than the box that stands for it, so the box alone would hold it up. */
+    tip(body, x, z) {
+      body.tipping = { x, z, seconds: TIP_SECONDS };
+      body.sleeping = false;
+    }
     create(objectId, root, halfExtents, localCenter, mass, velocity, angular) {
       const existing = this.get(objectId);
       if (existing) {
@@ -9012,6 +9145,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       const body = {
         objectId,
+        tipping: null,
         root,
         velocity: velocity ? [...velocity] : [0, 0, 0],
         angularVelocity: angular ? [...angular] : [0, 0, 0],
@@ -9081,8 +9215,21 @@ 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];
     }
+    /** What lies inside the disc looks at the ground again: it was dug or heaped under it. */
+    wakeRegion(x, z, radius) {
+      for (const b of this.list) {
+        if (!b.sleeping || b.held || Math.hypot(b.root.position.x - x, b.root.position.z - z) > radius) continue;
+        b.sleeping = false;
+        b.still = 0;
+      }
+    }
     update(dt) {
       this.time += dt;
+      this.solids = this.list.map((body) => {
+        const c = this.centerOf(body, new this.THREE.Vector3());
+        const h = body.halfExtents;
+        return { body, c: [c.x, c.y, c.z], e: [...new this.THREE.Matrix4().makeRotationFromQuaternion(body.root.quaternion).elements], half: h, r: Math.hypot(h[0], h[1], h[2]) };
+      });
       for (const b of this.list) {
         if (b.held) {
           b.velocity = [0, 0, 0];
@@ -9096,6 +9243,17 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       this.separate(dt);
     }
+    /** 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);
+      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;
+      }
+      const fixed = this.o.staticTopAt?.(x, z, y, step) ?? -Infinity;
+      return Math.max(top, fixed);
+    }
     integrate(b, dt) {
       const c = this.centerOf(b, this.p);
       const pos = [c.x, c.y, c.z];
@@ -9134,8 +9292,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const sy = i & 2 ? hy : -hy;
           const sz = i & 4 ? hz : -hz;
           const r = [e[0] * sx + e[4] * sy + e[8] * sz, e[1] * sx + e[5] * sy + e[9] * sz, e[2] * sx + e[6] * sy + e[10] * sz];
-          const gy = this.o.groundAt(pos[0] + r[0], pos[2] + r[2]);
-          const pen = gy - (pos[1] + r[1]);
+          const cy = pos[1] + r[1];
+          const gy = this.supportAt(b, pos[0] + r[0], cy, pos[2] + r[2], STEP + Math.max(0, -v[1]) * h * 2);
+          const pen = gy - cy;
           if (pen > -SLOP) {
             rs.push(r);
             if (pen > maxPen) maxPen = pen;
@@ -9158,7 +9317,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           }
           const lx = pos[0] + sx / rs.length;
           const lz = pos[2] + sz / rs.length;
-          landPoint = [lx, this.o.groundAt(lx, lz), lz];
+          landPoint = [lx, pos[1] - Math.max(...rs.map((r) => -r[1])), lz];
         }
         for (let it = 0; it < 4; it++) {
           for (const r of rs) {
@@ -9211,6 +9370,15 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const wx = x1 - x0;
         const wz = z1 - z0;
         unstable = Math.min(wx, wz) < NARROW * height || x0 > 0 || x1 < 0 || z0 > 0 || z1 < 0;
+        if (b.tipping) {
+          b.tipping.seconds -= h;
+          if (height < TIP_LYING || b.tipping.seconds <= 0) b.tipping = null;
+          else {
+            w[0] += b.tipping.x * TIP_ACCELERATION * h;
+            w[2] += b.tipping.z * TIP_ACCELERATION * h;
+            unstable = true;
+          }
+        }
         if (unstable) {
           const dirX = x0 + x1 > 0 ? -1 : 1;
           const dirZ = z0 + z1 > 0 ? -1 : 1;
@@ -9247,6 +9415,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         b.still = 0;
       }
     }
+    /** 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;
+      return Math.abs(e[1]) * b.halfExtents[0] + Math.abs(e[5]) * b.halfExtents[1] + Math.abs(e[9]) * b.halfExtents[2];
+    }
     /** Push overlapping pieces apart (horizontal bounding circles), gently, so they do not interpenetrate forever. */
     separate(dt) {
       const n = this.list.length;
@@ -9265,6 +9438,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           this.centerOf(a, ca);
           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;
           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;
@@ -9660,14 +9834,21 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14730131
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 1e5
+      compressive: 1e5,
+      hits: {
+        blunt: {
+          tear: "splinters",
+          tearJoules: 60
+        }
+      }
     },
     {
       id: "wood_hard",
@@ -9697,14 +9878,21 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 13213802
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 15e4
+      compressive: 15e4,
+      hits: {
+        blunt: {
+          tear: "splinters",
+          tearJoules: 150
+        }
+      }
     },
     {
       id: "plywood",
@@ -9734,14 +9922,24 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14862234
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 6e4
+      compressive: 6e4,
+      hits: {
+        ballistic: {
+          tear: "splinters"
+        },
+        blunt: {
+          tear: "splinters",
+          tearJoules: 80
+        }
+      }
     },
     {
       id: "mdf",
@@ -9768,14 +9966,25 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 12096362
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 3e4
+      compressive: 3e4,
+      hits: {
+        ballistic: {
+          tear: "lumps",
+          tearJoules: 120
+        },
+        blunt: {
+          tear: "lumps",
+          tearJoules: 20
+        }
+      }
     },
     {
       id: "glass",
@@ -9889,6 +10098,17 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       damageScale: {
         explosive: 1.2
       },
+      hits: {
+        ballistic: {
+          unitJoules: 500,
+          floor: 900,
+          crater: true
+        },
+        blunt: {
+          unitJoules: 1500,
+          floor: 60
+        }
+      },
       hitDebris: "chips",
       breakDebris: "dust",
       thermal: {
@@ -10257,7 +10477,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         smoke: "white"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14207126
       },
       tags: [
         "plant",
@@ -10265,7 +10486,12 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         "organic",
         "flammable"
       ],
-      compressive: 6e4
+      compressive: 6e4,
+      hits: {
+        blunt: {
+          tear: "none"
+        }
+      }
     },
     {
       id: "cactus",
@@ -10380,6 +10606,130 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         "masonry"
       ],
       compressive: 2e4
+    },
+    {
+      id: "asphalt",
+      density: 2350,
+      hpPerKg: 10,
+      penetration: 14,
+      penetrationClass: "concrete",
+      penetrationScale: 0.8,
+      ductility: 0.1,
+      fracture: "crumble",
+      fragmentSize: [
+        0.03,
+        0.15
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2,
+        ignitionC: 400,
+        burnRate: 2e-3,
+        smoke: "black"
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 3e4
+    },
+    {
+      id: "sand",
+      density: 1600,
+      hpPerKg: 2,
+      penetration: 6,
+      ductility: 0.4,
+      fracture: "crumble",
+      fragmentSize: [
+        0.01,
+        0.04
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2
+      },
+      tags: [
+        "soil"
+      ],
+      compressive: 1e4
+    },
+    {
+      id: "gravel",
+      density: 1800,
+      hpPerKg: 3,
+      penetration: 8,
+      ductility: 0.3,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.06
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2
+      },
+      tags: [
+        "soil",
+        "masonry"
+      ],
+      compressive: 2e4
+    },
+    {
+      id: "turf",
+      density: 900,
+      hpPerKg: 3,
+      penetration: 4,
+      ductility: 0.5,
+      fracture: "crumble",
+      fragmentSize: [
+        0.03,
+        0.1
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 1.5,
+        ignitionC: 250,
+        burnRate: 0.03,
+        smoke: "white"
+      },
+      tags: [
+        "soil",
+        "organic"
+      ],
+      compressive: 15e3
+    },
+    {
+      id: "mortar",
+      density: 1900,
+      hpPerKg: 10,
+      penetration: 12,
+      penetrationClass: "concrete",
+      penetrationScale: 1.2,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.08
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 1e5
     }
   ];
   var material_hints_default = {
@@ -10575,6 +10925,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const fill = options.fillOf?.(o, material);
           const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
           const contains = containsOf(ud.destructionContains);
+          const thickness = typeof ud.destructionThickness === "number" && ud.destructionThickness > 0 ? ud.destructionThickness : void 0;
           const existing = explicit ? byKey.get(explicit) : void 0;
           if (existing) {
             const before = sizeOf(existing.box);
@@ -10587,8 +10938,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
             existing.skin = existing.skin && skin;
             if (fill !== void 0) existing.fill = fill;
             if (contains) existing.contains = contains;
+            if (thickness !== void 0) existing.thickness = Math.min(existing.thickness ?? thickness, thickness);
           } else {
-            const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, skin, tags, fixedId: !!explicit, ...contains ? { contains } : {}, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
+            const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, skin, tags, fixedId: !!explicit, ...contains ? { contains } : {}, ...thickness !== void 0 ? { thickness } : {}, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
             entries.push(e);
             if (explicit) byKey.set(explicit, e);
           }
@@ -10656,7 +11008,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const minSide = Math.min(...size);
       if (e.fill !== void 0) part.fill = e.fill;
       else if (e.hollow) part.fill = 0.05;
-      if (minSide < 0.01 && METAL.test(e.material)) {
+      if (e.thickness !== void 0) part.thickness = e.thickness;
+      else if (minSide < 0.01 && METAL.test(e.material)) {
         part.fill = e.fill ?? 1;
         part.thickness = Math.max(minSide, 5e-4);
       }
@@ -10747,9 +11100,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const ids = [0, 1, 2].map((corner) => index ? index.getX(t * 3 + corner) : t * 3 + corner);
         ids.forEach((id, corner) => corners[corner].set(shell.before[id * 3], shell.before[id * 3 + 1], shell.before[id * 3 + 2]));
         triangle.set(corners[0], corners[1], corners[2]);
+        if (triangle.getArea() <= 1e-14) continue;
         triangle.closestPointToPoint(local2, closest);
         const distance = closest.distanceToSquared(local2);
-        if (distance >= nearest) continue;
+        if (!(distance < nearest)) continue;
         nearest = distance;
         nearestScale = shell.mesh.matrixWorld.getMaxScaleOnAxis() || 1;
         triangle.getBarycoord(closest, weights);
@@ -10928,6 +11282,20 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return out;
     }
     /** Box of the part in world space. */
+    /** Appends the boxes that follow the mesh in the world (`pushFittedBoxes`) to `out`. */
+    fittedBoxes(mv, out) {
+      const box = new this.THREE.Box3();
+      if (mv.host) this.localBox(mv, box);
+      else {
+        const geometry = mv.mesh.geometry;
+        if (!geometry.boundingBox) geometry.computeBoundingBox();
+        if (geometry.boundingBox) box.copy(geometry.boundingBox);
+        else box.makeEmpty();
+      }
+      if (box.isEmpty()) return;
+      mv.mesh.updateWorldMatrix(true, false);
+      pushFittedBoxes(box, mv.mesh.matrixWorld, out);
+    }
     worldBox(mv, out) {
       if (!mv.host) return out.setFromObject(mv.mesh);
       this.localBox(mv, out);
@@ -11676,6 +12044,11 @@ 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 STATIC_REFRESH = 0.5;
+  var STATIC_SPAN = 3;
+  var FEET_BAND = 0.03;
+  var TIP_MIN_HEIGHT = 0.3;
+  var TIP_NARROW = 0.3;
   var FIRE_CEILING_SECONDS = 3600;
   var GENERIC_REFERENCE_RADIUS = 15;
   var PRIMED_FIRE_RADIUS = 0.2;
@@ -11720,6 +12093,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     if (def.fracture === "tear") return "impact_soft";
     return def.fracture === "none" ? "impact_metal" : "impact_wood";
   }
+  var dragSoundKey = (def) => impactKey(def).replace("impact_", "drag_");
   function fractureKey(def, style) {
     switch (style) {
       case "shatter":
@@ -11761,6 +12135,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "autoSplit");
       __publicField(this, "maxFragments");
       __publicField(this, "bounds", /* @__PURE__ */ new Map());
+      /** World boxes (min xyz, max xyz) of the drawn meshes of the bound objects that are not pieces, for the pieces to land on. */
+      __publicField(this, "staticBoxes", /* @__PURE__ */ new Map());
+      /** Objects to measure again; `staticAll` measures every one. */
+      __publicField(this, "staticDirty", /* @__PURE__ */ new Set());
+      __publicField(this, "staticAll", true);
+      /** Boxes of the pieces' meshes (as `staticBoxes`), with the time they were measured. */
+      __publicField(this, "pieceBoxes", /* @__PURE__ */ new WeakMap());
+      __publicField(this, "staticAt", 0);
       __publicField(this, "queue", []);
       __publicField(this, "unsubscribe");
       __publicField(this, "visuals");
@@ -11822,6 +12204,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.cages = new RebarCages(THREE, o.scene);
       this.pieceSys = new PieceSystem(THREE, {
         groundAt: this.groundAt,
+        staticTopAt: (x, z, y, step) => this.staticTopAt(x, z, y, step),
         gravity: this.gravity,
         scene: o.scene,
         onHardLanding: (p, point, speed) => this.hardLanding(p, point, speed)
@@ -11834,6 +12217,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     // Binding
     // ----------------------------------------------------------------------------------------------------------------------------------
     bind(objectId, root, options = {}) {
+      this.staticDirty.add(objectId);
       if (this.bounds.has(objectId)) this.unbind(objectId);
       const state = this.world.state(objectId);
       const partIds = new Set((state?.parts ?? []).map((p) => p.id));
@@ -11953,6 +12337,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     }
     unbind(objectId) {
+      this.staticDirty.add(objectId);
       const b = this.bounds.get(objectId);
       if (!b) return;
       this.restore(objectId);
@@ -11992,6 +12377,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return m > 0 ? m : 5;
     }
     makePiece(objectId, options = {}) {
+      this.staticDirty.add(objectId);
       const b = this.bounds.get(objectId);
       if (!b) throw new Error(`game-destruction-three: object "${objectId}" is not bound`);
       if (b.root.parent && b.root.parent !== this.scene) this.scene.attach(b.root);
@@ -12104,7 +12490,100 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     // ----------------------------------------------------------------------------------------------------------------------------------
     // Events
     // ----------------------------------------------------------------------------------------------------------------------------------
+    /**
+     * The highest top of a bound object that is not a piece under (x, z) a corner at height `y` can land on (at most `step` above it). The world boxes
+     * of their drawn meshes are kept until an event or a moved root changes them; parts drawn inside a merged mesh and meshes wider than `STATIC_SPAN`
+     * are left out (walls, floors, roofs: the terrain under them is the host's `groundAt`).
+     */
+    staticTopAt(x, z, y, step) {
+      let top = -Infinity;
+      for (const a of this.staticNow().values()) {
+        if (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 boxes of the fixed objects (per object: the box around them all, then each one), each object measured again when an event touched it (all of them every `STATIC_REFRESH` s). */
+    staticNow() {
+      if (this.time - this.staticAt > STATIC_REFRESH) {
+        this.staticAt = this.time;
+        this.staticAll = true;
+      }
+      if (!this.staticAll && this.staticDirty.size === 0) return this.staticBoxes;
+      const box = new this.THREE.Box3();
+      const measure = (b) => {
+        if (b.piece || this.pieceSys.get(b.id)) {
+          this.staticBoxes.delete(b.id);
+          return;
+        }
+        const out = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+        for (const mv of this.meshesOf(b)) {
+          if (mv.host || mv.loose || !this.visuals.shown(mv)) continue;
+          this.visuals.worldBox(mv, box);
+          if (box.isEmpty() || box.max.x - box.min.x > STATIC_SPAN || box.max.z - box.min.z > STATIC_SPAN) continue;
+          this.visuals.fittedBoxes(mv, out);
+          for (let k = 0; k < 3; k++) {
+            out[k] = Math.min(out[k], box.min.getComponent(k));
+            out[k + 3] = Math.max(out[k + 3], box.max.getComponent(k));
+          }
+        }
+        this.staticBoxes.set(b.id, out.length > 6 ? out : []);
+      };
+      if (this.staticAll) {
+        this.staticBoxes.clear();
+        for (const b of this.bounds.values()) measure(b);
+      } else {
+        for (const id of this.staticDirty) {
+          const b = this.bounds.get(id);
+          if (b) measure(b);
+          else this.staticBoxes.delete(id);
+        }
+      }
+      this.staticAll = false;
+      this.staticDirty.clear();
+      return this.staticBoxes;
+    }
+    /** The boxes of a piece's drawn meshes, measured once per frame. */
+    pieceBoxesOf(pc) {
+      const cached = this.pieceBoxes.get(pc);
+      if (cached && cached.at === this.time) return cached.boxes;
+      const boxes = [];
+      const b = this.bounds.get(pc.objectId);
+      if (b) {
+        for (const mv of this.meshesOf(b)) {
+          if (this.visuals.shown(mv)) this.visuals.fittedBoxes(mv, boxes);
+        }
+      }
+      this.pieceBoxes.set(pc, { at: this.time, boxes });
+      return boxes;
+    }
+    solidsNear(x, z, radius) {
+      const found = [];
+      const scan = (a, id, piece, from) => {
+        if (from > 0 && (a.length === 0 || x < a[0] - radius || x > a[3] + radius || z < a[2] - radius || z > a[5] + radius)) return;
+        for (let i = from; i < a.length; i += 6) {
+          if (x < a[i] - radius || x > a[i + 3] + radius || z < a[i + 2] - radius || z > a[i + 5] + radius) continue;
+          found.push({ objectId: id, min: [a[i], a[i + 1], a[i + 2]], max: [a[i + 3], a[i + 4], a[i + 5]], piece });
+        }
+      };
+      for (const [id, a] of this.staticNow()) scan(a, id, null, 6);
+      const c = this.v1;
+      for (const pc of this.pieceSys.list) {
+        if (pc.held) continue;
+        this.pieceSys.centerOf(pc, c);
+        const reach = Math.hypot(pc.halfExtents[0], pc.halfExtents[1], pc.halfExtents[2]) + radius;
+        if (Math.abs(c.x - x) > reach || Math.abs(c.z - z) > reach) continue;
+        scan(this.pieceBoxesOf(pc), pc.objectId, pc, 0);
+      }
+      this.fragments.solidsNear(x, z, radius, (home, min2, max2, loose) => found.push({ objectId: home, min: min2, max: max2, piece: null, loose }));
+      return found;
+    }
     apply(ev) {
+      this.staticDirty.add(ev.object);
       switch (ev.type) {
         case "damage":
           if (ev.damageType === "heat" || ev.damageType === "fire" || ev.damageType === "explosive") this.activate(ev.object, ev.part);
@@ -12441,7 +12920,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const def = pv ? this.world.materials.get(pv.material) : void 0;
       const color = (pv ? this.partColor(pv, def) : null) ?? fallbackColor(pv?.material ?? "", def);
       const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
-      for (const fr of ev.fragments) this.fragments.spawn(fr, this.fragments.materialFor(fr.material, fallbackColor(fr.material, def), false), ev.object, maxAlive);
+      for (const fr of ev.fragments) {
+        const fdef = this.world.materials.get(fr.material);
+        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 (!this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.center)) this.vfx.burst("dust", ev.center, [0, 1, 0], 6, 0.8, { color });
       this.sound(impactKey(def), ev.center, 0.7);
     }
@@ -12522,6 +13005,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.pieceSys.setCenter(old, center);
         old.mass = Math.max(0.05, this.massOf(objectId));
         old.sleeping = false;
+      } else if (kitOriginOf(b.root)?.kind === "furniture") {
+        this.makePiece(objectId);
+        this.tipIfTopHeavy(b);
       }
     }
     /** The renderer side of `splitGroup`: a new group holding the meshes of the new object, made a piece. */
@@ -12568,8 +13054,32 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       const piece = this.pieceSys.create(newId, group, half, center, this.massOf(newId), vel, ang);
       nb.piece = piece;
+      if (kitOriginOf(from.root)?.kind === "furniture") this.tipIfTopHeavy(nb);
       this.o.onPiece?.(piece);
     }
+    /**
+     * 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.
+     */
+    tipIfTopHeavy(b) {
+      const piece = b.piece;
+      if (!piece) return;
+      const box = new this.THREE.Box3();
+      const boxes = this.meshesOf(b).filter((mv) => this.visuals.shown(mv)).map((mv) => this.visuals.worldBox(mv, new this.THREE.Box3()));
+      if (boxes.length === 0) return;
+      for (const one of boxes) box.union(one);
+      const height = box.max.y - box.min.y;
+      const feet = new this.THREE.Box3();
+      for (const one of boxes) if (one.min.y < box.min.y + FEET_BAND) feet.union(one);
+      const spanX = feet.max.x - feet.min.x;
+      const spanZ = feet.max.z - feet.min.z;
+      if (height < TIP_MIN_HEIGHT || Math.min(spanX, spanZ) >= TIP_NARROW * height) return;
+      const across = spanX <= spanZ ? 0 : 2;
+      const lean = across === 0 ? box.min.x + box.max.x - feet.min.x - feet.max.x : box.min.z + box.max.z - feet.min.z - feet.max.z;
+      const away = lean < 0 ? -1 : 1;
+      if (across === 0) this.pieceSys.tip(piece, 0, -away);
+      else this.pieceSys.tip(piece, away, 0);
+    }
     onExplode(ev, options = {}) {
       const p = ev.point;
       if (options.visual !== false) this.playExplosion(ev, options);
@@ -12820,6 +13330,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.vfx.sprites().clear();
       this.ownVfx?.world.clear();
     }
+    wakeRegion(x, z, radius) {
+      this.fragments.wakeRegion(x, z, radius);
+      this.pieceSys.wakeRegion(x, z, radius);
+    }
     stats() {
       return { fragments: this.fragments.count, particles: this.vfx.sprites().live + this.ownedVfxParticles(), pieces: this.pieceSys.list.length, decals: this.visuals.decalCount + this.ground.count };
     }
@@ -13112,7 +13626,15 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     volume: 0,
     sources: ["cena:L1316 fire loop (silent in the page: its gain is never raised)", "sdk: the level while burning"]
   };
-  var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
+  var drag = (id, layers) => ({ ...sceneRecipe(id, layers, ""), sources: ["sdk: a base dragged on a floor, one grain per stretch"] });
+  var DRAG_SOUNDS = [
+    drag("drag_wood", [sceneNoise({ type: "bandpass", f: 380, q: 1.4, d: 0.28, vol: 0.5 }), sceneNoise({ type: "bandpass", f: [900, 1300], q: 3, d: 0.08, vol: 0.14 })]),
+    drag("drag_metal", [sceneNoise({ type: "bandpass", f: 1500, q: 4, d: 0.26, vol: 0.32 }), sceneTone({ f: [880, 1240], f2: 760, d: 0.18, vol: 0.05 })]),
+    drag("drag_glass", [sceneNoise({ type: "bandpass", f: 2600, q: 5, d: 0.2, vol: 0.22 })]),
+    drag("drag_masonry", [sceneNoise({ type: "bandpass", f: 260, q: 0.9, d: 0.3, vol: 0.62 }), ...sceneMany(3, () => sceneNoise({ type: "bandpass", f: [600, 1200], q: 2, d: 0.04, vol: 0.14, delay: [0, 0.2] }))]),
+    drag("drag_soft", [sceneNoise({ type: "lowpass", f: 420, d: 0.28, vol: 0.3 })])
+  ];
+  var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
 
   // src/audio/sound.ts
   var DESTRUCTION_SOUND_KEYS = {
@@ -13122,6 +13644,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       impact_glass: { sound: "ping" },
       impact_masonry: { sound: "chip" },
       impact_soft: { sound: "thud" },
+      drag_wood: { sound: "drag_wood" },
+      drag_metal: { sound: "drag_metal" },
+      drag_glass: { sound: "drag_glass" },
+      drag_masonry: { sound: "drag_masonry" },
+      drag_soft: { sound: "drag_soft" },
       shatter_glass: { sound: "glass_shatter" },
       crumble: { sound: "crumble" },
       splinter: { sound: "crack" },