@adatechnology/game-floorplan-three 0.4.2 → 0.5.0

package/dist/index.d.ts

@@ -599,7 +599,8 @@ interface FurnitureSpecResult {
  * Materials: `wood` is `wood_hard`, and `wood_soft` for thin boards and panels (under 3.5 cm); `metal` is `steel`; `fabric`, `glass` and `plant` keep
  * their name; `plain` is `plastic`, or `paper` for shelves and racks (their books and boxes). Parts that touch the floor are anchored. Joints come from
  * `inferJoints` (screws between wood, welds or bolts between metal...), except that paper rests on what it lies on with a `resting` joint (weak: it falls when
- * the board breaks) and is not joined to its neighbours.
+ * the board breaks) and is not joined to its neighbours. Shelves and racks stand as a carcass: the sides carry, each shelf needs both of its ends
+ * held, and the back panel carries nothing, so a broken side drops the shelves it held, with their books.
  *
  * @example
  * const { spec, build, top } = furnitureSpec(THREE, 'bookcase') // 1.2 x 0.35 x 2 m, boards and books
@@ -648,6 +649,15 @@ interface WallPiece {
     readonly spec: any;
     /** Draws the wall with the house renderer: meshes carry `userData.destructionPart` of their part, in the space of the spec. */
     build(THREE: any): any;
+    /**
+     * Once a drawing from `build` is in a destruction world as `objectId` (with this `spec`), the house renderer follows its events and draws on it what
+     * a generic destruction renderer cannot: the bricks that shots and blows knock out (`chip`) and the opening of a breach, as gaps in the wall's
+     * courses. `restore` puts the wall back (after `world.reset`), `dispose` stops following.
+     */
+    follow(root: any, world: any, objectId: string): {
+        restore(): void;
+        dispose(): void;
+    } | null;
 }
 /**
  * The plan of a free-standing wall along x, centred on the origin: a one-storey plan whose only wall is exterior on both sides, with the masonry construction of

package/dist/index.global.js

@@ -3551,8 +3551,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var OPEN_ROOM_TYPES = /* @__PURE__ */ new Set(["balcony", "terrace", "veranda", "balcony_gourmet"]);
   var rectsOf = (c) => c.parts && c.parts.length ? c.parts : [[c.u0, c.v0, c.u1, c.v1]];
   var isOpenArea = (c) => OPEN_ROOM_TYPES.has(c.type) || c.outdoor === true;
