@its-not-rocket-science/ananke 0.1.0

package/dist/src/sim/injury.js

@@ -0,0 +1,66 @@
+import { q, clampQ, SCALE, qMul } from "../units.js";
+import { ALL_REGIONS } from "./body.js";
+/**
+ * Structural damage fraction at which a fracture is recorded.
+ * Once set, `fractured` persists until surgically cleared.
+ */
+export const FRACTURE_THRESHOLD = q(0.70);
+export const defaultRegionInjury = () => ({
+    surfaceDamage: q(0),
+    internalDamage: q(0),
+    structuralDamage: q(0),
+    bleedingRate: q(0),
+    fractured: false,
+    infectedTick: -1,
+    bleedDuration_ticks: 0,
+    permanentDamage: q(0),
+});
+/**
+ * Create a default InjuryState for the given segment ids.
+ * When omitted, defaults to the standard humanoid six regions.
+ */
+export const defaultInjury = (segmentIds) => {
+    const ids = segmentIds ?? ALL_REGIONS;
+    const byRegion = {};
+    for (const r of ids)
+        byRegion[r] = defaultRegionInjury();
+    return {
+        byRegion,
+        fluidLoss: q(0),
+        shock: q(0),
+        consciousness: q(1.0),
+        dead: false,
+        hemolymphLoss: q(0),
+    };
+};
+function totalRegionDamage(i, type) {
+    const segs = Object.values(i.byRegion);
+    let sum = 0;
+    for (const r of segs)
+        sum += r[type];
+    return clampQ(sum, 0, segs.length * SCALE.Q);
+}
+export function totalSurfaceDamage(i) {
+    return totalRegionDamage(i, 'surfaceDamage');
+}
+export function totalInternalDamage(i) {
+    return totalRegionDamage(i, 'internalDamage');
+}
+export function totalStructuralDamage(i) {
+    return totalRegionDamage(i, 'structuralDamage');
+}
+// If this name already exists in injury.ts, DO NOT duplicate it.
+// Either keep your existing export, or replace it with this implementation.
+export function totalBleedingRate(i) {
+    return totalRegionDamage(i, 'bleedingRate');
+}
+/**
+ * Compute KO risk from CNS-critical region damage.
+ * For humanoid and any plan that uses "head"/"torso" segment ids.
+ * For other body plans, falls back gracefully to q(0) for absent segments.
+ */
+export function regionKOFactor(i) {
+    const head = i.byRegion["head"]?.internalDamage ?? q(0);
+    const torso = i.byRegion["torso"]?.internalDamage ?? q(0);
+    return clampQ(qMul(head, q(1.2)) + qMul(torso, q(0.6)), 0, SCALE.Q);
+}

package/dist/src/sim/intent.d.ts

@@ -0,0 +1,26 @@
+import type { Q } from "../units.js";
+import { DefenceMode, MoveMode } from "./kinds.js";
+import type { Vec3 } from "./vec3.js";
+import type { LocomotionMode } from "../types.js";
+export interface MoveIntent {
+    dir: Vec3;
+    intensity: Q;
+    mode: MoveMode;
+}
+export interface DefenceIntent {
+    mode: DefenceMode;
+    intensity: Q;
+}
+export interface IntentState {
+    move: MoveIntent;
+    defence: DefenceIntent;
+    prone: boolean;
+    /** Phase 32A: requested locomotion mode. Validated against entity.attributes.locomotionModes. */
+    locomotionMode?: LocomotionMode;
+}
+export interface AIState {
+    focusTargetId: number;
+    retargetCooldownTicks: number;
+    decisionCooldownTicks: number;
+}
+export declare const defaultIntent: () => IntentState;

package/dist/src/sim/intent.js

@@ -0,0 +1,7 @@
+import { q } from "../units.js";
+import { DefenceModes, MoveModes } from "./kinds.js";
+export const defaultIntent = () => ({
+    move: { dir: { x: 0, y: 0, z: 0 }, intensity: q(0), mode: MoveModes.Walk },
+    defence: { mode: DefenceModes.None, intensity: q(0) },
+    prone: false,
+});

package/dist/src/sim/kernel.d.ts

@@ -0,0 +1,45 @@
+import type { WorldState } from "./world.js";
+import { type Entity } from "./entity.js";
+import type { CommandMap } from "./commands.js";
+import type { CapabilityEffect, EffectPayload } from "./capability.js";
+import type { KernelContext } from "./context.js";
+import { type Q, type I32 } from "../units.js";
+import { type Weapon } from "../equipment.js";
+import { type Vec3 } from "./vec3.js";
+import { type BlastSpec } from "./explosion.js";
+import { type TraceSink } from "./trace.js";
+export declare function stepWorld(world: WorldState, cmds: CommandMap, ctx: KernelContext): void;
+export declare function clampSpeed(v: Vec3, vmax_mps: I32): Vec3;
+export declare function scaleDirToSpeed(dirQ: Vec3, speed_mps: I32): Vec3;
+export declare function clampI32(x: number, lo: number, hi: number): number;
+export declare function armourCoversHit(world: WorldState, coverage: Q, aId: number, bId: number): boolean;
+export declare function applyImpactToInjury(target: Entity, wpn: Weapon, energy_J: number, region: string, armoured: boolean, trace: TraceSink, tick: number, tempCavityMul_Q?: number): void;
+/**
+ * Apply fall damage to a single entity (Phase 10).
+ * KE = mass × g × height; 85% absorbed by controlled landing.
+ * Remaining 15% distributed: locomotion-primary regions × 70%, others × 30%.
+ * Any fall ≥ 1 m forces prone.
+ */
+export declare function applyFallDamage(world: WorldState, entityId: number, height_m: I32, tick: number, trace: TraceSink): void;
+/**
+ * Apply a point-source explosion to all living entities within the blast radius (Phase 10).
+ *
+ * Features:
+ * - Blast wave delivered to torso; entities facing away take −30% blast damage.
+ * - Stochastic fragment hits to random regions.
+ * - Blast throw: entities are pushed outward; velocity proportional to blast energy / mass.
+ * - Emits a BlastHit trace event for each affected entity.
+ */
+export declare function applyExplosion(world: WorldState, origin: Vec3, spec: BlastSpec, tick: number, trace: TraceSink): void;
+/**
+ * Apply a single EffectPayload to target on behalf of actor.
+ * All payloads route to existing engine primitives — the engine does not distinguish
+ * magical from technological effects at this level.
+ */
+export declare function applyPayload(world: WorldState, actor: Entity, target: Entity, payload: EffectPayload, trace: TraceSink, tick: number, effectId: string): void;
+/**
+ * Resolve all payloads of a capability effect for the appropriate target set.
+ * AoE: all living entities within aoeRadius_m of target/actor position.
+ * Single-target: targetId entity, or self if absent.
+ */
+export declare function applyCapabilityEffect(world: WorldState, actor: Entity, targetId: number | undefined, effect: CapabilityEffect, trace: TraceSink, tick: number): void;