@adatechnology/game-floorplan-three 0.5.0 → 0.7.0

package/dist/index.global.js

@@ -11268,7 +11268,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     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);
+    if (inp.style === "snap") {
+      for (const b of bsp(band, Math.max(3, Math.min(6, inp.maxFragments - out.length)), [0, 1, 2], inp.rnd)) out.push({ center: b.c, size: b.s, q: quat.identity(), shape: "chunk", weight: b.s[0] * b.s[1] * b.s[2] });
+    } else 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) => {
@@ -11299,6 +11301,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const t = sorted[0];
     const [u, v] = [sorted[1], sorted[2]].sort((a, b) => a - b);
     if (style === "snap") {
+      if (inp.cut) return severAt(inp, root, inp.cut.at, inp.cut.gap);
       const n2 = Math.min(maxFragments, 2 + Math.floor(rnd() * 3));
       for (const b of bsp(root, n2, [0, 1, 2], rnd)) out.push({ center: b.c, size: b.s, q: idq, shape: "slab", weight: b.s[0] * b.s[1] * b.s[2] });
       return out;
@@ -11472,6 +11475,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     for (const x of spread(dims[u], COVER, spacing, MAX_BARS_PER_DIRECTION)) out.push(bar(v, dims[v] / 2 - 0.02, [[u, x], [thin, 0]]));
     return out;
   };
+  var clipBarsToBox = (bars, u, v, center, size) => {
+    const out = [];
+    for (const [a, b] of bars) {
+      const axis = a[u] !== b[u] ? u : v;
+      const other = axis === u ? v : u;
+      if (Math.abs(a[other] - center[other]) > size[other] / 2) continue;
+      const lo = Math.max(Math.min(a[axis], b[axis]), center[axis] - size[axis] / 2), hi = Math.min(Math.max(a[axis], b[axis]), center[axis] + size[axis] / 2);
+      if (hi - lo < 1e-6) continue;
+      const p = [a[0], a[1], a[2]], q = [b[0], b[1], b[2]];
+      p[axis] = lo;
+      q[axis] = hi;
+      out.push([p, q]);
+    }
+    return out;
+  };
+  var bendBar = ([a, b], thin, bow, i) => {
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    const m = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2];
+    m[thin] += (i % 2 === 0 ? 1 : -1) * bow * length;
+    return [[a, m], [m, b]];
+  };
   var clipBarsToDisc = (bars, u, v, center, radius) => {
     const out = [];
     for (const [a, b] of bars) {
@@ -12392,14 +12416,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14730131
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 1e5
+      compressive: 1e5,
+      hits: {
+        blunt: {
+          tear: "splinters",
+          tearJoules: 60
+        }
+      }
     },
     {
       id: "wood_hard",
@@ -12429,14 +12460,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 13213802
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 15e4
+      compressive: 15e4,
+      hits: {
+        blunt: {
+          tear: "splinters",
+          tearJoules: 150
+        }
+      }
     },
     {
       id: "plywood",
@@ -12466,14 +12504,24 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14862234
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 6e4
+      compressive: 6e4,
+      hits: {
+        ballistic: {
+          tear: "splinters"
+        },
+        blunt: {
+          tear: "splinters",
+          tearJoules: 80
+        }
+      }
     },
     {
       id: "mdf",
@@ -12500,14 +12548,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         smoke: "grey"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 12096362
       },
       tags: [
         "wood",
         "organic",
         "flammable"
       ],
-      compressive: 3e4
+      compressive: 3e4,
+      hits: {
+        ballistic: {
+          tear: "lumps",
+          tearJoules: 120
+        },
+        blunt: {
+          tear: "lumps",
+          tearJoules: 20
+        }
+      }
     },
     {
       id: "glass",
@@ -12621,8 +12680,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       damageScale: {
         explosive: 1.2
       },
+      hits: {
+        ballistic: {
+          unitJoules: 500,
+          floor: 900,
+          crater: true
+        },
+        blunt: {
+          unitJoules: 1500,
+          floor: 60
+        }
+      },
       hitDebris: "chips",
       breakDebris: "dust",
+      visual: { innerColor: 10197652 },
       thermal: {
         conductivity: 0.15,
         heatCapacity: 2.5
@@ -12653,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
@@ -12683,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
@@ -12708,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
@@ -12989,7 +13063,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         smoke: "white"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14207126
       },
       tags: [
         "plant",
@@ -12997,7 +13072,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         "organic",
         "flammable"
       ],
-      compressive: 6e4
+      compressive: 6e4,
+      hits: {
+        blunt: {
+          tear: "none"
+        }
+      }
     },
     {
       id: "cactus",
@@ -13112,6 +13192,130 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         "masonry"
       ],
       compressive: 2e4
