@adatechnology/game-destruction 0.13.2 → 0.15.0

package/dist/index.js

@@ -2796,6 +2796,7 @@ var createDestruction = (options = {}) => {
   const ignitionRules = resolveIgnitionRules(options.ignition);
   const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
   const chipEnergy = options.breach?.chipEnergy ?? CHIP_ENERGY;
+  const chainLinkCap = options.chainLinksPerUpdate !== void 0 && options.chainLinksPerUpdate >= 1 ? Math.floor(options.chainLinksPerUpdate) : Infinity;
   const rng = createRng(options.seed ?? 1);
   const rnd = () => rng.next();
   let time = 0;
@@ -2818,7 +2819,13 @@ var createDestruction = (options = {}) => {
     const typed = listeners.get(e.type);
     if (typed) for (const fn of [...typed]) fn(e);
   };
-  const base = (o, source) => source === void 0 ? { object: o.id, time } : { object: o.id, time, source };
+  let blow;
+  const base = (o, source) => ({
+    object: o.id,
+    time,
+    ...source === void 0 ? {} : { source },
+    ...blow === void 0 ? {} : { blow }
+  });
   const pendingCollapse = /* @__PURE__ */ new Map();
   let runDepth = 0;
   const drainBlasts = () => {
@@ -3743,7 +3750,7 @@ var createDestruction = (options = {}) => {
     if (disc < 0) return true;
     return -b - Math.sqrt(disc) > maxDist;
   };
-  const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false) => {
+  const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false, precise = false) => {
     const d = vec.normalize(dir);
     let best = null;
     for (const o of objects.values()) {
@@ -3758,13 +3765,25 @@ var createDestruction = (options = {}) => {
       }
     }
     for (const im of worldOnly ? [] : impls.values()) {
+      let boxHit = null;
       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);
         const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), origin, d, ov?.pos);
-        if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
-        if (!best || r.t0 < best.distance) best = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
+        if (!r || r.t1 < 0 || r.t0 > maxDist) continue;
+        if (r.t0 < 0) {
+          if (precise && im.impl.surfaceRay) boxHit = boxHit ?? { object: im.impl.id, part: ps.id, point: origin, normal: r.n, distance: 0, pathLen: r.t1 };
+          continue;
+        }
+        if (!boxHit || r.t0 < boxHit.distance) boxHit = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
       }
+      if (!boxHit) continue;
+      if (precise && im.impl.surfaceRay) {
+        const far = best ? Math.min(maxDist, best.distance) : maxDist;
+        const implId = im.impl.id;
+        const s = im.impl.surfaceRay({ origin, direction: d, maxDistance: far, ...ignore ? { ignored: (part) => ignore.has(`${implId}\0${part}`) } : {} });
+        if (s && (!best || s.distance < best.distance)) best = { object: implId, part: s.part, point: s.point, normal: s.normal, distance: s.distance, pathLen: s.pathLen };
+      } else if (!best || boxHit.distance < best.distance) best = boxHit;
     }
     return best;
   };
@@ -4951,7 +4970,17 @@ var createDestruction = (options = {}) => {
     res.events = cur.slice(start);
     return res;
   };
