@adatechnology/game-floorplan-three 0.6.0 → 0.8.0

package/dist/index.global.js

@@ -12693,6 +12693,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       },
       hitDebris: "chips",
       breakDebris: "dust",
+      visual: { innerColor: 10197652 },
       thermal: {
         conductivity: 0.15,
         heatCapacity: 2.5
@@ -12723,6 +12724,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ],
       hitDebris: "chips",
       breakDebris: "dust",
+      visual: { innerColor: 12085567 },
       thermal: {
         conductivity: 0.15,
         heatCapacity: 2.5
@@ -12753,6 +12755,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ],
       hitDebris: "dust",
       breakDebris: "dust",
+      visual: { innerColor: 14999507 },
       thermal: {
         conductivity: 0.1,
         heatCapacity: 1.5
@@ -12778,6 +12781,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ],
       hitDebris: "chips",
       breakDebris: "dust",
+      visual: { innerColor: 9407364 },
       thermal: {
         conductivity: 0.2,
         heatCapacity: 2.5
@@ -13519,6 +13523,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var FLAMMABLE_FLUIDS = ["gas", "fuel"];
   var VENT_DIAMETER = 8e-3;
   var FLAME_LIGHTS_LEAK_C = 470;
+  var RESTING_HOLD_COS = Math.cos(Math.PI / 6);
   var BREACH_RADIUS = 0.55;
   var BREACH_BLAST_FACTOR = 6;
   var BREACH_AREA = 0.25;
@@ -13534,7 +13539,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var BREACH_GRID_CAP = 4096;
   var CHIP_ENERGY = 200;
   var CHIP_SPLASH = 0.5;
+  var CRATER_SPENT = 0.6;
   var BAR_BOW = 0.08;
+  var BULLET_JOINT_SPAN = 0.3;
   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));
@@ -13553,12 +13560,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const cells = p.st.chipped;
     if (!cells?.length) return 0;
     const [u, v] = planeAxes(p.thin);
-    const along = p.dims[u] >= p.dims[v] ? u : v;
+    const role = p.spec.structure?.role;
+    const up = rotateVec(p.q, [0, 0, 0].map((_, k) => k === v ? 1 : 0));
+    const upright = Math.abs(up[1]) > 0.7 ? v : Math.abs(rotateVec(p.q, [0, 0, 0].map((_, k) => k === u ? 1 : 0))[1]) > 0.7 ? u : -1;
+    const along = (role === "wall" || role === "partition" || role === "column") && upright >= 0 ? upright : p.dims[u] >= p.dims[v] ? u : v;
     const across = along === u ? v : u;
     let worst = 0;
     for (const c of cells) {
-      let gone = 0;
-      for (const d of cells) if (Math.abs(d.center[along] - c.center[along]) < d.size[along] / 2 + 1e-6) gone += d.size[across];
+      const spans = [];
+      for (const d of cells) if (Math.abs(d.center[along] - c.center[along]) < d.size[along] / 2 + 1e-6) spans.push([d.center[across] - d.size[across] / 2, d.center[across] + d.size[across] / 2]);
+      spans.sort((a, b) => a[0] - b[0]);
+      let gone = 0, end = -Infinity;
+      for (const [a, b] of spans) {
+        if (b <= end) continue;
+        gone += b - Math.max(a, end);
+        end = b;
+      }
       worst = Math.max(worst, gone / Math.max(p.dims[across], 1e-6));
     }
     return Math.min(1, worst);
@@ -13854,7 +13871,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (k < 0 || j.spec.kind !== "tie") return k;
       return partXf(o, o.parts[k]).c[1] > partXf(o, o.parts[r]).c[1] + 1e-6 ? k : -1;
     };
+    let poseVersion = 0;
+    const contactMemo = /* @__PURE__ */ new WeakMap();
     const contactBox = (p, support) => {
+      let byTouching = contactMemo.get(p);
+      if (!byTouching) contactMemo.set(p, byTouching = /* @__PURE__ */ new Map());
+      const known = byTouching.get(support);
+      if (known && known.version === poseVersion) return known.box;
+      const box3 = measureContact(p, support);
+      byTouching.set(support, { version: poseVersion, box: box3 });
+      return box3;
+    };
+    const measureContact = (p, support) => {
       const A = aabbOf(p.spec.shape, p.pos, p.q), B = aabbOf(support.spec.shape, support.pos, support.q);
       const lo = [0, 0, 0], hi = [0, 0, 0];
       for (let k = 0; k < 3; k++) {
@@ -14649,7 +14677,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       p.st.holes.push(hole);
       if (p.st.holes.length > maxHoles) p.st.holes.shift();
       markDamaged(p);
-      emit({ ...base(o, src), type: "hole", part: p.spec.id, hole, worldPoint: wp, ...exit ? { exitPoint: exit } : {} });
+      emit({ ...base(o, src), type: "hole", part: p.spec.id, hole, worldPoint: wp, ...exit ? { exitPoint: exit } : {}, ...p.spec.powder ? { powder: { ...p.spec.powder } } : {} });
       setStage(o, p, 1, {}, src);
       return hole;
     };
@@ -14661,11 +14689,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       emit({ ...base(o, src), type: "crack", part: p.spec.id, crack, worldPoint: wp });
       setStage(o, p, 1, {}, src);
     };
-    const debris = (o, p, kind, point, normal, count, speed, src) => emit({ ...base(o, src), type: "debris", part: p.spec.id, kind, point, normal, count, speed });
+    const debris = (o, p, kind, point, normal, count, speed, src, material) => emit({ ...base(o, src), type: "debris", part: p.spec.id, kind, point, normal, count, speed, ...material && material !== p.spec.material ? { material } : {} });
     const holeRate = (hole, pressurized) => (pressurized ? 0.5 : 0.1) * (hole.diameter / 9e-3);
     const detachEvents = (o, opened, by, src) => {
       for (const j of opened) emit({ ...base(o, src), type: "detach", joint: j.spec.id, parts: [j.spec.a, j.spec.b], by, groups: o.st.groups.map((g) => [...g]) });
     };
