@adatechnology/game-destruction 0.4.2 → 0.6.0

package/dist/index.js

@@ -419,6 +419,153 @@ var planFragments = (inp) => {
   return out;
 };
 
+// src/breach.ts
+var planeAxes = (thin) => thin === 1 ? [0, 2] : [thin === 0 ? 2 : 0, 1];
+var unitGrid = (dims, thin, units, cap) => {
+  const [u, v] = planeAxes(thin);
+  let unitU = Math.min(units.size[0], dims[u]), unitV = Math.min(units.size[1], dims[v]);
+  const rowsFor = (h) => Math.ceil(dims[v] / h - 1e-9);
+  const colsFor = (w) => Math.ceil(dims[u] / w - 1e-9) + (units.bond === "running" ? 1 : 0);
+  const merge = Math.ceil(Math.sqrt(rowsFor(unitV) * colsFor(unitU) / cap));
+  if (merge > 1) {
+    unitU = Math.min(unitU * merge, dims[u]);
+    unitV = Math.min(unitV * merge, dims[v]);
+  }
+  const cells = [];
+  for (let row = 0; row < rowsFor(unitV); row++) {
+    const v0 = -dims[v] / 2 + row * unitV, v1 = Math.min(v0 + unitV, dims[v] / 2);
+    const shift = units.bond === "running" && row % 2 === 1 ? unitU / 2 : 0;
+    for (let col = 0; col < colsFor(unitU); col++) {
+      const u0 = Math.max(-dims[u] / 2 + col * unitU - shift, -dims[u] / 2), u1 = Math.min(-dims[u] / 2 + (col + 1) * unitU - shift, dims[u] / 2);
+      if (u1 - u0 < 0.01) continue;
+      const center = [0, 0, 0], size = [0, 0, 0];
+      center[u] = (u0 + u1) / 2;
+      center[v] = (v0 + v1) / 2;
+      size[u] = u1 - u0;
+      size[v] = v1 - v0;
+      size[thin] = dims[thin];
+      cells.push({ center, size });
+    }
+  }
+  return cells;
+};
+var planeDistance = (cell, thin, point) => {
+  const [u, v] = planeAxes(thin);
+  const du = cell.center[u] - point[u], dv = cell.center[v] - point[v];
+  return Math.sqrt(du * du + dv * dv);
+};
+var cellsWithin = (cells, thin, point, radius) => {
+  const inside = cells.filter((c) => planeDistance(c, thin, point) <= radius);
+  if (inside.length > 0 || cells.length === 0) return inside;
+  return [cells.reduce((best, c) => planeDistance(c, thin, point) < planeDistance(best, thin, point) ? c : best)];
+};
+var cellsOutside = (cells, thin, point, radius) => cells.filter((c) => planeDistance(c, thin, point) > radius);
+var MAX_MARKS_PER_FRAGMENT = 12;
+var marksInBox = (center, size, rotation, holes) => {
+  const inverse = rotation ? quat.conjugate(rotation) : void 0;
+  const marks = [];
+  for (const hole of holes) {
+    const offset = [hole.point[0] - center[0], hole.point[1] - center[1], hole.point[2] - center[2]];
+    const point = inverse ? rotateVec(inverse, offset) : offset;
+    const inside = point.every((value, k) => Math.abs(value) <= size[k] / 2 + hole.diameter / 2);
+    if (!inside) continue;
+    marks.push({ point, normal: inverse ? rotateVec(inverse, hole.normal) : hole.normal, diameter: hole.diameter });
+    if (marks.length >= MAX_MARKS_PER_FRAGMENT) break;
+  }
+  return marks;
+};
+
+// src/layers.ts
+var MAX_SPALLS = 64;
+var thinAxisOf = (dims) => dims[0] <= dims[1] && dims[0] <= dims[2] ? 0 : dims[1] <= dims[2] ? 1 : 2;
+var resolveLayer = (def, index, mat) => ({ index, def, mat, energy: mat.penetration * def.thickness * 1e3 });
+var onFace = (layer, face) => layer.def.faces === "both" || layer.def.faces === (face > 0 ? "+" : "-");
+var isSpalled = (spalls, layer, face, point) => {
+  for (const s of spalls ?? []) {
+    if (s[0] !== layer || s[1] !== face) continue;
+    const dx = s[2] - point[0], dy = s[3] - point[1], dz = s[4] - point[2];
+    if (dx * dx + dy * dy + dz * dz <= s[5] * s[5]) return true;
+  }
+  return false;
+};
+var outerLayer = (layers, spalls, face, point) => layers.find((l) => onFace(l, face) && !isSpalled(spalls, l.index, face, point));
+var layersEnergy = (layers, spalls, face, point) => {
+  let sum = 0;
+  for (const l of layers) if (onFace(l, face) && !isSpalled(spalls, l.index, face, point)) sum += l.energy;
+  return sum;
+};
+var layersThickness = (layers, face) => {
+  let sum = 0;
+  for (const l of layers) if (onFace(l, face)) sum += l.def.thickness;
+  return sum;
+};
+
+// src/rebar.ts
+var COVER = 0.03;
+var MAX_BARS_PER_DIRECTION = 24;
+var MAX_MEMBER_BARS_PER_SIDE = 6;
+var STEEL_DENSITY = 7850;
+var spread = (length, cover, spacing, cap) => {
+  const room = Math.max(0, length - 2 * cover);
+  const count = Math.min(cap, Math.max(2, Math.floor(room / spacing) + 1));
+  const step = count > 1 && room / (count - 1) < spacing ? room / (count - 1) : spacing;
+  return Array.from({ length: count }, (_, i) => (i - (count - 1) / 2) * step);
+};
+var bar = (axis, along, fixed) => {
+  const a = [0, 0, 0], b = [0, 0, 0];
+  for (const [index, value] of fixed) {
+    a[index] = value;
+    b[index] = value;
+  }
+  a[axis] = -along;
+  b[axis] = along;
+  return [a, b];
+};
+var isMember = (dims) => {
+  const [a = 0, b = 0, c = 0] = [...dims].sort((x, y) => x - y);
+  return b / a < 3 && c / b >= 3;
+};
+var rebarBars = (dims, thin, spacing) => {
+  const out = [];
+  if (isMember(dims)) {
+    const long = dims.indexOf(Math.max(...dims));
+    const [u2 = 0, v2 = 0] = [0, 1, 2].filter((i) => i !== long);
+    const us = spread(dims[u2], COVER, spacing, MAX_MEMBER_BARS_PER_SIDE);
+    const vs = spread(dims[v2], COVER, spacing, MAX_MEMBER_BARS_PER_SIDE);
+    us.forEach((x, i) => vs.forEach((y, j) => {
+      if (i === 0 || j === 0 || i === us.length - 1 || j === vs.length - 1) out.push(bar(long, dims[long] / 2 - 0.02, [[u2, x], [v2, y]]));
+    }));
+    return out;
+  }
+  const [u = 0, v = 0] = [0, 1, 2].filter((i) => i !== thin);
+  for (const y of spread(dims[v], COVER, spacing, MAX_BARS_PER_DIRECTION)) out.push(bar(u, dims[u] / 2 - 0.02, [[v, y], [thin, 0]]));
+  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 clipBarsToDisc = (bars, u, v, center, radius) => {
+  const out = [];
+  for (const [a, b] of bars) {
+    const axis = a[u] !== b[u] ? u : v;
+    const other = axis === u ? v : u;
+    const off = a[other] - center[other === u ? 0 : 1];
+    if (Math.abs(off) >= radius) continue;
+    const half = Math.sqrt(radius * radius - off * off);
+    const mid = center[axis === u ? 0 : 1];
+    const lo = Math.max(Math.min(a[axis], b[axis]), mid - half), hi = Math.min(Math.max(a[axis], b[axis]), mid + half);
+    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 rebarMass = (bars, diameter, density = STEEL_DENSITY) => {
+  let length = 0;
+  for (const [a, b] of bars) length += Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) + Math.abs(a[2] - b[2]);
+  return Math.PI * (diameter / 2) * (diameter / 2) * length * density;
+};
+
 // src/data/materials.json
 var materials_default = [
   {
@@ -1427,9 +1574,19 @@ var fragility = (ductility, thickness) => {
 var DMG_PER_J = 0.02;
 var BLAST_COUPLING = 0.1;
 var FLAMMABLE_FLUIDS = ["gas", "fuel"];
+var BREACH_RADIUS = 0.55;
+var BREACH_BLAST_FACTOR = 6;
+var BREACH_AREA = 0.25;
+var RESIDUAL_CAPACITY = 0.15;
+var UNIT_FRAGMENT_FACTOR = 4;
+var BREACH_GRID_CAP = 4096;
 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));
+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;
+};
 var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
 var clone = (v) => structuredClone(v);
 var overloadRate = (stress) => Math.min(0.6, 0.12 + 0.8 * (stress - 1));
@@ -1452,6 +1609,8 @@ var createDestruction = (options = {}) => {
   const maxDents = options.maxDents ?? 24;
   const maxHoles = options.maxHoles ?? 32;
   const fireSpread = options.fireSpread ?? 0.6;
+  const breachRadius = options.breach?.radius ?? BREACH_RADIUS;
+  const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
   const rng = createRng(options.seed ?? 1);
   const rnd = () => rng.next();
   let time = 0;
@@ -1460,6 +1619,8 @@ var createDestruction = (options = {}) => {
   const listeners = /* @__PURE__ */ new Map();
   let cur = [];
   const blasts = [];
+  const frontQueue = [];
+  const blastFrontSpeed = options.blastFrontSpeed ?? 0;
   const primed = /* @__PURE__ */ new Map();
   let orderCounter = 0;
   const impls = /* @__PURE__ */ new Map();
@@ -1556,6 +1717,13 @@ var createDestruction = (options = {}) => {
       const maxHp = Math.max(1, ps.hp ?? mass0 * mat.hpPerKg);
       const fuel0 = mat.thermal.ignitionC !== void 0 ? mass0 * (mat.thermal.fuelFraction ?? 0) : 0;
       const c = carry?.parts.get(ps.id);
+      const staged = !!(ps.layers?.length || ps.reinforcement || ps.units || ps.breach);
+      const layers = (ps.layers ?? []).map((l, i) => {
+        const lm = materials.get(l.material);
+        if (!lm) throw new Error(`unknown material "${l.material}" on layer ${i} of part "${ps.id}"`);
+        return resolveLayer(l, i, lm);
+      });
+      if (ps.reinforcement && !materials.has(ps.reinforcement.material)) throw new Error(`unknown material "${ps.reinforcement.material}" on the reinforcement of part "${ps.id}"`);
       const pst = c?.st ?? {
         id: ps.id,
         material: ps.material,
@@ -1571,7 +1739,8 @@ var createDestruction = (options = {}) => {
         dents: [],
         holes: [],
         cracks: [],
-        group: 0
+        group: 0,
+        ...staged ? { stage: 0 } : {}
       };
       if (!c && ps.contains) pst.liters = ps.contains.liters;
       const p = {
@@ -1590,7 +1759,10 @@ var createDestruction = (options = {}) => {
         rt: c?.rt ?? { ...freshRuntime(), prevTemp: pst.temperature },
         structural: !!ps.structure && ps.structure.role !== "none",
         anchored: !!ps.anchored || ps.structure?.role === "foundation",
-        cap: ps.structure ? partCapacity(ps, mat) : 0
+        cap: ps.structure ? partCapacity(ps, mat) : 0,
+        staged,
+        thin: thinAxisOf(shapeDims(ps.shape)),
+        layers
       };
       if (p.structural) o.hasStructure = true;
       if (p.rt.chainDue !== void 0 && !isLost(p)) primed.set(p, o);
@@ -1730,7 +1902,7 @@ var createDestruction = (options = {}) => {
         o.unsup[i] = o.anyAnchor && !isLost(p);
         continue;
       }
-      p.st.stress = p.st.load / p.cap;
+      p.st.stress = p.st.load / (p.cap * capacityScale(p));
       if (p.st.stress > o.maxStress) o.maxStress = p.st.stress;
     }
     if (o.maxStress > 0.8) o.active = true;
@@ -1749,6 +1921,7 @@ var createDestruction = (options = {}) => {
         for (const p of ps) {
           o.collapsed.add(p.spec.id);
           p.st.status = "collapsed";
+          setStage(o, p, 3, {}, src);
         }
         emit({ ...base(o, src), type: "collapse", parts: ps.map((p) => p.spec.id), mass: ps.reduce((sum, p) => sum + p.st.mass, 0) });
       }
@@ -1802,6 +1975,7 @@ var createDestruction = (options = {}) => {
         if (isLost(p) || ignore?.has(`${o.id}\0${p.spec.id}`)) continue;
         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 (!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 };
       }
     }
@@ -1910,6 +2084,7 @@ var createDestruction = (options = {}) => {
     if (p.st.holes.length > maxHoles) p.st.holes.shift();
     markDamaged(p);
     emit({ ...base(o, src), type: "hole", part: p.spec.id, hole, worldPoint: wp, ...exit ? { exitPoint: exit } : {} });
+    setStage(o, p, 1, {}, src);
     return hole;
   };
   const addCrack = (o, p, wp, wn, length, src) => {
@@ -1918,6 +2093,7 @@ var createDestruction = (options = {}) => {
     if (p.st.cracks.length > 16) p.st.cracks.shift();
     markDamaged(p);
     emit({ ...base(o, src), type: "crack", part: p.spec.id, crack, worldPoint: wp });
+    setStage(o, p, 1, {}, src);
   };
   const debris = (o, p, kind, point, normal, count, speed, src) => emit({ ...base(o, src), type: "debris", part: p.spec.id, kind, point, normal, count, speed });
   const holeRate = (hole, pressurized) => (pressurized ? 0.5 : 0.1) * (hole.diameter / 9e-3);
@@ -1966,6 +2142,7 @@ var createDestruction = (options = {}) => {
     if (split && mine.length) amount /= mine.length;
     for (const j of mine) {
       if (j.st.open) continue;
+      if (j.spec.kind === "rebar" && (o.parts[j.ia].spec.reinforcement || o.parts[j.ib].spec.reinforcement)) continue;
       if (near && jointReach(o, j, near) > Math.max(radius, jointReachLimit(o, j))) continue;
       j.st.hp -= amount;
       if (j.st.hp <= 0) {
@@ -1979,23 +2156,172 @@ var createDestruction = (options = {}) => {
       }
     }
   };
+  const setStage = (o, p, stage, extra = {}, src) => {
+    if (!p.staged || (p.st.stage ?? 0) >= stage) return;
+    p.st.stage = stage;
+    emit({ ...base(o, src), type: "stage", part: p.spec.id, stage, ...extra });
+  };
+  const faceOf = (o, p, worldNormal) => rotateVec(quat.conjugate(partXf(o, p).q), worldNormal)[p.thin] >= 0 ? 1 : -1;
+  const spallOuter = (o, p, wp, face, normal, radius, src) => {
+    var _a;
+    if (p.layers.length === 0) return;
+    const lp = objLocal(o, wp);
+    const layer = outerLayer(p.layers, p.rt.spalls, face, lp);
+    if (!layer) return;
+    const spalls = (_a = p.rt).spalls ?? (_a.spalls = []);
+    spalls.push([layer.index, face, lp[0], lp[1], lp[2], radius]);
+    if (spalls.length > MAX_SPALLS) spalls.shift();
+    markDamaged(p);
+    emit({ ...base(o, src), type: "spall", part: p.spec.id, layer: layer.index, point: wp, area: Math.PI * radius * radius });
+    debris(o, p, layer.mat.hitDebris, wp, normal, 5, 2, src);
+    setStage(o, p, 1, {}, src);
+  };
+  const insideOpening = (o, p, objectPoint) => {
+    const op = p.st.opening;
+    if (!op) return false;
+    const [u, v] = planeAxes(p.thin);
+    const lp = toLocal(p.pos, p.q, objectPoint);
+    const lc = toLocal(p.pos, p.q, op.center);
+    return Math.hypot(lp[u] - lc[u], lp[v] - lc[v]) <= op.radius;
+  };
+  const breachAreaOf = (p, damage, blast) => damage / (p.mat.hpPerKg * p.mat.density) / Math.max(p.thickness, 5e-3) * (blast ? breachBlastFactor : 1);
+  const localHolesOf = (p) => p.st.holes.map((h) => ({ point: toLocal(p.pos, p.q, h.point), normal: rotateVec(quat.conjugate(p.q), h.normal), diameter: h.diameter }));
+  const unitsOf = (p) => p.spec.units ?? { size: [p.mat.fragmentSize?.[1] ?? 0.2, p.mat.fragmentSize?.[1] ?? 0.2, p.thickness], bond: "stack" };
+  const FRAGMENT_SHAPE = { shatter: "shard", splinter: "splinter", tear: "scrap" };
+  const cellFragments = (o, p, cells, hitW, dir, speed, mass, tag) => {
+    const { c, q } = partXf(o, p);
+    const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
+    const [u, v] = planeAxes(p.thin);
+    const faceArea = (cell) => cell.size[u] * cell.size[v];
+    const total = cells.reduce((sum, cell) => sum + faceArea(cell), 0) || 1;
+    const shape = p.spec.units ? "chunk" : FRAGMENT_SHAPE[p.mat.fracture] ?? "chunk";
+    return cells.map((cell, i) => {
+      const cw = toWorld(c, q, cell.center);
+      const out = vec.normalize(vec.sub(cw, hitW), [0, 1, 0]);
+      const dv = dir ? vec.normalize(vec.madd(out, dir, 0.6)) : out;
+      const k = speed * (0.6 + 0.8 * rnd());
+      const marks = marksInBox(cell.center, cell.size, void 0, holes);
+      return {
+        id: `${p.spec.id}#${tag}${i}`,
+        part: p.spec.id,
+        material: p.spec.material,
+        shape,
+        center: cw,
+        size: [cell.size[0], cell.size[1], cell.size[2]],
+        rotation: q,
+        velocity: [dv[0] * k, dv[1] * k + 0.5 * rnd(), dv[2] * k],
+        angularVelocity: [(rnd() - 0.5) * 8, (rnd() - 0.5) * 8, (rnd() - 0.5) * 8],
+        mass: mass * faceArea(cell) / total,
+        ...marks.length > 0 ? { marks } : {}
+      };
+    });
+  };
+  const worldBars = (o, p, bars) => {
+    const { c, q } = partXf(o, p);
+    return bars.map(([a, b]) => [toWorld(c, q, a), toWorld(c, q, b)]);
+  };
+  const addBreach = (o, p, wp, area, energy, dir, src) => {
+    var _a;
+    if (!p.staged || area <= 0 || (p.st.stage ?? 0) >= 2 || p.st.stripped || isLost(p)) return;
+    const lp = objLocal(o, wp);
+    const list = (_a = p.rt).breach ?? (_a.breach = []);
+    list.push([lp[0], lp[1], lp[2], area]);
+    if (list.length > MAX_SPALLS) list.shift();
+    let total = 0;
+    const sum = [0, 0, 0];
+    for (const [x, y, z, a] of list) {
+      if (vec.distance([x, y, z], lp) > breachRadius) continue;
+      total += a;
+      sum[0] += x * a;
+      sum[1] += y * a;
+      sum[2] += z * a;
+    }
+    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 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);
+    const lc = toLocal(p.pos, p.q, center);
+    lc[p.thin] = 0;
+    const { c, q } = partXf(o, p);
+    const worldCenter = toWorld(c, q, lc);
+    if (2 * radius >= Math.min(p.dims[u], p.dims[v])) {
+      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 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");
+    const holes = localHolesOf(p);
+    p.st.holes = p.st.holes.filter((_, i) => !cells.some((cell) => marksInBox(cell.center, cell.size, void 0, [holes[i]]).length > 0));
+    p.st.mass = Math.max(0, p.st.mass - removed);
+    p.rt.removed = (p.rt.removed ?? 0) + removed;
+    p.st.opening = { center: objLocal(o, worldCenter), radius };
+    markDamaged(p);
+    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);
+    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 (p.structural) solveStructure(o);
+  };
+  const stripPart = (o, p, reinforcement, src) => {
+    const bars = rebarBars(p.dims, p.thin, reinforcement.spacing);
+    p.st.stripped = true;
+    p.st.hp = p.st.maxHp;
+    p.st.mass = rebarMass(bars, reinforcement.diameter, materials.get(reinforcement.material)?.density);
+    p.st.holes = [];
+    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);
+    collapseCheck(o, src);
+  };
+  const unitFragmentPlan = (p, cap) => {
+    const grid = unitGrid(p.dims, p.thin, unitsOf(p), cap);
+    const op = p.st.opening;
+    const cells = op ? cellsOutside(grid, p.thin, toLocal(p.pos, p.q, op.center), op.radius) : grid;
+    const [u, v] = planeAxes(p.thin);
+    return cells.map((cell) => ({ center: cell.center, size: cell.size, q: quat.identity(), shape: "chunk", weight: cell.size[u] * cell.size[v] }));
+  };
+  const loseCage = (o, p, src) => {
+    p.st.status = "broken";
+    p.st.hp = 0;
+    p.st.mass = 0;
+    emit({ ...base(o, src), type: "expose", part: p.spec.id, bars: [] });
+    debris(o, p, "sparks", partXf(o, p).c, [0, 1, 0], 6, 3, src);
+    partLost(o, p, src);
+  };
   const failPart = (o, p, origin, dir, fragEnergy, cap, src) => {
     if (isLost(p)) return;
+    if (p.st.stripped) {
+      loseCage(o, p, src);
+      return;
+    }
     const ex = p.spec.explodes;
     const style = p.mat.fracture === "none" ? "snap" : p.mat.fracture;
     const { c, q } = partXf(o, p);
     const hitW = origin ?? c;
     const grain = p.spec.grain ? AXIS[p.spec.grain] : void 0;
-    const plan = planFragments({
+    const hitLocal = toLocal(c, q, hitW);
+    const unitPlan = p.spec.units ? unitFragmentPlan(p, maxFragments * UNIT_FRAGMENT_FACTOR) : [];
+    const plan = unitPlan.length > 0 ? unitPlan : planFragments({
       style,
       dims: p.dims,
       thickness: p.thickness,
       grain,
-      hit: toLocal(c, q, hitW),
+      hit: hitLocal,
       fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
       maxFragments,
       rnd
     });
+    const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
     const mass = p.st.mass;
     const totW = plan.reduce((s, f) => s + f.weight, 0) || 1;
     const energy = ex ? ex.energy * 0.2 : fragEnergy;
@@ -2005,6 +2331,7 @@ var createDestruction = (options = {}) => {
       const out = vec.normalize(vec.sub(cw, hitW), [0, 1, 0]);
       const dv = dir ? vec.normalize(vec.madd(out, dir, 0.6)) : out;
       const k = speed * (0.6 + 0.8 * rnd());
+      const marks = marksInBox(f.center, f.size, f.q, holes);
       return {
         id: `${p.spec.id}#${i}`,
         part: p.spec.id,
@@ -2015,18 +2342,27 @@ var createDestruction = (options = {}) => {
         rotation: quat.mul(q, f.q),
         velocity: [dv[0] * k, dv[1] * k + 0.5 * rnd(), dv[2] * k],
         angularVelocity: [(rnd() - 0.5) * 12, (rnd() - 0.5) * 12, (rnd() - 0.5) * 12],
-        mass: mass * f.weight / totW
+        mass: mass * f.weight / totW,
+        ...marks.length > 0 ? { marks } : {}
       };
     });
-    p.st.status = "broken";
-    p.st.hp = 0;
-    p.st.mass = 0;
-    p.st.burning = false;
-    p.rt.jet = false;
+    const reinforcement = p.spec.reinforcement;
+    if (!reinforcement) {
+      p.st.status = "broken";
+      p.st.hp = 0;
+      p.st.mass = 0;
+      p.st.burning = false;
+      p.rt.jet = false;
+    }
     emit({ ...base(o, src), type: "fracture", part: p.spec.id, style, fragments, point: hitW });
     debris(o, p, p.mat.breakDebris, c, [0, 1, 0], clamp2(Math.round(Math.cbrt(partVolume(p.spec.shape)) * 30), 3, 20), 2, src);
+    setStage(o, p, 3, {}, src);
+    if (reinforcement) {
+      stripPart(o, p, reinforcement, src);
+      return;
+    }
     if (ex) {
-      emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius });
+      emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius, ...ex.effect !== void 0 ? { effect: ex.effect } : {} });
       blasts.push({ point: c, energy: ex.energy, radius: ex.radius, source: src });
     }
     partLost(o, p, src);
@@ -2058,10 +2394,17 @@ var createDestruction = (options = {}) => {
   };
   const ballistic = (o, p, entry, n, d, E, caliber, pathLen, src) => {
     const mat = p.mat;
+    if (p.st.stripped || p.st.opening && insideOpening(o, 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)));
     const angle = Math.asin(sin) * 180 / Math.PI;
-    const effM = p.thickness / Math.max(sin, 0.3);
-    const thr = mat.penetration * effM * 1e3;
+    const slant = Math.max(sin, 0.3);
+    const effM = p.thickness / slant;
+    const face = p.layers.length > 0 ? faceOf(o, p, n) : 1;
+    const exitLocal = objLocal(o, vec.madd(entry, d, Math.min(pathLen, effM)));
+    const coats = p.layers.length > 0 ? layersEnergy(p.layers, p.rt.spalls, face, objLocal(o, entry)) + layersEnergy(p.layers, p.rt.spalls, -face, exitLocal) : 0;
+    const thr = coats > 0 ? (mat.penetration * p.thickness * 1e3 + coats) / slant : mat.penetration * effM * 1e3;
     const penetrated = E > thr;
     const scale = (mat.damageScale?.ballistic ?? 1) * (mat.fracture === "shatter" ? fragility(mat.ductility, p.thickness) : 1);
     const id = p.spec.id;
@@ -2072,13 +2415,16 @@ var createDestruction = (options = {}) => {
       const dmg2 = applyDamage(o, p, E * DMG_PER_J * scale * 0.2, "ballistic", entry, d, E * 0.1, 12, src);
       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);
     const brittle = mat.ductility < 0.3;
     const ratio = E / Math.max(thr, 1e-6);
     const crackLen = clamp2(0.03 + ratio * 0.2, 0.03, 0.8);
     let exitPoint;
     if (penetrated) {
-      exitPoint = vec.madd(entry, d, Math.min(pathLen, effM));
+      exitPoint = vec.madd(entry, d, Math.min(pathLen, effM + layersThickness(p.layers, face) / slant + layersThickness(p.layers, -face) / slant));
       const hole = addHole(o, p, entry, n, caliber / 1e3 * (mat.ductility >= 0.3 ? 1 : 1.5), true, exitPoint, src);
+      if (p.layers.length > 0) spallOuter(o, p, exitPoint, -face, vec.scale(n, -1), Math.max(0.03, caliber / 1e3 * 4), src);
+      addBreach(o, p, entry, Math.PI * (hole.diameter / 2) * (hole.diameter / 2), E, d, src);
       if (brittle && mat.fracture === "shatter") addCrack(o, p, entry, n, crackLen, src);
       if (p.spec.contains && (p.st.liters ?? 0) > 0) {
         emit({
@@ -2123,8 +2469,11 @@ var createDestruction = (options = {}) => {
     }
     if (kind === "blunt") wearJoints(o, p, E * 0.3, void 0, 0, src);
     else wearJoints(o, p, E * 0.3, point, 0.06, src);
+    if (kind === "blunt" && E > 0 && p.layers.length > 0) spallOuter(o, p, point, faceOf(o, p, n), n, Math.max(contactR, 0.05), src);
     const scale = mat.damageScale?.[kind] ?? 1;
-    return applyDamage(o, p, Ec * DMG_PER_J * scale * (kind === "slash" ? p.cutFactor : 1), kind, point, d, E * 0.1, 12, src);
+    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);
+    return done;
   };
   const blastObject = (o, point, energy, radius, src) => {
     const start = cur.length;
@@ -2160,7 +2509,15 @@ var createDestruction = (options = {}) => {
         }
       }
       wearJoints(o, p, Ein * 0.5, void 0, 0, src);
-      res.damage += applyDamage(o, p, Ein * DMG_PER_J * (mat.damageScale?.explosive ?? 1), "explosive", point, null, Ein * 0.3, 40, src);
+      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 } : {} });
+        continue;
+      }
+      if (Ein > 20 && p.layers.length > 0) spallOuter(o, p, wp, faceOf(o, p, wn), wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), src);
+      const dealt = applyDamage(o, p, amount, "explosive", point, null, Ein * 0.3, 40, src);
+      res.damage += dealt;
+      addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
     }
     res.events = cur.slice(start);
     return res;