-  function planLod(houses, focus, budget) {
-    const l = houses.map((c) => ({ c, d: c.distance(focus), n0: c.stats.drawCalls, n1: c.stats.drawCallsLOD1, level: 0 })).sort((a, b) => a.d - b.d);
+  function planLod(houses2, focus, budget) {
+    const l = houses2.map((c) => ({ c, d: c.distance(focus), n0: c.stats.drawCalls, n1: c.stats.drawCallsLOD1, level: 0 })).sort((a, b) => a.d - b.d);
     let total = l.reduce((s, x) => s + x.n0, 0);
     for (let i = l.length - 1; i >= 0 && total > budget; i--) {
       total -= l[i].n0 - l[i].n1;
@@ -10695,12 +10695,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       A.invalidate = () => {
         for (let i = 0; i < NS; i++) PL[i].shadow.needsUpdate = true;
       };
-      A.update = function(houses, focus, op) {
+      A.update = function(houses2, focus, op) {
         op = op || {};
-        houses = (Array.isArray(houses) ? houses : [houses]).filter(Boolean);
+        houses2 = (Array.isArray(houses2) ? houses2 : [houses2]).filter(Boolean);
         _f.set(focus.x, focus.y, focus.z);
         const rooms = [], exterior = [];
-        for (const house of houses) {
+        for (const house of houses2) {
           if (house.group && !house.group.visible) continue;
           house.house.updateMatrixWorld(true);
           const M = house.house.matrixWorld, by = /* @__PURE__ */ new Map();
@@ -11232,6 +11232,45 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return angle === 0 ? q : quat.mul(q, quat.fromAxisAngle([0, 0, 1], angle));
   };
   var clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+  var splinterBox = (inp, box3, limit = inp.maxFragments) => {
+    const { rnd } = inp;
+    const dims = box3.s;
+    const [fmin, fmax] = inp.fragmentSize;
+    const g = inp.grain ?? [0, 1, 2].sort((a2, b2) => dims[b2] - dims[a2])[0];
+    const [a, b] = [0, 1, 2].filter((i) => i !== g);
+    const w = Math.max(fmin * 1.5, 0.01);
+    const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(limit / 2)));
+    const maxLen = fmax * 4;
+    const cells = bsp(box3, c, [a, b], rnd);
+    const pieces = [];
+    for (const cell of cells) {
+      const extra = rnd() < 0.4 ? 1 : 0;
+      const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
+      for (const p of bsp(cell, k, [g], rnd)) pieces.push(p);
+    }
+    return pieces.slice(0, limit).map((p) => ({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] }));
+  };
+  var severAt = (inp, root, at, gap) => {
+    const dims = root.s;
+    const L = [0, 1, 2].sort((x, y) => dims[y] - dims[x])[0];
+    const half = dims[L] / 2;
+    const lo = clamp(at - gap / 2, -half, half), hi = clamp(at + gap / 2, -half, half);
+    const out = [];
+    const stub = (from, to) => {
+      if (to - from < 0.02) return;
+      const c = [root.c[0], root.c[1], root.c[2]], sz = [dims[0], dims[1], dims[2]];
+      c[L] = (from + to) / 2;
+      sz[L] = to - from;
+      out.push({ center: c, size: sz, q: quat.identity(), shape: "slab", weight: sz[0] * sz[1] * sz[2] });
+    };
+    stub(-half, lo);
+    stub(hi, half);
+    const band = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
+    band.c[L] = (lo + hi) / 2;
+    band.s[L] = Math.max(hi - lo, 0.01);
+    for (const p of splinterBox(inp, band, Math.max(3, inp.maxFragments - out.length))) out.push(p);
+    return out;
+  };
   var tearStack = (inp, root, t, u, v, n, sheet) => {
     const { dims, rnd, maxFragments } = inp;
     const layers = clamp(Math.ceil(dims[t] / STACK_LAYER), 2, 4);
@@ -11270,23 +11309,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return out;
     }
     if (style === "splinter") {
-      const g = inp.grain ?? [0, 1, 2].sort((a2, b2) => dims[b2] - dims[a2])[0];
-      const [a, b] = [0, 1, 2].filter((i) => i !== g);
-      const w = Math.max(fmin * 1.5, 0.01);
-      const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(maxFragments / 2)));
-      const maxLen = fmax * 4;
-      const cells = bsp(root, c, [a, b], rnd);
-      const pieces = [];
-      for (const cell of cells) {
-        let list2 = [cell];
-        const extra = rnd() < 0.4 ? 1 : 0;
-        const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
-        list2 = bsp(cell, k, [g], rnd);
-        for (const p of list2) pieces.push(p);
-      }
-      for (const p of pieces.slice(0, maxFragments)) {
-        out.push({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] });
-      }
+      if (inp.cut) return severAt(inp, root, inp.cut.at, inp.cut.gap);
+      for (const p of splinterBox(inp, root)) out.push(p);
       return out;
     }
     if (style === "tear") {
@@ -13274,9 +13298,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var BREACH_AREA = 0.25;
   var BREACH_BLAST_REACH = 0.12;
   var RESIDUAL_CAPACITY = 0.15;
+  var SEVER_BAND = 0.1;
+  var SEVER_ASPECT = 3;
+  var SEVER_BALLISTIC = 2;
   var SUPPORT_TOLERANCE = 0.05;
   var UNIT_FRAGMENT_FACTOR = 4;
   var BREACH_GRID_CAP = 4096;
+  var CHIP_ENERGY = 200;
+  var CHIP_SPLASH = 0.5;
   var CUT_SLICE = 1;
   var cutFactorOf = (shape) => clamp2(Math.max(...shapeDims(shape)) / CUT_SLICE, 1, 50);
   var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
@@ -13320,6 +13349,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     let windCfg = windOpts ? resolveWind(windOpts) : null;
     const ignitionRules = resolveIgnitionRules(options.ignition);
     const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
+    const chipEnergy = options.breach?.chipEnergy ?? CHIP_ENERGY;
     const rng2 = createRng(options.seed ?? 1);
     const rnd = () => rng2.next();
     let time = 0;
@@ -13693,41 +13723,68 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       markDamaged(p);
       if (p.rt.hinge >= flexure.failRotationDeg * Math.PI / 180) hingeDrop(o, p, src);
     };