+    const slideOffResting = (o, rotation) => {
+      const upY = 1 - 2 * (rotation[0] * rotation[0] + rotation[2] * rotation[2]);
+      if (upY >= RESTING_HOLD_COS) return;
+      const opened = o.joints.filter((j) => j.spec.kind === "resting" && !j.st.open);
+      if (opened.length === 0) return;
+      run(() => {
+        for (const j of opened) {
+          j.st.open = true;
+          j.st.openedBy = "break";
+        }
+        solveStructure(o);
+        recomputeGroups(o);
+        detachEvents(o, opened, "break");
+        collapseCheck(o);
+      });
+    };
     const checkDestroyed = (o, src) => {
       if (!o.st.destroyed && o.parts.length > 0 && o.parts.every(isLost)) {
         o.st.destroyed = true;
@@ -14702,7 +14746,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const small = pa.dims[0] * pa.dims[1] * pa.dims[2] <= pb.dims[0] * pb.dims[1] * pb.dims[2] ? pa : pb;
       return Math.max(0.06, 0.5 * Math.min(small.dims[0], small.dims[1], small.dims[2]));
     };
-    const wearJoints = (o, p, amount, near, radius = 0.06, src, split = false) => {
+    const jointLength = (o, j) => {
+      const A = partWorldAabb(o, o.parts[j.ia]), B = partWorldAabb(o, o.parts[j.ib]);
+      let len = 0;
+      for (let k = 0; k < 3; k++) len = Math.max(len, Math.min(A.max[k], B.max[k]) - Math.max(A.min[k], B.min[k]));
+      return len;
+    };
+    const wearJoints = (o, p, amount, near, radius = 0.06, src, split = false, span) => {
       if (amount <= 0) return;
       const mine = (o.byPart.get(p.spec.id) ?? []).filter((j) => !j.st.open);
       if (split && mine.length) amount /= mine.length;
@@ -14710,7 +14760,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (j.st.open) continue;
         if (j.spec.kind === "rebar" && (isReinforced(o.parts[j.ia].spec) || isReinforced(o.parts[j.ib].spec))) continue;
         if (near && jointReach(o, j, near) > Math.max(radius, jointReachLimit(o, j))) continue;
-        j.st.hp -= amount;
+        j.st.hp -= span === void 0 ? amount : amount * Math.min(1, span / Math.max(jointLength(o, j), 1e-6));
         if (j.st.hp <= 0) {
           j.st.hp = 0;
           j.st.open = true;
@@ -14739,7 +14789,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (spalls.length > MAX_SPALLS) spalls.shift();
       markDamaged(p);
       emit({ ...base(o, src), type: "spall", part: p.spec.id, layer: layer.index, point: wp, area: Math.PI * radius * radius });
-      debris(o, p, layer.mat.hitDebris, wp, normal, 5, 2, src);
+      debris(o, p, layer.mat.hitDebris, wp, normal, 5, 2, src, layer.mat.id);
       setStage(o, p, 1, {}, src);
     };
     const crater = (o, p, wp, normal, radius, src) => {
@@ -14760,7 +14810,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const localHolesOf = (p) => p.st.holes.map((h) => ({ point: toLocal(p.pos, p.q, h.point), normal: rotateVec(quat.conjugate(p.q), h.normal), diameter: h.diameter }));
     const unitsOf2 = (p) => p.spec.units ?? { size: [p.mat.fragmentSize?.[1] ?? 0.2, p.mat.fragmentSize?.[1] ?? 0.2, p.thickness], bond: "stack" };
     const FRAGMENT_SHAPE = { shatter: "shard", splinter: "splinter", tear: "scrap" };
-    const cellFragments = (o, p, cells, hitW, dir, speed, mass, tag) => {
+    const cellFragments = (o, p, cells, hitW, dir, speed, mass, tag, inner = false) => {
       const { c, q } = partXf(o, p);
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
       const [u, v] = planeAxes(p.thin);
@@ -14784,7 +14834,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           velocity: [dv[0] * k, dv[1] * k + 0.5 * rnd(), dv[2] * k],
           angularVelocity: [(rnd() - 0.5) * 8, (rnd() - 0.5) * 8, (rnd() - 0.5) * 8],
           mass: mass * faceArea(cell) / total,
-          ...marks.length > 0 ? { marks } : {}
+          ...marks.length > 0 ? { marks } : {},
+          ...inner ? { inner } : {}
         };
       });
     };
@@ -14825,7 +14876,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       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, kind, wp, hitEnergy, dir, radius, src) => {
-      var _a, _b;
+      var _a, _b, _c;
       if (!p.spec.units || !p.staged || chipEnergy <= 0 || p.st.stripped || isLost(p) || (p.st.stage ?? 0) >= 2) return;
       const rule = p.mat.hits?.[kind];
       const perKg = rule?.unitJoules ?? chipEnergy;
@@ -14835,7 +14886,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const lp = toLocal(p.pos, p.q, objLocal(o, wp));
       const grid = gridOf(p);
       const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const cut = (_b = p.rt).craters ?? (_b.craters = {});
       const out = [];
+      const shot = kind === "ballistic";
       for (let i = 0; i < grid.length; i++) {
         const cell = grid[i];
         if (worn[i] === -1) continue;
@@ -14848,18 +14901,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           worn[i] = total;
           continue;
         }
-        worn[i] = -1;
-        out.push(cell);
+        if (!shot) {
+          worn[i] = -1;
+          out.push(cell);
+          continue;
+        }
+        const size = [cell.size[0], cell.size[1], cell.size[2]];
+        const center = [cell.center[0], cell.center[1], cell.center[2]];
+        for (const a of [u, v]) {
+          const w = Math.min(cell.size[a], craterAcross(hitEnergy) * (0.85 + 0.3 * rnd()));
+          const lo = cell.center[a] - cell.size[a] / 2 + w / 2, hi = cell.center[a] + cell.size[a] / 2 - w / 2;
+          size[a] = w;
+          center[a] = clamp2(lp[a], lo, hi);
+        }
+        const taken2 = (cut[i] ?? 0) + size[u] * size[v];
+        if (taken2 >= cell.size[u] * cell.size[v] * CRATER_SPENT) {
+          worn[i] = -1;
+          out.push({ ...cell, crater: true });
+          continue;
+        }
+        worn[i] = 0;
+        cut[i] = taken2;
+        out.push({ center, size, crater: true });
       }
       if (out.length === 0) return;
       const { c, q } = partXf(o, p);
-      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const chipped = (_c = p.st).chipped ?? (_c.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}_`);
+        const tag = `c${chipped.length}_`;
+        const fragments = cell.crater ? craterFragments(o, p, cell, dir, speed, mass, tag) : cellFragments(o, p, [cell], wp, dir, speed, mass, tag, true);
         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);
@@ -14876,6 +14950,44 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         collapseCheck(o, src);
       }
     };
+    const craterAcross = (energy) => clamp2(0.03 + 12e-4 * Math.sqrt(Math.max(0, energy)), 0.03, 0.14);
+    const craterFragments = (o, p, cell, dir, speed, mass, tag) => {
+      const { c, q } = partXf(o, p);
+      const [u, v] = planeAxes(p.thin);
+      const d = dir ?? rotateVec(q, [p.thin === 0 ? 1 : 0, p.thin === 1 ? 1 : 0, p.thin === 2 ? 1 : 0]);
+      const exitSign = Math.sign(rotateVec(quat.conjugate(q), d)[p.thin]) || 1;
+      const bit = Math.max(0.01, Math.min(cell.size[u], cell.size[v]) / 3);
+      const n = clamp2(Math.round(cell.size[u] * cell.size[v] / (bit * bit * 3)), 4, 10) + Math.floor(rnd() * 3);
+      const out = [];
+      for (let i = 0; i < n; i++) {
+        const back = i % 3 === 2;
+        const lc = [cell.center[0], cell.center[1], cell.center[2]];
+        lc[u] += (rnd() - 0.5) * cell.size[u] * 0.7;
+        lc[v] += (rnd() - 0.5) * cell.size[v] * 0.7;
+        lc[p.thin] += (back ? -exitSign : exitSign) * (p.thickness / 2 + 0.01);
+        const size = [0, 0, 0];
+        size[u] = bit * (0.6 + 0.8 * rnd());
+        size[v] = bit * (0.5 + 0.7 * rnd());
+        size[p.thin] = bit * (0.4 + 0.6 * rnd());
+        const spread3 = [(rnd() - 0.5) * 0.9, (rnd() - 0.3) * 0.9, (rnd() - 0.5) * 0.9];
+        const k = speed * (back ? 0.4 + 0.4 * rnd() : 0.7 + 0.8 * rnd());
+        const vdir = vec.normalize(vec.add(back ? vec.scale(d, -1) : d, spread3));
+        out.push({
+          id: `${p.spec.id}#${tag}${i}`,
+          part: p.spec.id,
+          material: p.spec.material,
+          shape: "chunk",
+          center: toWorld(c, q, lc),
+          size,
+          rotation: q,
+          velocity: [vdir[0] * k, vdir[1] * k + 0.5 * rnd(), vdir[2] * k],
+          angularVelocity: [(rnd() - 0.5) * 20, (rnd() - 0.5) * 20, (rnd() - 0.5) * 20],
+          mass: mass / n,
+          inner: true
+        });
+      }
+      return out;
+    };
     const exposeRebar = (o, p, src) => {
       const r = p.spec.reinforcement;
       if (!r) return;
@@ -15163,7 +15275,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         });
       }
       const patch = [scale * 4, scale * 4, scale * 4];
