@adatechnology/game-destruction 0.6.1 → 0.7.1

package/dist/index.js

@@ -836,7 +836,8 @@ var materials_default = [
       0.25
     ],
     damageScale: {
-      blunt: 1.5
+      blunt: 1.5,
+      shelter: 3
     },
     hitDebris: "shards",
     breakDebris: "shards",
@@ -887,7 +888,10 @@ var materials_default = [
       "glass",
       "brittle"
     ],
-    compressive: 2e5
+    compressive: 2e5,
+    damageScale: {
+      shelter: 3
+    }
   },
   {
     id: "ceramic",
@@ -1573,10 +1577,14 @@ var fragility = (ductility, thickness) => {
 // src/world.ts
 var DMG_PER_J = 0.02;
 var BLAST_COUPLING = 0.1;
+var SHELTER_DEFAULTS = { k: 2800, brokenTransmission: 0.5, minPath: 5e-3 };
+var FRAGMENT_HIT_DEFAULTS = { max: 24, energyFactor: 0.5, hitType: "blunt", range: 6, flightTime: 0.4, spread: 10, aim: 40 };
+var CONFINEMENT_DEFAULTS = { rays: 26, reach: 1.5, gain: 1.5, power: 2, max: 3 };
 var FLAMMABLE_FLUIDS = ["gas", "fuel"];
 var BREACH_RADIUS = 0.55;
 var BREACH_BLAST_FACTOR = 6;
 var BREACH_AREA = 0.25;
+var BREACH_BLAST_REACH = Infinity;
 var RESIDUAL_CAPACITY = 0.15;
 var UNIT_FRAGMENT_FACTOR = 4;
 var BREACH_GRID_CAP = 4096;
@@ -1611,6 +1619,7 @@ var createDestruction = (options = {}) => {
   const fireSpread = options.fireSpread ?? 0.6;
   const breachRadius = options.breach?.radius ?? BREACH_RADIUS;
   const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
+  const breachBlastReach = options.breach?.blastReach ?? BREACH_BLAST_REACH;
   const rng = createRng(options.seed ?? 1);
   const rnd = () => rng.next();
   let time = 0;
@@ -1966,7 +1975,7 @@ var createDestruction = (options = {}) => {
     if (disc < 0) return true;
     return -b - Math.sqrt(disc) > maxDist;
   };
-  const raycastInternal = (origin, dir, maxDist, ignore) => {
+  const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false) => {
     const d = vec.normalize(dir);
     let best = null;
     for (const o of objects.values()) {
@@ -1979,7 +1988,7 @@ var createDestruction = (options = {}) => {
         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 };
       }
     }
-    for (const im of impls.values()) {
+    for (const im of worldOnly ? [] : impls.values()) {
       for (const ps of im.impl.describe().parts) {
         if (ignore?.has(`${im.impl.id}\0${ps.id}`)) continue;
         const ov = im.poses.get(ps.id);
@@ -2392,7 +2401,7 @@ var createDestruction = (options = {}) => {
     else if (chained && (trigger === "explosion" || 1 - p.st.hp / p.st.maxHp >= shotDamageFractionOf(p.spec))) prime(o, p, trigger, src);
     return done;
   };
-  const ballistic = (o, p, entry, n, d, E, caliber, pathLen, src) => {
+  const ballistic = (o, p, entry, n, d, E, caliber, pathLen, src, piercing = 1) => {
     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 };
@@ -2405,7 +2414,9 @@ var createDestruction = (options = {}) => {
     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 hard = mat.tags?.includes("metal") || mat.tags?.includes("masonry");
+    const Ep = piercing === 1 || !hard ? E : E * piercing;
+    const penetrated = Ep > thr;
     const scale = (mat.damageScale?.ballistic ?? 1) * (mat.fracture === "shatter" ? fragility(mat.ductility, p.thickness) : 1);
     const id = p.spec.id;
     if (!penetrated && mat.ricochetDeg && angle < mat.ricochetDeg) {
@@ -2417,7 +2428,7 @@ var createDestruction = (options = {}) => {
     }
     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 ratio = Ep / Math.max(thr, 1e-6);
     const crackLen = clamp2(0.03 + ratio * 0.2, 0.03, 0.8);
     let exitPoint;
     if (penetrated) {
@@ -2447,7 +2458,7 @@ var createDestruction = (options = {}) => {
     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);
-    return { penetrated, exitEnergy: penetrated ? E - thr : 0, exitPoint, damage: dmg };
+    return { penetrated, exitEnergy: penetrated ? E - thr / (hard ? piercing : 1) : 0, exitPoint, damage: dmg };
   };
   const melee = (o, p, kind, E, point, n, d, contactR, src) => {
     const mat = p.mat;
@@ -2475,54 +2486,110 @@ var createDestruction = (options = {}) => {
     addBreach(o, p, point, breachAreaOf(p, done, false), E, d, src);
     return done;
   };
+  const blastPart = (o, p, point, energy, radius, src, res, reachAt) => {
+    if (isLost(p)) return null;
+    const { c, q } = partXf(o, p);
+    const lp = toLocal(c, q, point);
+    const dist = distanceToShape(p.spec.shape, lp);
+    if (dist >= radius) return null;
+    const sp = surfacePoint(p.spec.shape, lp);
+    const wp = toWorld(c, q, sp.point);
+    const reach = reachAt ? reachAt(wp, p) : 1;
+    const f = (1 - dist / radius) ** 2 * reach;
+    const Ein = energy * f * BLAST_COUPLING;
+    const wn = rotateVec(q, sp.normal);
+    if (!res.part) {
+      res.part = p.spec.id;
+      res.point = wp;
+    }
+    const mat = p.mat;
+    if (Ein > 20) {
+      if (mat.ductility >= 0.5) addDent(o, p, wp, wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), clamp2(4e-3 + Ein * 2e-5, 4e-3, 0.08), src);
+      else if (mat.ductility < 0.3 && Ein > 60) addCrack(o, p, wp, wn, clamp2(0.05 + Ein * 5e-4, 0.05, 1), src);
+      debris(o, p, mat.hitDebris, wp, wn, clamp2(Math.round(Ein / 80) + 1, 1, 12), clamp2(Math.sqrt(Ein) / 4, 2, 15), src);
+    }
+    const th = mat.thermal;
+    if (th.ignitionC !== void 0 && p.st.fuel > 0) {
+      p.st.temperature += 300 * f;
+      o.active = true;
+      if (f >= 0.25 && !p.st.burning) {
+        p.st.temperature = Math.max(p.st.temperature, th.ignitionC + 1);
+        checkIgnite(o, p, src);
+      }
+    }
+    wearJoints(o, p, Ein * 0.5, void 0, 0, 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 } : {} });
+      return reach;
+    }
+    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;
+    if (dist <= breachBlastReach * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
+    return reach;
+  };
   const blastObject = (o, point, energy, radius, src) => {
     const start = cur.length;
     const res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] };
-    for (const p of o.parts) {
-      if (isLost(p)) continue;
-      const { c, q } = partXf(o, p);
-      const lp = toLocal(c, q, point);
-      const dist = distanceToShape(p.spec.shape, lp);
-      if (dist >= radius) continue;
-      const f = (1 - dist / radius) ** 2;
-      const Ein = energy * f * BLAST_COUPLING;
-      const sp = surfacePoint(p.spec.shape, lp);
-      const wp = toWorld(c, q, sp.point);
-      const wn = rotateVec(q, sp.normal);
-      if (!res.part) {
-        res.part = p.spec.id;
-        res.point = wp;
-      }
-      const mat = p.mat;
-      if (Ein > 20) {
-        if (mat.ductility >= 0.5) addDent(o, p, wp, wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), clamp2(4e-3 + Ein * 2e-5, 4e-3, 0.08), src);
-        else if (mat.ductility < 0.3 && Ein > 60) addCrack(o, p, wp, wn, clamp2(0.05 + Ein * 5e-4, 0.05, 1), src);
-        debris(o, p, mat.hitDebris, wp, wn, clamp2(Math.round(Ein / 80) + 1, 1, 12), clamp2(Math.sqrt(Ein) / 4, 2, 15), src);
-      }
-      const th = mat.thermal;
-      if (th.ignitionC !== void 0 && p.st.fuel > 0) {
-        p.st.temperature += 300 * f;
-        o.active = true;
-        if (f >= 0.25 && !p.st.burning) {
-          p.st.temperature = Math.max(p.st.temperature, th.ignitionC + 1);
-          checkIgnite(o, p, src);
-        }
+    for (const p of o.parts) blastPart(o, p, point, energy, radius, src, res);
+    res.events = cur.slice(start);
+    return res;
+  };
+  const blastCfg = (call) => {
+    const pick = (key) => call && call[key] !== void 0 ? call[key] : options.blast?.[key];
+    const merge = (v, defaults) => {
+      if (!v) return null;
+      const out = { ...defaults };
+      if (v !== true) {
+        for (const [key, value] of Object.entries(v)) if (value !== void 0) out[key] = value;
       }
-      wearJoints(o, p, Ein * 0.5, void 0, 0, 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;
+      return out;
+    };
+    const conf = pick("confinement");
+    return {
+      shelter: merge(pick("shelter"), SHELTER_DEFAULTS),
+      frag: merge(pick("fragmentHits"), FRAGMENT_HIT_DEFAULTS),
+      conf: typeof conf === "number" ? Number.isFinite(conf) ? Math.max(0, conf) : 1 : merge(conf, CONFINEMENT_DEFAULTS)
+    };
+  };
+  const confinementRays = /* @__PURE__ */ new Map();
+  const raysOf = (n) => {
+    let rays = confinementRays.get(n);
+    if (rays) return rays;
+    const r = createRng((options.seed ?? 1) ^ 1540483477);
+    const off = r.next();
+    const phi0 = r.next() * Math.PI * 2;
+    rays = [];
+    for (let i = 0; i < n; i++) {
+      const y = 1 - 2 * (i + off) / n;
+      const s = Math.sqrt(Math.max(0, 1 - y * y));
+      const phi = phi0 + i * 2.399963229728653;
+      rays.push([Math.cos(phi) * s, y, Math.sin(phi) * s]);
+    }
+    confinementRays.set(n, rays);
+    return rays;
+  };
+  const confinementOf = (conf, point, radius) => {
+    if (conf === null) return 1;
+    if (typeof conf === "number") return conf;
+    let hits = 0;
+    let sum = 0;
+    for (const d of raysOf(Math.max(1, Math.round(conf.rays)))) {
+      const h = raycastInternal(point, d, radius * conf.reach, void 0, true);
+      if (h) {
+        hits++;
+        sum += h.distance;
       }
-      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;
+    if (hits === 0) return 1;
+    const closed = hits / Math.max(1, Math.round(conf.rays));
+    const ratio = clamp2(radius / Math.max(sum / hits, 1e-3), 0, 2);
+    return Math.min(Math.max(1, conf.max), 1 + conf.gain * closed ** conf.power * ratio);
   };
-  const blastWorld = (point, energy, radius, src) => {
+  const FLAG_LOST = 1;
+  const FLAG_OPEN = 2;
+  const blastPlain = (point, energy, radius, src) => {
     const out = [];
     for (const o of [...objects.values()]) {
       if (vec.distance(toWorld(o.st.position, o.st.rotation, o.bc), point) - o.br >= radius) continue;
@@ -2530,16 +2597,225 @@ var createDestruction = (options = {}) => {
       if (r.part) out.push(r);
     }
     for (const im of [...impls.values()]) {
-      const inRange = im.impl.describe().parts.some((ps) => {
-        const ov = im.poses.get(ps.id);
-        const c = toWorld(im.position, im.rotation, ov?.pos ?? ps.position);
-        const q = quat.mul(im.rotation, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]));
-        return distanceToShape(ps.shape, toLocal(c, q, point)) < radius;
-      });
-      if (inRange) out.push(implHit(im, { type: "explosive", point, energy, radius, ...src !== void 0 ? { source: src } : {} }));
+      if (implInRange(im, point, radius)) out.push(implHit(im, { type: "explosive", point, energy, radius, ...src !== void 0 ? { source: src } : {} }));
     }
     return out;
   };
+  const implParts = (im) => im.impl.describe().parts.map((ps) => {
+    const ov = im.poses.get(ps.id);
+    return { ps, c: toWorld(im.position, im.rotation, ov?.pos ?? ps.position), q: quat.mul(im.rotation, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0])) };
+  });
+  const implInRange = (im, point, radius) => implParts(im).some(({ ps, c, q }) => distanceToShape(ps.shape, toLocal(c, q, point)) < radius);
+  const blastScene = (point, energy, radius, src, cfg, only) => {
+    const mult = confinementOf(cfg.conf, point, radius);
+    const E = energy * mult;
+    const shelter = cfg.shelter;
+    const flags = /* @__PURE__ */ new Map();
+    const inRange = [];
+    for (const o of objects.values()) {
+      if (vec.distance(toWorld(o.st.position, o.st.rotation, o.bc), point) - o.br >= radius) continue;
+      inRange.push(o);
+      if (shelter) for (const p of o.parts) flags.set(p, (isLost(p) ? FLAG_LOST : 0) | (p.st.opening || p.st.stripped ? FLAG_OPEN : 0));
+    }
+    const shields = /* @__PURE__ */ new Map();
+    const reachAt = (tp, self) => {
+      if (!shelter) return 1;
+      const L = vec.distance(point, tp);
+      if (L < 1e-4) return 1;
+      const d = vec.scale(vec.sub(tp, point), 1 / L);
+      let t = 1;
+      for (const o of inRange) {
+        if (raySphereMiss(point, d, toWorld(o.st.position, o.st.rotation, o.bc), o.br, L)) continue;
+        for (const p of o.parts) {
+          if (p === self) continue;
+          const was = flags.get(p) ?? 0;
+          if (was & FLAG_LOST) continue;
+          const r = rayPart(o, p, point, d);
+          if (!r) continue;
+          const t0 = Math.max(r.t0, 0);
+          const path = Math.min(r.t1, L) - t0;
+          if (path < shelter.minPath) continue;
+          const mid = vec.madd(point, d, t0 + path / 2);
+          const opening = p.st.opening && insideOpening(o, p, mid);
+          if (opening && was & FLAG_OPEN) continue;
+          if (p.st.stripped && was & FLAG_OPEN) continue;
+          const resistance = p.mat.hpPerKg * p.mat.density * path * (p.mat.damageScale?.shelter ?? 1);
+          let ti = Math.exp(-resistance / shelter.k);
+          if (isLost(p) || opening || p.st.stripped && !(was & FLAG_OPEN)) ti += (1 - ti) * shelter.brokenTransmission;
+          t *= ti;
+          if (cfg.frag) {
+            let list = shields.get(p);
+            if (!list) shields.set(p, list = []);
+            list.push(tp);
+          }
+        }
+      }
+      return t;
+    };
+    const items = [];
+    let order = 0;
+    for (const o of inRange) {
+      if (only && only !== o) continue;
+      for (const p of o.parts) {
+        if (isLost(p)) continue;
+        const dist = distToPart(o, p, point);
+        if (dist < radius) items.push({ dist, order: order++, o, p });
+      }
+    }
+    for (const im of impls.values()) {
+      if (only && only !== im) continue;
+      let dist = Infinity;
+      for (const { ps, c, q } of implParts(im)) dist = Math.min(dist, distanceToShape(ps.shape, toLocal(c, q, point)));
+      if (dist < radius) items.push({ dist, order: order++, im });
+    }
+    items.sort((a, b) => a.dist - b.dist || a.order - b.order);
+    const results = /* @__PURE__ */ new Map();
+    const reports = /* @__PURE__ */ new Map();
+    const report = (key) => {
+      let r = reports.get(key);
+      if (!r) reports.set(key, r = { shelter: 0, confinement: mult, fragmentHits: 0 });
+      return r;
+    };
+    const thrown = [];
+    const sweep = (from) => {
+      if (!cfg.frag) return;
+      for (let i = from; i < cur.length; i++) {
+        const e = cur[i];
+        if (e.type !== "fracture" && e.type !== "stage") continue;
+        for (const frag of e.fragments ?? []) thrown.push({ frag, object: e.object, part: objects.get(e.object)?.byId.get(e.part) ?? null });
+      }
+    };
+    for (const it of items) {
+      if (it.o && it.p) {
+        const o = it.o;
+        let res = results.get(o);
+        if (!res) results.set(o, res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] });
+        const start = cur.length;
+        const k = blastPart(o, it.p, point, E, radius, src, res, shelter ? reachAt : void 0);
+        res.events.push(...cur.slice(start));
+        sweep(start);
+        if (k !== null) {
+          const rep = report(o);
+          rep.shelter = Math.max(rep.shelter, k);
+          if (shelter) (rep.parts ?? (rep.parts = {}))[it.p.spec.id] = k;
+        }
+      } else if (it.im) {
+        const im = it.im;
+        let num = 0;
+        let den = 0;
+        for (const { ps, c, q } of implParts(im)) {
+          const lp = toLocal(c, q, point);
+          const dist = distanceToShape(ps.shape, lp);
+          if (dist >= radius) continue;
+          const f = (1 - dist / radius) ** 2;
+          const sp = surfacePoint(ps.shape, lp);
+          num += f * reachAt(toWorld(c, q, sp.point), null);
+          den += f;
+        }
+        const k = den > 0 ? num / den : 1;
+        const res = implHit(im, { type: "explosive", point, energy: E * k, radius, ...shelter ? { shelter: k } : {}, ...src !== void 0 ? { source: src } : {} });
+        results.set(im, res);
+        report(im).shelter = k;
+      }
+    }
+    if (cfg.frag && thrown.length > 0) {
+      const g = cfg.frag;
+      const energyOf = (f) => 0.5 * f.mass * (f.velocity[0] ** 2 + f.velocity[1] ** 2 + f.velocity[2] ** 2);
+      const list = thrown.map((t, i) => ({ ...t, i, e: energyOf(t.frag) })).sort((a, b) => b.e - a.e || a.i - b.i).slice(0, Math.max(0, Math.floor(g.max)));
+      list.forEach((t, i) => throwFragment(t.frag, t.object, t.part, g, point, i, src, shields, results, reports, mult));
+    }
+    const out = [];
+    const reportShelter = (key, res) => {
+      res.blast = reports.get(key) ?? { shelter: 1, confinement: mult, fragmentHits: 0 };
+    };
+    const summary = [];
+    let fragmentHits = 0;
+    for (const o of objects.values()) {
+      const r = results.get(o);
+      if (!r?.part) continue;
+      reportShelter(o, r);
+      out.push(r);
+      for (const [part, factor] of Object.entries(r.blast?.parts ?? {})) summary.push({ object: o.id, part, factor });
+      fragmentHits += r.blast?.fragmentHits ?? 0;
+    }
+    for (const im of impls.values()) {
+      const r = results.get(im);
+      if (!r) continue;
+      reportShelter(im, r);
+      out.push(r);
+      if (shelter) summary.push({ object: im.impl.id, factor: r.blast?.shelter ?? 1 });
+      fragmentHits += r.blast?.fragmentHits ?? 0;
+    }
+    emit({ type: "blast", object: "", time, ...src !== void 0 ? { source: src } : {}, point, energy: E, radius, confinement: mult, shelter: summary, fragmentHits });
+    return out;
+  };
+  const seedOf = (...nums) => {
+    let h = 2166136261;
+    for (const n of nums) {
+      h = Math.imul(h ^ (Math.round(n * 1e3) | 0), 16777619);
+      h ^= h >>> 15;
+    }
+    return h | 0;
+  };
+  const throwFragment = (frag, objectId, from, g, centre, index, src, shields, results, reports, mult) => {
+    const v = frag.velocity;
+    const speed = Math.hypot(v[0], v[1], v[2]);
+    const energy = g.energyFactor * 0.5 * frag.mass * speed * speed;
+    if (speed < 0.5 || energy < 1) return;
+    const r = createRng(seedOf(options.seed ?? 1, centre[0], centre[1], centre[2], index, frag.center[0], frag.center[1], frag.center[2]));
+    let dir = vec.scale(v, 1 / speed);
+    const behind = from ? shields.get(from) : void 0;
+    if (behind) {
+      let best = Math.cos(g.aim * Math.PI / 180);
+      for (const tp of behind) {
+        const to = vec.sub(tp, frag.center);
+        const len = vec.length(to);
+        if (len < 1e-4) continue;
+        const cos = vec.dot(dir, to) / len;
+        if (cos >= best) {
+          best = cos;
+          dir = vec.scale(to, 1 / len);
+        }
+      }
+    }
+    const spread3 = Math.tan(g.spread * Math.PI / 180);
+    dir = vec.normalize([dir[0] + (r.next() - 0.5) * 2 * spread3, dir[1] + (r.next() - 0.5) * 2 * spread3, dir[2] + (r.next() - 0.5) * 2 * spread3], dir);
+    const range = Math.min(g.range, speed * g.flightTime);
+    const origin = vec.madd(frag.center, dir, 0.02);
+    const rh = raycastInternal(origin, dir, range, from ? /* @__PURE__ */ new Set([`${objectId}\0${from.spec.id}`]) : void 0);
+    if (!rh) return;
+    const hit = {
+      type: g.hitType,
+      point: rh.point,
+      direction: dir,
+      energy,
+      radius: 0.05,
+      part: rh.part,
+      ...g.hitType === "ballistic" ? { caliber: clamp2(Math.max(...frag.size) * 1e3, 3, 30), mass: frag.mass * 1e3 } : {},
+      ...src !== void 0 ? { source: src } : {}
+    };
+    emit({ type: "fragment_hit", object: objectId, time, ...src !== void 0 ? { source: src } : {}, from: { object: objectId, part: frag.part }, target: { object: rh.object, part: rh.part }, point: rh.point, direction: dir, energy, mass: frag.mass, speed });
+    const im = impls.get(rh.object);
+    const o = im ? void 0 : objects.get(rh.object);
+    const key = im ?? o;
+    if (!key) return;
+    const res = im ? implHit(im, hit) : doHit(o, hit, o.byId.get(rh.part));
+    const have = results.get(key);
+    if (have) {
+      have.damage += res.damage;
+      have.events.push(...res.events);
+      if (!have.part) have.part = res.part;
+      if (res.penetrated) have.penetrated = true;
+    } else results.set(key, { ...res, events: [...res.events] });
+    let rep = reports.get(key);
+    if (!rep) reports.set(key, rep = { shelter: 1, confinement: mult, fragmentHits: 0 });
+    rep.fragmentHits++;
+  };
+  const blastWorld = (point, energy, radius, src, call, only) => {
+    const cfg = blastCfg(call);
+    if (!cfg.shelter && !cfg.frag && cfg.conf === null) return blastPlain(point, energy, radius, src);
+    return blastScene(point, energy, radius, src, cfg, only);
+  };
   const heatObject = (o, point, T, radius, duration, src) => {
     const start = cur.length;
     const res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] };
@@ -2576,7 +2852,7 @@ var createDestruction = (options = {}) => {
     if (hit.type === "ballistic") {
       const loc = locate(o, point, dir, 0.05, only);
       if (loc) {
-        const out = ballistic(o, loc.p, loc.point, loc.normal, loc.dir, E, hit.caliber ?? 9, loc.pathLen, src);
+        const out = ballistic(o, loc.p, loc.point, loc.normal, loc.dir, E, hit.caliber ?? 9, loc.pathLen, src, hit.piercing ?? 1);
         res = { ...res, part: loc.p.spec.id, point: loc.point, damage: out.damage, penetrated: out.penetrated, exitEnergy: out.exitEnergy };
       }
     } else if (hit.type === "blunt" || hit.type === "slash") {
@@ -2598,7 +2874,13 @@ var createDestruction = (options = {}) => {
         }
       }
     } else if (hit.type === "explosive") {
-      res = blastObject(o, point, E, hit.radius ?? 2, src);
+      const call = hit.blast || hit.confinement !== void 0 ? { ...hit.blast, ...hit.confinement !== void 0 ? { confinement: hit.confinement } : {} } : void 0;
+      const cfg = blastCfg(call);
+      if (!cfg.shelter && !cfg.frag && cfg.conf === null) res = blastObject(o, point, E, hit.radius ?? 2, src);
+      else {
+        res = blastWorld(point, E, hit.radius ?? 2, src, call, o)[0] ?? res;
+        res.events = cur.slice(start);
+      }
     } else {
       res = heatObject(o, point, hit.temperature ?? 800, hit.radius ?? 0.25, hit.duration ?? 1, src);
     }
@@ -2855,6 +3137,14 @@ var createDestruction = (options = {}) => {
     for (const e of r.events) if (e.type === "collapse" && !r.value.some((h) => h.events.includes(e))) last.events.push(e);
     return r.value;
   };
+  const blastImpl = (im, h) => {
+    const call = h.blast || h.confinement !== void 0 ? { ...h.blast, ...h.confinement !== void 0 ? { confinement: h.confinement } : {} } : void 0;
+    const cfg = blastCfg(call);
+    if (!cfg.shelter && !cfg.frag && cfg.conf === null) return implHit(im, h);
+    const world2 = h.space === "local" ? toWorld(im.position, im.rotation, h.point) : h.point;
+    const r = blastWorld(world2, h.energy ?? 0, h.radius ?? 2, h.source, call, im);
+    return r.find((x) => x.object === im.impl.id) ?? implHit(im, h);
+  };
   const whole = (fn) => {
     const r = run(fn);
     r.value.events = r.events;
@@ -2942,7 +3232,7 @@ var createDestruction = (options = {}) => {
     },
     hit(objectId, h) {
       const im = impls.get(objectId);
-      if (im) return whole(() => implHit(im, h));
+      if (im) return whole(() => h.type === "explosive" ? blastImpl(im, h) : implHit(im, h));
       const o = getObj(objectId);
       return whole(() => doHit(o, h));
     },
@@ -2953,14 +3243,14 @@ var createDestruction = (options = {}) => {
       const p = getPart(o, partId);
       return whole(() => doHit(o, h, p));
     },
-    explode(point, energy, radius, source) {
-      return withCollapses(run(() => blastWorld(point, energy, radius, source)));
+    explode(point, energy, radius, source, blast) {
+      return withCollapses(run(() => blastWorld(point, energy, radius, source, blast)));
     },
     raycast(origin, direction, maxDistance = Infinity) {
       const r = raycastInternal(origin, direction, maxDistance);
       return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
     },
-    shoot(origin, direction, energy, caliber, source) {
+    shoot(origin, direction, energy, caliber, source, piercing) {
       return withCollapses(run(() => {
         const results = [];
         const d = vec.normalize(direction);
@@ -2972,7 +3262,7 @@ var createDestruction = (options = {}) => {
           if (!rh) break;
           const im = impls.get(rh.object);
           if (im) {
-            const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...source !== void 0 ? { source } : {} });
+            const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...piercing !== void 0 ? { piercing } : {}, ...source !== void 0 ? { source } : {} });
             r.part = rh.part;
             r.point = rh.point;
             r.exitEnergy = r.penetrated ? E * 0.5 : 0;
@@ -2986,7 +3276,7 @@ var createDestruction = (options = {}) => {
           const o = getObj(rh.object);
           const p = getPart(o, rh.part);
           const start = cur.length;
-          const out = ballistic(o, p, rh.point, rh.normal, d, E, caliber, rh.pathLen, source);
+          const out = ballistic(o, p, rh.point, rh.normal, d, E, caliber, rh.pathLen, source, piercing ?? 1);
           results.push({ object: o.id, part: p.spec.id, point: rh.point, damage: out.damage, penetrated: out.penetrated, exitEnergy: out.exitEnergy, events: cur.slice(start) });
           ignore.add(`${o.id}\0${p.spec.id}`);
           if (!out.penetrated || !out.exitPoint) break;
@@ -3174,6 +3464,21 @@ var createDestruction = (options = {}) => {
   return world;
 };
 
+// src/piercing.ts
+var PIERCING_BY_KIND = {
+  fmj: 1,
+  hp: 0.6,
+  ap: 1.6,
+  buck: 0.5,
+  slug: 0.25,
+  birdshot: 0.3,
+  rimfire: 1,
+  arrow: 1,
+  bolt: 1
+};
+var PIERCING_BY_CALIBER = { "5_56x45": 0.5, "5_45x39": 0.5, "22lr": 0.5 };
+var piercingOf = (caliber, kind) => PIERCING_BY_CALIBER[caliber] ?? PIERCING_BY_KIND[kind ?? "fmj"] ?? 1;
+
 // src/data/assemblies.json
 var assemblies_default = [
   {
@@ -3506,6 +3811,8 @@ var locales = {
       stage: "damage stage",
       expose: "rebar bare",
       body: "body",
+      blast: "blast",
+      fragment_hit: "fragment hit",
       destroyed: "destroyed"
     },
     fractureStyles: { shatter: "shatter", crumble: "crumble", splinter: "splinter", tear: "tear", snap: "snap", none: "none" },
@@ -3592,6 +3899,8 @@ var locales = {
       stage: "est\xE1gio de dano",
       expose: "vergalh\xE3o \xE0 mostra",
       body: "corpo",
+      blast: "explos\xE3o",
+      fragment_hit: "estilha\xE7o atingiu",
       destroyed: "destru\xEDdo"
     },
     fractureStyles: { shatter: "estilha\xE7ar", crumble: "esfarelar", splinter: "lascar", tear: "rasgar", snap: "partir", none: "nenhuma" },
@@ -3609,11 +3918,16 @@ var checkDestructible = (impl, options = {}) => {
 };
 export {
   ASSEMBLIES,
+  CONFINEMENT_DEFAULTS,
   FIRE_PRIME_C,
+  FRAGMENT_HIT_DEFAULTS,
   IMPACT_CONTRACT,
   JOINT_BY_MATERIALS,
   JOINT_DEFAULTS,
   MATERIALS,
+  PIERCING_BY_CALIBER,
+  PIERCING_BY_KIND,
+  SHELTER_DEFAULTS,
   assemblyDepth,
   assemblyPart,
   buildFrame,
@@ -3630,6 +3944,7 @@ export {
   partMass,
   partThickness,
   partVolume,
+  piercingOf,
   quat,
   quatFromEuler,
   registerAssembly,