@adatechnology/game-destruction-three 0.10.0 → 0.11.1

package/dist/index.js

@@ -7,6 +7,44 @@ import { blastShove } from "@adatechnology/game-contracts";
 import { createVfx, effectForEvent, EVENT_EFFECTS_MAP } from "@adatechnology/game-vfx";
 import { createVfxRenderer } from "@adatechnology/game-vfx-three";
 
+// src/fitted-boxes.ts
+var SLICE_LENGTH = 0.12;
+var MAX_SLICES = 12;
+var SNUG_RATIO = 1.1;
+function pushFittedBoxes(local, matrix, out) {
+  const e = matrix.elements;
+  const sizes = [0, 1, 2].map((k) => k === 0 ? local.max.x - local.min.x : k === 1 ? local.max.y - local.min.y : local.max.z - local.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(local, 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(local, matrix, longest, i / slices, (i + 1) / slices));
+}
+function worldBoxOf(local, matrix, axis, from, to) {
+  const e = matrix.elements;
+  const low = [local.min.x, local.min.y, local.min.z];
+  const high = [local.max.x, local.max.y, local.max.z];
+  const start = low[axis];
+  const size = high[axis] - start;
+  low[axis] = start + size * from;
+  high[axis] = 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;
@@ -48,12 +86,20 @@ function mixHex(a, b, t) {
 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");
@@ -62,6 +108,8 @@ var FragmentSystem = class {
     __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);
@@ -129,8 +177,28 @@ var FragmentSystem = class {
       mesh.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 mesh = new this.THREE.Mesh(geo, material);
     mesh.position.set(f.center[0], f.center[1], f.center[2]);
@@ -154,19 +222,42 @@ var FragmentSystem = class {
       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(mesh, f);
     return mesh;
   }
+  /** 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) {
@@ -182,7 +273,16 @@ var FragmentSystem = class {
       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];
@@ -197,7 +297,7 @@ var FragmentSystem = class {
       }
       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);
@@ -271,7 +371,7 @@ var FragmentSystem = class {
     let small = 0;
     for (let i = 1; i < 3; i++) if (half[i] < half[small]) small = i;
     let axis = small;
-    if (Math.abs(up[small]) < 0.35) {
+    if (Math.abs(up[small]) < 0.35 && !f.body) {
       axis = 0;
       for (let i = 1; i < 3; i++) if (Math.abs(up[i]) > Math.abs(up[axis])) axis = i;
     }
@@ -397,6 +497,30 @@ var HARD_LANDING = 3;
 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);
@@ -408,6 +532,7 @@ var PieceSystem = class {
     __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();
@@ -417,6 +542,11 @@ var PieceSystem = class {
   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) {
@@ -430,6 +560,7 @@ var PieceSystem = class {
     }
     const body = {
       objectId,
+      tipping: null,
       root,
       velocity: velocity ? [...velocity] : [0, 0, 0],
       angularVelocity: angular ? [...angular] : [0, 0, 0],
@@ -499,8 +630,21 @@ var PieceSystem = class {
     const lz = (e[8] * x + e[9] * y + e[10] * z) * iz;
     return [e[0] * lx + e[4] * ly + e[8] * lz, e[1] * lx + e[5] * ly + e[9] * lz, e[2] * lx + e[6] * ly + e[10] * lz];
   }
+  /** 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];
@@ -514,6 +658,17 @@ var PieceSystem = class {
     }
     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];
@@ -552,8 +707,9 @@ var PieceSystem = class {
         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;
@@ -576,7 +732,7 @@ var PieceSystem = class {
         }
         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) {
@@ -629,6 +785,15 @@ var PieceSystem = class {
       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;
@@ -665,6 +830,11 @@ var PieceSystem = class {
       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;
@@ -683,6 +853,7 @@ var PieceSystem = class {
         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;
@@ -843,6 +1014,7 @@ function specFromObject3D(THREE, root, options = {}) {
         const fill = options.fillOf?.(o, material);
         const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
         const contains = containsOf(ud.destructionContains);
+        const 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);
@@ -855,8 +1027,9 @@ function specFromObject3D(THREE, root, options = {}) {
           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);
         }
@@ -924,7 +1097,8 @@ function specFromObject3D(THREE, root, options = {}) {
     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);
     }
@@ -1018,9 +1192,10 @@ function shellDisplacementAt(THREE, worldPoint, shells, out) {
       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(local, closest);
       const distance = closest.distanceToSquared(local);
-      if (distance >= nearest) continue;
+      if (!(distance < nearest)) continue;
       nearest = distance;
       nearestScale = shell.mesh.matrixWorld.getMaxScaleOnAxis() || 1;
       triangle.getBarycoord(closest, weights);
@@ -1199,6 +1374,20 @@ var Visuals = class {
     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);
@@ -1462,6 +1651,21 @@ var Visuals = class {
     d.geometry?.dispose();
     this.decalCount = Math.max(0, this.decalCount - 1);
   }
+  /**
+   * Takes away the decals of a mesh that sit inside a box (world `center`, `half` extents along the axes of the world `rotation`): the surface they
+   * marked is gone (a unit came out of the wall with its bullet holes and spalls).
+   */
+  clearDecals(mv, center, half, rotation) {
+    const inv = rotation.clone().invert();
+    const p = new this.THREE.Vector3();
+    for (let i = mv.decals.length - 1; i >= 0; i--) {
+      const d = mv.decals[i];
+      d.obj.getWorldPosition(p).sub(center).applyQuaternion(inv);
+      if (Math.abs(p.x) > half.x || Math.abs(p.y) > half.y || Math.abs(p.z) > half.z) continue;
+      this.disposeDecal(d);
+      mv.decals.splice(i, 1);
+    }
+  }
   addHole(mv, worldPoint, worldNormal, diameter) {
     const { s, pos, quat } = this.decalPose(mv.mesh, worldPoint, worldNormal, 25e-4);
     const work = mv.host ? mv.host.work : mv.work;
@@ -1944,9 +2148,15 @@ var Visuals = class {
 // src/renderer.ts
 var rendererCount = 0;
 var COLLAPSE_CLOUD_KG = 1e3;
+var CHIP_DECAL_EDGE = 0.05;
 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;
@@ -1991,6 +2201,7 @@ function impactKey(def) {
   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":
@@ -2032,6 +2243,14 @@ var Renderer = class {
     __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");
@@ -2093,6 +2312,7 @@ var Renderer = class {
     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)
@@ -2105,6 +2325,7 @@ var Renderer = class {
   // 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));
@@ -2224,6 +2445,7 @@ var Renderer = class {
     }
   }
   unbind(objectId) {
+    this.staticDirty.add(objectId);
     const b = this.bounds.get(objectId);
     if (!b) return;
     this.restore(objectId);
@@ -2263,6 +2485,7 @@ var Renderer = class {
     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);
@@ -2375,7 +2598,100 @@ var Renderer = class {
   // ----------------------------------------------------------------------------------------------------------------------------------
   // 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, min, max, loose) => found.push({ objectId: home, min, max, 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);
@@ -2396,7 +2712,7 @@ var Renderer = class {
         break;
       }
       case "debris":
-        this.vfx.burst(ev.kind, ev.point, ev.normal, ev.count, ev.speed > 0 ? ev.speed : DEFAULT_SPEED[ev.kind] ?? 1, this.debrisOptions(ev.kind, ev.object, ev.part));
+        this.vfx.burst(ev.kind, ev.point, ev.normal, ev.count, ev.speed > 0 ? ev.speed : DEFAULT_SPEED[ev.kind] ?? 1, this.debrisOptions(ev.kind, ev.object, ev.part, ev.material));
         break;
       case "fracture":
         this.onFracture(ev);
@@ -2569,10 +2885,11 @@ var Renderer = class {
     }
     return def ? fallbackColor(def.id, def) : null;
   }
-  debrisOptions(kind, objectId, partId) {
+  debrisOptions(kind, objectId, partId, material) {
     const pv = this.partVis(objectId, partId);
-    const def = pv ? this.world.materials.get(pv.material) : void 0;
+    const def = this.world.materials.get(material ?? pv?.material ?? "");
     if (kind === "smoke") return { color: SMOKE_TONES[def?.thermal.smoke ?? "grey"] };
+    if ((kind === "dust" || kind === "chips") && def?.visual?.innerColor !== void 0) return { color: def.visual.innerColor };
     if (kind === "fibers" || kind === "leaves") {
       if (def?.visual?.innerColor !== void 0) return { color: def.visual.innerColor };
       const c = pv ? this.visuals.baseColorHex(pv.meshes[0] ?? {}) : -1;
@@ -2680,8 +2997,11 @@ var Renderer = class {
     const mv = this.nearestMesh(pv, wp);
     if (!mv) return;
     const def = this.world.materials.get(pv.material);
-    this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.point);
-    this.visuals.addSpall(mv, wp, this.faceNormal(mv, wp), Math.sqrt(ev.area / Math.PI), fallbackColor(pv.material, def));
+    const normal = this.faceNormal(mv, wp);
+    const core = def?.visual?.innerColor;
+    if (core !== void 0) this.vfx.burst("chips", ev.point, [normal.x, normal.y, normal.z], 5, 2.5, { color: core });
+    else this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.point);
+    this.visuals.addSpall(mv, wp, normal, Math.sqrt(ev.area / Math.PI), core ?? fallbackColor(pv.material, def));
   }
   /**
    * Stage 2 of a staged part: the unit-sized fragments come out and the part stays drawn (hiding it is what `fracture` does). The opening itself
@@ -2704,16 +3024,27 @@ var Renderer = class {
     this.sound(impactKey(def), ev.opening.center, 0.8);
   }
   /**
-   * A unit came out of a wall of units: the unit flies as a fragment with a puff of its dust. The gap itself is the drawing's (the house renderer redraws
-   * the wall as its courses without that unit); a part drawn as one box keeps its box.
+   * A unit came out of a wall of units: the unit flies as a fragment with a puff of its dust, and the marks drawn on it (bullet holes, spalls, the impact
+   * marks of the effects) go with it. The gap itself is the drawing's (the house renderer cuts the wall where the unit was); a part drawn as one box
+   * keeps its box.
    */
   onChip(ev) {
     const pv = this.partVis(ev.object, ev.part);
     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);
-    if (!this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.center)) this.vfx.burst("dust", ev.center, [0, 1, 0], 6, 0.8, { color });
+    for (const fr of ev.fragments) {
+      const fdef = this.world.materials.get(fr.material);
+      const tone2 = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === def ? color : fallbackColor(fr.material, fdef);
+      this.fragments.spawn(fr, this.fragments.materialFor(fr.material, tone2, false), ev.object, maxAlive);
+    }
+    const T = this.THREE;
+    const center = new T.Vector3(ev.center[0], ev.center[1], ev.center[2]);
+    const half = new T.Vector3(ev.size[0] / 2 + CHIP_DECAL_EDGE, ev.size[1] / 2 + CHIP_DECAL_EDGE, ev.size[2] / 2 + CHIP_DECAL_EDGE);
+    const rotation = new T.Quaternion(ev.rotation[0], ev.rotation[1], ev.rotation[2], ev.rotation[3]);
+    for (const part of this.bounds.get(ev.object)?.parts.values() ?? []) for (const mv of part.meshes) this.visuals.clearDecals(mv, center, half, rotation);
+    this.vfx.peekWorkshop()?.decals.clearInside(ev.center, [half.x, half.y, half.z], ev.rotation);
+    this.vfx.burst("dust", ev.center, [0, 1, 0], 8, 0.8, { color });
     this.sound(impactKey(def), ev.center, 0.7);
   }
   onFracture(ev) {
@@ -2793,6 +3124,9 @@ var Renderer = class {
       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. */
@@ -2839,8 +3173,32 @@ var Renderer = class {
     }
     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);
@@ -3091,6 +3449,10 @@ var Renderer = class {
     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 };
   }
@@ -3204,7 +3566,15 @@ var BURN_LOOP = {
   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", [noise({ type: "bandpass", f: 380, q: 1.4, d: 0.28, vol: 0.5 }), noise({ type: "bandpass", f: [900, 1300], q: 3, d: 0.08, vol: 0.14 })]),
+  drag("drag_metal", [noise({ type: "bandpass", f: 1500, q: 4, d: 0.26, vol: 0.32 }), tone({ f: [880, 1240], f2: 760, d: 0.18, vol: 0.05 })]),
+  drag("drag_glass", [noise({ type: "bandpass", f: 2600, q: 5, d: 0.2, vol: 0.22 })]),
+  drag("drag_masonry", [noise({ type: "bandpass", f: 260, q: 0.9, d: 0.3, vol: 0.62 }), ...many(3, () => noise({ type: "bandpass", f: [600, 1200], q: 2, d: 0.04, vol: 0.14, delay: [0, 0.2] }))]),
+  drag("drag_soft", [noise({ type: "lowpass", f: 420, d: 0.28, vol: 0.3 })])
+];
+var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
 
 // src/audio/sound.ts
 import { GAME_SFX_BANK } from "@adatechnology/game-audio";
@@ -3215,6 +3585,11 @@ var DESTRUCTION_SOUND_KEYS = {
     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" },
@@ -3287,11 +3662,14 @@ export {
   DEFAULT_FIRE,
   DESTRUCTION_SOUND_BANK,
   DESTRUCTION_SOUND_KEYS,
+  DRAG_SOUNDS,
   EXPLOSION_BOOM,
   SCENE_SOUNDS,
   createDestructionRenderer,
   createDestructionSound,
+  dragSoundKey,
   heatColor,
+  impactKey,
   specFromObject3D
 };
 //# sourceMappingURL=index.js.map