-      emit({ ...base(o, src), type: "chip", part: p.spec.id, center: exit ?? entry2, size: patch, rotation: q, fragments });
+      emit({ ...base(o, src), type: "chip", part: p.spec.id, center: exit ?? entry2, size: patch, rotation: q, fragments, torn: true });
     };
     const ballistic = (o, p, entry2, n, d, E, caliber, pathLen, src, round3 = {}) => {
       const mat = p.mat;
@@ -15222,12 +15334,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       } else if (mat.ductility >= 0.5) {
         addDent(o, p, entry2, n, Math.max(caliber * 3 / 1e3, 0.012), clamp2(Math.min(Math.max(p.thickness * 3, 3e-3), ratio * 0.01), 1e-3, 0.05), src);
       } else if (brittle) {
-        addCrack(o, p, entry2, n, crackLen, src);
+        if (!p.spec.units) addCrack(o, p, entry2, n, crackLen, src);
         if (mat.fracture !== "shatter") addHole(o, p, entry2, n, caliber / 1e3, false, void 0, src);
       } else addHole(o, p, entry2, n, caliber / 1e3, false, void 0, src);
       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 absorbed = penetrated && mat.ductility >= 0.5 && mat.fracture !== "tear" ? Math.min(E, thr) : E;
+      wearJoints(o, p, (penetrated ? thr : E) * 0.02, void 0, 0, src, true, BULLET_JOINT_SPAN);
+      const hollowTear = mat.fracture === "tear" && p.spec.fill !== void 0 && p.spec.fill < 0.5;
+      const absorbed = penetrated && (mat.ductility >= 0.5 && mat.fracture !== "tear" || hollowTear) ? Math.min(E, thr) : E;
       const dmg = applyDamage(o, p, absorbed * DMG_PER_J * scale, "ballistic", entry2, d, absorbed * 0.1, 12, src);
       if (!isLost(p)) tearAt(o, p, "ballistic", entry2, penetrated ? exitPoint : void 0, d, E, caliber / 1e3, src);
       chipUnits(o, p, "ballistic", entry2, penetrated ? Math.min(E, Math.max(thr, E * 0.5)) : E, d, Math.max(0.05, caliber / 1e3 * 8), src);
@@ -15312,10 +15425,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (dist <= BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       return reach;
     };
+    const blastProbe = { partsTested: 0, partsNear: 0 };
+    const blastCandidates = (o, point, radius) => {
+      const local = toLocal(o.st.position, o.st.rotation, point);
+      const near = [];
+      for (const p of o.parts) {
+        const reach = radius + p.bound;
+        const dx = local[0] - p.pos[0];
+        const dy = local[1] - p.pos[1];
+        const dz = local[2] - p.pos[2];
+        if (dx * dx + dy * dy + dz * dz < reach * reach) near.push(p);
+      }
+      blastProbe.partsTested += o.parts.length;
+      blastProbe.partsNear += near.length;
+      return near;
+    };
     const blastObject = (o, point, energy, radius, src) => {
       const start = cur.length;
       const res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] };
-      for (const p of o.parts) blastPart(o, p, point, energy, radius, src, res);
+      for (const p of blastCandidates(o, point, radius)) blastPart(o, p, point, energy, radius, src, res);
       res.events = cur.slice(start);
       return res;
     };
