@adatechnology/game-destruction 0.4.2 → 0.6.0

package/dist/index.global.js

@@ -21,17 +21,21 @@ var GameDestruction = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    ASSEMBLIES: () => ASSEMBLIES,
     FIRE_PRIME_C: () => FIRE_PRIME_C,
     IMPACT_CONTRACT: () => IMPACT_CONTRACT,
     JOINT_BY_MATERIALS: () => JOINT_BY_MATERIALS,
     JOINT_DEFAULTS: () => JOINT_DEFAULTS,
     MATERIALS: () => MATERIALS,
+    assemblyDepth: () => assemblyDepth,
+    assemblyPart: () => assemblyPart,
     buildFrame: () => buildFrame,
     checkDestructible: () => checkDestructible2,
     checkHit: () => checkHit,
     createDestruction: () => createDestruction,
     explosivePart: () => explosivePart,
     fragility: () => fragility,
+    getAssembly: () => getAssembly,
     guessMaterial: () => guessMaterial,
     inferJoints: () => inferJoints,
     locales: () => locales,
@@ -41,6 +45,7 @@ var GameDestruction = (() => {
     partVolume: () => partVolume,
     quat: () => quat,
     quatFromEuler: () => quatFromEuler,
+    registerAssembly: () => registerAssembly,
     resolveStrings: () => resolveStrings,
     rotateVec: () => rotateVec,
     sizeStructure: () => sizeStructure,
@@ -470,6 +475,153 @@ var GameDestruction = (() => {
     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 = [
     {
@@ -1478,9 +1630,19 @@ var GameDestruction = (() => {
   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));
@@ -1503,6 +1665,8 @@ var GameDestruction = (() => {
     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;
@@ -1511,6 +1675,8 @@ var GameDestruction = (() => {
     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();
@@ -1607,6 +1773,13 @@ var GameDestruction = (() => {
         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,
@@ -1622,7 +1795,8 @@ var GameDestruction = (() => {
           dents: [],
           holes: [],
           cracks: [],
-          group: 0
+          group: 0,
+          ...staged ? { stage: 0 } : {}
         };
         if (!c && ps.contains) pst.liters = ps.contains.liters;
         const p = {
@@ -1641,7 +1815,10 @@ var GameDestruction = (() => {
           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);
@@ -1781,7 +1958,7 @@ var GameDestruction = (() => {
           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;
@@ -1800,6 +1977,7 @@ var GameDestruction = (() => {
           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) });
         }
@@ -1853,6 +2031,7 @@ var GameDestruction = (() => {
           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 };
         }
       }
@@ -1961,6 +2140,7 @@ var GameDestruction = (() => {
       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) => {
@@ -1969,6 +2149,7 @@ var GameDestruction = (() => {
       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);
@@ -2017,6 +2198,7 @@ var GameDestruction = (() => {
       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) {
@@ -2030,23 +2212,172 @@ var GameDestruction = (() => {
         }
       }
     };
+    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;
@@ -2056,6 +2387,7 @@ var GameDestruction = (() => {
         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,
@@ -2066,18 +2398,27 @@ var GameDestruction = (() => {
           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);
@@ -2109,10 +2450,17 @@ var GameDestruction = (() => {
     };
     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;
@@ -2123,13 +2471,16 @@ var GameDestruction = (() => {
         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({
@@ -2174,8 +2525,11 @@ var GameDestruction = (() => {
       }
       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;
@@ -2211,7 +2565,15 @@ var GameDestruction = (() => {
           }
         }
         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;
@@ -2482,7 +2844,7 @@ var GameDestruction = (() => {
       }
       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);
@@ -2534,6 +2896,15 @@ var GameDestruction = (() => {
       }
       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;
@@ -2783,8 +3154,9 @@ var GameDestruction = (() => {
           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);
@@ -2822,7 +3194,7 @@ var GameDestruction = (() => {
           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 };
           }),
@@ -2839,7 +3211,7 @@ var GameDestruction = (() => {
           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
@@ -2858,6 +3230,109 @@ var GameDestruction = (() => {
     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;
@@ -2965,6 +3440,8 @@ var GameDestruction = (() => {
   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);
@@ -2977,11 +3454,11 @@ var GameDestruction = (() => {
       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),
@@ -3081,6 +3558,10 @@ var GameDestruction = (() => {
         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" },
@@ -3163,6 +3644,10 @@ var GameDestruction = (() => {
         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" },