+    const freeSpan = (p, supports) => {
+      if (supports.length === 0) return Infinity;
+      const d = p.dims;
+      const L = [0, 1, 2].sort((a, b) => d[b] - d[a])[0];
+      const spans = supports.map((k) => contactBox(p, k)).map(([lo, hi]) => [lo[L], hi[L]]);
+      let far = 0;
+      for (let i = 0; i <= 16; i++) {
+        const x = (i / 16 - 0.5) * d[L];
+        let near = Infinity;
+        for (const [lo, hi] of spans) near = Math.min(near, Math.max(lo - x, x - hi, 0));
+        far = Math.max(far, near);
+      }
+      return 2 * far;
+    };
     const solveStructure = (o) => {
       o.maxStress = 0;
       if (!o.hasStructure) return;
       const parts = o.parts;
       const n = parts.length;
       const dist = new Array(n).fill(-1);
-      const queue = [];
       const ok = (i) => parts[i].structural && !isLost(parts[i]);
       const isPartition = (i) => parts[i].spec.structure?.role === "partition";
-      for (let i = 0; i < n; i++) if (ok(i) && parts[i].anchored) {
-        dist[i] = 0;
-        queue.push(i);
-      }
-      for (let h = 0; h < queue.length; h++) {
-        const s = queue[h];
-        if (isPartition(s)) continue;
-        for (const j of o.byPart.get(parts[s].spec.id)) {
-          if (j.st.open || !j.bears) continue;
-          const r = j.ia === s ? j.ib : j.ia;
-          if (dist[r] >= 0 || !ok(r) || restsOn(o, j, r) !== s) continue;
-          dist[r] = dist[s] + 1;
-          queue.push(r);
+      const out = /* @__PURE__ */ new Set();
+      let queue = [];
+      let lowerOf = /* @__PURE__ */ new Map();
+      for (; ; ) {
+        dist.fill(-1);
+        queue = [];
+        for (let i = 0; i < n; i++) if (ok(i) && !out.has(i) && parts[i].anchored) {
+          dist[i] = 0;
+          queue.push(i);
+        }
+        for (let h = 0; h < queue.length; h++) {
+          const s = queue[h];
+          if (isPartition(s)) continue;
+          for (const j of o.byPart.get(parts[s].spec.id)) {
+            if (j.st.open || !j.bears) continue;
+            const r = j.ia === s ? j.ib : j.ia;
+            if (dist[r] >= 0 || !ok(r) || out.has(r) || restsOn(o, j, r) !== s) continue;
+            dist[r] = dist[s] + 1;
+            queue.push(r);
+          }
         }
-      }
-      const incoming = new Array(n).fill(0);
-      const lowerOf = /* @__PURE__ */ new Map();
-      for (const i of queue) {
-        const lower = [];
-        for (const j of o.byPart.get(parts[i].spec.id)) {
-          if (j.st.open || !j.bears) continue;
-          const k = restsOn(o, j, i);
-          if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
+        lowerOf = /* @__PURE__ */ new Map();
+        let dropped = false;
+        for (const i of queue) {
+          const lower = [];
+          for (const j of o.byPart.get(parts[i].spec.id)) {
+            if (j.st.open || !j.bears) continue;
+            const k = restsOn(o, j, i);
+            if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
+          }
+          lowerOf.set(i, lower);
+          const max = parts[i].spec.structure?.maxSpan;
+          if (max !== void 0 && !parts[i].anchored && freeSpan(parts[i], lower.map((k) => parts[k])) > max) {
+            out.add(i);
+            dropped = true;
+          }
         }
-        lowerOf.set(i, lower);
+        if (!dropped) break;
       }
+      const incoming = new Array(n).fill(0);
       const bending = new Array(n).fill(0);
       const through = parts.map(() => []);
       const pass = (k, at, mass) => {
@@ -14239,6 +14296,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const r = rayPart(o, p, origin, d);
           if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
           if (p.st.opening && insideOpening(o, p, vec.madd(origin, d, r.t0))) continue;
+          if (p.st.chipped && insideChip(p, objLocal(o, vec.madd(origin, d, r.t0)))) continue;
           if (!best || r.t0 < best.distance) best = { object: o.id, part: p.spec.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
         }
       }
@@ -14502,6 +14560,62 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (total < (p.spec.breach?.area ?? BREACH_AREA)) return;
       openBreach(o, p, [sum[0] / total, sum[1] / total, sum[2] / total], total, energy, dir, src);
     };
+    const unitGrids = /* @__PURE__ */ new WeakMap();
+    const gridOf = (p) => {
+      let grid = unitGrids.get(p);
+      if (!grid) unitGrids.set(p, grid = unitGrid(p.dims, p.thin, unitsOf2(p), BREACH_GRID_CAP));
+      return grid;
+    };
+    const insideChip = (p, objectPoint) => {
+      const cells = p.st.chipped;
+      if (!cells?.length) return false;
+      const [u, v] = planeAxes(p.thin);
+      const lp = toLocal(p.pos, p.q, objectPoint);
+      return cells.some((c) => Math.abs(lp[u] - c.center[u]) <= c.size[u] / 2 && Math.abs(lp[v] - c.center[v]) <= c.size[v] / 2);
+    };
+    const chipUnits = (o, p, wp, energy, dir, radius, src) => {
+      var _a, _b;
+      if (!p.spec.units || p.spec.reinforcement || !p.staged || chipEnergy <= 0 || energy <= 0 || p.st.stripped || isLost(p) || (p.st.stage ?? 0) >= 2) return;
+      const [u, v] = planeAxes(p.thin);
+      const lp = toLocal(p.pos, p.q, objLocal(o, wp));
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const out = [];
+      for (let i = 0; i < grid.length; i++) {
+        const cell = grid[i];
+        if (worn[i] === -1) continue;
+        const gap = Math.hypot(Math.max(0, Math.abs(lp[u] - cell.center[u]) - cell.size[u] / 2), Math.max(0, Math.abs(lp[v] - cell.center[v]) - cell.size[v] / 2));
+        if (gap > radius) continue;
+        const share = gap === 0 ? 1 : CHIP_SPLASH * (1 - gap / radius);
+        const total = (worn[i] ?? 0) + energy * share;
+        const mass = p.mat.density * cell.size[0] * cell.size[1] * cell.size[2];
+        if (total < chipEnergy * mass) {
+          worn[i] = total;
+          continue;
+        }
+        worn[i] = -1;
+        out.push(cell);
+      }
+      if (out.length === 0) return;
+      const { c, q } = partXf(o, p);
+      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const holes = localHolesOf(p);
+      for (const cell of out) {
+        const mass = Math.min(p.st.mass, p.mat.density * cell.size[0] * cell.size[1] * cell.size[2]);
+        const center = toWorld(c, q, cell.center);
+        const speed = clamp2(Math.sqrt(2 * energy * 0.05 / Math.max(mass, 0.05)), 0.5, 6);
+        const fragments = cellFragments(o, p, [cell], wp, dir, speed, mass, `c${chipped.length}_`);
+        p.st.holes = p.st.holes.filter((_, k) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length === 0);
+        chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
+        p.st.mass = Math.max(0, p.st.mass - mass);
+        p.rt.removed = (p.rt.removed ?? 0) + mass;
+        markDamaged(p);
+        setStage(o, p, 1, {}, src);
+        emit({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [cell.size[0], cell.size[1], cell.size[2]], rotation: q, fragments });
+        debris(o, p, p.mat.breakDebris, center, vec.scale(dir ?? [0, 1, 0], -1), 6, 2, src);
+      }
+      for (const cell of out) addBreach(o, p, toWorld(c, q, cell.center), cell.size[u] * cell.size[v], energy, dir, src);
+    };
     const openBreach = (o, p, center, total, energy, dir, src) => {
       const [u, v] = planeAxes(p.thin);
       const radius = clamp2(Math.sqrt(total / Math.PI), Math.sqrt((p.spec.breach?.area ?? BREACH_AREA) / Math.PI), breachRadius);
@@ -14513,7 +14627,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         failPart(o, p, worldCenter, dir, energy, 12, src);
         return;
       }
-      const cells = cellsWithin(unitGrid(p.dims, p.thin, unitsOf2(p), BREACH_GRID_CAP), p.thin, lc, radius);
+      const worn = p.rt.chips;
+      const cells = cellsWithin(gridOf(p).filter((_, i) => worn?.[i] !== -1), p.thin, lc, radius);
       const removed = p.st.mass * cells.reduce((sum, cell) => sum + cell.size[u] * cell.size[v], 0) / (p.dims[u] * p.dims[v]);
       const speed = clamp2(Math.sqrt(2 * energy * 0.1 / Math.max(removed, 0.05)), 0.5, 8);
       const fragments = cellFragments(o, p, cells, worldCenter, dir, speed, removed, "b");
@@ -14597,6 +14712,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const grain = p.spec.grain ? AXIS[p.spec.grain] : void 0;
       const hitLocal = toLocal(c, q, hitW);
       const unitPlan = p.spec.units ? unitFragmentPlan(p, maxFragments * UNIT_FRAGMENT_FACTOR) : [];
+      const axis = style === "splinter" ? severAxis(p) : -1;
+      const cutAt2 = axis < 0 ? void 0 : p.rt.cutAt ?? (origin ? hitLocal[axis] : void 0);
       const plan = unitPlan.length > 0 ? unitPlan : planFragments({
         style,
         dims: p.dims,
@@ -14606,7 +14723,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
         rnd,
-        sheet: p.mat.sheet
+        sheet: p.mat.sheet,
+        ...cutAt2 !== void 0 ? { cut: { at: cutAt2, gap: SEVER_BAND } } : {}
       });
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
       const mass = p.st.mass;
@@ -14665,10 +14783,33 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       emit({ ...base(o, src), type: "primed", part: p.spec.id, point: partXf(o, p).c, trigger, delay });
     };
     const CHAIN_TRIGGER_OF = { ballistic: "shot", explosive: "explosion" };
+    const severAxis = (p) => {
+      if (p.mat.fracture !== "splinter" || p.spec.shape.kind !== "box") return -1;
+      const d = p.dims;
+      const order = [0, 1, 2].sort((a, b) => d[b] - d[a]);
+      return d[order[0]] >= SEVER_ASPECT * d[order[1]] && d[order[0]] >= 3 * SEVER_BAND ? order[0] : -1;
+    };
+    const bandOf = (o, p, axis, origin) => {
+      const { c, q } = partXf(o, p);
+      const along = toLocal(c, q, origin)[axis];
+      const L = p.dims[axis];
+      return clamp2(Math.floor((along + L / 2) / SEVER_BAND), 0, Math.ceil(L / SEVER_BAND) - 1);
+    };
     const applyDamage = (o, p, amount, type, origin, dir, fragEnergy, cap, src) => {
+      var _a;
       if (isLost(p) || amount <= 0) return 0;
       const prev = p.st.hp;
       p.st.hp -= amount;
+      const axis = origin && type !== "fire" && type !== "heat" ? severAxis(p) : -1;
+      if (axis >= 0 && p.st.hp > 0) {
+        const band = bandOf(o, p, axis, origin);
+        const cuts = (_a = p.rt).cuts ?? (_a.cuts = {});
+        cuts[band] = (cuts[band] ?? 0) + amount * (type === "ballistic" ? SEVER_BALLISTIC : 1);
+        if (cuts[band] >= p.st.maxHp * SEVER_BAND / p.dims[axis]) {
+          p.rt.cutAt = -p.dims[axis] / 2 + (band + 0.5) * SEVER_BAND;
+          p.st.hp = 0;
+        }
+      }
       markDamaged(p);
       const trigger = CHAIN_TRIGGER_OF[type];
       const chained = trigger !== void 0 && chainDelayOf(p.spec, trigger) !== void 0;
@@ -14707,7 +14848,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const ballistic = (o, p, entry2, n, d, E, caliber, pathLen, src, round3 = {}) => {
       const mat = p.mat;
       const piercing = round3.piercing ?? 1;
-      if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry2))) {
+      if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry2)) || insideChip(p, objLocal(o, entry2))) {
         return { penetrated: true, exitEnergy: E, exitPoint: vec.madd(entry2, d, Math.min(pathLen, p.thickness)), damage: 0 };
       }
       const sin = Math.min(1, Math.abs(vec.dot(d, n)));
