@adatechnology/game-destruction 0.15.0 → 0.17.0

package/dist/index.global.js

@@ -452,6 +452,22 @@ var GameDestruction = (() => {
     return angle === 0 ? q : quat.mul(q, quat.fromAxisAngle([0, 0, 1], angle));
   };
   var clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+  var splitAlong = (box, count, axis, rnd) => {
+    const shares = Array.from({ length: count }, () => 0.25 + 1.5 * rnd());
+    const total = shares.reduce((sum, share) => sum + share, 0);
+    const out = [];
+    let from = box.c[axis] - box.s[axis] / 2;
+    for (const share of shares) {
+      const length = box.s[axis] * share / total;
+      const c = [box.c[0], box.c[1], box.c[2]];
+      const size = [box.s[0], box.s[1], box.s[2]];
+      c[axis] = from + length / 2;
+      size[axis] = length;
+      out.push({ c, s: size });
+      from += length;
+    }
+    return out;
+  };
   var splinterBox = (inp, box, limit = inp.maxFragments) => {
     const { rnd } = inp;
     const dims = box.s;
@@ -461,35 +477,81 @@ var GameDestruction = (() => {
     const w = Math.max(fmin * 1.5, 0.01);
     const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(limit / 2)));
     const maxLen = fmax * 4;
-    const cells = bsp(box, c, [a, b], rnd);
+    const cells = [];
+    for (const cell of bsp(box, c, [a, b], rnd)) {
+      const wide = cell.s[a] >= cell.s[b] ? a : b;
+      if (rnd() < 0.4 && cell.s[wide] > fmin * 0.5) for (const part of splitAlong(cell, 2, wide, rnd)) cells.push(part);
+      else cells.push(cell);
+    }
     const pieces = [];
     for (const cell of cells) {
-      const extra = rnd() < 0.4 ? 1 : 0;
+      const extra = Math.floor(rnd() * 3);
       const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
-      for (const p of bsp(cell, k, [g], rnd)) pieces.push(p);
+      for (const p of splitAlong(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 PLY = 3e-3;
+  var PLY_GAP = 0.6;
+  var PLY_SHEET = 0.012;
+  var plyBreak = (inp, root, limit) => {
+    const { rnd } = inp;
+    const dims = root.s;
+    const sorted = [0, 1, 2].sort((x, y) => dims[x] - dims[y]);
+    const t = sorted[0];
+    const [u, v] = [sorted[1], sorted[2]].sort((x, y) => x - y);
+    const along = dims[u] >= dims[v] ? u : v;
+    const across = along === u ? v : u;
+    const layers = clamp(Math.round(dims[t] / PLY / 2), 2, 3);
+    const pitch = dims[t] / layers;
+    const th = Math.min(pitch, PLY_SHEET);
+    const per = Math.max(2, Math.floor(limit / layers));
+    const out = [];
+    for (let k = 0; k < layers; k++) {
+      const layer = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
+      layer.c[t] = root.c[t] + (-dims[t] / 2 + (k + 0.5) * pitch) * (pitch > PLY_SHEET ? 1 : 1 + PLY_GAP);
+      layer.s[t] = th;
+      for (const cell of bsp(layer, per, [u, v], rnd)) {
+        if (out.length >= limit) return out;
+        if (rnd() < 0.35) {
+          const strand = cell.s[across] * (0.15 + 0.2 * rnd());
+          out.push({ center: cell.c, size: [cell.s[along], strand, th * 0.7], q: frame(along, across, t), shape: "splinter", weight: cell.s[along] * strand * th });
+        } else {
+          out.push({ center: cell.c, size: [cell.s[u], cell.s[v], th], q: frame(u, v, t, (rnd() - 0.5) * 0.5), shape: "scrap", weight: cell.s[u] * cell.s[v] * th });
+        }
+      }
+    }
+    return out;
+  };
+  var granules = (inp, box, count) => bsp(box, count, [0, 1, 2], inp.rnd).map((b) => ({ center: b.c, size: b.s, q: quat.identity(), shape: "chunk", weight: b.s[0] * b.s[1] * b.s[2] }));
+  var CRUMBS = 6;
   var severAt = (inp, root, at, gap) => {
     const dims = root.s;
     const L = [0, 1, 2].sort((x, y) => dims[y] - dims[x])[0];
     const half = dims[L] / 2;
     const lo = clamp(at - gap / 2, -half, half), hi = clamp(at + gap / 2, -half, half);
     const out = [];
-    const stub = (from, to) => {
+    const fibrous = inp.form === "slivers" || inp.form === "plies";
+    const [a, b] = [0, 1, 2].filter((i) => i !== L);
+    const stub = (from, to, breakAtEnd) => {
       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] });
+      const weight = sz[0] * sz[1] * sz[2];
+      if (fibrous) out.push({ center: c, size: [sz[L], sz[a], sz[b]], q: frame(L, a, b, breakAtEnd ? 0 : Math.PI), shape: "slab", weight });
+      else out.push({ center: c, size: sz, q: quat.identity(), shape: "slab", weight });
     };
-    stub(-half, lo);
-    stub(hi, half);
+    stub(-half, lo, true);
+    stub(hi, half, false);
     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] });
+    const room = inp.maxFragments - out.length;
+    if (inp.style === "snap" && inp.form === "plies") for (const p of plyBreak(inp, band, Math.max(3, room))) out.push(p);
+    else if (inp.style === "snap" && inp.form === "granules") for (const p of granules(inp, band, clamp(room, 3, 12))) out.push(p);
+    else if (inp.style === "snap") {
+      for (const b2 of bsp(band, Math.max(3, Math.min(6, room)), [0, 1, 2], inp.rnd)) out.push({ center: b2.c, size: b2.s, q: quat.identity(), shape: "chunk", weight: b2.s[0] * b2.s[1] * b2.s[2] });
     } else for (const p of splinterBox(inp, band, Math.max(3, inp.maxFragments - out.length))) out.push(p);
     return out;
   };
