@adatechnology/game-destruction 0.12.0 → 0.13.0

package/dist/index.d.ts

@@ -452,6 +452,11 @@ interface DestructionWorld {
      * that target, and a `blast` event sums it up.
      */
     explode(point: Vec3, energy: number, radius: number, source?: string, options?: BlastOptions): HitResult[];
+    /** Cost of the last `explode`: parts in range of the broad phase (`partsTested`) and those whose bounding sphere the blast reached (`partsNear`). */
+    blastProbe(): {
+        partsTested: number;
+        partsNear: number;
+    };
     /** Raycast against every part shape (world space). */
     raycast(origin: Vec3, direction: Vec3, maxDistance?: number): RayHit | null;
     /**
@@ -550,6 +555,8 @@ interface PartRuntime {
     breach?: Array<[number, number, number, number]>;
     /** Energy each unit of the part took so far (`breach.chipEnergy`), by its index in the unit grid; -1 when the unit came out. */
     chips?: Record<number, number>;
+    /** Face area (m²) the craters of shots took out of each unit so far, by its index in the unit grid: the rest of a unit comes out past `CRATER_SPENT`. */
+    craters?: Record<number, number>;
     /** Mass in kg that left the part in a breach. */
     removed?: number;
     /** Damage taken by each band across a long wooden part (`splinter`), by band index from its negative end: the band that runs out breaks it there. */

package/dist/index.global.js

@@ -2967,6 +2967,7 @@ var GameDestruction = (() => {
   var FLAMMABLE_FLUIDS = ["gas", "fuel"];
   var VENT_DIAMETER = 8e-3;
   var FLAME_LIGHTS_LEAK_C = 470;
+  var RESTING_HOLD_COS = Math.cos(Math.PI / 6);
   var BREACH_RADIUS = 0.55;
   var BREACH_BLAST_FACTOR = 6;
   var BREACH_AREA = 0.25;
@@ -2982,6 +2983,7 @@ var GameDestruction = (() => {
   var BREACH_GRID_CAP = 4096;
   var CHIP_ENERGY = 200;
   var CHIP_SPLASH = 0.5;
+  var CRATER_SPENT = 0.6;
   var BAR_BOW = 0.08;
   var BULLET_JOINT_SPAN = 0.3;
   var CUT_SLICE = 1;
@@ -3002,12 +3004,22 @@ var GameDestruction = (() => {
     const cells = p.st.chipped;
     if (!cells?.length) return 0;
     const [u, v] = planeAxes(p.thin);
-    const along = p.dims[u] >= p.dims[v] ? u : v;
+    const role = p.spec.structure?.role;
+    const up = rotateVec(p.q, [0, 0, 0].map((_, k) => k === v ? 1 : 0));
+    const upright = Math.abs(up[1]) > 0.7 ? v : Math.abs(rotateVec(p.q, [0, 0, 0].map((_, k) => k === u ? 1 : 0))[1]) > 0.7 ? u : -1;
+    const along = (role === "wall" || role === "partition" || role === "column") && upright >= 0 ? upright : p.dims[u] >= p.dims[v] ? u : v;
     const across = along === u ? v : u;
     let worst = 0;
     for (const c of cells) {
-      let gone = 0;
-      for (const d of cells) if (Math.abs(d.center[along] - c.center[along]) < d.size[along] / 2 + 1e-6) gone += d.size[across];
+      const spans = [];
+      for (const d of cells) if (Math.abs(d.center[along] - c.center[along]) < d.size[along] / 2 + 1e-6) spans.push([d.center[across] - d.size[across] / 2, d.center[across] + d.size[across] / 2]);
+      spans.sort((a, b) => a[0] - b[0]);
+      let gone = 0, end = -Infinity;
+      for (const [a, b] of spans) {
+        if (b <= end) continue;
+        gone += b - Math.max(a, end);
+        end = b;
+      }
       worst = Math.max(worst, gone / Math.max(p.dims[across], 1e-6));
     }
     return Math.min(1, worst);
@@ -3303,7 +3315,18 @@ var GameDestruction = (() => {
       if (k < 0 || j.spec.kind !== "tie") return k;
       return partXf(o, o.parts[k]).c[1] > partXf(o, o.parts[r]).c[1] + 1e-6 ? k : -1;
     };
+    let poseVersion = 0;
+    const contactMemo = /* @__PURE__ */ new WeakMap();
     const contactBox = (p, support) => {
+      let byTouching = contactMemo.get(p);
+      if (!byTouching) contactMemo.set(p, byTouching = /* @__PURE__ */ new Map());
+      const known = byTouching.get(support);
+      if (known && known.version === poseVersion) return known.box;
+      const box = measureContact(p, support);
+      byTouching.set(support, { version: poseVersion, box });
+      return box;
+    };
+    const measureContact = (p, support) => {
       const A = aabbOf(p.spec.shape, p.pos, p.q), B = aabbOf(support.spec.shape, support.pos, support.q);
       const lo = [0, 0, 0], hi = [0, 0, 0];
       for (let k = 0; k < 3; k++) {
@@ -4098,7 +4121,7 @@ var GameDestruction = (() => {
       p.st.holes.push(hole);
       if (p.st.holes.length > maxHoles) p.st.holes.shift();
       markDamaged(p);
-      emit({ ...base(o, src), type: "hole", part: p.spec.id, hole, worldPoint: wp, ...exit ? { exitPoint: exit } : {} });
+      emit({ ...base(o, src), type: "hole", part: p.spec.id, hole, worldPoint: wp, ...exit ? { exitPoint: exit } : {}, ...p.spec.powder ? { powder: { ...p.spec.powder } } : {} });
       setStage(o, p, 1, {}, src);
       return hole;
     };
@@ -4115,6 +4138,22 @@ var GameDestruction = (() => {
     const detachEvents = (o, opened, by, src) => {
       for (const j of opened) emit({ ...base(o, src), type: "detach", joint: j.spec.id, parts: [j.spec.a, j.spec.b], by, groups: o.st.groups.map((g) => [...g]) });
     };
+    const slideOffResting = (o, rotation) => {
+      const upY = 1 - 2 * (rotation[0] * rotation[0] + rotation[2] * rotation[2]);
+      if (upY >= RESTING_HOLD_COS) return;
+      const opened = o.joints.filter((j) => j.spec.kind === "resting" && !j.st.open);
+      if (opened.length === 0) return;
+      run(() => {
+        for (const j of opened) {
+          j.st.open = true;
+          j.st.openedBy = "break";
+        }
+        solveStructure(o);
+        recomputeGroups(o);
+        detachEvents(o, opened, "break");
+        collapseCheck(o);
+      });
+    };
     const checkDestroyed = (o, src) => {
       if (!o.st.destroyed && o.parts.length > 0 && o.parts.every(isLost)) {
         o.st.destroyed = true;
@@ -4215,7 +4254,7 @@ var GameDestruction = (() => {
     const localHolesOf = (p) => p.st.holes.map((h) => ({ point: toLocal(p.pos, p.q, h.point), normal: rotateVec(quat.conjugate(p.q), h.normal), diameter: h.diameter }));
     const unitsOf = (p) => p.spec.units ?? { size: [p.mat.fragmentSize?.[1] ?? 0.2, p.mat.fragmentSize?.[1] ?? 0.2, p.thickness], bond: "stack" };
     const FRAGMENT_SHAPE = { shatter: "shard", splinter: "splinter", tear: "scrap" };
-    const cellFragments = (o, p, cells, hitW, dir, speed, mass, tag) => {
+    const cellFragments = (o, p, cells, hitW, dir, speed, mass, tag, inner = false) => {
       const { c, q } = partXf(o, p);
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
       const [u, v] = planeAxes(p.thin);
@@ -4239,7 +4278,8 @@ var GameDestruction = (() => {
           velocity: [dv[0] * k, dv[1] * k + 0.5 * rnd(), dv[2] * k],
           angularVelocity: [(rnd() - 0.5) * 8, (rnd() - 0.5) * 8, (rnd() - 0.5) * 8],
           mass: mass * faceArea(cell) / total,
-          ...marks.length > 0 ? { marks } : {}
+          ...marks.length > 0 ? { marks } : {},
+          ...inner ? { inner } : {}
         };
       });
     };
@@ -4280,7 +4320,7 @@ var GameDestruction = (() => {
       return cells.some((c) => Math.abs(lp[u] - c.center[u]) <= c.size[u] / 2 && Math.abs(lp[v] - c.center[v]) <= c.size[v] / 2);
     };
     const chipUnits = (o, p, kind, wp, hitEnergy, dir, radius, src) => {
-      var _a, _b;
+      var _a, _b, _c;
       if (!p.spec.units || !p.staged || chipEnergy <= 0 || p.st.stripped || isLost(p) || (p.st.stage ?? 0) >= 2) return;
       const rule = p.mat.hits?.[kind];
       const perKg = rule?.unitJoules ?? chipEnergy;
@@ -4290,7 +4330,9 @@ var GameDestruction = (() => {
       const lp = toLocal(p.pos, p.q, objLocal(o, wp));
       const grid = gridOf(p);
       const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const cut = (_b = p.rt).craters ?? (_b.craters = {});
       const out = [];
+      const shot = kind === "ballistic";
       for (let i = 0; i < grid.length; i++) {
         const cell = grid[i];
         if (worn[i] === -1) continue;
@@ -4303,18 +4345,39 @@ var GameDestruction = (() => {
           worn[i] = total;
           continue;
         }
-        worn[i] = -1;
-        out.push(cell);
+        if (!shot) {
+          worn[i] = -1;
+          out.push(cell);
+          continue;
+        }
+        const size = [cell.size[0], cell.size[1], cell.size[2]];
+        const center = [cell.center[0], cell.center[1], cell.center[2]];
+        for (const a of [u, v]) {
+          const w = Math.min(cell.size[a], craterAcross(hitEnergy) * (0.85 + 0.3 * rnd()));
+          const lo = cell.center[a] - cell.size[a] / 2 + w / 2, hi = cell.center[a] + cell.size[a] / 2 - w / 2;
+          size[a] = w;
+          center[a] = clamp2(lp[a], lo, hi);
+        }
+        const taken2 = (cut[i] ?? 0) + size[u] * size[v];
+        if (taken2 >= cell.size[u] * cell.size[v] * CRATER_SPENT) {
+          worn[i] = -1;
+          out.push({ ...cell, crater: true });
+          continue;
+        }
+        worn[i] = 0;
+        cut[i] = taken2;
+        out.push({ center, size, crater: true });
       }
       if (out.length === 0) return;
       const { c, q } = partXf(o, p);
-      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const chipped = (_c = p.st).chipped ?? (_c.chipped = []);
       const holes = localHolesOf(p);
       for (const cell of out) {
         const mass = Math.min(p.st.mass, p.mat.density * cell.size[0] * cell.size[1] * cell.size[2]);
         const center = toWorld(c, q, cell.center);
         const speed = clamp2(Math.sqrt(2 * energy * 0.05 / Math.max(mass, 0.05)), 0.5, 6);
-        const fragments = cellFragments(o, p, [cell], wp, dir, speed, mass, `c${chipped.length}_`);
+        const tag = `c${chipped.length}_`;
+        const fragments = cell.crater ? craterFragments(o, p, cell, dir, speed, mass, tag) : cellFragments(o, p, [cell], wp, dir, speed, mass, tag, true);
         p.st.holes = p.st.holes.filter((_, k) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length === 0);
         chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
         p.st.mass = Math.max(0, p.st.mass - mass);
@@ -4331,6 +4394,44 @@ var GameDestruction = (() => {
         collapseCheck(o, src);
       }
     };
+    const craterAcross = (energy) => clamp2(0.03 + 12e-4 * Math.sqrt(Math.max(0, energy)), 0.03, 0.14);
+    const craterFragments = (o, p, cell, dir, speed, mass, tag) => {
+      const { c, q } = partXf(o, p);
+      const [u, v] = planeAxes(p.thin);
+      const d = dir ?? rotateVec(q, [p.thin === 0 ? 1 : 0, p.thin === 1 ? 1 : 0, p.thin === 2 ? 1 : 0]);
+      const exitSign = Math.sign(rotateVec(quat.conjugate(q), d)[p.thin]) || 1;
+      const bit = Math.max(0.01, Math.min(cell.size[u], cell.size[v]) / 3);
+      const n = clamp2(Math.round(cell.size[u] * cell.size[v] / (bit * bit * 3)), 4, 10) + Math.floor(rnd() * 3);
+      const out = [];
+      for (let i = 0; i < n; i++) {
+        const back = i % 3 === 2;
+        const lc = [cell.center[0], cell.center[1], cell.center[2]];
+        lc[u] += (rnd() - 0.5) * cell.size[u] * 0.7;
+        lc[v] += (rnd() - 0.5) * cell.size[v] * 0.7;
+        lc[p.thin] += (back ? -exitSign : exitSign) * (p.thickness / 2 + 0.01);
+        const size = [0, 0, 0];
+        size[u] = bit * (0.6 + 0.8 * rnd());
+        size[v] = bit * (0.5 + 0.7 * rnd());
+        size[p.thin] = bit * (0.4 + 0.6 * rnd());
+        const spread3 = [(rnd() - 0.5) * 0.9, (rnd() - 0.3) * 0.9, (rnd() - 0.5) * 0.9];
+        const k = speed * (back ? 0.4 + 0.4 * rnd() : 0.7 + 0.8 * rnd());
+        const vdir = vec.normalize(vec.add(back ? vec.scale(d, -1) : d, spread3));
+        out.push({
+          id: `${p.spec.id}#${tag}${i}`,
+          part: p.spec.id,
+          material: p.spec.material,
+          shape: "chunk",
+          center: toWorld(c, q, lc),
+          size,
+          rotation: q,
+          velocity: [vdir[0] * k, vdir[1] * k + 0.5 * rnd(), vdir[2] * k],
+          angularVelocity: [(rnd() - 0.5) * 20, (rnd() - 0.5) * 20, (rnd() - 0.5) * 20],
+          mass: mass / n,
+          inner: true
+        });
+      }
+      return out;
+    };
     const exposeRebar = (o, p, src) => {
       const r = p.spec.reinforcement;
       if (!r) return;
@@ -4618,7 +4719,7 @@ var GameDestruction = (() => {
         });
       }
       const patch = [scale * 4, scale * 4, scale * 4];
-      emit({ ...base(o, src), type: "chip", part: p.spec.id, center: exit ?? entry, size: patch, rotation: q, fragments });
+      emit({ ...base(o, src), type: "chip", part: p.spec.id, center: exit ?? entry, size: patch, rotation: q, fragments, torn: true });
     };
     const ballistic = (o, p, entry, n, d, E, caliber, pathLen, src, round = {}) => {
       const mat = p.mat;
@@ -4677,12 +4778,13 @@ var GameDestruction = (() => {
       } else if (mat.ductility >= 0.5) {
         addDent(o, p, entry, n, Math.max(caliber * 3 / 1e3, 0.012), clamp2(Math.min(Math.max(p.thickness * 3, 3e-3), ratio * 0.01), 1e-3, 0.05), src);
       } else if (brittle) {
-        addCrack(o, p, entry, n, crackLen, src);
+        if (!p.spec.units) addCrack(o, p, entry, n, crackLen, src);
         if (mat.fracture !== "shatter") addHole(o, p, entry, n, caliber / 1e3, false, void 0, src);
       } else addHole(o, p, entry, n, caliber / 1e3, false, void 0, src);
       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, BULLET_JOINT_SPAN);
-      const absorbed = penetrated && mat.ductility >= 0.5 && mat.fracture !== "tear" ? Math.min(E, thr) : E;
+      const hollowTear = mat.fracture === "tear" && p.spec.fill !== void 0 && p.spec.fill < 0.5;
+      const absorbed = penetrated && (mat.ductility >= 0.5 && mat.fracture !== "tear" || hollowTear) ? Math.min(E, thr) : E;
       const dmg = applyDamage(o, p, absorbed * DMG_PER_J * scale, "ballistic", entry, d, absorbed * 0.1, 12, src);
       if (!isLost(p)) tearAt(o, p, "ballistic", entry, penetrated ? exitPoint : void 0, d, E, caliber / 1e3, src);
       chipUnits(o, p, "ballistic", entry, penetrated ? Math.min(E, Math.max(thr, E * 0.5)) : E, d, Math.max(0.05, caliber / 1e3 * 8), src);
@@ -4767,10 +4869,25 @@ var GameDestruction = (() => {
       if (dist <= BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       return reach;
     };
+    const blastProbe = { partsTested: 0, partsNear: 0 };
+    const blastCandidates = (o, point, radius) => {
+      const local = toLocal(o.st.position, o.st.rotation, point);
+      const near = [];
+      for (const p of o.parts) {
+        const reach = radius + p.bound;
+        const dx = local[0] - p.pos[0];
+        const dy = local[1] - p.pos[1];
+        const dz = local[2] - p.pos[2];
+        if (dx * dx + dy * dy + dz * dz < reach * reach) near.push(p);
+      }
+      blastProbe.partsTested += o.parts.length;
+      blastProbe.partsNear += near.length;
+      return near;
+    };
     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) blastPart(o, p, point, energy, radius, src, res);
+      for (const p of blastCandidates(o, point, radius)) blastPart(o, p, point, energy, radius, src, res);
       res.events = cur.slice(start);
       return res;
     };
@@ -4894,7 +5011,7 @@ var GameDestruction = (() => {
       let order = 0;
       for (const o of inRange) {
         if (only && only !== o) continue;
-        for (const p of o.parts) {
+        for (const p of blastCandidates(o, point, radius)) {
           if (isLost(p)) continue;
           const dist = distToPart(o, p, point);
           if (dist < radius) items.push({ dist, order: order++, o, p });
@@ -5441,6 +5558,7 @@ var GameDestruction = (() => {
         const p = getPart(o, partId);
         p.pos = [position[0], position[1], position[2]];
         p.q = q;
+        poseVersion++;
         updateBound(o);
       },
       remove(id) {
@@ -5459,6 +5577,7 @@ var GameDestruction = (() => {
         const o = getObj(id);
         o.base = { pos: [position[0], position[1], position[2]], rot: [rotation[0], rotation[1], rotation[2], rotation[3]] };
         applySoilPose(o);
+        slideOffResting(o, rotation);
       },
       splitGroup(id, group, newId) {
         if (impls.has(id)) throw new Error(`object "${id}" is a registered DestructibleImpl and cannot be split; its module owns its pieces`);
@@ -5482,7 +5601,7 @@ var GameDestruction = (() => {
           if (o.spec.name !== void 0) s.name = o.spec.name;
           if (o.spec.tags) s.tags = [...o.spec.tags];
           if (o.spec.soil !== void 0) s.soil = o.spec.soil;
-          return clone(s);
+          return s;
         };
         const inNew = (pid) => moved.has(pid);
         const inOld = (pid) => !moved.has(pid);
@@ -5509,7 +5628,12 @@ var GameDestruction = (() => {
         const p = getPart(o, partId);
         return whole(() => doHit(o, h, p));
       },
+      blastProbe() {
+        return { ...blastProbe };
+      },
       explode(point, energy, radius, source, blast) {
+        blastProbe.partsTested = 0;
+        blastProbe.partsNear = 0;
         return withCollapses(run(() => blastWorld(point, energy, radius, source, blast)));
       },
       raycast(origin, direction, maxDistance = Infinity) {
@@ -5519,7 +5643,8 @@ var GameDestruction = (() => {
       sweepBox(box, direction, distance, options2 = {}) {
         const d = vec.normalize(direction);
         const ignored = options2.ignore === void 0 ? void 0 : objects.get(options2.ignore);
-        const ignore = ignored ? new Set(ignored.parts.map((p) => `${ignored.id}\0${p.spec.id}`)) : void 0;
+        const hosted = options2.ignore === void 0 || ignored ? void 0 : impls.get(options2.ignore);
+        const ignore = ignored ? new Set(ignored.parts.map((p) => `${ignored.id}\0${p.spec.id}`)) : hosted ? new Set(hosted.impl.describe().parts.map((p) => `${hosted.impl.id}\0${p.id}`)) : void 0;
         let best = null;
         for (const origin of sweepOrigins(box, d, options2.spacing ?? 0.2)) {
           const r = raycastInternal(origin, d, distance + SWEEP_BACK, ignore);