@adatechnology/game-destruction 0.3.2 → 0.4.0

package/dist/index.js

@@ -1,3 +1,22 @@
+// src/chain.ts
+var FIRE_PRIME_C = 300;
+var drawChainDelay = (delay, random) => {
+  if (typeof delay === "number") return delay;
+  const [min, max] = delay;
+  return min + random() * (max - min);
+};
+var chainDelayOf = (spec, trigger) => spec.explodes?.chain?.[trigger];
+var shotDamageFractionOf = (spec) => spec.explodes?.chain?.shotDamageFraction ?? 0;
+var explosivePart = (explosive, part, options = {}) => ({
+  ...part,
+  explodes: {
+    energy: explosive.energy,
+    radius: explosive.injuryRadius,
+    ...options.atC !== void 0 ? { atC: options.atC } : {},
+    ...explosive.chain ? { chain: { ...explosive.chain } } : {}
+  }
+});
+
 // src/math.ts
 var EPS = 1e-9;
 var vec = {
@@ -1441,6 +1460,8 @@ var createDestruction = (options = {}) => {
   const listeners = /* @__PURE__ */ new Map();
   let cur = [];
   const blasts = [];
+  const primed = /* @__PURE__ */ new Map();
+  let orderCounter = 0;
   const impls = /* @__PURE__ */ new Map();
   const taken = (id) => objects.has(id) || impls.has(id);
   const emit = (e) => {
@@ -1454,6 +1475,9 @@ var createDestruction = (options = {}) => {
   const base = (o, source) => source === void 0 ? { object: o.id, time } : { object: o.id, time, source };
   const pendingCollapse = /* @__PURE__ */ new Map();
   let runDepth = 0;
+  const drainBlasts = () => {
+    for (let blast = blasts.shift(); blast; blast = blasts.shift()) blastWorld(blast.point, blast.energy, blast.radius, blast.source);
+  };
   const run = (fn) => {
     const prev = cur;
     const mine = [];
@@ -1461,11 +1485,7 @@ var createDestruction = (options = {}) => {
     runDepth++;
     try {
       const value = fn();
-      let guard = 0;
-      while (blasts.length && guard++ < 64) {
-        const b = blasts.shift();
-        blastWorld(b.point, b.energy, b.radius, b.source);
-      }
+      drainBlasts();
       if (runDepth === 1) flushCollapse();
       return { value, events: mine };
     } finally {
@@ -1525,7 +1545,8 @@ var createDestruction = (options = {}) => {
       maxStress: 0,
       collapsed: new Set(carry?.collapsed ?? []),
       unsup: [],
-      anyAnchor: false
+      anyAnchor: false,
+      order: ++orderCounter
     };
     for (const ps of spec.parts) {
       if (o.byId.has(ps.id)) throw new Error(`duplicate part id "${ps.id}"`);
@@ -1572,6 +1593,7 @@ var createDestruction = (options = {}) => {
         cap: ps.structure ? partCapacity(ps, mat) : 0
       };
       if (p.structural) o.hasStructure = true;
+      if (p.rt.chainDue !== void 0 && !isLost(p)) primed.set(p, o);
       o.idx.set(ps.id, o.parts.length);
       o.parts.push(p);
       o.byId.set(ps.id, p);
@@ -2009,15 +2031,29 @@ var createDestruction = (options = {}) => {
     }
     partLost(o, p, src);
   };
+  const prime = (o, p, trigger, src) => {
+    const spec = chainDelayOf(p.spec, trigger);
+    if (spec === void 0 || isLost(p) || p.rt.chainDue !== void 0) return;
+    const delay = drawChainDelay(spec, rnd);
+    p.rt.chainDue = time + delay;
+    primed.set(p, o);
+    o.active = true;
+    emit({ ...base(o, src), type: "primed", part: p.spec.id, point: partXf(o, p).c, trigger, delay });
+  };
+  const CHAIN_TRIGGER_OF = { ballistic: "shot", explosive: "explosion" };
   const applyDamage = (o, p, amount, type, origin, dir, fragEnergy, cap, src) => {
     if (isLost(p) || amount <= 0) return 0;
     const prev = p.st.hp;
     p.st.hp -= amount;
     markDamaged(p);
+    const trigger = CHAIN_TRIGGER_OF[type];
+    const chained = trigger !== void 0 && chainDelayOf(p.spec, trigger) !== void 0;
+    if (chained && p.st.hp <= 0 && p.rt.chainDue === void 0) p.st.hp = Math.min(prev, 1);
     if (p.st.hp <= 0 && p.mat.fracture === "none" && !p.spec.explodes) p.st.hp = Math.min(prev, 1);
     const done = prev - p.st.hp;
     if (done > 0) emit({ ...base(o, src), type: "damage", part: p.spec.id, amount: done, hp: Math.max(0, p.st.hp), damageType: type });
     if (p.st.hp <= 0) failPart(o, p, origin, dir, fragEnergy, cap, src);
+    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) => {
@@ -2318,7 +2354,9 @@ var createDestruction = (options = {}) => {
       if (isLost(p)) continue;
       checkIgnite(o, p);
       const ex = p.spec.explodes;
-      if (ex && ex.atC !== void 0 && s.temperature >= ex.atC) {
+      if (ex && chainDelayOf(p.spec, "fire") !== void 0) {
+        if (s.temperature >= (ex.atC ?? FIRE_PRIME_C)) prime(o, p, "fire");
+      } else if (ex && ex.atC !== void 0 && s.temperature >= ex.atC) {
         failPart(o, p, null, null, 0, 40);
         continue;
       }
@@ -2330,6 +2368,10 @@ var createDestruction = (options = {}) => {
           s.liters = Math.max(0, (s.liters ?? 0) - rate * dt);
           hot = true;
           if (FLAMMABLE_FLUIDS.includes(cont.fluid) && s.temperature >= 350 && !p.rt.jet) {
+            if (ex && chainDelayOf(p.spec, "fire") !== void 0) {
+              prime(o, p, "fire");
+              continue;
+            }
             if (ex) {
               failPart(o, p, null, null, 0, 40);
               continue;
@@ -2413,6 +2455,34 @@ var createDestruction = (options = {}) => {
       }
     }
   };
+  const nextPrimed = (until) => {
+    let best = null;
+    for (const [p, o] of primed) {
+      if (objects.get(o.id) !== o || isLost(p)) {
+        primed.delete(p);
+        continue;
+      }
+      const due = p.rt.chainDue;
+      if (due > until) continue;
+      if (!best) best = { o, p };
+      else {
+        const bestDue = best.p.rt.chainDue;
+        if (due < bestDue || due === bestDue && (o.order < best.o.order || o.order === best.o.order && (o.idx.get(p.spec.id) ?? 0) < (best.o.idx.get(best.p.spec.id) ?? 0))) best = { o, p };
+      }
+    }
+    return best;
+  };
+  const detonatePrimed = (until) => {
+    const end = time;
+    for (let next = nextPrimed(until); next; next = nextPrimed(until)) {
+      primed.delete(next.p);
+      time = Math.max(0, Math.min(end, next.p.rt.chainDue));
+      next.p.rt.chainDue = void 0;
+      failPart(next.o, next.p, null, null, 0, 40);
+      drainBlasts();
+    }
+    time = end;
+  };
   const withCollapses = (r) => {
     const last = r.value[r.value.length - 1];
     if (!last) return r.value;
@@ -2663,6 +2733,7 @@ var createDestruction = (options = {}) => {
         const sources = [];
         for (const o of [...objects.values()]) if (o.active) stepObject(o, dt, sources);
         if (sources.length) spread(sources, dt);
+        detonatePrimed(time);
         for (const im of [...impls.values()]) {
           if (!im.impl.update) continue;
           for (const e of im.impl.update(dt) ?? []) emit(e.time === void 0 ? { ...e, time } : e);
@@ -2956,6 +3027,7 @@ var locales = {
       drip: "dripping",
       leak: "leak",
       explode: "exploded",
+      primed: "about to explode",
       stress: "overload",
       collapse: "collapsed",
       destroyed: "destroyed"
@@ -3037,6 +3109,7 @@ var locales = {
       drip: "pingando",
       leak: "vazamento",
       explode: "explodiu",
+      primed: "prestes a explodir",
       stress: "sobrecarga",
       collapse: "desabou",
       destroyed: "destru\xEDdo"
@@ -3055,6 +3128,7 @@ var checkDestructible = (impl, options = {}) => {
   return check(impl, contractOptions);
 };
 export {
+  FIRE_PRIME_C,
   IMPACT_CONTRACT,
   JOINT_BY_MATERIALS,
   JOINT_DEFAULTS,
@@ -3063,6 +3137,7 @@ export {
   checkDestructible,
   checkHit,
   createDestruction,
+  explosivePart,
   fragility,
   guessMaterial,
   inferJoints,