@adatechnology/game-destruction 0.6.1 → 0.7.0

package/dist/index.global.js

@@ -22,11 +22,16 @@ var GameDestruction = (() => {
   var index_exports = {};
   __export(index_exports, {
     ASSEMBLIES: () => ASSEMBLIES,
+    CONFINEMENT_DEFAULTS: () => CONFINEMENT_DEFAULTS,
     FIRE_PRIME_C: () => FIRE_PRIME_C,
+    FRAGMENT_HIT_DEFAULTS: () => FRAGMENT_HIT_DEFAULTS,
     IMPACT_CONTRACT: () => IMPACT_CONTRACT,
     JOINT_BY_MATERIALS: () => JOINT_BY_MATERIALS,
     JOINT_DEFAULTS: () => JOINT_DEFAULTS,
     MATERIALS: () => MATERIALS,
+    PIERCING_BY_CALIBER: () => PIERCING_BY_CALIBER,
+    PIERCING_BY_KIND: () => PIERCING_BY_KIND,
+    SHELTER_DEFAULTS: () => SHELTER_DEFAULTS,
     assemblyDepth: () => assemblyDepth,
     assemblyPart: () => assemblyPart,
     buildFrame: () => buildFrame,
@@ -43,6 +48,7 @@ var GameDestruction = (() => {
     partMass: () => partMass,
     partThickness: () => partThickness,
     partVolume: () => partVolume,
+    piercingOf: () => piercingOf,
     quat: () => quat,
     quatFromEuler: () => quatFromEuler,
     registerAssembly: () => registerAssembly,
@@ -892,7 +898,8 @@ var GameDestruction = (() => {
         0.25
       ],
       damageScale: {
-        blunt: 1.5
+        blunt: 1.5,
+        shelter: 3
       },
       hitDebris: "shards",
       breakDebris: "shards",
@@ -943,7 +950,10 @@ var GameDestruction = (() => {
         "glass",
         "brittle"
       ],
-      compressive: 2e5
+      compressive: 2e5,
+      damageScale: {
+        shelter: 3
+      }
     },
     {
       id: "ceramic",
@@ -1629,10 +1639,14 @@ var GameDestruction = (() => {
   // 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;
@@ -1667,6 +1681,7 @@ var GameDestruction = (() => {
     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;
@@ -2022,7 +2037,7 @@ var GameDestruction = (() => {
       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()) {
@@ -2035,7 +2050,7 @@ var GameDestruction = (() => {
           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);
@@ -2448,7 +2463,7 @@ var GameDestruction = (() => {
       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 };
@@ -2461,7 +2476,9 @@ var GameDestruction = (() => {
       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) {
@@ -2473,7 +2490,7 @@ var GameDestruction = (() => {
       }
       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) {
@@ -2503,7 +2520,7 @@ var GameDestruction = (() => {
       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;
@@ -2531,54 +2548,110 @@ var GameDestruction = (() => {
       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;
@@ -2586,16 +2659,225 @@ var GameDestruction = (() => {
         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: [] };
@@ -2632,7 +2914,7 @@ var GameDestruction = (() => {
       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") {
@@ -2654,7 +2936,13 @@ var GameDestruction = (() => {
           }
         }
       } 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);
       }
@@ -2911,6 +3199,14 @@ var GameDestruction = (() => {
       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;
@@ -2998,7 +3294,7 @@ var GameDestruction = (() => {
       },
       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));
       },
@@ -3009,14 +3305,14 @@ var GameDestruction = (() => {
         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);
@@ -3028,7 +3324,7 @@ var GameDestruction = (() => {
             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;
@@ -3042,7 +3338,7 @@ var GameDestruction = (() => {
             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;
@@ -3230,6 +3526,21 @@ var GameDestruction = (() => {
     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 = [
     {
@@ -3562,6 +3873,8 @@ var GameDestruction = (() => {
         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" },
@@ -3648,6 +3961,8 @@ var GameDestruction = (() => {
         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" },