-  const doHit = (o, hit, only) => {
+  const withBlow = (type, fn) => () => {
+    const outer = blow;
+    blow = type;
+    try {
+      return fn();
+    } finally {
+      blow = outer;
+    }
+  };
+  const doHit = (o, hit, only) => withBlow(hit.type, () => resolveHit(o, hit, only))();
+  const resolveHit = (o, hit, only) => {
     let point = hit.point;
     let dir = hit.direction;
     if (hit.space === "local") {
@@ -5248,7 +5277,9 @@ var createDestruction = (options = {}) => {
   };
   const detonatePrimed = (until) => {
     const end = time;
-    for (let next = nextPrimed(until); next; next = nextPrimed(until)) {
+    let fired = 0;
+    for (let next = nextPrimed(until); next && fired < chainLinkCap; next = nextPrimed(until)) {
+      fired++;
       primed.delete(next.p);
       time = Math.max(0, Math.min(end, next.p.rt.chainDue));
       next.p.rt.chainDue = void 0;
@@ -5318,6 +5349,7 @@ var createDestruction = (options = {}) => {
       updateBound(o);
     },
     remove(id) {
+      impls.get(id)?.impl.dispose?.();
       objects.delete(id);
       impls.delete(id);
     },
@@ -5387,13 +5419,51 @@ var createDestruction = (options = {}) => {
     blastProbe() {
       return { ...blastProbe };
     },
+    blastReach(point, target, options2 = {}) {
+      const L = vec.distance(point, target);
+      if (L < 1e-4) return 1;
+      const shelter = { ...SHELTER_DEFAULTS, ...options2.shelter };
+      const ignore = new Set(options2.ignore ?? []);
+      const d = vec.scale(vec.sub(target, point), 1 / L);
+      let t = 1;
+      for (const o of objects.values()) {
+        if (ignore.has(o.id) || raySphereMiss(point, d, toWorld(o.st.position, o.st.rotation, o.bc), o.br, L)) continue;
+        for (const p of o.parts) {
+          if (isLost(p) || p.st.stripped) 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;
+          if (p.st.opening && insideOpening(o, p, toLocal(o.st.position, o.st.rotation, vec.madd(point, d, t0 + path / 2)))) continue;
+          t *= Math.exp(-(p.mat.hpPerKg * p.mat.density * path * (p.mat.damageScale?.shelter ?? 1)) / shelter.k);
+          if (t < 1e-4) return 0;
+        }
+      }
+      for (const im of impls.values()) {
+        if (ignore.has(im.impl.id)) continue;
+        for (const ps of im.impl.describe().parts) {
+          const mat = materials.get(ps.material);
+          if (!mat) continue;
+          const ov = im.poses.get(ps.id);
+          const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), point, d, ov?.pos);
+          if (!r || r.t1 < 0 || r.t0 > L) continue;
+          let path = Math.min(r.t1, L) - Math.max(r.t0, 0);
+          if (ps.thickness !== void 0 && ps.thickness > 0) path = Math.min(path, 2 * ps.thickness);
+          else if (path < shelter.minPath) continue;
+          t *= Math.exp(-(mat.hpPerKg * mat.density * path * (mat.damageScale?.shelter ?? 1)) / shelter.k);
+          if (t < 1e-4) return 0;
+        }
+      }
+      return t;
+    },
     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) {
-      const r = raycastInternal(origin, direction, maxDistance);
+      const r = raycastInternal(origin, direction, maxDistance, void 0, false, true);
       return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
     },
     sweepBox(box, direction, distance, options2 = {}) {
@@ -5411,21 +5481,23 @@ var createDestruction = (options = {}) => {
     },
     shoot(origin, direction, energy, caliber, source, round) {
       const extras = typeof round === "number" ? { piercing: round } : round ?? {};
-      return withCollapses(run(() => {
+      return withCollapses(run(withBlow("ballistic", () => {
         const results = [];
         const d = vec.normalize(direction);
         const ignore = /* @__PURE__ */ new Set();
         let org = origin;
         let E = energy;
         for (let i = 0; i < 4 && E > 0; i++) {
-          const rh = raycastInternal(org, d, Infinity, ignore);
+          const rh = raycastInternal(org, d, Infinity, ignore, false, true);
           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, ...extras, ...source !== void 0 ? { source } : {} });
+            const scaled = extras.penetration && E < energy ? { ...extras, penetration: Object.fromEntries(Object.entries(extras.penetration).map(([k, mm]) => [k, mm * (E / energy)])) } : extras;
+            const r = implHit(im, { type: "ballistic", point: rh.point, part: rh.part, normal: rh.normal, direction: d, energy: E, caliber, ...scaled, ...source !== void 0 ? { source } : {} });
             r.part = rh.part;
             r.point = rh.point;
-            r.exitEnergy = r.penetrated ? E * 0.5 : 0;
+            const left = r.events.find((e) => e.type === "hole" && e.energyLeft !== void 0);
+            r.exitEnergy = r.penetrated ? left?.energyLeft ?? E * 0.5 : 0;
             results.push(r);
             ignore.add(`${im.impl.id}\0${rh.part}`);
             if (!r.penetrated) break;
@@ -5444,7 +5516,7 @@ var createDestruction = (options = {}) => {
           E = out.exitEnergy;
         }
         return results;
-      }));
+      })));
     },
     disassemble(objectId, jointId, tool, dt) {
       const im = impls.get(objectId);
@@ -5683,6 +5755,9 @@ var createDestruction = (options = {}) => {
   return world;
 };
 
+// src/assemblies.ts
+import { applyPatches, mergeById, removeIds } from "@adatechnology/game-contracts";
+
 // src/data/assemblies.json
 var assemblies_default = [
   {
@@ -5748,17 +5823,34 @@ var assemblies_default = [
 ];
 
 // src/assemblies.ts
+var SHIPPED = structuredClone(assemblies_default);
 var ASSEMBLIES = assemblies_default;
-var registerAssembly = (def) => {
-  const at = ASSEMBLIES.findIndex((a) => a.id === def.id);
-  if (at >= 0) ASSEMBLIES[at] = def;
-  else ASSEMBLIES.push(def);
+var assembliesOver = (defs) => {
+  const get = (id) => defs.find((a) => a.id === id);
+  return {
+    list: () => defs,
+    get,
+    register(def) {
+      const at = defs.findIndex((a) => a.id === def.id);
+      if (at >= 0) defs[at] = def;
+      else defs.push(def);
+    },
+    part: (assemblyId, options) => buildAssemblyPart(get(assemblyId), assemblyId, options)
+  };
+};
+var createAssemblies = (options = {}) => {
+  const entries = mergeById(SHIPPED.map((def) => structuredClone(def)), (options.packs ?? []).flat());
+  applyPatches(entries, options.patch);
+  removeIds(entries, options.remove);
+  return assembliesOver([...entries.values()]);
 };
-var getAssembly = (id) => ASSEMBLIES.find((a) => a.id === id);
+var defaultSet;
+var defaultAssemblies = () => defaultSet ?? (defaultSet = assembliesOver(ASSEMBLIES));
+var registerAssembly = (def) => defaultAssemblies().register(def);
+var getAssembly = (id) => defaultAssemblies().get(id);
 var faceCount = (layer) => layer.faces === "both" ? 2 : 1;
 var assemblyDepth = (def) => def.depth ?? def.core.thickness + (def.layers ?? []).reduce((sum, l) => sum + l.thickness * faceCount(l), 0);
-var assemblyPart = (assemblyId, options) => {
-  const def = getAssembly(assemblyId);
+var buildAssemblyPart = (def, assemblyId, options) => {
   if (!def) throw new Error(`unknown assembly "${assemblyId}"`);
   const densityOf = (id) => {
     const m = options.materials?.get(id) ?? MATERIALS.find((x) => x.id === id);
@@ -5785,6 +5877,7 @@ var assemblyPart = (assemblyId, options) => {
     ...options.extra
   };
 };
+var assemblyPart = (assemblyId, options) => defaultAssemblies().part(assemblyId, options);
 
 // src/frame.ts
 var buildFrame = (o = {}) => {
@@ -6224,7 +6317,7 @@ var resolveStrings = (locale) => locales[locale ?? "en"] ?? locales.en;
 import { checkDestructible as check } from "@adatechnology/game-contracts";
 import { IMPACT_CONTRACT, checkHit } from "@adatechnology/game-contracts";
 var checkDestructible = (impl, options = {}) => {
-  const contractOptions = { materials: [...MATERIALS.map((m) => m.id), ...options.materials ?? []] };
+  const contractOptions = { materials: [...MATERIALS.map((m) => m.id), ...options.materials ?? []], ...options.cost === void 0 ? {} : { cost: options.cost } };
   return check(impl, contractOptions);
 };
 export {
@@ -6254,9 +6347,11 @@ export {
   checkDestructible,
   checkHit,
   crackingMoment,
+  createAssemblies,
   createDestruction,
   damperAmplification,
   damperTuning,
+  defaultAssemblies,
   elasticEnergy,
   explosivePart,
   exposureOf,