@adatechnology/game-contracts 0.13.0 → 0.14.0

package/dist/index.js

@@ -1,9 +1,27 @@
+// 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)" }
 };
@@ -226,6 +244,19 @@ var checkSpec = (spec, options = {}) => {
 };
 
 // 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];
@@ -239,9 +270,79 @@ var shotToHit = (shot, point, normal) => {
     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));
@@ -457,6 +558,9 @@ var createToolClipPlayer = (options) => {
     },
     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 }));
     }
   };
 };
@@ -570,15 +674,124 @@ function createEnvironmentBus(initial = {}) {
     }
   };
 }
+
+// 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 };
+};
 export {
+  DEFAULT_BLAST_SHOVE,
   DEFAULT_ENVIRONMENT,
+  DEFAULT_IGNITION_RULES,
   IMPACT_CONTRACT,
   MISSING_BITS,
   STAGE_EVENT,
   TOOL_CLIP,
   applyPatches,
+  blastShove,
   checkAnimation,
   checkBench,
+  checkCategorized,
   checkDestructible,
   checkHit,
   checkSpec,
@@ -586,11 +799,19 @@ export {
   createEnvironmentBus,
   createToolClipPlayer,
   deepMerge,
+  defineCategories,
+  fillFactor,
+  ignitionChance,
   mergeById,
   removeIds,
+  resolveEntry,
+  resolveIgnitionRules,
   sampleClip,
   scaleClip,
+  shotExtras,
   shotToHit,
-  toolAnimationStep
+  sparkTargetFactor,
+  toolAnimationStep,
+  useToHit
 };
 //# sourceMappingURL=index.js.map