@adatechnology/game-destruction 0.3.2 → 0.4.0

package/README.md

@@ -94,6 +94,15 @@ melts anything. Melting emits `melt` and `drip`; a melted part is lost and its j
 when the part has `explodes`). `contains` parts leak through punctures: the `leak` event carries the hole's world point, the outward normal as
 `direction` and the rate in litres per second, and `PartState.liters` drops in `update` (`setLiters` fills or empties a container).
 
+### Chain reaction
+
+A part with `explodes.chain` (fuel barrel, gas bottle, car tank, gas pump, station tank) answers to what happens around it: `shot` (a bullet, once it has taken off
+`shotDamageFraction` of the hit points), `fire` (the part reaches `explodes.atC`, 300 °C by default) and `explosion` (a blast reaches it). Each gives the seconds until the
+blast, fixed or `[min, max]` drawn from the world seed. The world emits `primed` when it arms a part and `explode` when the delay ends; a bullet or a blast arms the part
+instead of tearing it apart on the spot, and a part goes off once. Blasts resolve in order of time, then object, then part, and the delay counts from the blast that armed the
+part, so the timeline does not depend on the `dt` you pass to `update`. `explosivePart(explosive, part)` builds the part from an `ExplosiveDef` of `@adatechnology/game-weapons`
+(`explosives.get('fuel_barrel')`), so energy, reach and delays come from one place and a game changes them with `patch.explosives`.
+
 ## Joints and tools
 
 | Kind | Strength | Tools | Seconds |
@@ -177,7 +186,7 @@ valid (unique ids, known materials, joints reference parts), a 500 J ballistic h
 ## Events
 
 `damage`, `dent`, `hole`, `crack`, `ricochet`, `debris`, `fracture` (with oriented `fragments` in world space), `detach`, `disassemble_progress`,
-`ignite`, `extinguish`, `burnout`, `melt`, `drip`, `leak`, `explode`, `stress`, `collapse`, `destroyed`. All points are in world space. Subscribe with
+`ignite`, `extinguish`, `burnout`, `melt`, `drip`, `leak`, `explode`, `primed`, `stress`, `collapse`, `destroyed`. All points are in world space. Subscribe with
 `world.on(type | '*', fn)` or the `onEvent` option; `hit` and `update` also return their events.
 
 ## Determinism and LAN

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Vec3, Quat, MaterialId, FractureStyle, DamageType, DebrisKind, DestructionEvent, DestructibleSpec, ObjectState, DestructibleImpl, Hit, HitResult, RayHit, ToolKind, JointState, PartState, DestructionEventType, JointKind, PartSpec, JointSpec, PartShape, PartStatus, StructureRole } from '@adatechnology/game-contracts';
-export { Crack, DamageType, DebrisKind, Dent, DestructibleImpl, DestructibleSpec, DestructionEvent, DestructionEventType, FluidKind, FractureStyle, Fragment, Hit, HitResult, Hole, IMPACT_CONTRACT, ImpactContract, JointKind, JointSpec, JointState, MaterialId, ObjectState, PartShape, PartSpec, PartState, PartStatus, Quat, RayHit, StructureRole, ToolKind, Vec3, checkHit } from '@adatechnology/game-contracts';
+import { Vec3, Quat, MaterialId, FractureStyle, DamageType, DebrisKind, DestructionEvent, DestructibleSpec, ObjectState, DestructibleImpl, Hit, HitResult, RayHit, ToolKind, JointState, PartState, DestructionEventType, ExplosionChain, PartSpec, JointKind, JointSpec, PartShape, PartStatus, StructureRole } from '@adatechnology/game-contracts';
+export { ChainDelay, Crack, DamageType, DebrisKind, Dent, DestructibleImpl, DestructibleSpec, DestructionEvent, DestructionEventType, ExplosionChain, FluidKind, FractureStyle, Fragment, Hit, HitResult, Hole, IMPACT_CONTRACT, ImpactContract, JointKind, JointSpec, JointState, MaterialId, ObjectState, PartShape, PartSpec, PartState, PartStatus, Quat, RayHit, StructureRole, ToolKind, Vec3, checkHit } from '@adatechnology/game-contracts';
 
 /**
  * Public types of @adatechnology/game-destruction.
@@ -204,6 +204,8 @@ interface PartRuntime {
     jet: boolean;
     /** Seconds left before the next `stress` event. */
     stressT?: number;