@@ -14766,6 +14907,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       debris(o, p, mat.hitDebris, entry2, n, clamp2(Math.round(E / 60) + 2, 2, 14), clamp2(Math.sqrt(E) / 6, 1, 8), src);
       wearJoints(o, p, (penetrated ? thr : E) * 0.02, void 0, 0, src, true);
       const dmg = applyDamage(o, p, E * DMG_PER_J * scale, "ballistic", entry2, d, E * 0.1, 12, src);
+      chipUnits(o, p, entry2, penetrated ? Math.min(E, Math.max(thr, E * 0.5)) : E, d, Math.max(0.05, caliber / 1e3 * 8), src);
       return { penetrated, exitEnergy: penetrated ? penMm !== void 0 ? E * (1 - thr / Ep) : E - thr / (hard ? piercing : 1) : 0, exitPoint, damage: dmg };
     };
     const melee = (o, p, kind, E, point, n, d, contactR, src) => {
@@ -14793,6 +14935,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const scale = mat.damageScale?.[kind] ?? 1;
       const done = applyDamage(o, p, Ec * DMG_PER_J * scale * (kind === "slash" ? p.cutFactor : 1), kind, point, d, E * 0.1, 12, src);
       addBreach(o, p, point, breachAreaOf(p, done, false), E, d, src);
+      if (kind === "blunt") chipUnits(o, p, point, E, d, Math.max(contactR, 0.03), src);
       return done;
     };
     const blastPart = (o, p, point, energy, radius, src, res, reachAt) => {
@@ -19106,7 +19249,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return null;
       };
