@adatechnology/game-test-room 0.8.0 → 0.10.0

package/dist/index.global.js

@@ -1190,7 +1190,8 @@ var GameTestRoom = (() => {
         0.25
       ],
       damageScale: {
-        blunt: 1.5
+        blunt: 1.5,
+        shelter: 3
       },
       hitDebris: "shards",
       breakDebris: "shards",
@@ -1241,7 +1242,10 @@ var GameTestRoom = (() => {
         "glass",
         "brittle"
       ],
-      compressive: 2e5
+      compressive: 2e5,
+      damageScale: {
+        shelter: 3
+      }
     },
     {
       id: "ceramic",
@@ -1921,10 +1925,14 @@ var GameTestRoom = (() => {
   };
   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;
@@ -1959,6 +1967,7 @@ var GameTestRoom = (() => {
     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 rnd2 = () => rng.next();
     let time = 0;
@@ -2314,7 +2323,7 @@ var GameTestRoom = (() => {
       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()) {
@@ -2327,7 +2336,7 @@ var GameTestRoom = (() => {
           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);
@@ -2740,7 +2749,7 @@ var GameTestRoom = (() => {
       else if (chained && (trigger === "explosion" || 1 - p.st.hp / p.st.maxHp >= shotDamageFractionOf(p.spec))) prime(o, p, trigger, src);
       return done;
     };
-    const ballistic2 = (o, p, entry, n, d, E, caliber, pathLen, src) => {
+    const ballistic2 = (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 };
@@ -2753,7 +2762,9 @@ var GameTestRoom = (() => {
       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 scale2 = (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) {
@@ -2765,7 +2776,7 @@ var GameTestRoom = (() => {
       }
       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) {
@@ -2795,7 +2806,7 @@ var GameTestRoom = (() => {
       debris2(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 * scale2, "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;
@@ -2823,54 +2834,110 @@ var GameTestRoom = (() => {
       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);
+        debris2(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);
-          debris2(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 = (call3) => {
+      const pick3 = (key) => call3 && call3[key] !== void 0 ? call3[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 = pick3("confinement");
+      return {
+        shelter: merge(pick3("shelter"), SHELTER_DEFAULTS),
+        frag: merge(pick3("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 sum2 = 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++;
+          sum2 += 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(sum2 / 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;
@@ -2878,16 +2945,225 @@ var GameTestRoom = (() => {
         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 energyOf2 = (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: energyOf2(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;
+      }
+      emit2({ 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 cos2 = vec.dot(dir, to) / len;
+          if (cos2 >= best) {
+            best = cos2;
+            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 range2 = Math.min(g.range, speed * g.flightTime);
+      const origin = vec.madd(frag.center, dir, 0.02);
+      const rh = raycastInternal(origin, dir, range2, 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 } : {}
+      };
+      emit2({ 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, call3, only) => {
+      const cfg = blastCfg(call3);
+      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: [] };
@@ -2924,7 +3200,7 @@ var GameTestRoom = (() => {
       if (hit.type === "ballistic") {
         const loc = locate(o, point, dir, 0.05, only);
         if (loc) {
-          const out = ballistic2(o, loc.p, loc.point, loc.normal, loc.dir, E, hit.caliber ?? 9, loc.pathLen, src);
+          const out = ballistic2(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") {
@@ -2946,7 +3222,13 @@ var GameTestRoom = (() => {
           }
         }
       } else if (hit.type === "explosive") {
-        res = blastObject(o, point, E, hit.radius ?? 2, src);
+        const call3 = hit.blast || hit.confinement !== void 0 ? { ...hit.blast, ...hit.confinement !== void 0 ? { confinement: hit.confinement } : {} } : void 0;
+        const cfg = blastCfg(call3);
+        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, call3, o)[0] ?? res;
+          res.events = cur.slice(start);
+        }
       } else {
         res = heatObject(o, point, hit.temperature ?? 800, hit.radius ?? 0.25, hit.duration ?? 1, src);
       }
@@ -3203,6 +3485,14 @@ var GameTestRoom = (() => {
       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 call3 = h.blast || h.confinement !== void 0 ? { ...h.blast, ...h.confinement !== void 0 ? { confinement: h.confinement } : {} } : void 0;
+      const cfg = blastCfg(call3);
+      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, call3, 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;
@@ -3290,7 +3580,7 @@ var GameTestRoom = (() => {
       },
       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));
       },
@@ -3301,14 +3591,14 @@ var GameTestRoom = (() => {
         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);
@@ -3320,7 +3610,7 @@ var GameTestRoom = (() => {
             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;
@@ -3334,7 +3624,7 @@ var GameTestRoom = (() => {
             const o = getObj(rh.object);
             const p = getPart(o, rh.part);
             const start = cur.length;
-            const out = ballistic2(o, p, rh.point, rh.normal, d, E, caliber, rh.pathLen, source);
+            const out = ballistic2(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;
@@ -3704,6 +3994,8 @@ var GameTestRoom = (() => {
         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" },
@@ -3790,6 +4082,8 @@ var GameTestRoom = (() => {
         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" },
@@ -15699,6 +15993,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (options.visual !== false) this.playExplosion(ev, options);
       this.vfx.push(p, ev.radius, 4);
       const c = this.v1;
+      const report = options.report;
+      const confinement = report?.find((r) => r.blast !== void 0)?.blast?.confinement ?? 1;
+      const energy = ev.energy * confinement;
       for (const pc of this.pieceSys.list) {
         this.pieceSys.centerOf(pc, c);
         const dx = c.x - p[0];
@@ -15707,13 +16004,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const d = Math.hypot(dx, dy, dz);
         if (d > ev.radius) continue;
         const fall = (1 - d / ev.radius) ** 2;
-        const speed = Math.min(30, Math.sqrt(2 * ev.energy * 0.02 / pc.mass)) * fall;
+        const reach = report?.find((r) => r.object === pc.objectId)?.blast?.shelter ?? 1;
+        const speed = Math.min(30, Math.sqrt(2 * energy * reach * 0.02 / pc.mass)) * fall;
         const inv = d > 1e-4 ? 1 / d : 0;
         const dir = d > 1e-4 ? [dx * inv, dy * inv + 0.3, dz * inv] : [0, 1, 0];
         const spread2 = pc.halfExtents[0];
         this.pieceSys.impulse(pc, [dir[0] * speed * pc.mass, dir[1] * speed * pc.mass, dir[2] * speed * pc.mass], [c.x + (this.rng() - 0.5) * spread2, c.y + spread2 * 0.5, c.z + (this.rng() - 0.5) * spread2]);
       }
-      this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(ev.energy) * 0.08));
+      this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(energy) * 0.08));
       this.sound("explode", p, clamp6(0.5 + ev.radius / 10, 0.5, 1));
     }
     playExplosion(ev, options) {
@@ -34349,6 +34647,16 @@ void main(){
       "ui.slow": "Slow motion 0.25\xD7",
       "ui.fast": "Time \xD710",
       "ui.tap": "Tap",
+      "ui.blast.shelter": "Shelter",
+      "ui.blast.fragmentHits": "Fragments",
+      "ui.blast.confinement": "Confinement",
+      "ui.blast.shelter.hint": "Blasts: walls and other parts between the blast and the target take their share",
+      "ui.blast.fragmentHits.hint": "Blasts: the pieces of what breaks fly on and hit what is behind",
+      "ui.blast.confinement.hint": "Blasts: pressure builds up in an enclosed room",
+      "metric.blast_shelter": "Blast reaching (%)",
+      "metric.blast_confinement": "Blast pressure (x)",
+      "metric.blast_fragments": "Fragment hits",
+      "act.blast_report": "Blast: {shelter}% reached the most sheltered target, pressure x{confinement}, {fragments} fragment hits, {n} targets",
       "ui.quality": "Quality",
       "ui.quality.low": "low",
       "ui.quality.medium": "medium",
@@ -34674,6 +34982,16 @@ void main(){
       "ui.slow": "C\xE2mera lenta 0,25\xD7",
       "ui.fast": "Tempo \xD710",
       "ui.tap": "Torneira",
+      "ui.blast.shelter": "Abrigo",
+      "ui.blast.fragmentHits": "Estilha\xE7os",
+      "ui.blast.confinement": "Confinamento",
+      "ui.blast.shelter.hint": "Explos\xF5es: paredes e outras partes entre a explos\xE3o e o alvo ficam com a sua parte",
+      "ui.blast.fragmentHits.hint": "Explos\xF5es: os peda\xE7os do que quebra voam e acertam o que est\xE1 atr\xE1s",
+      "ui.blast.confinement.hint": "Explos\xF5es: a press\xE3o sobe num ambiente fechado",
+      "metric.blast_shelter": "Explos\xE3o que chegou (%)",
+      "metric.blast_confinement": "Press\xE3o da explos\xE3o (x)",
+      "metric.blast_fragments": "Estilha\xE7os que acertaram",
+      "act.blast_report": "Explos\xE3o: {shelter}% chegou ao alvo mais abrigado, press\xE3o x{confinement}, {fragments} estilha\xE7os acertaram, {n} alvos",
       "ui.quality": "Qualidade",
       "ui.quality.low": "baixa",
       "ui.quality.medium": "m\xE9dia",
@@ -35396,6 +35714,16 @@ void main(){
 
   // src/explosives.ts
   var CONE_BLAST_RADIUS = 0.5;
+  var summarizeBlast = (results) => {
+    const reports = results.flatMap((r) => r.blast ? [r.blast] : []);
+    if (reports.length === 0) return void 0;
+    return {
+      shelter: Math.min(...reports.map((r) => r.shelter)),
+      confinement: reports[0].confinement,
+      fragmentHits: reports.reduce((n, r) => n + r.fragmentHits, 0),
+      targets: reports.length
+    };
+  };
   var toArray = (vector) => [vector.x, vector.y, vector.z];
   function createExplosives(context) {
     const { THREE, scene: scene2, camera: camera2, world, renderer, arsenal, translate, format, action } = context;
@@ -35542,17 +35870,27 @@ void main(){
         if (box2.isEmpty()) box2.expandByPoint(object.position);
         const at3 = mostExposedPoint(box2, detonation);
         if (!at3) continue;
-        reached += world.explode(at3, detonation.energy * blastEffect(detonation, at3).falloff, CONE_BLAST_RADIUS, "player").length;
+        const results = world.explode(at3, detonation.energy * blastEffect(detonation, at3).falloff, CONE_BLAST_RADIUS, "player", context.blast());
+        reached += results.length;
+        told(results);
       }
       return reached;
     };
+    const told = (results) => {
+      const summary = summarizeBlast(results);
+      if (!summary) return;
+      context.blasted(summary);
+      action("blast_report", translate("act.blast_report", { shelter: format(summary.shelter * 100, 0), confinement: format(summary.confinement, 2), fragments: summary.fragmentHits, n: summary.targets }), { data: { ...summary } });
+    };
     const detonate = (projectile, detonation) => {
       const weaponName = context.toolName(projectile.weapon);
       const reach = Math.max(detonation.injuryRadius, detonation.lethalRadius);
-      const reached = detonation.energy <= 0 ? 0 : detonation.cone ? coneBlast(detonation) : world.explode(detonation.point, detonation.energy, reach, "player").length;
+      const results = detonation.energy <= 0 || detonation.cone ? [] : world.explode(detonation.point, detonation.energy, reach, "player", context.blast());
+      const reached = detonation.energy <= 0 ? 0 : detonation.cone ? coneBlast(detonation) : results.length;
+      if (!detonation.cone) told(results);
       if (detonation.energy > 0) {
         const isPlayed = context.effects.explosion(detonation.explosive, detonation.point, { direction: detonation.direction }) !== null;
-        renderer.explode(detonation.point, detonation.energy, reach, { visual: !isPlayed });
+        renderer.explode(detonation.point, detonation.energy, reach, { visual: !isPlayed, report: results });
       }
       if (detonation.stunSeconds !== void 0) renderer.emit("flash", detonation.point, [0, 1, 0], 1, 1);
       const onPlayer = blastEffect(detonation, toArray(camera2.position));
@@ -35849,7 +36187,7 @@ void main(){
   }
 
   // src/metrics.ts
-  var ROOM_METRICS = ["fps", "frame_ms", "draw_calls", "triangles", "objects", "fragments", "particles", "decals"];
+  var ROOM_METRICS = ["fps", "frame_ms", "draw_calls", "triangles", "objects", "fragments", "particles", "decals", "blast_shelter", "blast_confinement", "blast_fragments"];
   var WINDOW_S = 0.5;
   function createRoomMetrics(sources) {
     const wanted = new Set(sources.ids);
@@ -35886,6 +36224,12 @@ void main(){
         const render = ownsRender ? { calls, triangles } : gl.info?.render;
         put("draw_calls", render?.calls);
         put("triangles", render?.triangles);
+        const blast = sources.blast?.();
+        if (blast) {
+          put("blast_shelter", blast.shelter * 100);
+          put("blast_confinement", blast.confinement);
+          put("blast_fragments", blast.fragmentHits);
+        }
         if (!["objects", "fragments", "particles", "decals"].some((id) => wanted.has(id))) return out;
         const destruction = sources.destruction.stats();
         const fluids = sources.fluids.stats();
@@ -36439,6 +36783,9 @@ void main(){
     const blocked = (x, z) => {
       if (Math.abs(x) > o.limit - PLAYER_RADIUS || Math.abs(z) > o.limit - PLAYER_RADIUS) return true;
       for (const c of o.colliders) if (x > c[0] - PLAYER_RADIUS && x < c[2] + PLAYER_RADIUS && z > c[1] - PLAYER_RADIUS && z < c[3] + PLAYER_RADIUS) return true;
+      if (o.blockers) {
+        for (const blocked2 of o.blockers) if (blocked2(x, z, PLAYER_RADIUS)) return true;
+      }
       return false;
     };
     const move = (dx, dz) => {
@@ -37567,6 +37914,8 @@ void main(){
       o.onFast(fast);
     });
     const tapBtn = ctl(t("ui.tap"), () => o.onTap());
+    const blastBtns = ["shelter", "fragmentHits", "confinement"].map((key) => ({ key, b: ctl(t(`ui.blast.${key}`), () => o.onBlast(key)) }));
+    for (const { key, b } of blastBtns) b.title = t(`ui.blast.${key}.hint`);
     const qSel = mk2("select");
     for (const q of ["low", "medium", "high"]) {
       const op = mk2("option", void 0, t(`ui.quality.${q}`));
@@ -37771,6 +38120,7 @@ void main(){
         }
         slotsEl.forEach((b, i) => b.classList.toggle("on", i === s.slot));
         tapBtn.classList.toggle("on", s.tap);
+        for (const { key: key2, b } of blastBtns) b.classList.toggle("on", s.blast[key2]);
         count.textContent = t("ui.objects", { n: s.objects });
         const ak = JSON.stringify(s.animations);
         if (ak !== lastAnim) {
@@ -38084,10 +38434,12 @@ void main(){
     log.setBeforeRead(flush);
     let useHeld = false;
     let useFirst = false;
+    const blockers = /* @__PURE__ */ new Set();
     const player = createPlayer(THREE, {
       camera: camera2,
       dom,
       colliders: arena.colliders,
+      blockers,
       limit: arenaSize,
       start: arena.playerStart,
       hooks: {
@@ -38270,8 +38622,10 @@ void main(){
       film.clear();
       fluids.setTap(TAP_ID, false);
     };
+    const clearListeners = /* @__PURE__ */ new Set();
     const clear = () => {
       clearEverything();
+      for (const listener of [...clearListeners]) listener();
       restingTops.length = 0;
       pending = [];
       action("clear", t("act.clear"));
@@ -38652,6 +39006,12 @@ void main(){
       bodies.push({ id: "player", box: new THREE.Box3(new THREE.Vector3(x - PLAYER_RADIUS, feet, z - PLAYER_RADIUS), new THREE.Vector3(x + PLAYER_RADIUS, y + 0.1, z + PLAYER_RADIUS)) });
       return bodies;
     }
+    let blastOptions = { ...options.blast };
+    let lastBlast;
+    const blastOn = (key) => Boolean(blastOptions[key]);
+    const toggleBlast = (key) => {
+      blastOptions = { ...blastOptions, [key]: blastOn(key) ? false : true };
+    };
     const explosives = createExplosives({
       THREE,
       scene: scene2,
@@ -38666,6 +39026,10 @@ void main(){
       toolName,
       withoutHeld,
       groundAt,
+      blast: () => blastOptions,
+      blasted: (summary) => {
+        lastBlast = summary;
+      },
       translate: t,
       format: num,
       action,
@@ -39092,7 +39456,7 @@ void main(){
     let metricsAcc = 0;
     let ownsLoop = false;
     const roomMetricIds = options.metrics === false ? [] : options.metrics ?? ROOM_METRICS;
-    const roomMetrics = createRoomMetrics({ gl, destruction: renderer, fluids: fluidView, effects: vfx.world, ids: roomMetricIds });
+    const roomMetrics = createRoomMetrics({ gl, destruction: renderer, fluids: fluidView, effects: vfx.world, ids: roomMetricIds, blast: () => lastBlast });
     let qualityName = quality;
     const syncContainers = (sdt) => {
       for (const e of entries.values()) {
@@ -39211,6 +39575,7 @@ void main(){
         timeScale,
         fast: fastForward,
         tap: isTapOn(),
+        blast: { shelter: blastOn("shelter"), fragmentHits: blastOn("fragmentHits"), confinement: blastOn("confinement") },
         quality: qualityName,
         objects: [...entries.values()].filter((e) => !e.arena).length
       };
@@ -39459,6 +39824,14 @@ void main(){
       },
       log(text, data) {
         action("module_note", text, { data });
+      },
+      addBlocker(blocked) {
+        blockers.add(blocked);
+        return () => blockers.delete(blocked);
+      },
+      onClear(listener) {
+        clearListeners.add(listener);
+        return () => clearListeners.delete(listener);
       }
     };
     const lendBench = (store) => ({
@@ -39726,6 +40099,10 @@ void main(){
         heldTilt = rad;
       },
       toggleTap,
+      blast: () => ({ ...blastOptions }),
+      setBlast: (next) => {
+        blastOptions = { ...blastOptions, ...next };
+      },
       pause() {
         paused = true;
       },
@@ -39836,6 +40213,7 @@ void main(){
           setTool(loadout[index]);
         },
         onTap: () => toggleTap(),
+        onBlast: (key) => toggleBlast(key),
         onPlay: (objectId, clipId) => {
           playAnimation(clipId, objectId);
         },