@@ -2431,7 +2788,7 @@ var createDestruction = (options = {}) => {
     }
     o.active = hot;
   };
-  const spread = (sources, dt) => {
+  const spread2 = (sources, dt) => {
     for (const src of sources) {
       if (!src.p.st.burning && !src.p.rt.jet) continue;
       const sc = toWorld(src.o.st.position, src.o.st.rotation, src.p.pos);
@@ -2483,6 +2840,15 @@ var createDestruction = (options = {}) => {
     }
     time = end;
   };
+  const releaseFront = () => {
+    if (frontQueue.length === 0) return;
+    frontQueue.sort((a, b) => a.due - b.due);
+    while (frontQueue.length > 0 && frontQueue[0].due <= time) {
+      const hit = frontQueue.shift();
+      if (objects.get(hit.o.id) !== hit.o) continue;
+      applyDamage(hit.o, hit.p, hit.amount, "explosive", hit.point, null, hit.fragEnergy, 40, hit.src);
+    }
+  };
   const withCollapses = (r) => {
     const last = r.value[r.value.length - 1];
     if (!last) return r.value;
@@ -2732,8 +3098,9 @@ var createDestruction = (options = {}) => {
         time += dt;
         const sources = [];
         for (const o of [...objects.values()]) if (o.active) stepObject(o, dt, sources);
-        if (sources.length) spread(sources, dt);
+        if (sources.length) spread2(sources, dt);
         detonatePrimed(time);
+        releaseFront();
         for (const im of [...impls.values()]) {
           if (!im.impl.update) continue;
           for (const e of im.impl.update(dt) ?? []) emit(e.time === void 0 ? { ...e, time } : e);
@@ -2771,7 +3138,7 @@ var createDestruction = (options = {}) => {
         counter,
         objects: [...objects.values()].map((o) => {
           const runtime = { parts: {}, joints: {}, collapsed: [...o.collapsed] };
-          for (const p of o.parts) runtime.parts[p.spec.id] = { ...p.rt };
+          for (const p of o.parts) runtime.parts[p.spec.id] = clone(p.rt);
           for (const j of o.joints) runtime.joints[j.spec.id] = j.step;
           return { id: o.id, spec: clone(o.spec), state: clone(o.st), runtime };
         }),
@@ -2788,7 +3155,7 @@ var createDestruction = (options = {}) => {
         const state = clone(e.state);
         const carry = {
           parts: new Map(
-            state.parts.map((st) => [st.id, { st, rt: e.runtime?.parts[st.id] ? { ...e.runtime.parts[st.id] } : { ...freshRuntime(), prevTemp: st.temperature } }])
+            state.parts.map((st) => [st.id, { st, rt: e.runtime?.parts[st.id] ? clone(e.runtime.parts[st.id]) : { ...freshRuntime(), prevTemp: st.temperature } }])
           ),
           joints: new Map(state.joints.map((st) => [st.id, { st, step: e.runtime?.joints[st.id] ?? 0 }])),
           collapsed: e.runtime?.collapsed
@@ -2807,6 +3174,109 @@ var createDestruction = (options = {}) => {
   return world;
 };
 
+// src/data/assemblies.json
+var assemblies_default = [
+  {
+    id: "brick_wall_plastered",
+    name: "Plastered brick wall",
+    core: { material: "brick", thickness: 0.09 },
+    layers: [{ material: "plaster", thickness: 0.02, faces: "both" }],
+    units: { size: [0.23, 0.075, 0.11], bond: "running", mortar: "plaster" },
+    breach: { area: 0.25 }
+  },
+  {
+    id: "concrete_block_wall",
+    name: "Concrete block wall",
+    core: { material: "concrete", thickness: 0.14 },
+    fill: 0.55,
+    units: { size: [0.39, 0.19, 0.14], bond: "running", mortar: "plaster" },
+    breach: { area: 0.25 }
+  },
+  {
+    id: "reinforced_concrete",
+    name: "Reinforced concrete wall",
+    core: { material: "concrete", thickness: 0.2 },
+    reinforcement: { material: "steel", spacing: 0.18, diameter: 8e-3, residualCapacity: 0.15 },
+    units: { size: [0.6, 0.42, 0.2], bond: "stack", mortar: "concrete" },
+    breach: { area: 0.25 }
+  },
+  {
+    id: "drywall",
+    name: "Drywall partition on steel studs",
+    core: { material: "plaster", thickness: 0.0125 },
+    layers: [{ material: "plaster", thickness: 0.0125, faces: "+" }],
+    depth: 0.095,
+    breach: { area: 0.25 }
+  },
+  {
+    id: "wood_frame_wall",
+    name: "Wood frame wall",
+    core: { material: "plywood", thickness: 0.012 },
+    layers: [{ material: "plaster", thickness: 0.0125, faces: "-" }],
+    depth: 0.1135,
+    breach: { area: 0.25 }
+  },
+  {
+    id: "log_wall",
+    name: "Log wall",
+    core: { material: "wood_soft", thickness: 0.2 },
+    fill: 0.785,
+    breach: { area: 0.25 }
+  },
+  {
+    id: "sheet_metal_shack",
+    name: "Corrugated sheet metal wall",
+    core: { material: "steel", thickness: 6e-4 },
+    depth: 0.02,
+    breach: { area: 0.25 }
+  },
+  {
+    id: "glass_pane",
+    name: "Glass pane",
+    core: { material: "glass", thickness: 6e-3 },
+    breach: { area: 0.1 }
+  }
+];
+
+// src/assemblies.ts
+var ASSEMBLIES = assemblies_default;
+var registerAssembly = (def) => {
+  const at = ASSEMBLIES.findIndex((a) => a.id === def.id);
+  if (at >= 0) ASSEMBLIES[at] = def;
+  else ASSEMBLIES.push(def);
+};
+var getAssembly = (id) => ASSEMBLIES.find((a) => a.id === id);
+var faceCount = (layer) => layer.faces === "both" ? 2 : 1;
+var assemblyDepth = (def) => def.depth ?? def.core.thickness + (def.layers ?? []).reduce((sum, l) => sum + l.thickness * faceCount(l), 0);
+var assemblyPart = (assemblyId, options) => {
+  const def = getAssembly(assemblyId);
+  if (!def) throw new Error(`unknown assembly "${assemblyId}"`);
+  const densityOf = (id) => {
+    const m = options.materials?.get(id) ?? MATERIALS.find((x) => x.id === id);
+    if (!m) throw new Error(`unknown material "${id}" in assembly "${assemblyId}"`);
+    return m.density;
+  };
+  const fill = def.fill ?? 1;
+  const area = options.width * options.height;
+  const coreMass = area * def.core.thickness * fill * densityOf(def.core.material);
+  const layerMass = (def.layers ?? []).reduce((sum, l) => sum + area * l.thickness * faceCount(l) * densityOf(l.material), 0);
+  return {
+    id: options.id,
+    material: def.core.material,
+    shape: { kind: "box", size: [options.width, options.height, assemblyDepth(def)] },
+    position: options.position,
+    ...options.rotation ? { rotation: options.rotation } : {},
+    mass: coreMass + layerMass,
+    thickness: def.core.thickness * fill,
+    ...def.layers ? { layers: def.layers.map((l) => ({ ...l })) } : {},
+    ...def.units ? { units: { ...def.units, size: [...def.units.size] } } : {},
+    ...def.reinforcement ? { reinforcement: { ...def.reinforcement } } : {},
+    ...def.breach ? { breach: { ...def.breach } } : {},
+    ...options.structure ? { structure: options.structure } : {},
+    ...options.extra
+  };
+};
+
 // src/frame.ts
 var buildFrame = (o = {}) => {
   const spanX = o.spanX ?? 8, spanZ = o.spanZ ?? 8;
@@ -2914,6 +3384,8 @@ var buildFrame = (o = {}) => {
 var sizeStructure = (spec, options = {}) => {
   const safety = options.safety ?? 0.65;
   const redundancy = options.redundancy;
+  const redundancyRoles = options.redundancyRoles ?? ["column"];
+  const safetyOf = (role) => options.safetyByRole?.[role] ?? safety;
   const loads = (s) => {
     const w = createDestruction(options.materials ? { materials: options.materials } : {});
     const id = w.add(s);
@@ -2926,11 +3398,11 @@ var sizeStructure = (spec, options = {}) => {
     if (!p.structure || p.structure.role === "none") continue;
     const b = base.get(p.id);
     if (!b || b.stress <= 0) continue;
-    need.set(p.id, b.load / safety);
+    need.set(p.id, b.load / safetyOf(p.structure.role));
   }
   if (redundancy !== void 0) {
     for (const col of out.parts) {
-      if (col.structure?.role !== "column") continue;
+      if (!col.structure || !redundancyRoles.includes(col.structure.role)) continue;
       const reduced = {
         ...out,
         parts: out.parts.filter((p) => p.id !== col.id),
@@ -3030,6 +3502,10 @@ var locales = {
       primed: "about to explode",
       stress: "overload",
       collapse: "collapsed",
+      spall: "plaster came off",
+      stage: "damage stage",
+      expose: "rebar bare",
+      body: "body",
       destroyed: "destroyed"
     },
     fractureStyles: { shatter: "shatter", crumble: "crumble", splinter: "splinter", tear: "tear", snap: "snap", none: "none" },
@@ -3112,6 +3588,10 @@ var locales = {
       primed: "prestes a explodir",
       stress: "sobrecarga",
       collapse: "desabou",
+      spall: "reboco soltou",
+      stage: "est\xE1gio de dano",
+      expose: "vergalh\xE3o \xE0 mostra",
+      body: "corpo",
       destroyed: "destru\xEDdo"
     },
     fractureStyles: { shatter: "estilha\xE7ar", crumble: "esfarelar", splinter: "lascar", tear: "rasgar", snap: "partir", none: "nenhuma" },
@@ -3128,17 +3608,21 @@ var checkDestructible = (impl, options = {}) => {
   return check(impl, contractOptions);
 };
 export {
+  ASSEMBLIES,
   FIRE_PRIME_C,
   IMPACT_CONTRACT,
   JOINT_BY_MATERIALS,
   JOINT_DEFAULTS,
   MATERIALS,
+  assemblyDepth,
+  assemblyPart,
   buildFrame,
   checkDestructible,
   checkHit,
   createDestruction,
   explosivePart,
   fragility,
+  getAssembly,
   guessMaterial,
   inferJoints,
   locales,
@@ -3148,6 +3632,7 @@ export {
   partVolume,
   quat,
   quatFromEuler,
+  registerAssembly,
   resolveStrings,
   rotateVec,
   sizeStructure,