-      function courses(part, units, opening, paint) {
+      const local = (p) => {
+        house.updateMatrixWorld(true);
+        const v = house.worldToLocal(tmp.p.set(p[0], p[1], p[2]));
+        return [v.x, v.y, v.z];
+      };
+      function courses(part, units, opening, chips, paint) {
         const [u0, v0, u1, v1] = part.aabb;
         const alongU = u1 - u0 >= v1 - v0;
         const len = alongU ? u1 - u0 : v1 - v0;
@@ -19130,23 +19278,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             const x = alongU ? u0 + mid : (u0 + u1) / 2;
             const z = alongU ? (v0 + v1) / 2 : v0 + mid;
             const y = part.y0 + (r + 0.5) * rowH;
-            const d = Math.hypot(x - opening.center[0], y - opening.center[1], z - opening.center[2]);
-            if (d < opening.radius) continue;
-            list2.push({ x, y, z, sx: alongU ? b - a : thick, sy: rowH, sz: alongU ? thick : b - a, colour: d < opening.radius + 0.25 || paint === null ? edge : paint });
+            const d = opening ? Math.hypot(x - opening.center[0], y - opening.center[1], z - opening.center[2]) : Infinity;
+            if (opening && d < opening.radius) continue;
+            const gone = (c) => Math.abs(c[1] - y) <= rowH / 2 && (alongU ? c[0] >= u0 + a && c[0] <= u0 + b : c[2] >= v0 + a && c[2] <= v0 + b);
+            if (chips.some(gone)) continue;
+            const near = opening && d < opening.radius + 0.25 || chips.some((c) => Math.hypot(c[0] - x, c[1] - y, c[2] - z) < 0.15);
+            list2.push({ x, y, z, sx: alongU ? b - a : thick, sy: rowH, sz: alongU ? thick : b - a, colour: near || paint === null ? edge : paint });
           }
         }
         return list2;
       }