+    },
+    {
+      id: "asphalt",
+      density: 2350,
+      hpPerKg: 10,
+      penetration: 14,
+      penetrationClass: "concrete",
+      penetrationScale: 0.8,
+      ductility: 0.1,
+      fracture: "crumble",
+      fragmentSize: [
+        0.03,
+        0.15
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2,
+        ignitionC: 400,
+        burnRate: 2e-3,
+        smoke: "black"
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 3e4
+    },
+    {
+      id: "sand",
+      density: 1600,
+      hpPerKg: 2,
+      penetration: 6,
+      ductility: 0.4,
+      fracture: "crumble",
+      fragmentSize: [
+        0.01,
+        0.04
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2
+      },
+      tags: [
+        "soil"
+      ],
+      compressive: 1e4
+    },
+    {
+      id: "gravel",
+      density: 1800,
+      hpPerKg: 3,
+      penetration: 8,
+      ductility: 0.3,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.06
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2
+      },
+      tags: [
+        "soil",
+        "masonry"
+      ],
+      compressive: 2e4
+    },
+    {
+      id: "turf",
+      density: 900,
+      hpPerKg: 3,
+      penetration: 4,
+      ductility: 0.5,
+      fracture: "crumble",
+      fragmentSize: [
+        0.03,
+        0.1
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 1.5,
+        ignitionC: 250,
+        burnRate: 0.03,
+        smoke: "white"
+      },
+      tags: [
+        "soil",
+        "organic"
+      ],
+      compressive: 15e3
+    },
+    {
+      id: "mortar",
+      density: 1900,
+      hpPerKg: 10,
+      penetration: 12,
+      penetrationClass: "concrete",
+      penetrationScale: 1.2,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.08
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 1e5
     }
   ];
   var material_hints_default = {
@@ -13285,6 +13489,32 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return (1 + 4 * (0.3 - ductility) / 0.3) * Math.min(25, Math.max(1, (0.02 / Math.max(thickness, 1e-4)) ** 2));
   };
   var THIN_SHEET_DISHING = 5e-3;
+  var SWEEP_BACK = 0.01;
+  function sweepOrigins(box3, d, spacing) {
+    const origins = [];
+    const line = (from, to) => {
+      const n = Math.max(1, Math.ceil((to - from) / spacing));
+      return Array.from({ length: n + 1 }, (_, i) => from + (to - from) * i / n);
+    };
+    for (const axis of [0, 1, 2]) {
+      if (Math.abs(d[axis]) < 1e-3) continue;
+      const lead = d[axis] > 0 ? box3.max[axis] - SWEEP_BACK : box3.min[axis] + SWEEP_BACK;
+      const u = (axis + 1) % 3;
+      const v = (axis + 2) % 3;
+      for (const a of line(box3.min[u], box3.max[u])) {
+        for (const b of line(box3.min[v], box3.max[v])) {
+          const point = [0, 0, 0];
+          point[axis] = lead;
+          point[u] = a;
+          point[v] = b;
+          origins.push(point);
+        }
+      }
+    }
+    return origins;
+  }
+  var THIN_SHEET_CRUSH = 5e-4;
+  var THIN_SHEET_CONTACT = 0.025;
   var DMG_PER_J = 0.02;
   var BLAST_COUPLING = 0.1;
   var SHELTER_DEFAULTS = { k: 2800, brokenTransmission: 0.5, minPath: 5e-3 };
@@ -13301,11 +13531,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var SEVER_BAND = 0.1;
   var SEVER_ASPECT = 3;
   var SEVER_BALLISTIC = 2;
+  var TEAR_JOULES = 150;
+  var tears = 0;
   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 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));
