@adatechnology/game-destruction 0.13.2 → 0.14.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;
@@ -3743,7 +3744,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 +3759,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;
   };
@@ -5248,7 +5261,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 +5333,7 @@ var createDestruction = (options = {}) => {
       updateBound(o);
     },
     remove(id) {
+      impls.get(id)?.impl.dispose?.();
       objects.delete(id);
       impls.delete(id);
     },
@@ -5393,7 +5409,7 @@ var createDestruction = (options = {}) => {
       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 = {}) {
@@ -5418,11 +5434,11 @@ var createDestruction = (options = {}) => {
         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 r = implHit(im, { type: "ballistic", point: rh.point, part: rh.part, normal: rh.normal, direction: d, energy: E, caliber, ...extras, ...source !== void 0 ? { source } : {} });
             r.part = rh.part;
             r.point = rh.point;
             r.exitEnergy = r.penetrated ? E * 0.5 : 0;
@@ -5683,6 +5699,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 +5767,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 +5821,7 @@ var assemblyPart = (assemblyId, options) => {
     ...options.extra
   };
 };
+var assemblyPart = (assemblyId, options) => defaultAssemblies().part(assemblyId, options);
 
 // src/frame.ts
 var buildFrame = (o = {}) => {
@@ -6224,7 +6261,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 +6291,11 @@ export {
   checkDestructible,
   checkHit,
   crackingMoment,
+  createAssemblies,
   createDestruction,
   damperAmplification,
   damperTuning,
+  defaultAssemblies,
   elasticEnergy,
   explosivePart,
   exposureOf,