+    /** World time at which a primed explosive part goes off (`explodes.chain`). */
+    chainDue?: number;
 }
 /** Opaque bookkeeping of an object (see `PartRuntime`). `joints` holds the last disassembly step reported per joint id. */
 interface ObjectRuntime {
@@ -235,6 +237,27 @@ interface DestructionSnapshot {
 
 declare const createDestruction: (options?: DestructionOptions) => DestructionWorld;
 
+/** What can set an explosive part off from outside, in the order a hit can carry it. */
+type ChainTrigger = 'shot' | 'fire' | 'explosion';
+/** Temperature in °C that primes a part with `chain.fire` when its `explodes.atC` is not set. */
+declare const FIRE_PRIME_C = 300;
+/** The numbers of an explosive that sits in the world, as `game-weapons` gives them (`ExplosiveDef` fits). */
+interface WorldExplosive {
+    readonly energy: number;
+    /** Metres within which the blast reaches other parts (and primes theirs). */
+    readonly injuryRadius: number;
+    readonly chain?: ExplosionChain;
+}
+interface ExplosivePartOptions {
+    /** Temperature in °C at which fire primes (or sets off) the part; default `FIRE_PRIME_C` when the explosive answers to fire. */
+    readonly atC?: number;
+}
+/**
+ * A part that explodes with the energy and reach of `explosive` and answers to what `explosive.chain` says: a bullet, fire or a blast
+ * nearby primes it and it goes off after the delay. `part` is everything else about the part (shape, material, position, fluid inside).
+ */
+declare const explosivePart: (explosive: WorldExplosive, part: Omit<PartSpec, "explodes">, options?: ExplosivePartOptions) => PartSpec;
+
 /** Built-in materials (data in `src/data/materials.json`). Override or extend with the `materials` option of `createDestruction`. */
 declare const MATERIALS: MaterialDef[];
 /** Default joint strength (joint hit points), tools that undo it and seconds of tool work. */
@@ -387,4 +410,4 @@ declare const checkDestructible: (impl: DestructibleImpl, options?: CheckOptions
     problems: string[];
 };
 
-export { type AddOptions, type CheckOptions, type DestructionLocale, type DestructionOptions, type DestructionSnapshot, type DestructionStrings, type DestructionWorld, type FrameOptions, JOINT_BY_MATERIALS, JOINT_DEFAULTS, MATERIALS, type MaterialDef, type MaterialThermal, type ObjectRuntime, type PartRuntime, type SizeStructureOptions, buildFrame, checkDestructible, createDestruction, fragility, guessMaterial, inferJoints, locales, partCapacity, partMass, partThickness, partVolume, quat, quatFromEuler, resolveStrings, rotateVec, sizeStructure, toLocal, toWorld, vec };
+export { type AddOptions, type ChainTrigger, type CheckOptions, type DestructionLocale, type DestructionOptions, type DestructionSnapshot, type DestructionStrings, type DestructionWorld, type ExplosivePartOptions, FIRE_PRIME_C, type FrameOptions, JOINT_BY_MATERIALS, JOINT_DEFAULTS, MATERIALS, type MaterialDef, type MaterialThermal, type ObjectRuntime, type PartRuntime, type SizeStructureOptions, type WorldExplosive, buildFrame, checkDestructible, createDestruction, explosivePart, fragility, guessMaterial, inferJoints, locales, partCapacity, partMass, partThickness, partVolume, quat, quatFromEuler, resolveStrings, rotateVec, sizeStructure, toLocal, toWorld, vec };

package/dist/index.global.js

@@ -21,6 +21,7 @@ var GameDestruction = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    FIRE_PRIME_C: () => FIRE_PRIME_C,
     IMPACT_CONTRACT: () => IMPACT_CONTRACT,
     JOINT_BY_MATERIALS: () => JOINT_BY_MATERIALS,
     JOINT_DEFAULTS: () => JOINT_DEFAULTS,
@@ -29,6 +30,7 @@ var GameDestruction = (() => {
     checkDestructible: () => checkDestructible2,
     checkHit: () => checkHit,
     createDestruction: () => createDestruction,
+    explosivePart: () => explosivePart,
     fragility: () => fragility,
     guessMaterial: () => guessMaterial,
     inferJoints: () => inferJoints,
@@ -47,6 +49,25 @@ var GameDestruction = (() => {
     vec: () => vec
   });
 
+  // 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 = {
@@ -1490,6 +1511,8 @@ var GameDestruction = (() => {
     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) => {
@@ -1503,6 +1526,9 @@ var GameDestruction = (() => {
     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 = [];
@@ -1510,11 +1536,7 @@ var GameDestruction = (() => {
       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 {
@@ -1574,7 +1596,8 @@ var GameDestruction = (() => {
         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}"`);
@@ -1621,6 +1644,7 @@ var GameDestruction = (() => {
           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);
@@ -2058,15 +2082,29 @@ var GameDestruction = (() => {
       }
       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) => {
@@ -2367,7 +2405,9 @@ var GameDestruction = (() => {
         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;
         }
@@ -2379,6 +2419,10 @@ var GameDestruction = (() => {
             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;
@@ -2462,6 +2506,34 @@ var GameDestruction = (() => {
         }
       }
     };
+    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;
@@ -2712,6 +2784,7 @@ var GameDestruction = (() => {
           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);
@@ -3005,6 +3078,7 @@ var GameDestruction = (() => {
         drip: "dripping",
         leak: "leak",
         explode: "exploded",
+        primed: "about to explode",
         stress: "overload",
         collapse: "collapsed",
         destroyed: "destroyed"
@@ -3086,6 +3160,7 @@ var GameDestruction = (() => {
         drip: "pingando",
         leak: "vazamento",
         explode: "explodiu",
+        primed: "prestes a explodir",
         stress: "sobrecarga",
         collapse: "desabou",
         destroyed: "destru\xEDdo"