@@ -522,8 +584,18 @@ var GameDestruction = (() => {
     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);
+      if (inp.form === "plies") return plyBreak(inp, root, maxFragments);
       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] });
+      if (inp.form !== "granules") return out;
+      const crumbs = Math.min(CRUMBS, maxFragments - out.length);
+      if (crumbs <= 0) return out;
+      const band = { c: [0, 0, 0], s: [0, 0, 0] };
+      for (let i = 0; i < 3; i++) {
+        band.s[i] = Math.min(dims[i], Math.max(fmin, dims[i] * 0.2));
+        band.c[i] = clamp(inp.hit[i], -dims[i] / 2 + band.s[i] / 2, dims[i] / 2 - band.s[i] / 2);
+      }
+      for (const p of granules(inp, band, crumbs)) out.push({ ...p, weight: p.weight * 0.5 });
       return out;
     }
     if (style === "crumble" || style === "none") {
@@ -632,6 +704,88 @@ var GameDestruction = (() => {
     }
     return marks;
   };
+  var JOINT_GAP = 1e-4;
+  var MIN_BEARING_SHARE = 0.25;
+  var unsupportedCells = (cells, thin, dims, standing) => {
+    if (thin === 1) return [];
+    const [u, v] = planeAxes(thin);
+    const bottom = -dims[v] / 2;
+    const rowOf = (y) => Math.round((y - bottom) * 1e4);
+    const rows = /* @__PURE__ */ new Map();
+    for (let i = 0; i < cells.length; i++) {
+      if (!standing(i)) continue;
+      const cell = cells[i];
+      const key = rowOf(cell.center[v] - cell.size[v] / 2);
+      const row = rows.get(key);
+      if (row) row.push(i);
+      else rows.set(key, [i]);
+    }
+    const held = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const i of rows.get(0) ?? []) {
+      held.add(i);
+      queue.push(i);
+    }
+    const overlap = (a, b) => Math.min(a.center[u] + a.size[u] / 2, b.center[u] + b.size[u] / 2) - Math.max(a.center[u] - a.size[u] / 2, b.center[u] - b.size[u] / 2);
+    const climb = () => {
+      while (queue.length > 0) {
+        const cell = cells[queue.pop()];
+        for (const j of rows.get(rowOf(cell.center[v] + cell.size[v] / 2)) ?? []) {
+          const other = cells[j];
+          if (held.has(j) || overlap(cell, other) <= Math.max(JOINT_GAP, MIN_BEARING_SHARE * Math.min(cell.size[u], other.size[u]))) continue;
+          held.add(j);
+          queue.push(j);
+        }
+      }
+    };
+    for (const row of rows.values()) row.sort((a, b) => cells[a].center[u] - cells[b].center[u]);
+    const touching = (a, b) => Math.abs(a.center[u] + a.size[u] / 2 - (b.center[u] - b.size[u] / 2)) <= 1e-3;
+    for (let wedged = true; wedged; ) {
+      climb();
+      wedged = false;
+      for (const row of rows.values()) {
+        for (let k = 1; k < row.length - 1; k++) {
+          const i = row[k];
+          if (held.has(i) || !held.has(row[k - 1]) || !held.has(row[k + 1])) continue;
+          if (!touching(cells[row[k - 1]], cells[i]) || !touching(cells[i], cells[row[k + 1]])) continue;
+          held.add(i);
+          queue.push(i);
+          wedged = true;
+        }
+      }
+    }
+    const loose = [];
+    for (const row of rows.values()) for (const i of row) if (!held.has(i)) loose.push(i);
+    return loose;
+  };
+  var clumpCells = (cells, thin, cap) => {
+    if (cells.length <= cap) return [...cells];
+    const [u, v] = planeAxes(thin);
+    let lo0 = Infinity, lo1 = Infinity, hi0 = -Infinity, hi1 = -Infinity;
+    for (const cell of cells) {
+      lo0 = Math.min(lo0, cell.center[u] - cell.size[u] / 2);
+      hi0 = Math.max(hi0, cell.center[u] + cell.size[u] / 2);
+      lo1 = Math.min(lo1, cell.center[v] - cell.size[v] / 2);
+      hi1 = Math.max(hi1, cell.center[v] + cell.size[v] / 2);
+    }
+    let side = Math.sqrt((hi0 - lo0) * (hi1 - lo1) / cap);
+    for (; ; ) {
+      const bins = /* @__PURE__ */ new Map();
+      for (const cell of cells) {
+        const key = `${Math.floor((cell.center[u] - lo0) / side)}:${Math.floor((cell.center[v] - lo1) / side)}`;
+        const bin = bins.get(key) ?? { lo: [Infinity, Infinity, Infinity], hi: [-Infinity, -Infinity, -Infinity] };
+        for (let k = 0; k < 3; k++) {
+          bin.lo[k] = Math.min(bin.lo[k], cell.center[k] - cell.size[k] / 2);
+          bin.hi[k] = Math.max(bin.hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+        bins.set(key, bin);
+      }
+      if (bins.size <= cap) {
+        return [...bins.values()].map(({ lo, hi }) => ({ center: [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2], size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]] }));
+      }
+      side *= 1.25;
+    }
+  };
 
   // src/layers.ts
   var MAX_SPALLS = 64;