@@ -13315,8 +13549,24 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return v === void 0 ? void 0 : v * (mat.penetrationScale ?? 1);
   };
   var capacityScale = (p) => {
-    if (p.st.stripped) return p.spec.reinforcement?.residualCapacity ?? RESIDUAL_CAPACITY;
-    return p.rt.removed ? Math.max(0.05, 1 - p.rt.removed / p.mass0) : 1;
+    const residual = p.spec.reinforcement?.residualCapacity ?? RESIDUAL_CAPACITY;
+    if (p.st.stripped) return residual;
+    const kept = Math.min(p.rt.removed ? 1 - p.rt.removed / p.mass0 : 1, 1 - sectionLoss(p));
+    return Math.max(p.spec.reinforcement ? residual : 0.05, kept);
+  };
+  var sectionLoss = (p) => {
+    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 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];
+      worst = Math.max(worst, gone / Math.max(p.dims[across], 1e-6));
+    }
+    return Math.min(1, worst);
   };
   var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
   var clone = (v) => structuredClone(v);
@@ -14416,7 +14666,7 @@ 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]) });
@@ -14457,7 +14707,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;
@@ -14465,7 +14721,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;
@@ -14494,7 +14750,13 @@ 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) => {
+      markDamaged(p);
+      emit({ ...base(o, src), type: "spall", part: p.spec.id, layer: -1, point: wp, area: Math.PI * radius * radius });
+      debris(o, p, p.mat.breakDebris, wp, normal, 6, 1.5, src);
       setStage(o, p, 1, {}, src);
     };
     const insideOpening = (o, p, objectPoint) => {
@@ -14573,9 +14835,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       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) => {
+    const chipUnits = (o, p, kind, wp, hitEnergy, 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;
+      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;
+      const energy = hitEnergy - (rule?.floor ?? 0);
+      if (perKg <= 0 || energy <= 0) return;
       const [u, v] = planeAxes(p.thin);
       const lp = toLocal(p.pos, p.q, objLocal(o, wp));
       const grid = gridOf(p);
@@ -14589,7 +14855,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         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) {
+        if (total < perKg * mass) {
           worn[i] = total;
           continue;
         }
@@ -14614,7 +14880,32 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         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);
       }
+      if (p.spec.reinforcement) exposeRebar(o, p, src);
       for (const cell of out) addBreach(o, p, toWorld(c, q, cell.center), cell.size[u] * cell.size[v], energy, dir, src);