@@ -15439,7 +15567,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       let order = 0;
       for (const o of inRange) {
         if (only && only !== o) continue;
-        for (const p of o.parts) {
+        for (const p of blastCandidates(o, point, radius)) {
           if (isLost(p)) continue;
           const dist = distToPart(o, p, point);
           if (dist < radius) items.push({ dist, order: order++, o, p });
@@ -15986,6 +16114,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const p = getPart(o, partId);
         p.pos = [position[0], position[1], position[2]];
         p.q = q;
+        poseVersion++;
         updateBound(o);
       },
       remove(id) {
@@ -16004,6 +16133,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const o = getObj(id);
         o.base = { pos: [position[0], position[1], position[2]], rot: [rotation[0], rotation[1], rotation[2], rotation[3]] };
         applySoilPose(o);
+        slideOffResting(o, rotation);
       },
       splitGroup(id, group, newId) {
         if (impls.has(id)) throw new Error(`object "${id}" is a registered DestructibleImpl and cannot be split; its module owns its pieces`);
@@ -16027,7 +16157,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (o.spec.name !== void 0) s.name = o.spec.name;
           if (o.spec.tags) s.tags = [...o.spec.tags];
           if (o.spec.soil !== void 0) s.soil = o.spec.soil;
-          return clone(s);
+          return s;
         };
         const inNew = (pid) => moved.has(pid);
         const inOld = (pid) => !moved.has(pid);
@@ -16054,7 +16184,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const p = getPart(o, partId);
         return whole(() => doHit(o, h, p));
       },
+      blastProbe() {
+        return { ...blastProbe };
+      },
       explode(point, energy, radius, source, blast) {
+        blastProbe.partsTested = 0;
+        blastProbe.partsNear = 0;
         return withCollapses(run(() => blastWorld(point, energy, radius, source, blast)));
       },
       raycast(origin, direction, maxDistance = Infinity) {
@@ -16064,7 +16199,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       sweepBox(box3, direction, distance2, options2 = {}) {
         const d = vec.normalize(direction);
         const ignored = options2.ignore === void 0 ? void 0 : objects.get(options2.ignore);
-        const ignore = ignored ? new Set(ignored.parts.map((p) => `${ignored.id}\0${p.spec.id}`)) : void 0;
+        const hosted = options2.ignore === void 0 || ignored ? void 0 : impls.get(options2.ignore);
+        const ignore = ignored ? new Set(ignored.parts.map((p) => `${ignored.id}\0${p.spec.id}`)) : hosted ? new Set(hosted.impl.describe().parts.map((p) => `${hosted.impl.id}\0${p.id}`)) : void 0;
         let best = null;
         for (const origin of sweepOrigins(box3, d, options2.spacing ?? 0.2)) {
           const r = raycastInternal(origin, d, distance2 + SWEEP_BACK, ignore);
@@ -19578,6 +19714,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function collapseRange(mesh2, v0, v1) {
     const pos = mesh2.geometry.attributes.position;
     const a = pos.array;
+    const u = mesh2.userData;
+    if (!u._p0) u._p0 = a.slice();
+    const list2 = u.collapsedRanges ?? (u.collapsedRanges = []);
+    if (!list2.some((r) => r[0] === v0 && r[1] === v1)) list2.push([v0, v1]);
     const saved = a.slice(v0 * 3, v1 * 3);
     const x = a[v0 * 3], y = a[v0 * 3 + 1], z = a[v0 * 3 + 2];
     for (let k = v0; k < v1; k++) {
@@ -19592,65 +19732,57 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const pos = mesh2.geometry.attributes.position;
     pos.array.set(saved, v0 * 3);
     pos.needsUpdate = true;
-  }
+    const list2 = mesh2.userData.collapsedRanges;
+    if (list2) mesh2.userData.collapsedRanges = list2.filter((r) => r[0] !== v0);
+  }
+  function noise2(x, y, cell) {
+    const h = (i2, j2) => {
+      const s = Math.sin(i2 * 127.1 + j2 * 311.7) * 43758.5453;
+      return s - Math.floor(s);
+    };
+    const fx = x / cell, fy = y / cell, i = Math.floor(fx), j = Math.floor(fy), u = fx - i, v = fy - j;
+    const su = u * u * (3 - 2 * u), sv = v * v * (3 - 2 * v);
+    return (h(i, j) * (1 - su) + h(i + 1, j) * su) * (1 - sv) + (h(i, j + 1) * (1 - su) + h(i + 1, j + 1) * su) * sv;
+  }
+  var MASK_TEXEL = 0.02;
+  var SPALL_MIN = 0.025;
+  var SPALL_RAGGED = 0.045;
+  var COVER2 = 0.015;
+  var MAX_FLAKES = 64;
   function installDestructionBreach(K, _shared) {
     const { THREE, fragmentMaterial, invalidate, invalidateShadow } = K;
     function createBreachView(opts) {
       const { house, structure } = opts;
       const views = /* @__PURE__ */ new Map();
+      const dirty = /* @__PURE__ */ new Set();
+      const paintBudgetMs = opts.paintBudgetMs ?? Infinity;
+      const dropped = [];
       let lod = 0;
-      const unitMaterial = new THREE.MeshLambertMaterial({ color: 16777215 });
       const unitGeometry = new THREE.BoxGeometry(1, 1, 1);
       const tmp = { m: new THREE.Matrix4(), q: new THREE.Quaternion(), p: new THREE.Vector3(), s: new THREE.Vector3(), c: new THREE.Color() };
-      const wallColour = (items) => {
-        for (const it of items) {
-          if (!it.mesh) continue;
-          const c = it.mesh.geometry.attributes.color;
-          if (!c) continue;
-          const a = c.array;
-          tmp.c.setRGB(a[it.v0 * 3], a[it.v0 * 3 + 1], a[it.v0 * 3 + 2]);
-          return tmp.c.getHex();
-        }
-        return null;
-      };
       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) {
+      function cells(part, units) {
         const [u0, v0, u1, v1] = part.aabb;
         const alongU = u1 - u0 >= v1 - v0;
         const len = alongU ? u1 - u0 : v1 - v0;
-        const thick = alongU ? v1 - v0 : u1 - u0;
         const [ul, uh] = units.size;
         const rows = Math.max(1, Math.round((part.y1 - part.y0) / uh));
         const rowH = (part.y1 - part.y0) / rows;
         const per = Math.max(1, Math.round(len / ul));
         const w = len / per;
-        const edge = fragmentMaterial(part.material).color.getHex();
-        const list2 = [];
+        const out = [];
         for (let r = 0; r < rows; r++) {
           const shift = units.bond === "running" && r & 1 ? w / 2 : 0;
-          const cells = per + (shift ? 1 : 0);
-          for (let i = 0; i < cells; i++) {
-            let a = i * w - shift, b = a + w;
-            a = Math.max(0, a);
-            b = Math.min(len, b);
-            if (b - a < 1e-3) continue;
-            const mid = (a + b) / 2;
-            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 = 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 });
+          for (let i = 0; i < per + (shift ? 1 : 0); i++) {
+            const a = Math.max(0, i * w - shift), b = Math.min(len, i * w - shift + w);
+            if (b - a > 1e-3) out.push({ a, b, y0: part.y0 + r * rowH, y1: part.y0 + (r + 1) * rowH, r, i });
           }
         }
-        return list2;
+        return out;
       }
       const specOf = (id) => opts.spec()?.parts?.find((q) => q.id === id);
       const same = (a, b) => a.every((x, k) => Math.abs(x - b[k]) < 1e-3);
@@ -19664,6 +19796,200 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return null;
       }
       const riders = (hostId) => structure.parts.filter((q) => q.id !== hostId && specOf(q.id)?.units && hostOf(q.id) === hostId && !structure.meshesOf(q.id).some((it) => it.mesh)).map((q) => q.id);
+      function shell(it, mask) {
+        const g0 = it.mesh.geometry, g = new THREE.BufferGeometry();
+        const src = it.mesh.userData._p0 || g0.attributes.position.array;
+        for (const [name, attr] of Object.entries(g0.attributes)) {
+          const k = attr.itemSize;
+          g.setAttribute(name, new THREE.BufferAttribute((name === "position" ? src : attr.array).slice(it.v0 * k, it.v1 * k), k));
+        }
+        if (g0.index) {
+          const ix = g0.index.array.slice(it.i0, it.i1);
+          for (let k = 0; k < ix.length; k++) ix[k] -= it.v0;
+          g.setIndex(new THREE.BufferAttribute(ix, 1));
+        }
+        g.computeBoundingBox();
+        g.computeBoundingSphere();
+        const base = it.mesh.material;
+        const material = base.clone();
+        const toHouse = { value: new THREE.Matrix4() };
+        material.onBeforeCompile = (sh) => {
+          base.onBeforeCompile?.(sh);
+          sh.uniforms.uToHouse = toHouse;
+          sh.uniforms.uMask = { value: mask.texture };
+          sh.uniforms.uMaskRect = { value: mask.rect };
+          sh.uniforms.uMaskAlongX = { value: mask.alongU ? 1 : 0 };
+          sh.vertexShader = sh.vertexShader.replace("void main() {", "uniform mat4 uToHouse;\nvarying vec3 vHousePos;\nvoid main() {").replace("#include <begin_vertex>", "#include <begin_vertex>\nvHousePos = (uToHouse * vec4(transformed, 1.0)).xyz;");
+          sh.fragmentShader = sh.fragmentShader.replace("void main() {", "uniform sampler2D uMask;\nuniform vec4 uMaskRect;\nuniform float uMaskAlongX;\nvarying vec3 vHousePos;\nvoid main() {\n  vec2 mUv = vec2(((uMaskAlongX > 0.5 ? vHousePos.x : vHousePos.z) - uMaskRect.x) / uMaskRect.z, (vHousePos.y - uMaskRect.y) / uMaskRect.w);\n  if (mUv.x >= 0.0 && mUv.x <= 1.0 && mUv.y >= 0.0 && mUv.y <= 1.0 && texture2D(uMask, mUv).r > 0.5) discard;");
+        };
+        material.customProgramCacheKey = () => "breachMask" + (base.customProgramCacheKey?.() ?? "");
+        const mesh2 = new THREE.Mesh(g, material);
+        mesh2.name = "breach-shell";
+        mesh2.userData.breachMask = mask;
+        mesh2.userData.cutAt = (p) => {
+          const v = local([p.x, p.y, p.z]);
+          const i = Math.floor(((mask.alongU ? v[0] : v[2]) - mask.start) / mask.len * mask.w), j = Math.floor((v[1] - mask.y0) / mask.height * mask.h);
+          return i >= 0 && i < mask.w && j >= 0 && j < mask.h && mask.data[j * mask.w + i] > 127;
+        };
+        mesh2.position.copy(it.mesh.position);
+        mesh2.quaternion.copy(it.mesh.quaternion);
+        mesh2.scale.copy(it.mesh.scale);
+        mesh2.castShadow = it.mesh.castShadow;
+        mesh2.receiveShadow = it.mesh.receiveShadow;
+        mesh2.renderOrder = it.mesh.renderOrder;
+        mesh2.onBeforeRender = () => {
+          house.updateMatrixWorld();
+          toHouse.value.copy(house.matrixWorld).invert().multiply(mesh2.matrixWorld);
+        };
+        it.mesh.parent.add(mesh2);
+        mesh2.updateMatrixWorld(true);
+        toHouse.value.copy(house.matrixWorld).invert().multiply(mesh2.matrixWorld);
+        return mesh2;
+      }
+      function unitsMaterial(core) {
+        const material = new THREE.MeshLambertMaterial({ color: 16777215, side: THREE.DoubleSide });
+        material.onBeforeCompile = (sh) => {
+          sh.uniforms.uCore = { value: core.texture };
+          sh.uniforms.uCoreRect = { value: core.rect };
+          sh.uniforms.uCoreAlongX = { value: core.alongU ? 1 : 0 };
+          sh.vertexShader = sh.vertexShader.replace("void main() {", "varying vec3 vHousePos;\nvoid main() {").replace("#include <begin_vertex>", "#include <begin_vertex>\n#ifdef USE_INSTANCING\nvHousePos = (instanceMatrix * vec4(transformed, 1.0)).xyz;\n#else\nvHousePos = transformed;\n#endif");
+          sh.fragmentShader = sh.fragmentShader.replace("void main() {", "uniform sampler2D uCore;\nuniform vec4 uCoreRect;\nuniform float uCoreAlongX;\nvarying vec3 vHousePos;\nvoid main() {\n  vec2 cUv = vec2(((uCoreAlongX > 0.5 ? vHousePos.x : vHousePos.z) - uCoreRect.x) / uCoreRect.z, (vHousePos.y - uCoreRect.y) / uCoreRect.w);\n  if (cUv.x >= 0.0 && cUv.x <= 1.0 && cUv.y >= 0.0 && cUv.y <= 1.0 && texture2D(uCore, cUv).r > 0.5) discard;").replace("#include <color_fragment>", "#include <color_fragment>\nif (!gl_FrontFacing) diffuseColor.rgb *= 0.55;");
+        };
+        material.customProgramCacheKey = () => "breachCore";
+        material.userData.breachCore = core;
+        return material;
+      }
+      function maskOf(hostId, parts) {
+        const host = structure.byId.get(hostId);
+        const [u0, v0, u1, v1] = host.aabb;
+        const alongU = u1 - u0 >= v1 - v0;
+        const y0 = Math.min(...parts.map((id) => structure.byId.get(id).y0)), y1 = Math.max(...parts.map((id) => structure.byId.get(id).y1));
+        const len = alongU ? u1 - u0 : v1 - v0;
+        const w = Math.max(2, Math.min(2048, Math.ceil(len / MASK_TEXEL))), h = Math.max(2, Math.min(1024, Math.ceil((y1 - y0) / MASK_TEXEL)));
+        const data = new Uint8Array(w * h);
+        const texture = new THREE.DataTexture(data, w, h, THREE.RedFormat);
+        texture.magFilter = THREE.LinearFilter;
+        texture.minFilter = THREE.LinearFilter;
+        texture.needsUpdate = true;
+        return { data, texture, w, h, alongU, start: alongU ? u0 : v0, len, y0, height: y1 - y0, rect: new THREE.Vector4(alongU ? u0 : v0, y0, len, y1 - y0) };
+      }
+      const boxDistance = (s, y, a, b, c, d) => Math.hypot(Math.max(a - s, 0, s - b), Math.max(c - y, 0, y - d));
+      const ellipseDistance = (s, y, cs, cy, rs, ry) => (Math.hypot((s - cs) / Math.max(rs, 1e-4), (y - cy) / Math.max(ry, 1e-4)) - 1) * Math.min(rs, ry);
+      function covered(c, boxes) {
+        const n = 8;
+        let hit = 0;
+        for (let j = 0; j < n; j++) {
+          const y = c.y0 + (j + 0.5) / n * (c.y1 - c.y0);
+          for (let i = 0; i < n; i++) {
+            const s = c.a + (i + 0.5) / n * (c.b - c.a);
+            if (boxes.some((k) => s >= k.s0 && s <= k.s1 && y >= k.y0 && y <= k.y1)) hit++;
+          }
+        }
+        return hit / (n * n);
+      }
+      function paint(view) {
+        const { mask, core } = view;
+        const along = (p) => (mask.alongU ? p[0] : p[2]) - mask.start;
+        const holes = [];
+        const pits = [];
+        const discs = [];
+        const flakes = [];
+        const shown = [];
+        for (const id of view.parts) {
+          const part = structure.byId.get(id), units2 = specOf(id).units, chips = view.chips.get(id), opening = view.openings.get(id), spalls = view.spalls.get(id);
+          const all = cells(part, units2);
+          const thick = mask.alongU ? part.aabb[3] - part.aabb[1] : part.aabb[2] - part.aabb[0];
+          const mid = mask.alongU ? (part.aabb[1] + part.aabb[3]) / 2 : (part.aabb[0] + part.aabb[2]) / 2;
+          if (opening) discs.push({ s: along(opening.center), y: opening.center[1], r: opening.radius });
+          for (const k of spalls) flakes.push({ s: along(k.center), y: k.center[1], r: k.radius });
+          const boxes = chips.map((k) => ({ s0: along(k.center) - k.along, s1: along(k.center) + k.along, y0: k.center[1] - k.up, y1: k.center[1] + k.up }));
+          const gone = (c) => covered(c, boxes.filter((k) => k.s1 > c.a && k.s0 < c.b && k.y1 > c.y0 && k.y0 < c.y1)) >= 0.9 || opening && Math.hypot((c.a + c.b) / 2 - along(opening.center), (c.y0 + c.y1) / 2 - opening.center[1]) < opening.radius;
+          const kept = [];
+          for (const c of all) (gone(c) ? holes : kept).push(c);
+          for (const c of kept) shown.push({ c, part, units: units2, thick, mid });
+          for (const k of boxes) {
+            if (holes.some((h) => k.s0 >= h.a - 1e-4 && k.s1 <= h.b + 1e-4 && k.y0 >= h.y0 - 1e-4 && k.y1 <= h.y1 + 1e-4)) continue;
+            pits.push({ s: (k.s0 + k.s1) / 2, y: (k.y0 + k.y1) / 2, rs: (k.s1 - k.s0) / 2, ry: (k.y1 - k.y0) / 2 });
+          }
+        }
+        const reach = SPALL_MIN + SPALL_RAGGED;
+        const ragged = (s, y) => 0.6 * noise2(s, y, 0.03) + 0.4 * noise2(s + 7.3, y - 3.1, 0.011);
+        mask.data.fill(0);
+        core.data.fill(0);
+        const stamp = (m, s0, s1, y0, y1, inside2) => {
+          const i0 = Math.max(0, Math.floor((s0 - reach) / m.len * m.w)), i1 = Math.min(m.w - 1, Math.ceil((s1 + reach) / m.len * m.w));
+          const j0 = Math.max(0, Math.floor((y0 - reach - m.y0) / m.height * m.h)), j1 = Math.min(m.h - 1, Math.ceil((y1 + reach - m.y0) / m.height * m.h));
+          for (let j = j0; j <= j1; j++) {
+            const y = m.y0 + (j + 0.5) / m.h * m.height;
+            for (let i = i0; i <= i1; i++) {
+              const s = (i + 0.5) / m.w * m.len;
+              if (inside2(s, y)) m.data[j * m.w + i] = 255;
+            }
+          }
+        };
+        const plaster = (d, s, y) => d <= SPALL_MIN + SPALL_RAGGED * ragged(s, y);
+        for (const c of holes) stamp(mask, c.a, c.b, c.y0, c.y1, (s, y) => plaster(boxDistance(s, y, c.a, c.b, c.y0, c.y1), s, y));
+        for (const d of discs) stamp(mask, d.s - d.r, d.s + d.r, d.y - d.r, d.y + d.r, (s, y) => plaster(Math.max(0, Math.hypot(s - d.s, y - d.y) - d.r), s, y));
+        for (const f of flakes) {
+          const rough = (s, y) => Math.hypot(s - f.s, y - f.y) - f.r * (0.65 + 0.7 * ragged(s * 2.3, y * 2.3));
+          stamp(mask, f.s - 2 * f.r, f.s + 2 * f.r, f.y - 2 * f.r, f.y + 2 * f.r, (s, y) => rough(s, y) <= 0);
+        }
+        for (const p of pits) {
+          stamp(mask, p.s - p.rs, p.s + p.rs, p.y - p.ry, p.y + p.ry, (s, y) => plaster(Math.max(0, ellipseDistance(s, y, p.s, p.y, p.rs, p.ry)), s, y));
+          stamp(core, p.s - p.rs, p.s + p.rs, p.y - p.ry, p.y + p.ry, (s, y) => ellipseDistance(s, y, p.s, p.y, p.rs, p.ry) <= -0.35 * Math.min(p.rs, p.ry) * noise2(s * 1.7, y * 1.3, 0.012));
+        }
+        mask.texture.needsUpdate = true;
+        core.texture.needsUpdate = true;
+        const near = (c) => holes.some((h) => boxDistance((c.a + c.b) / 2, (c.y0 + c.y1) / 2, h.a - (c.b - c.a) / 2, h.b + (c.b - c.a) / 2, h.y0 - (c.y1 - c.y0) / 2, h.y1 + (c.y1 - c.y0) / 2) <= reach) || discs.some((d) => boxDistance(d.s, d.y, c.a, c.b, c.y0, c.y1) <= d.r + reach) || pits.some((p) => boxDistance(p.s, p.y, c.a, c.b, c.y0, c.y1) <= Math.max(p.rs, p.ry) + reach) || flakes.some((f) => boxDistance(f.s, f.y, c.a, c.b, c.y0, c.y1) <= 2 * f.r);
+        const list2 = [];
+        const tone = (hex2, k) => tmp.c.setHex(hex2).multiplyScalar(k).getHex();
+        for (const { c, part, units: units2, thick, mid } of shown) {
+          if (!near(c)) continue;
+          const centre = mask.start + (c.a + c.b) / 2, y = (c.y0 + c.y1) / 2, len = c.b - c.a, h = c.y1 - c.y0;
+          const at = (s, dy, d, colour) => list2.push({ x: mask.alongU ? centre : mid, y, z: mask.alongU ? mid : centre, sx: mask.alongU ? s : d, sy: dy, sz: mask.alongU ? d : s, colour });
+          const base = fragmentMaterial(part.material).color.getHex();
+          const n = noise2(centre * 3.1, y * 2.7, 0.07);
+          if (units2.mortar === "concrete") {
+            at(len, h, thick - 2 * COVER2, tone(base, 0.9 + 0.04 * n));
+          } else {
+            at(len, h, thick - 2 * COVER2 - 0.012, 10327948);
+            at(len - 0.012, h - 0.012, thick - 2 * COVER2, tone(base, 0.8 + 0.35 * n));
+          }
+        }
+        if (view.units) {
+          view.units.removeFromParent();
+          view.units.dispose();
+        }
+        const units = new THREE.InstancedMesh(unitGeometry, view.unitMaterial, Math.max(1, list2.length));
+        units.name = "breach:" + view.host;
+        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));
+          units.setMatrixAt(i, tmp.m);
+          units.setColorAt(i, tmp.c.setHex(u.colour));
+        });
+        units.count = list2.length;
+        units.instanceMatrix.needsUpdate = true;
+        if (units.instanceColor) units.instanceColor.needsUpdate = true;
+        units.castShadow = true;
+        units.receiveShadow = true;
+        units.visible = lod === 0;
+        house.add(units);
+        view.units = units;
+        view.gone = holes.length;
+        view.pits = pits.length;
+        view.flakes = flakes.length;
+      }
+      function chipBox(chip, alongU) {
+        house.updateMatrixWorld(true);
+        const q = tmp.q.set(chip.rotation[0], chip.rotation[1], chip.rotation[2], chip.rotation[3]).premultiply(house.getWorldQuaternion(new THREE.Quaternion()).invert());
+        let a = 0, u = 0;
+        for (let k = 0; k < 3; k++) {
+          const axis = tmp.p.set(k === 0 ? 1 : 0, k === 1 ? 1 : 0, k === 2 ? 1 : 0).applyQuaternion(q);
+          a += Math.abs(alongU ? axis.x : axis.z) * chip.size[k] / 2;
+          u += Math.abs(axis.y) * chip.size[k] / 2;
+        }
+        return { center: local(chip.center), along: a, up: u };
+      }
       function draw2(partId, change) {
         if (lod !== 0) return false;
         const hostId = hostOf(partId);
@@ -19673,40 +19999,50 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const items = structure.meshesOf(hostId).filter((it) => it.mesh);
           if (!items.length) return false;
           const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
-          view = { mesh: null, saved: null, items, paint: wallColour(items), units: 0, opening: null, chips: new Map(parts.map((id) => [id, []])), openings: /* @__PURE__ */ new Map() };
+          if (!parts.includes(partId)) return false;
+          const mask = maskOf(hostId, parts), core = maskOf(hostId, parts);
+          view = {
+            host: hostId,
+            parts,
+            items,
+            mask,
+            core,
+            unitMaterial: unitsMaterial(core),
+            shells: [],
+            saved: null,
+            units: null,
+            gone: 0,
+            pits: 0,
+            chips: new Map(parts.map((id) => [id, []])),
+            spalls: new Map(parts.map((id) => [id, []])),
+            openings: /* @__PURE__ */ new Map(),
+            flakes: 0
+          };
         }
         if (!view.chips.has(partId)) return false;
         if (change.opening) {
           if (view.openings.has(partId)) return false;
           view.openings.set(partId, { center: local(change.opening.center), radius: change.opening.radius });
-          if (partId === hostId) view.opening = view.openings.get(partId);
         }
