@adatechnology/game-contracts 0.13.0 → 0.15.0

package/dist/index.global.js

@@ -21,14 +21,19 @@ var GameContracts = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    DEFAULT_BLAST_SHOVE: () => DEFAULT_BLAST_SHOVE,
     DEFAULT_ENVIRONMENT: () => DEFAULT_ENVIRONMENT,
+    DEFAULT_IGNITION_RULES: () => DEFAULT_IGNITION_RULES,
     IMPACT_CONTRACT: () => IMPACT_CONTRACT,
+    KIT_ORIGIN_KEY: () => KIT_ORIGIN_KEY,
     MISSING_BITS: () => MISSING_BITS,
     STAGE_EVENT: () => STAGE_EVENT,
     TOOL_CLIP: () => TOOL_CLIP,
     applyPatches: () => applyPatches,
+    blastShove: () => blastShove,
     checkAnimation: () => checkAnimation,
     checkBench: () => checkBench,
+    checkCategorized: () => checkCategorized,
     checkDestructible: () => checkDestructible,
     checkHit: () => checkHit,
     checkSpec: () => checkSpec,
@@ -36,20 +41,49 @@ var GameContracts = (() => {
     createEnvironmentBus: () => createEnvironmentBus,
     createToolClipPlayer: () => createToolClipPlayer,
     deepMerge: () => deepMerge,
+    defineCategories: () => defineCategories,
+    fillFactor: () => fillFactor,
+    ignitionChance: () => ignitionChance,
+    kitOriginOf: () => kitOriginOf,
+    markKitOrigin: () => markKitOrigin,
     mergeById: () => mergeById,
     removeIds: () => removeIds,
+    resolveEntry: () => resolveEntry,
+    resolveIgnitionRules: () => resolveIgnitionRules,
     sampleClip: () => sampleClip,
     scaleClip: () => scaleClip,
+    shotExtras: () => shotExtras,
     shotToHit: () => shotToHit,
-    toolAnimationStep: () => toolAnimationStep
+    sparkTargetFactor: () => sparkTargetFactor,
+    toolAnimationStep: () => toolAnimationStep,
+    unmarkedDrawings: () => unmarkedDrawings,
+    useToHit: () => useToHit
   });
 
+  // src/blast-shove.ts
+  var DEFAULT_BLAST_SHOVE = { coupling: 0.02, maxSpeed: 20, lift: 0.3, minSpeed: 0.3, falloffPower: 2 };
+  function blastShove(blast, target, options = {}) {
+    const o = { ...DEFAULT_BLAST_SHOVE, ...options };
+    const dx = target.position[0] - blast.point[0];
+    const dy = target.position[1] - blast.point[1];
+    const dz = target.position[2] - blast.point[2];
+    const distance = Math.hypot(dx, dy, dz);
+    if (!(blast.radius > 0) || distance > blast.radius) return void 0;
+    const falloff = (1 - distance / blast.radius) ** o.falloffPower;
+    const mass = Math.max(target.mass, 0.05);
+    const speed = Math.min(o.maxSpeed, Math.sqrt(2 * blast.energy * (blast.reach ?? 1) * o.coupling / mass)) * falloff;
+    if (!(speed >= o.minSpeed)) return void 0;
+    const direction = distance > 1e-4 ? [dx / distance, dy / distance + o.lift, dz / distance] : [0, 1, 0];
+    const length = Math.hypot(direction[0], direction[1], direction[2]);
+    return { speed, direction: [direction[0] / length, direction[1] / length, direction[2] / length], distance, falloff };
+  }
+
   // src/impact.ts
   var IMPACT_CONTRACT = {
     ballistic: { required: ["type", "point", "direction", "energy", "caliber"], optional: ["space", "source"], note: "bullets and pellets: joules and diameter in millimetres" },
     blunt: { required: ["type", "point", "energy"], optional: ["direction", "radius", "space", "source"], note: "contact radius in metres (default 3 cm)" },
     slash: { required: ["type", "point", "energy"], optional: ["direction", "radius", "space", "source"], note: "axes, knives, machetes" },
-    explosive: { required: ["type", "point", "energy", "radius"], optional: ["space", "source"], note: "point is the centre of the blast, radius the range in metres" },
+    explosive: { required: ["type", "point", "energy", "radius"], optional: ["lethalRadius", "space", "source"], note: "point is the centre of the blast, radius the range in metres" },
     fire: { required: ["type", "point", "temperature", "radius"], optional: ["duration", "space", "source"], note: "flame temperature in \xB0C; duration in seconds (call every frame with `dt`)" },
     heat: { required: ["type", "point", "temperature", "radius"], optional: ["duration", "space", "source"], note: "heat without flame (cutting torch, hot plate)" }
   };