+      if (p.structural && !isLost(p)) {
+        solveStructure(o);
+        collapseCheck(o, src);
+      }
+    };
+    const exposeRebar = (o, p, src) => {
+      const r = p.spec.reinforcement;
+      if (!r) return;
+      const [u, v] = planeAxes(p.thin);
+      const all = rebarBars(p.dims, p.thin, r.spacing);
+      let bars;
+      if (p.st.stripped) bars = all;
+      else {
+        bars = [];
+        for (const cell of p.st.chipped ?? []) bars.push(...clipBarsToBox(all, u, v, cell.center, cell.size));
+        const op = p.st.opening;
+        if (op) {
+          const lc = toLocal(p.pos, p.q, op.center);
+          bars.push(...clipBarsToDisc(all, u, v, [lc[u], lc[v]], op.radius + 0.05));
+        }
+      }
+      const bow = clamp2(((p.st.stress ?? 0) - 1) / 0.5, 0, 1);
+      if (bow > 0) bars = bars.flatMap((bar2, i) => bendBar(bar2, p.thin, bow * BAR_BOW, i));
+      emit({ ...base(o, src), type: "expose", part: p.spec.id, bars: worldBars(o, p, bars) });
     };
     const openBreach = (o, p, center, total, energy, dir, src) => {
       const [u, v] = planeAxes(p.thin);
@@ -14642,10 +14933,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       setStage(o, p, 2, { opening: { center: worldCenter, radius }, fragments }, src);
       debris(o, p, p.mat.breakDebris, worldCenter, vec.scale(dir ?? [0, 1, 0], -1), 14, 3, src);
       const reinforcement = p.spec.reinforcement;
-      if (reinforcement) {
-        const bars = worldBars(o, p, clipBarsToDisc(rebarBars(p.dims, p.thin, reinforcement.spacing), u, v, [lc[u], lc[v]], radius + 0.05));
-        if (bars.length > 0) emit({ ...base(o, src), type: "expose", part: p.spec.id, bars });
-      }
+      if (reinforcement) exposeRebar(o, p, src);
       if (p.structural) solveStructure(o);
     };
     const stripPart = (o, p, reinforcement, src) => {
@@ -14657,8 +14945,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       p.st.burning = false;
       p.rt.jet = false;
       markDamaged(p);
-      emit({ ...base(o, src), type: "expose", part: p.spec.id, bars: worldBars(o, p, bars) });
       solveStructure(o);
+      exposeRebar(o, p, src);
       collapseCheck(o, src);
     };
     const unitFragmentPlan = (p, cap) => {
@@ -14712,7 +15000,7 @@ 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 axis = style === "splinter" || style === "snap" ? 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,
@@ -14784,7 +15072,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     const CHAIN_TRIGGER_OF = { ballistic: "shot", explosive: "explosion" };
     const severAxis = (p) => {
-      if (p.mat.fracture !== "splinter" || p.spec.shape.kind !== "box") return -1;
+      if (p.mat.fracture !== "splinter" && p.mat.fracture !== "snap" || 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;
@@ -14845,6 +15133,49 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     };
+    const tearOf = (mat, kind) => {
+      const h = mat.hits?.[kind];
+      const tear = h?.tear ?? (kind === "ballistic" && mat.penetrationClass === "wood" ? "splinters" : "none");
+      return { tear, joules: h?.tearJoules ?? TEAR_JOULES };
+    };
+    const tearAt = (o, p, kind, entry2, exit, d, E, scale, src) => {
+      const { tear, joules } = tearOf(p.mat, kind);
+      if (tear === "none") return;
+      const shot = kind === "ballistic";
+      const n = shot ? exit ? clamp2(Math.round(E / joules), 1, 7) : 1 : clamp2(Math.floor(E / joules), 0, 5);
+      if (n === 0) return;
+      const fibre = tear === "lumps";
+      const { q } = partXf(o, p);
+      const along = (p.spec.grain ? AXIS[p.spec.grain] : void 0) ?? [0, 1, 2].sort((a, b) => p.dims[b] - p.dims[a])[0];
+      const fragments = [];
+      for (let i = 0; i < n; i++) {
+        const back = !exit || i % 3 === 2;
+        const len = scale * (fibre ? 1.2 + 1.2 * rnd() : 3 + 4 * rnd()), w = scale * (0.8 + 0.8 * rnd()), t = scale * (fibre ? 0.7 + 0.6 * rnd() : 0.4 + 0.4 * rnd());
+        const size = [w, w, w];
+        size[along] = len;
+        size[(along + 1) % 3] = w;
+        size[(along + 2) % 3] = t;
+        const spread3 = [(rnd() - 0.5) * 0.8, (rnd() - 0.2) * 0.8, (rnd() - 0.5) * 0.8];
+        const speed = shot ? back ? 1.5 + 2 * rnd() : 2 + 4 * rnd() : 0.8 + 1.2 * rnd();
+        const v = vec.scale(vec.normalize(vec.add(back ? vec.scale(d, -1) : d, spread3)), speed);
+        const mass = size[0] * size[1] * size[2] * p.mat.density;
+        fragments.push({
+          id: `${p.spec.id}#t${tears++}-${i}`,
+          part: p.spec.id,
+          material: p.spec.material,
+          shape: fibre ? "chunk" : "splinter",
+          center: back || !exit ? vec.madd(entry2, d, -0.01) : vec.madd(exit, d, 0.01),
+          size,
+          rotation: q,
+          velocity: v,
+          inner: true,
+          angularVelocity: [(rnd() - 0.5) * 30, (rnd() - 0.5) * 30, (rnd() - 0.5) * 30],
+          mass
+        });
+      }
+      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 });
+    };
     const ballistic = (o, p, entry2, n, d, E, caliber, pathLen, src, round3 = {}) => {
       const mat = p.mat;
       const piercing = round3.piercing ?? 1;
@@ -14873,6 +15204,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return { penetrated: false, exitEnergy: 0, damage: dmg2 };
       }
       if (p.layers.length > 0) spallOuter(o, p, entry2, face, n, Math.max(0.03, caliber / 1e3 * 4), src);
+      else if (mat.hits?.ballistic?.crater) crater(o, p, entry2, n, clamp2(0.02 + Math.sqrt(E) * 15e-4, 0.02, 0.15), src);
       const brittle = mat.ductility < 0.3;
       const ratio = Ep / Math.max(thr, 1e-6);
       const crackLen = clamp2(0.03 + ratio * 0.2, 0.03, 0.8);