-        if (change.chip) view.chips.get(partId).push(local(change.chip));
-        const list2 = [];
-        for (const [id, chips] of view.chips) list2.push(...courses(structure.byId.get(id), specOf(id).units, view.openings.get(id) ?? null, chips, view.paint));
-        if (view.mesh) {
-          view.mesh.removeFromParent();
-          view.mesh.dispose();
+        if (change.chip) view.chips.get(partId).push(chipBox(change.chip, view.mask.alongU));
+        if (change.spall) {
+          const list2 = view.spalls.get(partId);
+          list2.push({ center: local(change.spall.center), radius: change.spall.radius });
+          if (list2.length > MAX_FLAKES) list2.shift();
+        }
+        if (!view.saved) {
+          view.shells = view.items.map((it) => shell(it, view.mask));
+          for (const m of view.shells) m.userData.behind = () => view.units;
+          view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
         }
-        const mesh2 = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list2.length));
-        mesh2.name = "breach:" + hostId;
-        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);
-          mesh2.setColorAt(i, tmp.c.setHex(u.colour));
-        });
-        mesh2.count = list2.length;
-        mesh2.instanceMatrix.needsUpdate = true;
-        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
-        mesh2.castShadow = true;
-        mesh2.receiveShadow = true;
-        house.add(mesh2);
-        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(hostId, view);
-        invalidate();
-        invalidateShadow();
+        if (opts.deferPaint && change.spall) dirty.add(view);
+        else {
+          dirty.delete(view);
+          paint(view);
+          invalidate();
+          invalidateShadow();
+        }
         return true;
       }
       function plain2(view, shown) {
@@ -19715,30 +20051,88 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           else s.data = collapseRange(s.it.mesh, s.v0, s.it.v1);
         }
       }
