@adatechnology/game-destruction 0.9.0 → 0.11.0

package/dist/index.js

@@ -340,6 +340,47 @@ 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 splinterBox = (inp, box, limit = inp.maxFragments) => {
+  const { rnd } = inp;
+  const dims = box.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 = 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 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, 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) => {
+    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 = clamp(Math.ceil(dims[t] / STACK_LAYER), 2, 4);
@@ -368,6 +409,7 @@ var planFragments = (inp) => {
   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;
@@ -378,23 +420,8 @@ var planFragments = (inp) => {
     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 = clamp(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") {
@@ -562,6 +589,27 @@ var rebarBars = (dims, thin, spacing) => {
   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) {
@@ -1539,14 +1587,21 @@ var materials_default = [
       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",
@@ -1576,14 +1631,21 @@ var materials_default = [
       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",
@@ -1613,14 +1675,24 @@ var materials_default = [
       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",
@@ -1647,14 +1719,25 @@ var materials_default = [
       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",
@@ -1768,6 +1851,17 @@ var materials_default = [
     damageScale: {
       explosive: 1.2
     },
+    hits: {
+      ballistic: {
+        unitJoules: 500,
+        floor: 900,
+        crater: true
+      },
+      blunt: {
+        unitJoules: 1500,
+        floor: 60
+      }
+    },
     hitDebris: "chips",
     breakDebris: "dust",
     thermal: {
@@ -2136,7 +2230,8 @@ var materials_default = [
       smoke: "white"
     },
     visual: {
-      charColor: 1709072
+      charColor: 1709072,
+      innerColor: 14207126
     },
     tags: [
       "plant",
@@ -2144,7 +2239,12 @@ var materials_default = [
       "organic",
       "flammable"
     ],
-    compressive: 6e4
+    compressive: 6e4,
+    hits: {
+      blunt: {
+        tear: "none"
+      }
+    }
   },
   {
     id: "cactus",
@@ -2259,6 +2359,130 @@ var materials_default = [
       "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
   }
 ];
 
@@ -2444,6 +2668,32 @@ var fragility = (ductility, thickness) => {
 // src/world.ts
 import { ignitionChance, resolveIgnitionRules, sparkTargetFactor } from "@adatechnology/game-contracts";
 var THIN_SHEET_DISHING = 5e-3;
+var SWEEP_BACK = 0.01;
+function sweepOrigins(box, 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 ? box.max[axis] - SWEEP_BACK : box.min[axis] + SWEEP_BACK;
+    const u = (axis + 1) % 3;
+    const v = (axis + 2) % 3;
+    for (const a of line(box.min[u], box.max[u])) {
+      for (const b of line(box.min[v], box.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 };
@@ -2457,9 +2707,17 @@ var BREACH_BLAST_FACTOR = 6;
 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) => clamp2(Math.max(...shapeDims(shape)) / CUT_SLICE, 1, 50);
 var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
@@ -2469,8 +2727,24 @@ var penetrationOf = (mat, table) => {
   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);
@@ -2503,6 +2777,7 @@ var createDestruction = (options = {}) => {
   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;
@@ -2876,41 +3151,68 @@ var createDestruction = (options = {}) => {
     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, at, mass) => {
@@ -3422,6 +3724,7 @@ var createDestruction = (options = {}) => {
         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 };
       }
     }
@@ -3622,6 +3925,12 @@ var createDestruction = (options = {}) => {
     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;
@@ -3685,6 +3994,91 @@ var createDestruction = (options = {}) => {
     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, unitsOf(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 = clamp2(Math.sqrt(2 * energy * 0.05 / Math.max(mass, 0.05)), 0.5, 6);
+      const fragments = cellFragments(o, p, [cell], wp, dir, speed, mass, `c${chipped.length}_`);
+      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 = clamp2(((p.st.stress ?? 0) - 1) / 0.5, 0, 1);
+    if (bow > 0) bars = bars.flatMap((bar2, i) => bendBar(bar2, p.thin, bow * BAR_BOW, i));
+    emit({ ...base(o, src), type: "expose", part: p.spec.id, bars: worldBars(o, p, bars) });
+  };
   const openBreach = (o, p, center, total, energy, dir, src) => {
     const [u, v] = planeAxes(p.thin);
     const radius = clamp2(Math.sqrt(total / Math.PI), Math.sqrt((p.spec.breach?.area ?? BREACH_AREA) / Math.PI), breachRadius);
@@ -3696,7 +4090,8 @@ var createDestruction = (options = {}) => {
       failPart(o, p, worldCenter, dir, energy, 12, src);
       return;
     }
-    const cells = cellsWithin(unitGrid(p.dims, p.thin, unitsOf(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 = clamp2(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");
@@ -3710,10 +4105,7 @@ var createDestruction = (options = {}) => {
     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) => {
@@ -3725,8 +4117,8 @@ var createDestruction = (options = {}) => {
     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) => {
@@ -3780,6 +4172,8 @@ var createDestruction = (options = {}) => {
     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 cutAt = axis < 0 ? void 0 : p.rt.cutAt ?? (origin ? hitLocal[axis] : void 0);
     const plan = unitPlan.length > 0 ? unitPlan : planFragments({
       style,
       dims: p.dims,
@@ -3789,7 +4183,8 @@ var createDestruction = (options = {}) => {
       fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
       maxFragments,
       rnd,
-      sheet: p.mat.sheet
+      sheet: p.mat.sheet,
+      ...cutAt !== void 0 ? { cut: { at: cutAt, gap: SEVER_BAND } } : {}
     });
     const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
     const mass = p.st.mass;
@@ -3848,10 +4243,33 @@ var createDestruction = (options = {}) => {
     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 clamp2(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;
@@ -3887,10 +4305,53 @@ var createDestruction = (options = {}) => {
       }
     }
   };
+  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, entry, exit, d, E, scale, src) => {
+    const { tear, joules } = tearOf(p.mat, kind);
+    if (tear === "none") return;
+    const shot = kind === "ballistic";
+    const n = shot ? exit ? clamp2(Math.round(E / joules), 1, 7) : 1 : clamp2(Math.floor(E / joules), 0, 5);
+    if (n === 0) return;
+    const fibre = tear === "lumps";
+    const { q } = partXf(o, p);
+    const along = (p.spec.grain ? AXIS[p.spec.grain] : void 0) ?? [0, 1, 2].sort((a, b) => p.dims[b] - p.dims[a])[0];
+    const fragments = [];
+    for (let i = 0; i < n; i++) {
+      const back = !exit || i % 3 === 2;
+      const len = scale * (fibre ? 1.2 + 1.2 * rnd() : 3 + 4 * rnd()), w = scale * (0.8 + 0.8 * rnd()), t = scale * (fibre ? 0.7 + 0.6 * rnd() : 0.4 + 0.4 * rnd());
+      const size = [w, w, w];
+      size[along] = len;
+      size[(along + 1) % 3] = w;
+      size[(along + 2) % 3] = t;
+      const spread3 = [(rnd() - 0.5) * 0.8, (rnd() - 0.2) * 0.8, (rnd() - 0.5) * 0.8];
+      const speed = shot ? back ? 1.5 + 2 * rnd() : 2 + 4 * rnd() : 0.8 + 1.2 * rnd();
+      const v = vec.scale(vec.normalize(vec.add(back ? vec.scale(d, -1) : d, spread3)), speed);
+      const mass = size[0] * size[1] * size[2] * p.mat.density;
+      fragments.push({
+        id: `${p.spec.id}#t${tears++}-${i}`,
+        part: p.spec.id,
+        material: p.spec.material,
+        shape: fibre ? "chunk" : "splinter",
+        center: back || !exit ? vec.madd(entry, 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 ?? entry, size: patch, rotation: q, fragments });
+  };
   const ballistic = (o, p, entry, n, d, E, caliber, pathLen, src, round = {}) => {
     const mat = p.mat;
     const piercing = round.piercing ?? 1;
-    if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry))) {
+    if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry)) || insideChip(p, objLocal(o, entry))) {
       return { penetrated: true, exitEnergy: E, exitPoint: vec.madd(entry, d, Math.min(pathLen, p.thickness)), damage: 0 };
     }
     const sin = Math.min(1, Math.abs(vec.dot(d, n)));
@@ -3915,6 +4376,7 @@ var createDestruction = (options = {}) => {
       return { penetrated: false, exitEnergy: 0, damage: dmg2 };
     }
     if (p.layers.length > 0) spallOuter(o, p, entry, face, n, Math.max(0.03, caliber / 1e3 * 4), src);
+    else if (mat.hits?.ballistic?.crater) crater(o, p, entry, n, clamp2(0.02 + Math.sqrt(E) * 15e-4, 0.02, 0.15), src);
     const brittle = mat.ductility < 0.3;
     const ratio = Ep / Math.max(thr, 1e-6);
     const crackLen = clamp2(0.03 + ratio * 0.2, 0.03, 0.8);
@@ -3948,7 +4410,10 @@ var createDestruction = (options = {}) => {
     } else addHole(o, p, entry, n, caliber / 1e3, false, void 0, src);
     debris(o, p, mat.hitDebris, entry, n, clamp2(Math.round(E / 60) + 2, 2, 14), clamp2(Math.sqrt(E) / 6, 1, 8), src);
     wearJoints(o, p, (penetrated ? thr : E) * 0.02, void 0, 0, src, true);
-    const dmg = applyDamage(o, p, E * DMG_PER_J * scale, "ballistic", entry, 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", entry, d, absorbed * 0.1, 12, src);
+    if (!isLost(p)) tearAt(o, p, "ballistic", entry, penetrated ? exitPoint : void 0, d, E, caliber / 1e3, src);
+    chipUnits(o, p, "ballistic", entry, 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) => {
@@ -3956,14 +4421,20 @@ var createDestruction = (options = {}) => {
     const thrMm = mat.penetration * p.thickness * 1e3;
     const fragile = kind === "blunt" ? fragility(mat.ductility, p.thickness) : 1;
     const Ec = E * fragile;
+    const sheet = mat.ductility >= 0.5 && p.thickness <= THIN_SHEET_CRUSH;
+    const fold = sheet ? Math.min(4, Math.sqrt(1e-3 / p.thickness)) : 1;
+    const patch = sheet ? Math.min(contactR, THIN_SHEET_CONTACT) : contactR;
     if (E > 0) {
       if (kind === "blunt") {
-        if (mat.ductility >= 0.5) addDent(o, p, point, n, Math.max(contactR, 0.015), clamp2(E * 1e-4, 1e-3, 0.06), src);
+        if (mat.ductility >= 0.5) addDent(o, p, point, n, Math.max(patch, 0.015), clamp2(E * 1e-4 * fold, 1e-3, sheet ? Math.min(0.06, Math.min(...p.dims) * 0.45) : 0.06), src);
         else if (mat.ductility < 0.3) {
           if (Ec >= 5) addCrack(o, p, point, n, clamp2(0.04 + Math.min(Ec, E * 6) * 8e-4, 0.04, 0.6), src);
         } else if (E >= thrMm * 0.2) addDent(o, p, point, n, Math.max(contactR, 0.015), clamp2(E * 6e-5, 1e-3, 0.04), src);
       } else if (mat.fracture === "tear") {
         addHole(o, p, point, n, clamp2(0.02 + E * 5e-4, 0.02, 0.3), true, void 0, src);
+      } else if (mat.ductility >= 0.3 && E >= thrMm) {
+        addHole(o, p, point, n, clamp2(contactR, 0.01, 0.08), true, void 0, src);
+        if (sheet) addDent(o, p, point, n, Math.max(patch * 0.6, 0.01), clamp2(E * 4e-5 * fold, 5e-4, 0.02), src);
       } else if (mat.ductility >= 0.5) {
         addDent(o, p, point, n, Math.max(contactR, 0.01), clamp2(E * 4e-5, 5e-4, 0.02), src);
       }
@@ -3976,6 +4447,8 @@ var createDestruction = (options = {}) => {
     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, clamp2(contactR * 0.2, 6e-3, 0.02), src);
     return done;
   };
   const blastPart = (o, p, point, energy, radius, src, res, reachAt) => {
@@ -4554,6 +5027,7 @@ var createDestruction = (options = {}) => {
           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) {
@@ -4770,6 +5244,18 @@ var createDestruction = (options = {}) => {
       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(box, direction, distance, 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(box, d, options2.spacing ?? 0.2)) {
+        const r = raycastInternal(origin, d, distance + 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, round) {
       const extras = typeof round === "number" ? { piercing: round } : round ?? {};
       return withCollapses(run(() => {
@@ -5414,7 +5900,12 @@ var locales = {
       cactus: "cactus",
       flesh_fruit: "fruit",
       wax: "wax",
-      soil: "soil"
+      soil: "soil",
+      asphalt: "asphalt",
+      sand: "sand",
+      gravel: "gravel",
+      turf: "turf",
+      mortar: "mortar"
     },
     partStatus: { intact: "intact", damaged: "damaged", collapsed: "collapsed", broken: "broken", melted: "melted", ashes: "ashes" },
     jointKinds: {
@@ -5467,6 +5958,7 @@ var locales = {
       sway: "sway",
       spall: "plaster came off",
       stage: "damage stage",
+      chip: "brick knocked out",
       expose: "rebar bare",
       body: "body",
       blast: "blast",
@@ -5504,7 +5996,12 @@ var locales = {
       cactus: "cacto",
       flesh_fruit: "fruta",
       wax: "cera",
-      soil: "terra"
+      soil: "terra",
+      asphalt: "asfalto",
+      sand: "areia",
+      gravel: "brita",
+      turf: "grama",
+      mortar: "argamassa"
     },
     partStatus: { intact: "intacto", damaged: "danificado", collapsed: "desabado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
     jointKinds: {
@@ -5557,6 +6054,7 @@ var locales = {
       sway: "balan\xE7o",
       spall: "reboco soltou",
       stage: "est\xE1gio de dano",
+      chip: "tijolo arrancado",
       expose: "vergalh\xE3o \xE0 mostra",
       body: "corpo",
       blast: "explos\xE3o",