@@ -14905,9 +15237,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         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 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);
+      wearJoints(o, p, (penetrated ? thr : E) * 0.02, void 0, 0, src, true, BULLET_JOINT_SPAN);
+      const absorbed = penetrated && mat.ductility >= 0.5 && mat.fracture !== "tear" ? 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);
       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) => {
@@ -14915,14 +15249,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const thrMm = mat.penetration * p.thickness * 1e3;
       const fragile = kind === "blunt" ? fragility(mat.ductility, p.thickness) : 1;
       const Ec = E * fragile;
+      const sheet = mat.ductility >= 0.5 && p.thickness <= THIN_SHEET_CRUSH;
+      const fold = sheet ? Math.min(4, Math.sqrt(1e-3 / p.thickness)) : 1;
+      const patch = sheet ? Math.min(contactR, THIN_SHEET_CONTACT) : contactR;
       if (E > 0) {
         if (kind === "blunt") {
-          if (mat.ductility >= 0.5) addDent(o, p, point, n, Math.max(contactR, 0.015), clamp2(E * 1e-4, 1e-3, 0.06), src);
+          if (mat.ductility >= 0.5) addDent(o, p, point, n, Math.max(patch, 0.015), clamp2(E * 1e-4 * fold, 1e-3, sheet ? Math.min(0.06, Math.min(...p.dims) * 0.45) : 0.06), src);
           else if (mat.ductility < 0.3) {
             if (Ec >= 5) addCrack(o, p, point, n, clamp2(0.04 + Math.min(Ec, E * 6) * 8e-4, 0.04, 0.6), src);
           } else if (E >= thrMm * 0.2) addDent(o, p, point, n, Math.max(contactR, 0.015), clamp2(E * 6e-5, 1e-3, 0.04), src);
         } else if (mat.fracture === "tear") {
           addHole(o, p, point, n, clamp2(0.02 + E * 5e-4, 0.02, 0.3), true, void 0, src);
+        } else if (mat.ductility >= 0.3 && E >= thrMm) {
+          addHole(o, p, point, n, clamp2(contactR, 0.01, 0.08), true, void 0, src);
+          if (sheet) addDent(o, p, point, n, Math.max(patch * 0.6, 0.01), clamp2(E * 4e-5 * fold, 5e-4, 0.02), src);
         } else if (mat.ductility >= 0.5) {
           addDent(o, p, point, n, Math.max(contactR, 0.01), clamp2(E * 4e-5, 5e-4, 0.02), src);
         }
@@ -14935,7 +15275,8 @@ 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);
+      if (kind === "blunt") chipUnits(o, p, "blunt", point, E, d, Math.max(contactR, 0.03), src);
+      if (E > 0 && !isLost(p)) tearAt(o, p, kind, point, void 0, d, E, clamp2(contactR * 0.2, 6e-3, 0.02), src);
       return done;
     };
     const blastPart = (o, p, point, energy, radius, src, res, reachAt) => {
@@ -15514,6 +15855,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (p.rt.stressT <= 0) {
               p.rt.stressT = 0.5;
               emit({ ...base(o), type: "stress", part: p.spec.id, stress, load: p.st.load ?? 0 });
+              if (p.spec.reinforcement && (p.st.stripped || p.st.chipped?.length || p.st.opening)) exposeRebar(o, p);
             }
             applyDamage(o, p, overloadRate(stress) * p.st.maxHp * dt, "blunt", null, null, 5, 3);
           } else if (stress > 0.8 && p.mat.ductility < 0.3 && p.rt.stressT <= 0 && p.st.cracks.length < 6) {
@@ -15730,6 +16072,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const r = raycastInternal(origin, direction, maxDistance);
         return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
       },