-      function open(event) {
-        if (lod !== 0 || views.has(event.part) || !event.opening) return false;
-        const part = structure.byId.get(event.part);
-        const spec = opts.spec()?.parts?.find((q) => q.id === event.part);
+      function draw2(partId, change) {
+        if (lod !== 0) return false;
+        const part = structure.byId.get(partId);
+        const spec = opts.spec()?.parts?.find((q) => q.id === partId);
         if (!part || !spec || !spec.units) return false;
-        const items = structure.meshesOf(event.part).filter((it) => it.mesh);
-        if (!items.length) return false;
-        const list2 = courses(part, spec.units, event.opening, wallColour(items));
+        let view = views.get(partId);
+        if (!view) {
+          const items = structure.meshesOf(partId).filter((it) => it.mesh);
+          if (!items.length) return false;
+          view = { mesh: null, saved: null, items, paint: wallColour(items), units: 0, opening: null, chips: [] };
+        }
+        if (change.opening) {
+          if (view.opening) return false;
+          view.opening = { center: local(change.opening.center), radius: change.opening.radius };
+        }
+        if (change.chip) view.chips.push(local(change.chip));
+        const list2 = courses(part, spec.units, view.opening, view.chips, view.paint);
+        if (view.mesh) {
+          view.mesh.removeFromParent();
+          view.mesh.dispose();
+        }
         const mesh2 = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list2.length));