@@ -1672,6 +1826,7 @@ var GameDestruction = (() => {
     },
     {
       id: "wood_soft",
+      splitForm: "slivers",
       density: 500,
       hpPerKg: 90,
       penetration: 9,
@@ -1717,6 +1872,7 @@ var GameDestruction = (() => {
     },
     {
       id: "wood_hard",
+      splitForm: "slivers",
       density: 750,
       hpPerKg: 140,
       penetration: 14,
@@ -1761,6 +1917,7 @@ var GameDestruction = (() => {
     },
     {
       id: "plywood",
+      splitForm: "plies",
       density: 600,
       hpPerKg: 70,
       penetration: 7,
@@ -1808,6 +1965,7 @@ var GameDestruction = (() => {
     },
     {
       id: "mdf",
+      splitForm: "granules",
       density: 750,
       hpPerKg: 45,
       penetration: 6,
@@ -2319,6 +2477,7 @@ var GameDestruction = (() => {
     },
     {
       id: "green_wood",
+      splitForm: "slivers",
       density: 650,
       hpPerKg: 5,
       penetration: 10,
@@ -2599,6 +2758,125 @@ var GameDestruction = (() => {
         "brittle"
       ],
       compressive: 1e5
+    },
+    {
+      id: "mud",
+      density: 1700,
+      hpPerKg: 1,
+      penetration: 5,
+      ductility: 0.8,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.08
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.5,
+        heatCapacity: 3.2
+      },
+      tags: [
+        "soil",
+        "wet"
+      ],
+      compressive: 5e3
+    },
+    {
+      id: "clay",
+      density: 1800,
+      hpPerKg: 5,
+      penetration: 7,
+      ductility: 0.05,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.1
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.2
+      },
+      tags: [
+        "soil",
+        "brittle"
+      ],
+      compressive: 6e4
+    },
+    {
+      id: "snow",
+      density: 300,
+      hpPerKg: 1,
+      penetration: 3,
+      ductility: 0.6,
+      fracture: "crumble",
+      fragmentSize: [
+        0.01,
+        0.05
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2.1
+      },
+      tags: [
+        "soil",
+        "frozen"
+      ],
+      compressive: 1e3
+    },
+    {
+      id: "cobble",
+      density: 2650,
+      hpPerKg: 25,
+      penetration: 25,
+      penetrationClass: "concrete",
+      penetrationScale: 0.9,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.05,
+        0.15
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        conductivity: 0.2,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 3e5
+    },
+    {
+      id: "paver",
+      density: 2300,
+      hpPerKg: 14,
+      penetration: 18,
+      penetrationClass: "concrete",
+      penetrationScale: 1,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.04,
+        0.12
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 35e4
     }
   ];
 
@@ -2782,6 +3060,7 @@ var GameDestruction = (() => {
   };
 
   // ../game-contracts/dist/index.js
+  var DEFAULT_BLAST_IMPULSE = { bodyArea: 0.7, lift: 0.15, minSpeed: 0.3, tntPerJoule: 0.24 / 2e5 };
   var DEFAULT_COST_READS = 1e4;
   var DEFAULT_COST_CEILING_MS = 50;
   var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
@@ -3102,6 +3381,11 @@ var GameDestruction = (() => {
   var BREACH_BLAST_FACTOR = 6;
   var BREACH_AREA = 0.25;
   var BREACH_BLAST_REACH = 0.12;
+  var MEMBER_CUT_REACH = 0.5;
+  var BLAST_REFERENCE_RESISTANCE = 200 * 1900 * 0.13;
+  var BLAST_EDGE_RAGGED = 0.3;
+  var BLAST_EDGE_LOOSE = 1.35;
+  var BLAST_EDGE_WEAR = 0.6;
   var RESIDUAL_CAPACITY = 0.15;
   var SEVER_BAND = 0.1;
   var SEVER_ASPECT = 3;
@@ -4354,7 +4638,7 @@ var GameDestruction = (() => {
         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 -= span === void 0 ? amount : amount * Math.min(1, span / Math.max(jointLength(o, j), 1e-6));
+        j.st.hp -= span === void 0 ? amount : Math.min(amount, j.st.maxHp) * Math.min(1, span / Math.max(jointLength(o, j), 1e-6));
         if (j.st.hp <= 0) {
           j.st.hp = 0;
           j.st.open = true;
@@ -4482,6 +4766,7 @@ var GameDestruction = (() => {
       const worn = (_a = p.rt).chips ?? (_a.chips = {});
       const cut = (_b = p.rt).craters ?? (_b.craters = {});
       const out = [];
+      const wholeBefore = Object.values(worn).filter((w) => w === -1).length;
       const shot = kind === "ballistic";
       for (let i = 0; i < grid.length; i++) {
         const cell = grid[i];
@@ -4540,6 +4825,7 @@ var GameDestruction = (() => {
         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 (Object.values(worn).filter((w) => w === -1).length > wholeBefore) dropUnsupported(o, p, 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)) {
@@ -4643,10 +4929,122 @@ var GameDestruction = (() => {
       setStage(o, p, 1, {}, src);
       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);
+      dropUnsupported(o, p, src);
       const reinforcement = p.spec.reinforcement;
       if (reinforcement) exposeRebar(o, p, src);
       if (p.structural) solveStructure(o);
     };
+    const blastReachOf = (p, energy) => {
+      const perKg = p.mat.hits?.blunt?.unitJoules ?? chipEnergy;
+      const resistance = Math.max(1, perKg * p.mat.density * p.thickness);
+      return BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3) * clamp2(Math.cbrt(BLAST_REFERENCE_RESISTANCE / resistance), 0.3, 2);
+    };
+    const blastUnits = (o, p, wp, energy, dist, src) => {
+      var _a, _b;
+      if (!p.staged || p.st.stripped || isLost(p) || chipEnergy <= 0) return false;
+      const reach = blastReachOf(p, energy);
+      if (dist >= reach) return false;
+      const radius = Math.sqrt(reach * reach - dist * dist);
+      const [u, v] = planeAxes(p.thin);
+      const lp = toLocal(p.pos, p.q, objLocal(o, wp));
+      const op = p.st.opening ? toLocal(p.pos, p.q, p.st.opening.center) : null;
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const perKg = p.mat.hits?.blunt?.unitJoules ?? chipEnergy;
+      const lobes = [rnd() * 2 * Math.PI, rnd() * 2 * Math.PI];
+      const out = [];
+      for (let i = 0; i < grid.length; i++) {
+        const cell = grid[i];
+        if (worn[i] === -1) continue;
+        if (op && p.st.opening && Math.hypot(cell.center[u] - op[u], cell.center[v] - op[v]) <= p.st.opening.radius) continue;
+        const du = cell.center[u] - lp[u], dv = cell.center[v] - lp[v];
+        const angle = Math.atan2(dv, du);
+        const edge = radius * (1 + BLAST_EDGE_RAGGED * (0.5 * Math.sin(3 * angle + lobes[0]) + 0.3 * Math.sin(5 * angle + lobes[1]) + 0.4 * (rnd() - 0.5)));
+        const d = Math.hypot(du, dv);
+        if (d <= edge) {
+          worn[i] = -1;
+          out.push(i);
+        } else if (d <= edge * BLAST_EDGE_LOOSE) {
+          const mass = p.mat.density * cell.size[0] * cell.size[1] * cell.size[2];
+          worn[i] = Math.max(worn[i] ?? 0, perKg * mass * BLAST_EDGE_WEAR);
+        }
+      }
+      if (out.length === 0) return false;
+      const loose = unsupportedCells(grid, p.thin, p.dims, (i) => worn[i] !== -1 && !(op && p.st.opening && Math.hypot(grid[i].center[u] - op[u], grid[i].center[v] - op[v]) <= p.st.opening.radius));
+      for (const i of loose) worn[i] = -1;
+      const blown = out.map((i) => grid[i]), fallen = loose.map((i) => grid[i]);
+      const volume = (cells2) => cells2.reduce((sum, cell) => sum + cell.size[0] * cell.size[1] * cell.size[2], 0);
+      const blownMass = Math.min(p.st.mass, p.mat.density * volume(blown));
+      const fallenMass = Math.min(p.st.mass - blownMass, p.mat.density * volume(fallen));
+      const speed = clamp2(Math.sqrt(2 * energy * 0.02 / Math.max(blownMass, 0.05)), 1, 12);
+      const { c, q } = partXf(o, p);
+      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const tag = `x${chipped.length}_`;
+      const fragments = [
+        ...cellFragments(o, p, clumpCells(blown, p.thin, maxFragments), wp, null, speed, blownMass, tag, true),
+        ...fallen.length > 0 ? cellFragments(o, p, clumpCells(fallen, p.thin, Math.max(2, Math.round(maxFragments / 4))), wp, null, 0.3, fallenMass, `${tag}f`, true) : []
+      ];
+      const cells = [...blown, ...fallen];
+      const holes = localHolesOf(p);
+      p.st.holes = p.st.holes.filter((_, k) => !cells.some((cell) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length > 0));
+      const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+      for (const cell of cells) {
+        chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], cell.center[k] - cell.size[k] / 2);
+          hi[k] = Math.max(hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+      }
+      p.st.mass = Math.max(0, p.st.mass - blownMass - fallenMass);
+      p.rt.removed = (p.rt.removed ?? 0) + blownMass + fallenMass;
+      markDamaged(p);
+      setStage(o, p, 1, {}, src);
+      const center = toWorld(c, q, [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2]);
+      const units = cells.map((cell) => ({ center: toWorld(c, q, cell.center), size: [cell.size[0], cell.size[1], cell.size[2]] }));
+      emit({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]], rotation: q, fragments, units });
+      debris(o, p, p.mat.breakDebris, center, vec.normalize(vec.sub(center, wp), [0, 1, 0]), 14, 3, src);
+      if (p.spec.reinforcement) exposeRebar(o, p, src);
+      if (p.structural && !isLost(p)) {
+        solveStructure(o);
+        collapseCheck(o, src);
+      }
+      return true;
+    };
+    const dropUnsupported = (o, p, src) => {
+      var _a, _b;
+      if (!p.spec.units || p.spec.units.mortar === p.spec.material || p.st.stripped || isLost(p)) return 0;
+      const [u, v] = planeAxes(p.thin);
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const op = p.st.opening ? toLocal(p.pos, p.q, p.st.opening.center) : null;
+      const opened = (cell) => !!op && !!p.st.opening && Math.hypot(cell.center[u] - op[u], cell.center[v] - op[v]) <= p.st.opening.radius;
+      const loose = unsupportedCells(grid, p.thin, p.dims, (i) => worn[i] !== -1 && !opened(grid[i]));
+      if (loose.length === 0) return 0;
+      for (const i of loose) worn[i] = -1;
+      const fallen = loose.map((i) => grid[i]);
+      const mass = Math.min(p.st.mass, p.mat.density * fallen.reduce((sum, cell) => sum + cell.size[0] * cell.size[1] * cell.size[2], 0));
+      const { c, q } = partXf(o, p);
+      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+      for (const cell of fallen) {
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], cell.center[k] - cell.size[k] / 2);
+          hi[k] = Math.max(hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+      }
+      const center = toWorld(c, q, [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2]);
+      const fragments = cellFragments(o, p, clumpCells(fallen, p.thin, Math.max(2, Math.round(maxFragments / 4))), vec.add(center, [0, 1, 0]), null, 0.3, mass, `u${chipped.length}_`, true);
+      const holes = localHolesOf(p);
+      p.st.holes = p.st.holes.filter((_, k) => !fallen.some((cell) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length > 0));
+      for (const cell of fallen) 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);
+      const units = fallen.map((cell) => ({ center: toWorld(c, q, cell.center), size: [cell.size[0], cell.size[1], cell.size[2]] }));
+      emit({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]], rotation: q, fragments, units });
+      debris(o, p, p.mat.breakDebris, center, [0, -1, 0], 6, 1, src);
+      return loose.length;
+    };
     const stripPart = (o, p, reinforcement, src) => {
       const bars = rebarBars(p.dims, p.thin, reinforcement.spacing);
       p.st.stripped = true;
@@ -4713,6 +5111,7 @@ var GameDestruction = (() => {
       const unitPlan = p.spec.units ? unitFragmentPlan(p, maxFragments * UNIT_FRAGMENT_FACTOR) : [];
       const axis = style === "splinter" || style === "snap" ? severAxis(p) : -1;
       const cutAt = axis < 0 ? void 0 : p.rt.cutAt ?? (origin ? hitLocal[axis] : void 0);
+      const planRnd = p.mat.splitForm ? splitStream(o.id, p.spec.id, hitLocal) : rnd;
       const plan = unitPlan.length > 0 ? unitPlan : planFragments({
         style,
         dims: p.dims,
@@ -4721,8 +5120,9 @@ var GameDestruction = (() => {
         hit: hitLocal,
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
-        rnd,
+        rnd: planRnd,
         sheet: p.mat.sheet,
+        ...p.mat.splitForm ? { form: p.mat.splitForm } : {},
         ...cutAt !== void 0 ? { cut: { at: cutAt, gap: SEVER_BAND } } : {}
       });
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
@@ -4767,7 +5167,7 @@ var GameDestruction = (() => {
         return;
       }
       if (ex) {
-        emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, ...ex.effect !== void 0 ? { effect: ex.effect } : {} });
+        emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, ...ex.tnt !== void 0 ? { tnt: ex.tnt } : {}, ...ex.effect !== void 0 ? { effect: ex.effect } : {} });
         blasts.push({ point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, source: src });
       }
       partLost(o, p, src);
@@ -4861,7 +5261,8 @@ var GameDestruction = (() => {
       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 plies = p.mat.splitForm === "plies";
+        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() : plies ? 0.15 + 0.15 * rnd() : 0.4 + 0.4 * rnd());
         const size = [w, w, w];
         size[along] = len;
         size[(along + 1) % 3] = w;
@@ -5022,7 +5423,7 @@ var GameDestruction = (() => {
           checkIgnite(o, p, src);
         }
       }
-      wearJoints(o, p, Ein * 0.5, void 0, 0, src);
+      wearJoints(o, p, Ein * 0.5, void 0, 0, src, false, 2 * BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3));
       const amount = Ein * DMG_PER_J * (mat.damageScale?.explosive ?? 1);
       if (blastFrontSpeed > 0 && dist > 0 && mat.tags?.includes("glass")) {
         frontQueue.push({ o, p, due: time + dist / blastFrontSpeed, amount, fragEnergy: Ein * 0.3, point, ...src !== void 0 ? { src } : {} });
@@ -5032,7 +5433,10 @@ var GameDestruction = (() => {
       const dealt = applyDamage(o, p, amount, "explosive", point, null, Ein * 0.3, 40, src);
       res.damage += dealt;
       if (p.bend && flexure.enabled) bendByBlast(o, p, point, energy, radius, reach, src);
-      if (dist <= BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
+      const breachReach = BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3);
+      if (p.spec.units && p.spec.units.mortar !== p.spec.material) blastUnits(o, p, wp, energy, dist, src);
+      else if (p.spec.reinforcement && p.spec.units && dist > MEMBER_CUT_REACH * breachReach) blastUnits(o, p, wp, energy, dist, src);
+      else if (dist <= breachReach) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       return reach;
     };
     const blastProbe = { partsTested: 0, partsNear: 0 };
@@ -5278,6 +5682,11 @@ var GameDestruction = (() => {
       }
       return h | 0;
     };
+    const splitStream = (objectId, partId, hit) => {
+      const codes = Array.from(`${objectId}|${partId}`, (char) => char.charCodeAt(0) / 1e3);
+      const stream = createRng(seedOf(rng.state() / 1e3, ...codes, hit[0], hit[1], hit[2]));
+      return () => stream.next();
+    };
     const throwFragment = (frag, objectId, from, g, centre, index, src, shields, results, reports, mult) => {
       const v = frag.velocity;
       const speed = Math.hypot(v[0], v[1], v[2]);
@@ -6539,7 +6948,12 @@ var GameDestruction = (() => {
         sand: "sand",
         gravel: "gravel",
         turf: "turf",
-        mortar: "mortar"
+        mortar: "mortar",
+        mud: "mud",
+        clay: "dry clay",
+        snow: "snow",
+        cobble: "cobblestone",
+        paver: "concrete paver"
       },
       partStatus: { intact: "intact", damaged: "damaged", collapsed: "collapsed", broken: "broken", melted: "melted", ashes: "ashes" },
       jointKinds: {
@@ -6635,7 +7049,12 @@ var GameDestruction = (() => {
         sand: "areia",
         gravel: "brita",
         turf: "grama",
-        mortar: "argamassa"
+        mortar: "argamassa",
+        mud: "lama",
+        clay: "barro seco",
+        snow: "neve",
+        cobble: "paralelep\xEDpedo",
+        paver: "bloquete"
       },
       partStatus: { intact: "intacto", damaged: "danificado", collapsed: "desabado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
       jointKinds: {