+      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;
+        let best = null;
+        for (const origin of sweepOrigins(box3, d, options2.spacing ?? 0.2)) {
+          const r = raycastInternal(origin, d, distance2 + SWEEP_BACK, ignore);
+          if (!r || best && r.distance >= best.distance) continue;
+          best = { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: Math.max(0, r.distance - SWEEP_BACK) };
+        }
+        return best;
+      },
       shoot(origin, direction, energy, caliber, source, round3) {
         const extras = typeof round3 === "number" ? { piercing: round3 } : round3 ?? {};
         return withCollapses(run(() => {
@@ -18295,7 +18649,24 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return spec;
   };
-  var partSpecOf = (part, capacity, detailed) => detailed && part.assembly ? assemblySpec(part, capacity) : boxSpec(part, capacity);
+  var MEMBER_CAGE = { spacing: 0.1, diameter: 8e-3, unit: 0.1 };
+  var CAGED_ROLES = /* @__PURE__ */ new Set(["beam", "column"]);
+  var caged = (spec, part, rebar) => {
+    if (!rebar || part.material !== "concrete" || !CAGED_ROLES.has(part.role) || spec.reinforcement) return spec;
+    const size = spec.shape.kind === "box" ? spec.shape.size : null;
+    if (!size) return spec;
+    const thin = Math.min(...size);
+    return {
+      ...spec,
+      reinforcement: { material: rebar, spacing: MEMBER_CAGE.spacing, diameter: MEMBER_CAGE.diameter },
+      units: { size: [MEMBER_CAGE.unit, MEMBER_CAGE.unit, thin], bond: "stack", mortar: "concrete" }
+    };
+  };
+  var partSpecOf = (part, capacity, detailed, rebar) => {
+    if (detailed && part.assembly) return assemblySpec(part, capacity);
+    const spec = boxSpec(part, capacity);
+    return detailed ? caged(spec, part, rebar) : spec;
+  };
   function toDestructibleSpec(structure, options = {}) {
     const { safety = 0.65, redundancy = 0.97, safetyOthers = 0.45 } = options;
     const kept = structure.parts.filter((part) => !options.filter || options.filter(part));
@@ -18312,7 +18683,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const sizing = { safety, redundancy, safetyOthers };
     const sized = { ...panels, capacities: options.sized === false ? /* @__PURE__ */ new Map() : sizeCapacities(panels.parts, panels.supports, sizing) };
     const { parts, supports, capacities } = detail === "units" ? applyUnits(sized, structure) : sized;
-    const specs = parts.map((part) => partSpecOf(part, capacities.get(part.id), detail !== "coarse"));
+    const specs = parts.map((part) => partSpecOf(part, capacities.get(part.id), detail !== "coarse", structure.construction.frame.rebar));
     const margin = options.terrainMargin ?? TERRAIN_MARGIN;
     const x0 = Math.min(...parts.map((part) => part.aabb[0]));
     const z0 = Math.min(...parts.map((part) => part.aabb[1]));
@@ -19192,7 +19563,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (!pc || pc.unit) return sp;
             if (pc.role !== "wall" && pc.role !== "partition") {
               const def = getAssembly(pc.assembly || (pc.material === "concrete" && ["slab", "beam", "column", "stair"].includes(pc.role) ? "reinforced_concrete" : ""));
-              return def && def.reinforcement && !sp.reinforcement ? { ...sp, reinforcement: { ...def.reinforcement } } : sp;
+              const out = def && def.reinforcement && !sp.reinforcement ? { ...sp, reinforcement: { ...def.reinforcement } } : sp;
+              if (out.reinforcement && !out.units && pc.material === "concrete" && (pc.role === "beam" || pc.role === "column") && sp.shape.kind === "box") {
+                return { ...out, units: { size: [MEMBER_CAGE.unit, MEMBER_CAGE.unit, Math.min(...sp.shape.size)], bond: "stack", mortar: "concrete" } };
+              }
+              return out;
             }
             if (!pc.assembly) return sp;
             const [u0, v0, u1, v1] = pc.aabb, alongU = u1 - u0 >= v1 - v0;
@@ -19229,6 +19604,19 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     pos.array.set(saved, v0 * 3);
     pos.needsUpdate = true;
   }
+  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;
   function installDestructionBreach(K, _shared) {
     const { THREE, fragmentMaterial, invalidate, invalidateShadow } = K;
     function createBreachView(opts) {
@@ -19238,94 +19626,198 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       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);
+      function hostOf(partId) {
+        if (structure.meshesOf(partId).some((it) => it.mesh)) return partId;
+        const part = structure.byId.get(partId);
+        if (!part) return null;
+        for (const q of structure.parts) {
+          if (q.id !== partId && same(q.aabb, part.aabb) && Math.abs(q.y1 - part.y0) < 0.01 && structure.meshesOf(q.id).some((it) => it.mesh)) return q.id;
+        }
+        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.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 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));
+      function paint(view) {
+        const { mask } = view;
+        const along = (p) => (mask.alongU ? p[0] : p[2]) - mask.start;
+        const holes = [];
+        const discs = [];
+        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);
+          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 });
+          const gone = (c) => chips.some((p) => p[1] >= c.y0 && p[1] <= c.y1 && along(p) >= c.a && along(p) <= c.b) || 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 });
+        }
+        const reach = SPALL_MIN + SPALL_RAGGED;
+        mask.data.fill(0);
+        const stamp = (s0, s1, y0, y1, inside2) => {
+          const i0 = Math.max(0, Math.floor((s0 - reach) / mask.len * mask.w)), i1 = Math.min(mask.w - 1, Math.ceil((s1 + reach) / mask.len * mask.w));
+          const j0 = Math.max(0, Math.floor((y0 - reach - mask.y0) / mask.height * mask.h)), j1 = Math.min(mask.h - 1, Math.ceil((y1 + reach - mask.y0) / mask.height * mask.h));
+          for (let j = j0; j <= j1; j++) {
+            const y = mask.y0 + (j + 0.5) / mask.h * mask.height;
+            for (let i = i0; i <= i1; i++) {
+              const s = (i + 0.5) / mask.w * mask.len;
+              const edge = SPALL_MIN + SPALL_RAGGED * (0.6 * noise2(s, y, 0.03) + 0.4 * noise2(s + 7.3, y - 3.1, 0.011));
+              if (inside2(s, y) <= edge) mask.data[j * mask.w + i] = 255;
+            }
+          }
+        };
+        for (const c of holes) stamp(c.a, c.b, c.y0, c.y1, (s, y) => boxDistance(s, y, c.a, c.b, c.y0, c.y1));
+        for (const d of discs) stamp(d.s - d.r, d.s + d.r, d.y - d.r, d.y + d.r, (s, y) => Math.max(0, Math.hypot(s - d.s, y - d.y) - d.r));
+        mask.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);
+        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 - 0.03 * n, tone(base, 0.86 + 0.2 * 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, 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;
       }
       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;