@@ -272,6 +306,19 @@ var GameContracts = (() => {
   };
 
   // src/weapons.ts
+  var shotExtras = (shot, distance = 0) => {
+    const out = {};
+    if (shot.penetration) {
+      const k = shot.energy > 0 ? Math.min(1, Math.max(0, shot.energyAt(distance) / shot.energy)) : 1;
+      const scaled = {};
+      for (const key of Object.keys(shot.penetration)) scaled[key] = shot.penetration[key] * k;
+      out.penetration = scaled;
+    }
+    if (shot.incendiary) out.incendiary = true;
+    if (shot.tracer) out.tracer = true;
+    if (shot.ignition) out.ignition = { spark: shot.ignition.spark, flame: shot.ignition.flame };
+    return out;
+  };
   var shotToHit = (shot, point, normal) => {
     void normal;
     const dx = point[0] - shot.origin[0];
@@ -285,9 +332,79 @@ var GameContracts = (() => {
       energy: shot.energyAt(distance),
       caliber: shot.caliber,
       ...shot.mass === void 0 ? {} : { mass: shot.mass },
+      ...shotExtras(shot, distance),
       source: shot.source ?? shot.weapon
     };
   };
+  var useToHit = (use, point, normal) => {
+    void normal;
+    const p = [point[0], point[1], point[2]];
+    switch (use.kind) {
+      case "melee":
+        return { type: use.damage, point: p, direction: [use.direction[0], use.direction[1], use.direction[2]], energy: use.energy, radius: use.radius };
+      case "flame":
+      case "heat":
+        return {
+          type: use.kind === "flame" ? "fire" : "heat",
+          point: p,
+          direction: [use.direction[0], use.direction[1], use.direction[2]],
+          temperature: use.temperature,
+          radius: Math.min(use.radius, 0.3),
+          duration: use.duration
+        };
+      case "throw":
+        if (use.energy > 0) return { type: "explosive", point: p, energy: use.energy, radius: use.radius };
+        if (use.fire) return { type: "fire", point: p, temperature: use.fire.temperature, radius: use.fire.radius, duration: use.fire.seconds };
+        return null;
+      default:
+        return null;
+    }
+  };
+
+  // src/ignition.ts
+  var DEFAULT_IGNITION_RULES = {
+    fillCurve: [
+      [0, 0.6],
+      [0.1, 1],
+      [0.35, 0.6],
+      [0.65, 0.3],
+      [0.9, 0.15],
+      [1, 0.12]
+    ],
+    flameFillInfluence: 0.5,
+    flameDefaults: { incendiary: 0.7, tracer: 0.2 },
+    sparkTarget: { steel: 1, iron: 1, aluminium: 0.25 },
+    sparkMetalDefault: 0.5,
+    sparkFluid: { diesel: 0.15 },
+    fireNear: { radius: 1.5, chancePerSecond: 0.5 }
+  };
+  var resolveIgnitionRules = (rules) => ({
+    ...DEFAULT_IGNITION_RULES,
+    ...rules,
+    flameDefaults: { ...DEFAULT_IGNITION_RULES.flameDefaults, ...rules?.flameDefaults },
+    sparkTarget: { ...DEFAULT_IGNITION_RULES.sparkTarget, ...rules?.sparkTarget },
+    sparkFluid: { ...DEFAULT_IGNITION_RULES.sparkFluid, ...rules?.sparkFluid },
+    fireNear: { ...DEFAULT_IGNITION_RULES.fireNear, ...rules?.fireNear }
+  });
+  var fillFactor = (fill, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
+    if (curve.length === 0) return 1;
+    const f = Math.min(1, Math.max(0, fill));
+    if (f <= curve[0][0]) return curve[0][1];
+    for (let i = 1; i < curve.length; i++) {
+      const [x1, y1] = curve[i];
+      const [x0, y0] = curve[i - 1];
+      if (f <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (f - x0) / (x1 - x0);
+    }
+    return curve[curve.length - 1][1];
+  };
+  var sparkTargetFactor = (materialId, metal, rules = DEFAULT_IGNITION_RULES) => !metal ? 0 : rules.sparkTarget[materialId] ?? rules.sparkMetalDefault;
+  var ignitionChance = (hit, target, rules = DEFAULT_IGNITION_RULES) => {
+    const k = fillFactor(target.fill, rules.fillCurve);
+    const spark = (hit.ignition?.spark ?? 0) * target.sparkTarget * (target.fluid === void 0 ? 1 : rules.sparkFluid[target.fluid] ?? 1) * k;
+    const flameBase = hit.ignition?.flame ?? Math.max(hit.incendiary ? rules.flameDefaults.incendiary : 0, hit.tracer ? rules.flameDefaults.tracer : 0);
+    const flame = flameBase * (1 - rules.flameFillInfluence * (1 - k));
+    return 1 - (1 - Math.min(1, Math.max(0, spark))) * (1 - Math.min(1, Math.max(0, flame)));
+  };
 
   // src/animation.ts
   var finite3 = (v) => Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === "number" && Number.isFinite(n));
@@ -503,6 +620,9 @@ var GameContracts = (() => {
       },
       get playing() {
         return instances.map((instance) => instance.name);
+      },
+      get running() {
+        return instances.filter((instance) => instance.delay <= 0).map((instance) => ({ name: instance.name, time: instance.time, clip: instance.clip }));
       }
     };
   };
@@ -616,6 +736,143 @@ var GameContracts = (() => {
       }
     };
   }