+      function flush(budgetMs = paintBudgetMs) {
+        if (dirty.size === 0) return 0;
+        const deadline = performance.now() + budgetMs;
+        for (const view of dirty) {
+          dirty.delete(view);
+          paint(view);
+          if (performance.now() >= deadline) break;
+        }
+        invalidate();
+        invalidateShadow();
+        return dirty.size;
+      }
+      function dispose(view) {
+        dirty.delete(view);
+        if (view.units) {
+          view.units.removeFromParent();
+          view.units.dispose();
+        }
+        view.unitMaterial.dispose();
+        for (const m of view.shells) {
+          m.removeFromParent();
+          m.geometry.dispose();
+          m.material.dispose();
+        }
+        view.mask.texture.dispose();
+        view.core.texture.dispose();
+      }
       return {
-        /** Handles a `stage` event of the house's object. Returns true when the wall was redrawn as courses. */
+        /** Handles a `stage` event of the house's object. Returns true when the wall was cut. */
         stage(event) {
           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. */
+        /**
+         * Handles a `spall` of a wall of units: the coat comes off in a ragged patch and the units show under it, drawn by the house (the destruction
+         * renderer leaves its flat patch out on the meshes `claim` marked). Returns true when the wall was cut.
+         */
+        spall(event) {
+          const r = Math.sqrt(Math.max(0, event.area) / Math.PI);
+          return r > 0 ? draw2(event.part, { spall: { center: event.point, radius: r } }) : false;
+        },
+        /**
+         * Marks the meshes that draw a wall of units as drawing its spalls itself (`userData.drawnSpalls`, the part ids): the destruction renderer then
+         * throws the bits and leaves its patch out. Call it once the spec is known.
+         */
+        claim() {
+          var _a;
+          for (const q of opts.spec()?.parts ?? []) {
+            if (!q.units) continue;
+            const host = hostOf(q.id);
+            if (!host) continue;
+            for (const it of structure.meshesOf(host)) {
+              if (!it.mesh) continue;
+              const list2 = (_a = it.mesh.userData).drawnSpalls ?? (_a.drawnSpalls = []);
+              if (!list2.includes(q.id)) list2.push(q.id);
+            }
+          }
+        },
+        /**
+         * Handles a `chip` event: what came out (a unit, or a crater a shot broke through one) leaves a hole in the wall where it was; a `torn` chip (what a blow
+         * tore off a face) leaves the marks the renderer drew. Returns true when the wall was cut.
+         */
         chip(event) {
-          return draw2(event.part, { chip: event.center });
+          if (event.torn) return false;
+          return draw2(event.part, { chip: { center: event.center, size: event.size ?? [0, 0, 0], rotation: event.rotation ?? [0, 0, 0, 1] } });
         },
-        /** The part broke or fell: the courses go (the plain range stays collapsed, the renderer hides the part). */
+        /** The part broke or fell: its damage goes (the plain range stays collapsed, the renderer hides the part). */
         drop(partId) {
           const v = views.get(partId);
           if (!v) return;
-          v.mesh.removeFromParent();
-          v.mesh.dispose();
+          dispose(v);
           views.delete(partId);
+          if (v.saved) dropped.push(v);
         },
-        /** LOD 0 draws the courses; LOD 1 and 2 give the wall its box back. */
+        /** LOD 0 draws the cut wall; LOD 1 and 2 give the wall its box back. */
         setLod(level) {
+          flush(Infinity);
           const was = lod;
           lod = level;
           if (was === 0 === (level === 0)) return;
           for (const v of views.values()) {
-            v.mesh.visible = level === 0;
+            v.units.visible = level === 0;
+            for (const m of v.shells) m.visible = level === 0;
             plain2(v, level !== 0);
           }
           invalidate();
@@ -19747,23 +20141,33 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         /** Everything back to what it was (after `world.reset`). */
         restore() {
           for (const v of views.values()) {
-            v.mesh.removeFromParent();
-            v.mesh.dispose();
+            dispose(v);
             if (lod === 0) plain2(v, true);
           }
           views.clear();
+          for (const v of dropped) plain2(v, true);
+          dropped.length = 0;
         },
-        /** The wall's opening, if it has courses. */
+        flush,
+        /** The wall has damage drawn. */
         has(partId) {
           return views.has(partId);
         },
-        statistics: () => ({ walls: views.size, units: [...views.values()].reduce((n, v) => n + v.units, 0) })
+        /** Walls with damage drawn, units out of them, craters shots broke through units that stay, and units laid bare at the edge of the cuts. */
+        statistics: () => (flush(Infinity), {
+          walls: views.size,
+          gone: [...views.values()].reduce((n, v) => n + v.gone, 0),
+          craters: [...views.values()].reduce((n, v) => n + v.pits, 0),
+          flakes: [...views.values()].reduce((n, v) => n + v.flakes, 0),
+          units: [...views.values()].reduce((n, v) => n + v.units.count, 0)
+        })
       };
     }
     Object.assign(K, { createBreachView });
   }
 
   // src/destruction/world.ts