-        let view = views.get(partId);
+        const hostId = hostOf(partId);
+        if (!hostId || !specOf(partId)?.units) return false;
+        let view = views.get(hostId);
         if (!view) {
-          const items = structure.meshesOf(partId).filter((it) => it.mesh);
+          const items = structure.meshesOf(hostId).filter((it) => it.mesh);
           if (!items.length) return false;
-          view = { mesh: null, saved: null, items, paint: wallColour(items), units: 0, opening: null, chips: [] };
+          const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
+          if (!parts.includes(partId)) return false;
+          const mask = maskOf(hostId, parts);
+          view = { host: hostId, parts, items, mask, shells: [], saved: null, units: null, gone: 0, chips: new Map(parts.map((id) => [id, []])), openings: /* @__PURE__ */ new Map() };
         }
+        if (!view.chips.has(partId)) return false;
         if (change.opening) {
-          if (view.opening) return false;
-          view.opening = { center: local(change.opening.center), radius: change.opening.radius };
+          if (view.openings.has(partId)) return false;
+          view.openings.set(partId, { 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();
+        if (change.chip) view.chips.get(partId).push(local(change.chip));
+        if (!view.saved) {
+          view.shells = view.items.map((it) => shell(it, view.mask));
+          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:" + 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);
-          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(partId, view);
+        paint(view);
+        views.set(hostId, view);
         invalidate();
         invalidateShadow();
         return true;
@@ -19336,30 +19828,40 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           else s.data = collapseRange(s.it.mesh, s.v0, s.it.v1);
         }
       }
+      function dispose(view) {
+        view.units.removeFromParent();
+        view.units.dispose();
+        for (const m of view.shells) {
+          m.removeFromParent();
+          m.geometry.dispose();
+          m.material.dispose();
+        }
+        view.mask.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 `chip` event: the unit that came out leaves a hole in the wall where it was. Returns true when the wall was cut. */
         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). */
+        /** 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);
         },
-        /** 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) {
           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();
@@ -19368,17 +19870,21 @@ 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();
         },
-        /** The wall's opening, if it has courses. */
+        /** 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, and units laid bare at the edge of the cuts. */
+        statistics: () => ({
+          walls: views.size,
+          gone: [...views.values()].reduce((n, v) => n + v.gone, 0),
+          units: [...views.values()].reduce((n, v) => n + v.units.count, 0)
+        })
       };
     }
     Object.assign(K, { createBreachView });
@@ -21495,6 +22001,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return {
       id: FLOORPLAN_AREA_ID,
       name: text.name,
+      ground: { surface: "lawn" },
       group: text.group,
       get houses() {
         return placed;
@@ -22779,6 +23286,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
 
   // src/furniture/spec.ts
   var WOOD_THIN = 0.035;
+  var BOARD_TOP_THICK = 0.07;
+  var BOARD_TOP_WIDTH = 0.5;
+  var BOARD_WIDTH = 0.16;
   var SHELF_SPAN = 1.5;
   var SHELVING = /shelf|bookcase|rack/;
   function carcass(parts, drawn) {
@@ -22793,6 +23303,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       } else if (y <= x && y <= z) part.structure = { role: "beam", maxSpan: SHELF_SPAN * Math.max(x, z) };
     }
   }
