@adatechnology/game-destruction 0.15.0 → 0.17.0

package/dist/index.js

@@ -340,6 +340,22 @@ var frame = (ax, ay, az, angle = 0) => {
   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;
@@ -349,35 +365,81 @@ var splinterBox = (inp, box, limit = inp.maxFragments) => {
   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;
 };
@@ -410,8 +472,18 @@ var planFragments = (inp) => {
   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") {
@@ -520,6 +592,88 @@ var marksInBox = (center, size, rotation, holes) => {
   }
   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;
@@ -1560,6 +1714,7 @@ var materials_default = [
   },
   {
     id: "wood_soft",
+    splitForm: "slivers",
     density: 500,
     hpPerKg: 90,
     penetration: 9,
@@ -1605,6 +1760,7 @@ var materials_default = [
   },
   {
     id: "wood_hard",
+    splitForm: "slivers",
     density: 750,
     hpPerKg: 140,
     penetration: 14,
@@ -1649,6 +1805,7 @@ var materials_default = [
   },
   {
     id: "plywood",
+    splitForm: "plies",
     density: 600,
     hpPerKg: 70,
     penetration: 7,
@@ -1696,6 +1853,7 @@ var materials_default = [
   },
   {
     id: "mdf",
+    splitForm: "granules",
     density: 750,
     hpPerKg: 45,
     penetration: 6,
@@ -2207,6 +2365,7 @@ var materials_default = [
   },
   {
     id: "green_wood",
+    splitForm: "slivers",
     density: 650,
     hpPerKg: 5,
     penetration: 10,
@@ -2487,6 +2646,125 @@ var materials_default = [
       "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
   }
 ];
 
@@ -2711,6 +2989,11 @@ var BREACH_RADIUS = 0.55;
 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;
@@ -3963,7 +4246,7 @@ var createDestruction = (options = {}) => {
       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;
@@ -4091,6 +4374,7 @@ var createDestruction = (options = {}) => {
     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];
@@ -4149,6 +4433,7 @@ var createDestruction = (options = {}) => {
       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)) {
@@ -4252,10 +4537,122 @@ var createDestruction = (options = {}) => {
     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;
@@ -4322,6 +4719,7 @@ var createDestruction = (options = {}) => {
     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,
@@ -4330,8 +4728,9 @@ var createDestruction = (options = {}) => {
       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) : [];
@@ -4376,7 +4775,7 @@ var createDestruction = (options = {}) => {
       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);
@@ -4470,7 +4869,8 @@ var createDestruction = (options = {}) => {
     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;
@@ -4631,7 +5031,7 @@ var createDestruction = (options = {}) => {
         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 } : {} });
@@ -4641,7 +5041,10 @@ var createDestruction = (options = {}) => {
     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 };
@@ -4887,6 +5290,11 @@ var createDestruction = (options = {}) => {
     }
     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]);
@@ -6151,7 +6559,12 @@ var locales = {
       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: {
@@ -6247,7 +6660,12 @@ var locales = {
       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: {