+  var FOLLOW_FLUSH_FALLBACK_MS = 100;
   function installDestructionWorld(K, shared) {
     const { THREE, cfg, invalidateShadow, invalidate, rngString, FRAGMENT_GEO, fragmentMaterial, createBreachView } = K;
     function createHouseDestruction(root, house, structure, parts, colliders, water) {
@@ -19772,7 +20176,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const R = cfg.destructionRenderer || null, listeners = /* @__PURE__ */ new Set();
       D.renderer = R;
       D.spec = null;
-      const breach = createBreachView({ house, structure, spec: () => D.spec });
+      const breach = createBreachView({ house, structure, spec: () => D.spec, deferPaint: true, ...cfg.breachPaintBudgetMs !== void 0 ? { paintBudgetMs: cfg.breachPaintBudgetMs } : {} });
       D.breach = breach;
       D.onEvent = (fn) => {
         listeners.add(fn);
@@ -19957,6 +20361,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           case "chip":
             breach.chip(e);
             break;
+          case "spall":
+            breach.spall(e);
+            break;
           case "collapse":
             for (const id of e.parts) {
               breach.drop(id);
@@ -19998,7 +20405,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         D.specOptions = specOptions || null;
         D.spec = structure.spec(specOptions);
         D.id = D.world.add(D.spec, { id: "house3d:" + ++shared.destructionSeq, position: [p.x, p.y, p.z], rotation: [q.x, q.y, q.z, q.w] });
-        if (R) R.bind(D.id, house, { parts: rangesOf() });
+        breach.claim();
+        if (R) R.bind(D.id, house, { parts: rangesOf(), onFrame: () => breach.flush() });
         off = D.world.on("*", handleEvent);
         D.active = true;
         return D;
@@ -20013,6 +20421,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       D.follow = (world, id, spec) => {
         D.spec = spec;
+        breach.claim();
+        let fallback = null;
         const offFollow = world.on("*", (e) => {
           if (e.object !== id) return;
           switch (e.type) {
@@ -20022,6 +20432,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             case "chip":
               breach.chip(e);
               break;
+            case "spall":
+              breach.spall(e);
+              break;
             case "fracture":
               breach.drop(e.part);
               break;
@@ -20031,10 +20444,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             default:
               break;
           }
+          if (!fallback && typeof setTimeout === "function") fallback = setTimeout(() => {
+            fallback = null;
+            breach.flush(Infinity);
+          }, FOLLOW_FLUSH_FALLBACK_MS);
         });
         return { restore: () => breach.restore(), dispose: () => {
           offFollow();
           breach.restore();
+        }, update: () => {
+          breach.flush();
         } };
       };
       D.piece = (id) => D.active ? D.world.part(D.id, id) : null;
@@ -20067,6 +20486,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return r;
       };
       D.animate = (dt) => {
+        breach.flush();
         if (R) return;
         let moved = false;
         for (const [id, list2] of bodies) {
@@ -21531,6 +21951,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         houseRenderer = create3(THREE, {
           locale,
           lod: { interior: 10, hide: 40 },
+          breachPaintBudgetMs: 4,
           ...options.house,
           quality: settings.quality,
           ...options.world ? { destruction: options.world } : {},
@@ -21686,9 +22107,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         host?.log(text.steps.no_door);
         return;
       }
-      p.house.interact(eyeOf(p));
+      const fo = target.target;
+      const reach = fo && host?.reachFor && fo.type === "swing" && fo.gs?.[0] && fo.handles?.[0] ? doorReach(p, fo) : null;
+      if (reach && host?.reachFor) {
+        host.reachFor({ ...reach, onGrip: () => void p.house.toggleDoor(fo) });
+      } else p.house.interact(eyeOf(p));
       host?.log(fill(text.steps.door, { text: String(target.text) }));
     };
+    const doorReach = (p, fo) => {
+      const g = fo.gs[0];
+      const pivot = fo.handles[0].pivot;
+      const at = (angle) => {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const v = new THREE.Vector3(pivot[0] * c + pivot[2] * s, pivot[1], -pivot[0] * s + pivot[2] * c).add(g.position);
+        return g.parent ? g.parent.localToWorld(v) : v;
+      };
+      const camera = host?.camera;
+      const eye = new THREE.Vector3(camera.position.x, 0, camera.position.z);
+      const flat = (v) => Math.hypot(v.x - eye.x, v.z - eye.z);
+      const closed = at(0);
+      const open = at(fo.rot);
+      const opening = !fo.open;
+      return {
+        handle: () => {
+          g.updateMatrixWorld(true);
+          return g.localToWorld(new THREE.Vector3(pivot[0], pivot[1], pivot[2])).toArray();
+        },
+        hinge: () => g.getWorldPosition(new THREE.Vector3()).toArray(),
+        seconds: fo.locked || fo.blockedFlag ? 0.6 : 0.55,
+        pull: opening ? flat(open) <= flat(closed) : flat(closed) <= flat(open),
+        locked: !!(fo.locked || fo.blockedFlag)
+      };
+    };
     const strike = () => {
       const world = options.world;
       if (!world || !host) return;