+  function splitTopsIntoBoards(drawn, materialOf2, carcassed) {
+    const tops = /* @__PURE__ */ new Map();
+    if (carcassed) return tops;
+    for (let i = drawn.length - 1; i >= 0; i--) {
+      const p = drawn[i];
+      if (p.key !== "wood" || materialOf2.wood !== "wood_hard" || p.shape.kind !== "box" || p.rotation) continue;
+      const [sx, sy, sz] = p.shape.size;
+      const across = sx < sz ? 0 : 2;
+      const width = Math.min(sx, sz);
+      if (sy < WOOD_THIN || sy > BOARD_TOP_THICK || sy >= width || width < BOARD_TOP_WIDTH) continue;
+      const count = Math.round(width / BOARD_WIDTH);
+      const boards = [];
+      for (let b = 0; b < count; b++) {
+        const size = [sx, sy, sz];
+        size[across] = width / count;
+        const position = [...p.position];
+        position[across] += (b + 0.5) * size[across] - width / 2;
+        const min = [...p.min];
+        const max = [...p.max];
+        min[across] = position[across] - size[across] / 2;
+        max[across] = position[across] + size[across] / 2;
+        boards.push({ ...p, id: `${p.id}_b${b}`, shape: { kind: "box", size }, position, min, max, color: shadeBoard(p.color, b) });
+      }
+      drawn.splice(i, 1, ...boards);
+      tops.set(p.id, boards);
+    }
+    return tops;
+  }
+  function shadeBoard(color2, board) {
+    const k = [1, 0.94, 1.05, 0.97, 1.03][board % 5];
+    const channel = (shift) => Math.min(255, Math.round((color2 >> shift & 255) * k)) << shift;
+    return channel(16) | channel(8) | channel(0);
+  }
   var FLOOR_TOUCH = 5e-3;
   var LOOSE = /* @__PURE__ */ new Set(["paper"]);
   var BASE_MATERIAL = {
@@ -22870,10 +23413,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     run(A);
     if (!drawn.length) throw new Error(`game-floorplan-three: the builder of "${name}" drew no box or cylinder`);
+    const boardsOf = splitTopsIntoBoards(drawn, materialOf2, Boolean(opts.carcass));
     const parts = drawn.map((p) => {
       const thin = Math.min(...p.shape.kind === "box" ? p.shape.size : p.shape.kind === "cylinder" ? [p.shape.radius * 2, p.shape.height] : [p.shape.radius * 2]);
       let material = materialOf2[p.key] ?? "plastic";
-      if (p.key === "wood" && material === "wood_hard" && thin < WOOD_THIN) material = "wood_soft";
+      if (p.key === "wood" && material === "wood_hard" && opts.carcass && !opts.materials?.wood) material = "mdf";
+      else if (p.key === "wood" && material === "wood_hard" && thin < WOOD_THIN) material = "wood_soft";
       const part = { id: p.id, material, shape: p.shape, position: p.position };
       if (p.rotation) part.rotation = p.rotation;
       if (!LOOSE.has(material) && p.min[1] <= FLOOR_TOUCH) part.anchored = true;
@@ -22908,6 +23453,13 @@ 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] };
     }
+    for (const boards of boardsOf.values()) {
+      if (top && boards[0].max[1] <= top.y - 1e-6) continue;
+      const mid = boards[boards.length >> 1];
+      const min = [Math.min(...boards.map((b) => b.min[0])), Math.min(...boards.map((b) => b.min[2]))];
+      const max = [Math.max(...boards.map((b) => b.max[0])), Math.max(...boards.map((b) => b.max[2]))];
+      if ((max[0] - min[0]) * (max[1] - min[1]) >= 0.6 * footprint && mid.max[1] >= 0.2) top = { part: mid.id, y: mid.max[1], parts: boards.map((b) => b.id) };
+    }
     if (opts.carcass) carcass(parts, byId);
     const spec = { name, parts, joints, tags: ["furniture"] };
     const colors = new Map(drawn.map((p) => [p.id, p.color]));