-        mesh2.name = "breach:" + event.part;
+        mesh2.name = "breach:" + partId;
         list2.forEach((u, i) => {
           tmp.m.compose(tmp.p.set(u.x, u.y, u.z), tmp.q.identity(), tmp.s.set(u.sx, u.sy, u.sz));
           mesh2.setMatrixAt(i, tmp.m);
@@ -19158,8 +19322,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         mesh2.castShadow = true;
         mesh2.receiveShadow = true;
         house.add(mesh2);
-        const saved = items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
-        views.set(event.part, { mesh: mesh2, saved, units: list2.length, opening: event.opening });
+        if (!view.saved) view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
+        view.mesh = mesh2;
+        view.units = list2.length;
+        views.set(partId, view);
         invalidate();
         invalidateShadow();
         return true;
@@ -19173,7 +19339,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return {
         /** Handles a `stage` event of the house's object. Returns true when the wall was redrawn as courses. */
         stage(event) {
-          return event.stage === 2 ? open(event) : false;
+          return event.stage === 2 && !!event.opening ? draw2(event.part, { opening: event.opening }) : false;
+        },
+        /** Handles a `chip` event: the unit that came out leaves a gap in the courses. Returns true when the wall was redrawn. */
+        chip(event) {
+          return draw2(event.part, { chip: event.center });
         },
         /** The part broke or fell: the courses go (the plain range stays collapsed, the renderer hides the part). */
         drop(partId) {
@@ -19405,6 +19575,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           case "stage":
             breach.stage(e);
             break;
+          case "chip":
+            breach.chip(e);
+            break;
           case "collapse":
             for (const id of e.parts) {
               breach.drop(id);
@@ -19459,6 +19632,32 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (D.active && D.world.has(D.id)) D.world.remove(D.id);
         D.active = false;
       };
+      D.follow = (world, id, spec) => {
+        D.spec = spec;
+        const offFollow = world.on("*", (e) => {
+          if (e.object !== id) return;
+          switch (e.type) {
+            case "stage":
+              breach.stage(e);
+              break;
+            case "chip":
+              breach.chip(e);
+              break;
+            case "fracture":
+              breach.drop(e.part);
+              break;
+            case "collapse":
+              for (const p of e.parts) breach.drop(p);
+              break;
+            default:
+              break;
+          }
+        });
+        return { restore: () => breach.restore(), dispose: () => {
+          offFollow();
+          breach.restore();
+        } };
+      };
       D.piece = (id) => D.active ? D.world.part(D.id, id) : null;
       D.state = () => D.active ? D.world.state(D.id) : null;
       D.reset = () => {
@@ -22580,6 +22779,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
 
   // src/furniture/spec.ts
   var WOOD_THIN = 0.035;
+  var SHELF_SPAN = 1.5;
+  var SHELVING = /shelf|bookcase|rack/;
+  function carcass(parts, drawn) {
+    const all = [...drawn.values()];
+    const width = Math.max(...all.map((p) => p.max[0])) - Math.min(...all.map((p) => p.min[0]));
+    for (const part of parts) {
+      if (LOOSE.has(part.material) || part.shape.kind !== "box" || part.rotation) continue;
+      const [x, y, z] = part.shape.size;
+      if (y >= x && y >= z) {
+        if (z < x && x >= 0.6 * width) continue;
+        part.structure = { role: "column" };
+      } else if (y <= x && y <= z) part.structure = { role: "beam", maxSpan: SHELF_SPAN * Math.max(x, z) };
+    }
+  }
   var FLOOR_TOUCH = 5e-3;
   var LOOSE = /* @__PURE__ */ new Set(["paper"]);
   var BASE_MATERIAL = {
@@ -22695,6 +22908,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (area3 < 0.6 * footprint || p.max[1] < 0.2) continue;
       if (!top || p.max[1] > top.y + 1e-6) top = { part: p.id, y: p.max[1] };
     }
+    if (opts.carcass) carcass(parts, byId);
     const spec = { name, parts, joints, tags: ["furniture"] };
     const colors = new Map(drawn.map((p) => [p.id, p.color]));
     const build = (T3) => {
@@ -22738,7 +22952,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (w === void 0 || d === void 0 || h === void 0) throw new Error(`game-floorplan-three: furniture type "${type}" is not in the catalogue, so give w, d and h`);
     const o = opts.options ?? {};
     const seed = Math.round(opts.seed ?? 1);
-    const plain2 = /shelf|bookcase|rack/.test(type) ? "paper" : "plastic";
+    const plain2 = SHELVING.test(type) ? "paper" : "plastic";
     const root = { x: seed, z: 0, ry: 0, w, d, h, y: 0, base: 0, palette: o.palette, seed: `furniture_${type}_${seed}` };
     const { K, shared } = renderer.internals;
     const before = K.PARTS.length;
@@ -22757,7 +22971,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           shared.ctx = saved.ctx;
         }
       },
-      { materials: { plain: plain2, ...o.materials }, chairs: o.chairs }
+      { materials: { plain: plain2, ...o.materials }, chairs: o.chairs, carcass: SHELVING.test(type) }
     );
     const spouts = K.PARTS.slice(before).filter((p) => p.type === "water_tap").map((p) => [p.pos[0] - root.x, p.pos[1], p.pos[2] - root.z]);
     K.PARTS.length = before;
@@ -22824,7 +23038,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function draw(THREE, plan, options) {
     return create3(THREE, { ...options, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true, pieces: "meshes" });
   }
+  var houses = /* @__PURE__ */ new WeakMap();
   function label(house) {
+    houses.set(house.group, house);
     for (const [id, items] of Object.entries(house.destruction.ranges())) {
       for (const item of items) {
         const object2 = item.isObject3D ? item : item.mesh;
@@ -22837,12 +23053,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const plan = wallPlan(options);
     const houseOptions = options.house ?? {};
     const probe = draw(THREE, plan, { ...houseOptions, destruction: void 0, destructionRenderer: void 0 });
-    const spec = probe.structure.spec({ wallDetail: "coarse" });
+    const spec = probe.structure.spec();
     probe.dispose();
     return {
       plan,
       spec,
-      build: (T2) => label(draw(T2, plan, houseOptions))
+      build: (T2) => label(draw(T2, plan, houseOptions)),
+      follow: (root, world, objectId) => houses.get(root)?.destruction?.follow?.(world, objectId, spec) ?? null
     };
   }
   return __toCommonJS(index_exports);