@adatechnology/game-floorplan-structure 1.2.2 → 1.3.0

package/dist/index.global.js

@@ -32,6 +32,7 @@ var GameFloorplanStructure = (() => {
     FLAT_ROOF_DEFAULTS: () => FLAT_ROOF_DEFAULTS,
     GROUND: () => GROUND,
     MECHANICAL_DEFAULTS: () => MECHANICAL_DEFAULTS,
+    MEMBER_CAGE: () => MEMBER_CAGE,
     PILE_AREA: () => PILE_AREA,
     PILE_DEFAULTS: () => PILE_DEFAULTS,
     PLATE_DEFAULTS: () => PLATE_DEFAULTS,
@@ -2755,6 +2756,47 @@ var GameFloorplanStructure = (() => {
     return angle === 0 ? q : quat.mul(q, quat.fromAxisAngle([0, 0, 1], angle));
   };
   var clamp3 = (v, a, b) => Math.max(a, Math.min(b, v));
+  var splinterBox = (inp, box2, limit = inp.maxFragments) => {
+    const { rnd } = inp;
+    const dims = box2.s;
+    const [fmin, fmax] = inp.fragmentSize;
+    const g = inp.grain ?? [0, 1, 2].sort((a2, b2) => dims[b2] - dims[a2])[0];
+    const [a, b] = [0, 1, 2].filter((i) => i !== g);
+    const w = Math.max(fmin * 1.5, 0.01);
+    const c = clamp3(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(limit / 2)));
+    const maxLen = fmax * 4;
+    const cells = bsp(box2, c, [a, b], rnd);
+    const pieces = [];
+    for (const cell of cells) {
+      const extra = rnd() < 0.4 ? 1 : 0;
+      const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
+      for (const p of bsp(cell, k, [g], rnd)) pieces.push(p);
+    }
+    return pieces.slice(0, limit).map((p) => ({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] }));
+  };
+  var severAt = (inp, root, at2, gap) => {
+    const dims = root.s;
+    const L = [0, 1, 2].sort((x, y) => dims[y] - dims[x])[0];
+    const half = dims[L] / 2;
+    const lo = clamp3(at2 - gap / 2, -half, half), hi = clamp3(at2 + gap / 2, -half, half);
+    const out = [];
+    const stub = (from, to) => {
+      if (to - from < 0.02) return;
+      const c = [root.c[0], root.c[1], root.c[2]], sz = [dims[0], dims[1], dims[2]];
+      c[L] = (from + to) / 2;
+      sz[L] = to - from;
+      out.push({ center: c, size: sz, q: quat.identity(), shape: "slab", weight: sz[0] * sz[1] * sz[2] });
+    };
+    stub(-half, lo);
+    stub(hi, half);
+    const band = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
+    band.c[L] = (lo + hi) / 2;
+    band.s[L] = Math.max(hi - lo, 0.01);
+    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) => {
     const { dims, rnd, maxFragments } = inp;
     const layers = clamp3(Math.ceil(dims[t] / STACK_LAYER), 2, 4);
@@ -2783,6 +2825,7 @@ var GameFloorplanStructure = (() => {
     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;
@@ -2793,23 +2836,8 @@ var GameFloorplanStructure = (() => {
       return out;
     }
     if (style === "splinter") {
-      const g = inp.grain ?? [0, 1, 2].sort((a2, b2) => dims[b2] - dims[a2])[0];
-      const [a, b] = [0, 1, 2].filter((i) => i !== g);
-      const w = Math.max(fmin * 1.5, 0.01);
-      const c = clamp3(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(maxFragments / 2)));
-      const maxLen = fmax * 4;
-      const cells = bsp(root, c, [a, b], rnd);
-      const pieces = [];
-      for (const cell of cells) {
-        let list = [cell];
-        const extra = rnd() < 0.4 ? 1 : 0;
-        const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
-        list = bsp(cell, k, [g], rnd);
-        for (const p of list) pieces.push(p);
-      }
-      for (const p of pieces.slice(0, maxFragments)) {
-        out.push({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] });
-      }
+      if (inp.cut) return severAt(inp, root, inp.cut.at, inp.cut.gap);
+      for (const p of splinterBox(inp, root)) out.push(p);
       return out;
     }
     if (style === "tear") {
@@ -2971,6 +2999,27 @@ var GameFloorplanStructure = (() => {
     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) {
@@ -3891,14 +3940,21 @@ var GameFloorplanStructure = (() => {
         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",
@@ -3928,14 +3984,21 @@ var GameFloorplanStructure = (() => {
         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",
@@ -3965,14 +4028,24 @@ var GameFloorplanStructure = (() => {
         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",
@@ -3999,14 +4072,25 @@ var GameFloorplanStructure = (() => {
         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",
@@ -4120,6 +4204,17 @@ var GameFloorplanStructure = (() => {
       damageScale: {
         explosive: 1.2
       },
+      hits: {
+        ballistic: {
+          unitJoules: 500,
+          floor: 900,
+          crater: true
+        },
+        blunt: {
+          unitJoules: 1500,
+          floor: 60
+        }
+      },
       hitDebris: "chips",
       breakDebris: "dust",
       thermal: {
@@ -4488,7 +4583,8 @@ var GameFloorplanStructure = (() => {
         smoke: "white"
       },
       visual: {
-        charColor: 1709072
+        charColor: 1709072,
+        innerColor: 14207126
       },
       tags: [
         "plant",
@@ -4496,7 +4592,12 @@ var GameFloorplanStructure = (() => {
         "organic",
         "flammable"
       ],
-      compressive: 6e4
+      compressive: 6e4,
+      hits: {
+        blunt: {
+          tear: "none"
+        }
+      }
     },
     {
       id: "cactus",
@@ -4611,6 +4712,130 @@ var GameFloorplanStructure = (() => {
         "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 = {
@@ -4784,6 +5009,32 @@ var GameFloorplanStructure = (() => {
     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(box2, 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 ? box2.max[axis] - SWEEP_BACK : box2.min[axis] + SWEEP_BACK;
+      const u = (axis + 1) % 3;
+      const v = (axis + 2) % 3;
+      for (const a of line(box2.min[u], box2.max[u])) {
+        for (const b of line(box2.min[v], box2.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 };
@@ -4797,9 +5048,17 @@ var GameFloorplanStructure = (() => {
   var BREACH_AREA = 0.25;
   var BREACH_BLAST_REACH = 0.12;
   var RESIDUAL_CAPACITY = 0.15;
+  var SEVER_BAND = 0.1;
+  var SEVER_ASPECT = 3;
+  var SEVER_BALLISTIC = 2;
+  var 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 CUT_SLICE = 1;
   var cutFactorOf = (shape) => clamp22(Math.max(...shapeDims(shape)) / CUT_SLICE, 1, 50);
   var clamp22 = (v, a, b) => Math.max(a, Math.min(b, v));
@@ -4809,8 +5068,24 @@ var GameFloorplanStructure = (() => {
     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);
@@ -4843,6 +5118,7 @@ var GameFloorplanStructure = (() => {
     let windCfg = windOpts ? resolveWind(windOpts) : null;
     const ignitionRules = resolveIgnitionRules(options.ignition);
     const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
+    const chipEnergy = options.breach?.chipEnergy ?? CHIP_ENERGY;
     const rng = createRng(options.seed ?? 1);
     const rnd = () => rng.next();
     let time = 0;
@@ -5216,41 +5492,68 @@ var GameFloorplanStructure = (() => {
       markDamaged(p);
       if (p.rt.hinge >= flexure.failRotationDeg * Math.PI / 180) hingeDrop(o, p, src);
     };
+    const freeSpan = (p, supports) => {
+      if (supports.length === 0) return Infinity;
+      const d = p.dims;
+      const L = [0, 1, 2].sort((a, b) => d[b] - d[a])[0];
+      const spans = supports.map((k) => contactBox(p, k)).map(([lo, hi]) => [lo[L], hi[L]]);
+      let far = 0;
+      for (let i = 0; i <= 16; i++) {
+        const x = (i / 16 - 0.5) * d[L];
+        let near = Infinity;
+        for (const [lo, hi] of spans) near = Math.min(near, Math.max(lo - x, x - hi, 0));
+        far = Math.max(far, near);
+      }
+      return 2 * far;
+    };
     const solveStructure = (o) => {
       o.maxStress = 0;
       if (!o.hasStructure) return;
       const parts = o.parts;
       const n = parts.length;
       const dist = new Array(n).fill(-1);
-      const queue = [];
       const ok = (i) => parts[i].structural && !isLost(parts[i]);
       const isPartition = (i) => parts[i].spec.structure?.role === "partition";
-      for (let i = 0; i < n; i++) if (ok(i) && parts[i].anchored) {
-        dist[i] = 0;
-        queue.push(i);
-      }
-      for (let h = 0; h < queue.length; h++) {
-        const s = queue[h];
-        if (isPartition(s)) continue;
-        for (const j of o.byPart.get(parts[s].spec.id)) {
-          if (j.st.open || !j.bears) continue;
-          const r = j.ia === s ? j.ib : j.ia;
-          if (dist[r] >= 0 || !ok(r) || restsOn(o, j, r) !== s) continue;
-          dist[r] = dist[s] + 1;
-          queue.push(r);
+      const out = /* @__PURE__ */ new Set();
+      let queue = [];
+      let lowerOf = /* @__PURE__ */ new Map();
+      for (; ; ) {
+        dist.fill(-1);
+        queue = [];
+        for (let i = 0; i < n; i++) if (ok(i) && !out.has(i) && parts[i].anchored) {
+          dist[i] = 0;
+          queue.push(i);
         }
-      }
-      const incoming = new Array(n).fill(0);
-      const lowerOf = /* @__PURE__ */ new Map();
-      for (const i of queue) {
-        const lower = [];
-        for (const j of o.byPart.get(parts[i].spec.id)) {
-          if (j.st.open || !j.bears) continue;
-          const k = restsOn(o, j, i);
-          if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
+        for (let h = 0; h < queue.length; h++) {
+          const s = queue[h];
+          if (isPartition(s)) continue;
+          for (const j of o.byPart.get(parts[s].spec.id)) {
+            if (j.st.open || !j.bears) continue;
+            const r = j.ia === s ? j.ib : j.ia;
+            if (dist[r] >= 0 || !ok(r) || out.has(r) || restsOn(o, j, r) !== s) continue;
+            dist[r] = dist[s] + 1;
+            queue.push(r);
+          }
         }
-        lowerOf.set(i, lower);
+        lowerOf = /* @__PURE__ */ new Map();
+        let dropped = false;
+        for (const i of queue) {
+          const lower = [];
+          for (const j of o.byPart.get(parts[i].spec.id)) {
+            if (j.st.open || !j.bears) continue;
+            const k = restsOn(o, j, i);
+            if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
+          }
+          lowerOf.set(i, lower);
+          const max = parts[i].spec.structure?.maxSpan;
+          if (max !== void 0 && !parts[i].anchored && freeSpan(parts[i], lower.map((k) => parts[k])) > max) {
+            out.add(i);
+            dropped = true;
+          }
+        }
+        if (!dropped) break;
       }
+      const incoming = new Array(n).fill(0);
       const bending = new Array(n).fill(0);
       const through = parts.map(() => []);
       const pass = (k, at2, mass) => {
@@ -5762,6 +6065,7 @@ var GameFloorplanStructure = (() => {
           const r = rayPart(o, p, origin, d);
           if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
           if (p.st.opening && insideOpening(o, p, vec.madd(origin, d, r.t0))) continue;
+          if (p.st.chipped && insideChip(p, objLocal(o, vec.madd(origin, d, r.t0)))) continue;
           if (!best || r.t0 < best.distance) best = { object: o.id, part: p.spec.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
         }
       }
@@ -5962,6 +6266,12 @@ var GameFloorplanStructure = (() => {
       debris(o, p, layer.mat.hitDebris, wp, normal, 5, 2, src);
       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) => {
       const op = p.st.opening;
       if (!op) return false;
@@ -6025,6 +6335,91 @@ var GameFloorplanStructure = (() => {
       if (total < (p.spec.breach?.area ?? BREACH_AREA)) return;
       openBreach(o, p, [sum[0] / total, sum[1] / total, sum[2] / total], total, energy, dir, src);
     };
+    const unitGrids = /* @__PURE__ */ new WeakMap();
+    const gridOf = (p) => {
+      let grid = unitGrids.get(p);
+      if (!grid) unitGrids.set(p, grid = unitGrid(p.dims, p.thin, unitsOf2(p), BREACH_GRID_CAP));
+      return grid;
+    };
+    const insideChip = (p, objectPoint) => {
+      const cells = p.st.chipped;
+      if (!cells?.length) return false;
+      const [u, v] = planeAxes(p.thin);
+      const lp = toLocal(p.pos, p.q, objectPoint);
+      return cells.some((c) => Math.abs(lp[u] - c.center[u]) <= c.size[u] / 2 && Math.abs(lp[v] - c.center[v]) <= c.size[v] / 2);
+    };
+    const chipUnits = (o, p, kind, wp, hitEnergy, dir, radius, src) => {
+      var _a, _b;
+      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);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const out = [];
+      for (let i = 0; i < grid.length; i++) {
+        const cell = grid[i];
+        if (worn[i] === -1) continue;
+        const gap = Math.hypot(Math.max(0, Math.abs(lp[u] - cell.center[u]) - cell.size[u] / 2), Math.max(0, Math.abs(lp[v] - cell.center[v]) - cell.size[v] / 2));
+        if (gap > radius) continue;
+        const share = gap === 0 ? 1 : CHIP_SPLASH * (1 - gap / radius);
+        const total = (worn[i] ?? 0) + energy * share;
+        const mass = p.mat.density * cell.size[0] * cell.size[1] * cell.size[2];
+        if (total < perKg * mass) {
+          worn[i] = total;
+          continue;
+        }
+        worn[i] = -1;
+        out.push(cell);
+      }
+      if (out.length === 0) return;
+      const { c, q } = partXf(o, p);
+      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const holes = localHolesOf(p);
+      for (const cell of out) {
+        const mass = Math.min(p.st.mass, p.mat.density * cell.size[0] * cell.size[1] * cell.size[2]);
+        const center = toWorld(c, q, cell.center);
+        const speed = clamp22(Math.sqrt(2 * energy * 0.05 / Math.max(mass, 0.05)), 0.5, 6);
+        const fragments = cellFragments(o, p, [cell], wp, dir, speed, mass, `c${chipped.length}_`);
+        p.st.holes = p.st.holes.filter((_, k) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length === 0);
+        chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
+        p.st.mass = Math.max(0, p.st.mass - mass);
+        p.rt.removed = (p.rt.removed ?? 0) + mass;
+        markDamaged(p);
+        setStage(o, p, 1, {}, src);
+        emit({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [cell.size[0], cell.size[1], cell.size[2]], rotation: q, fragments });
+        debris(o, p, p.mat.breakDebris, center, vec.scale(dir ?? [0, 1, 0], -1), 6, 2, src);
+      }
+      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 = clamp22(((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);
       const radius = clamp22(Math.sqrt(total / Math.PI), Math.sqrt((p.spec.breach?.area ?? BREACH_AREA) / Math.PI), breachRadius);
@@ -6036,7 +6431,8 @@ var GameFloorplanStructure = (() => {
         failPart(o, p, worldCenter, dir, energy, 12, src);
         return;
       }
-      const cells = cellsWithin(unitGrid(p.dims, p.thin, unitsOf2(p), BREACH_GRID_CAP), p.thin, lc, radius);
+      const worn = p.rt.chips;
+      const cells = cellsWithin(gridOf(p).filter((_, i) => worn?.[i] !== -1), p.thin, lc, radius);
       const removed = p.st.mass * cells.reduce((sum, cell) => sum + cell.size[u] * cell.size[v], 0) / (p.dims[u] * p.dims[v]);
       const speed = clamp22(Math.sqrt(2 * energy * 0.1 / Math.max(removed, 0.05)), 0.5, 8);
       const fragments = cellFragments(o, p, cells, worldCenter, dir, speed, removed, "b");
@@ -6050,10 +6446,7 @@ var GameFloorplanStructure = (() => {
       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) => {
@@ -6065,8 +6458,8 @@ var GameFloorplanStructure = (() => {
       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) => {
@@ -6120,6 +6513,8 @@ var GameFloorplanStructure = (() => {
       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" || 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,
         dims: p.dims,
@@ -6129,7 +6524,8 @@ var GameFloorplanStructure = (() => {
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
         rnd,
-        sheet: p.mat.sheet
+        sheet: p.mat.sheet,
+        ...cutAt2 !== void 0 ? { cut: { at: cutAt2, gap: SEVER_BAND } } : {}
       });
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
       const mass = p.st.mass;
@@ -6188,10 +6584,33 @@ var GameFloorplanStructure = (() => {
       emit({ ...base(o, src), type: "primed", part: p.spec.id, point: partXf(o, p).c, trigger, delay });
     };
     const CHAIN_TRIGGER_OF = { ballistic: "shot", explosive: "explosion" };
+    const severAxis = (p) => {
+      if (p.mat.fracture !== "splinter" && p.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;
+    };
+    const bandOf = (o, p, axis, origin) => {
+      const { c, q } = partXf(o, p);
+      const along = toLocal(c, q, origin)[axis];
+      const L = p.dims[axis];
+      return clamp22(Math.floor((along + L / 2) / SEVER_BAND), 0, Math.ceil(L / SEVER_BAND) - 1);
+    };
     const applyDamage = (o, p, amount, type, origin, dir, fragEnergy, cap, src) => {
+      var _a;
       if (isLost(p) || amount <= 0) return 0;
       const prev = p.st.hp;
       p.st.hp -= amount;
+      const axis = origin && type !== "fire" && type !== "heat" ? severAxis(p) : -1;
+      if (axis >= 0 && p.st.hp > 0) {
+        const band = bandOf(o, p, axis, origin);
+        const cuts = (_a = p.rt).cuts ?? (_a.cuts = {});
+        cuts[band] = (cuts[band] ?? 0) + amount * (type === "ballistic" ? SEVER_BALLISTIC : 1);
+        if (cuts[band] >= p.st.maxHp * SEVER_BAND / p.dims[axis]) {
+          p.rt.cutAt = -p.dims[axis] / 2 + (band + 0.5) * SEVER_BAND;
+          p.st.hp = 0;
+        }
+      }
       markDamaged(p);
       const trigger = CHAIN_TRIGGER_OF[type];
       const chained = trigger !== void 0 && chainDelayOf(p.spec, trigger) !== void 0;
@@ -6227,10 +6646,53 @@ var GameFloorplanStructure = (() => {
         }
       }
     };
+    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 ? clamp22(Math.round(E / joules), 1, 7) : 1 : clamp22(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;
-      if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry2))) {
+      if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry2)) || insideChip(p, objLocal(o, entry2))) {
         return { penetrated: true, exitEnergy: E, exitPoint: vec.madd(entry2, d, Math.min(pathLen, p.thickness)), damage: 0 };
       }
       const sin = Math.min(1, Math.abs(vec.dot(d, n)));
@@ -6255,6 +6717,7 @@ var GameFloorplanStructure = (() => {
         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, clamp22(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 = clamp22(0.03 + ratio * 0.2, 0.03, 0.8);
@@ -6288,7 +6751,10 @@ var GameFloorplanStructure = (() => {
       } else addHole(o, p, entry2, n, caliber / 1e3, false, void 0, src);
       debris(o, p, mat.hitDebris, entry2, n, clamp22(Math.round(E / 60) + 2, 2, 14), clamp22(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);
+      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) => {
@@ -6296,14 +6762,20 @@ var GameFloorplanStructure = (() => {
       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), clamp22(E * 1e-4, 1e-3, 0.06), src);
+          if (mat.ductility >= 0.5) addDent(o, p, point, n, Math.max(patch, 0.015), clamp22(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, clamp22(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), clamp22(E * 6e-5, 1e-3, 0.04), src);
         } else if (mat.fracture === "tear") {
           addHole(o, p, point, n, clamp22(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, clamp22(contactR, 0.01, 0.08), true, void 0, src);
+          if (sheet) addDent(o, p, point, n, Math.max(patch * 0.6, 0.01), clamp22(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), clamp22(E * 4e-5, 5e-4, 0.02), src);
         }
@@ -6316,6 +6788,8 @@ var GameFloorplanStructure = (() => {
       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, "blunt", point, E, d, Math.max(contactR, 0.03), src);
+      if (E > 0 && !isLost(p)) tearAt(o, p, kind, point, void 0, d, E, clamp22(contactR * 0.2, 6e-3, 0.02), src);
       return done;
     };
     const blastPart = (o, p, point, energy, radius, src, res, reachAt) => {
@@ -6894,6 +7368,7 @@ var GameFloorplanStructure = (() => {
             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) {
@@ -7110,6 +7585,18 @@ var GameFloorplanStructure = (() => {
         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(box2, 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(box2, 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(() => {
@@ -8534,7 +9021,24 @@ var GameFloorplanStructure = (() => {
     }
     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));
@@ -8551,7 +9055,7 @@ var GameFloorplanStructure = (() => {
     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]));