+
+  // src/categories.ts
+  var defineCategories = (defs, options = {}) => {
+    const problems = [];
+    const duplicates = (list) => {
+      const ids = /* @__PURE__ */ new Set();
+      for (const def of list) {
+        if (ids.has(def.id)) problems.push(`duplicate category "${def.id}"`);
+        ids.add(def.id);
+      }
+    };
+    duplicates(defs);
+    duplicates(options.extra ?? []);
+    const entries = mergeById(defs, options.extra);
+    applyPatches(entries, options.patches);
+    removeIds(entries, options.remove);
+    const chain = (id) => {
+      const path = [];
+      let current = id;
+      while (current !== void 0) {
+        const def = entries.get(current);
+        if (!def) throw new Error(path.length === 0 ? `unknown category "${current}"` : `category "${path[0]}" has unknown parent "${current}"`);
+        if (path.includes(current)) throw new Error(`category cycle: ${[...path, current].reverse().join(" -> ")}`);
+        path.push(current);
+        current = def.extends;
+      }
+      return path.reverse();
+    };
+    const registry = {
+      get: (id) => entries.get(id),
+      has: (id) => entries.has(id),
+      ids: () => [...entries.keys()],
+      chain,
+      defaults: (id) => chain(id).reduce((acc, ancestor) => deepMerge(acc, entries.get(ancestor)?.defaults), {}),
+      requires: (id) => {
+        const out = [];
+        for (const ancestor of chain(id)) for (const contract of entries.get(ancestor)?.requires ?? []) if (!out.includes(contract)) out.push(contract);
+        return out;
+      },
+      isA: (id, ancestorId) => {
+        try {
+          return chain(id).includes(ancestorId);
+        } catch {
+          return false;
+        }
+      },
+      check: () => {
+        const found = [...problems];
+        for (const [id, def] of entries) {
+          if (def.extends !== void 0 && !entries.has(def.extends)) found.push(`category "${id}" extends unknown "${def.extends}"`);
+          else {
+            try {
+              chain(id);
+            } catch (error) {
+              const message = error.message;
+              if (message.startsWith("category cycle") && !found.includes(message)) found.push(message);
+            }
+          }
+        }
+        return found;
+      }
+    };
+    return registry;
+  };
+  var resolveEntry = (registry, entry, kindField = "kind") => deepMerge(registry.defaults(String(entry[kindField])), entry);
+  var checkCategorized = (entries, registry, checkers, options = {}) => {
+    const kindField = options.kindField ?? "kind";
+    const byId = new Map(checkers.map((checker) => [checker.id, checker]));
+    const problems = [...registry.check()];
+    const allowed = [];
+    for (const entry of entries) {
+      const kind = String(entry[kindField]);
+      if (!registry.has(kind)) {
+        problems.push(`"${entry.id}" has unknown kind "${kind}"`);
+        continue;
+      }
+      if (registry.get(kind)?.abstract) {
+        problems.push(`"${entry.id}" has abstract kind "${kind}"`);
+        continue;
+      }
+      let path;
+      try {
+        path = registry.chain(kind);
+      } catch (error) {
+        problems.push(`"${entry.id}" (${kind}): ${error.message}`);
+        continue;
+      }
+      const resolved = resolveEntry(registry, entry, kindField);
+      for (const contract of registry.requires(kind)) {
+        const owner = path.find((ancestor) => registry.get(ancestor)?.requires?.includes(contract)) ?? kind;
+        const checker = byId.get(contract);
+        if (!checker) {
+          problems.push(`kind "${kind}" requires contract "${contract}" but no checker is registered`);
+          continue;
+        }
+        const prefix = `"${entry.id}" (${kind}): `;
+        for (const problem of checker.check(resolved, { kind, chain: path })) {
+          const text = `${prefix}${problem}, required by ${owner}`;
+          if ((options.allow?.[entry.id] ?? []).some((start) => problem.startsWith(start))) allowed.push(text);
+          else problems.push(text);
+        }
+      }
+    }
+    return { ok: problems.length === 0, problems: [...new Set(problems)], allowed };
+  };
+
+  // src/origin.ts
+  var KIT_ORIGIN_KEY = "kitOrigin";
+  function markKitOrigin(object, origin) {
+    const node = object;
+    node.userData = node.userData ?? {};
+    node.userData[KIT_ORIGIN_KEY] = { ...origin };
+    return object;
+  }
+  function kitOriginOf(object) {
+    for (let node = object; node; node = node.parent) {
+      const origin = node.userData?.[KIT_ORIGIN_KEY];
+      if (origin && typeof origin.owner === "string") return origin;
+    }
+    return null;
+  }
+  function unmarkedDrawings(root) {
+    const out = [];
+    const pathOf = (node) => {
+      const names = [];
+      for (let n = node; n && n !== root; n = n.parent) if (n.name) names.push(n.name);
+      return names.reverse().join(" > ") || "(no name)";
+    };
+    const walk = (node, marked) => {
+      if (node.visible === false) return;
+      const here = marked || node !== root && Boolean(node.userData?.[KIT_ORIGIN_KEY]?.owner);
+      if (!here && (node.isMesh || node.isPoints || node.isLine || node.isSprite)) out.push({ path: pathOf(node), object: node });
+      for (const child of node.children ?? []) walk(child, here);
+    };
+    walk(root, false);
+    return out;
+  }
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map