@its-not-rocket-science/ananke 0.1.0

package/dist/src/traits.js

@@ -0,0 +1,178 @@
+import { DamageChannel, channelMask } from "./channels.js";
+import { SCALE, clampQ, q, qMul } from "./units.js";
+export const TRAITS = {
+    sealed: {
+        id: "sealed",
+        name: "Sealed",
+        description: "Resistant to chemical exposure and suffocation-like hazards (sealed system).",
+        resistantTo: channelMask(DamageChannel.Chemical, DamageChannel.Suffocation),
+        mult: { shockTolerance: q(1.10) },
+    },
+    nonConductive: {
+        id: "nonConductive",
+        name: "Non-conductive",
+        description: "Highly resistant to electrical hazards.",
+        immuneTo: channelMask(DamageChannel.Electrical),
+    },
+    distributedControl: {
+        id: "distributedControl",
+        name: "Distributed control",
+        description: "No single control core; more tolerant of local disruption.",
+        resistantTo: channelMask(DamageChannel.ControlDisruption),
+        mult: { concussionTolerance: q(1.20), shockTolerance: q(1.10) },
+    },
+    noSurfaceLayer: {
+        id: "noSurfaceLayer",
+        name: "No surface layer",
+        description: "Surface injuries are largely irrelevant.",
+        mult: { surfaceIntegrity: q(9.99) },
+    },
+    noBulkMedium: {
+        id: "noBulkMedium",
+        name: "No bulk medium",
+        description: "Bulk trauma effects are reduced.",
+        mult: { bulkIntegrity: q(2.00), shockTolerance: q(1.25) },
+    },
+    highThermalMass: {
+        id: "highThermalMass",
+        name: "High thermal mass",
+        description: "Temperature changes slowly; tolerant of thermal exposure.",
+        mult: { heatTolerance: q(1.30), coldTolerance: q(1.30) },
+    },
+    fragileStructure: {
+        id: "fragileStructure",
+        name: "Fragile structure",
+        description: "More susceptible to structural failure.",
+        mult: { structureIntegrity: q(0.75), structureScale: q(0.90) },
+    },
+    reinforcedStructure: {
+        id: "reinforcedStructure",
+        name: "Reinforced structure",
+        description: "Upgraded load-bearing structure.",
+        mult: { structureIntegrity: q(1.25), structureScale: q(1.10) },
+    },
+    chemicalImmune: {
+        id: "chemicalImmune",
+        name: "Chemical immune",
+        description: "Unaffected by chemical/toxin hazards.",
+        immuneTo: channelMask(DamageChannel.Chemical),
+    },
+    radiationHardened: {
+        id: "radiationHardened",
+        name: "Radiation hardened",
+        description: "Resistant to radiation damage and radiation-induced control glitches.",
+        resistantTo: channelMask(DamageChannel.Radiation, DamageChannel.ControlDisruption),
+        mult: { controlQuality: q(1.05) },
+    },
+    leader: {
+        id: "leader",
+        name: "Leader",
+        description: "Provides morale aura to nearby allies, reducing their fear accumulation.",
+    },
+    standardBearer: {
+        id: "standardBearer",
+        name: "Standard-bearer",
+        description: "Carries a rallying standard; provides a smaller morale aura to nearby allies.",
+    },
+};
+const MULT_ACCESSORS = {
+    // Resilience
+    shockTolerance: {
+        get: (a) => a.resilience.shockTolerance,
+        set: (a, v) => { a.resilience.shockTolerance = v; },
+        max: 10 * SCALE.Q,
+    },
+    concussionTolerance: {
+        get: (a) => a.resilience.concussionTolerance,
+        set: (a, v) => { a.resilience.concussionTolerance = v; },
+        max: 10 * SCALE.Q,
+    },
+    distressTolerance: {
+        get: (a) => a.resilience.distressTolerance,
+        set: (a, v) => { a.resilience.distressTolerance = v; },
+        max: 10 * SCALE.Q,
+    },
+    // Integrity (your traits imply these exist; adjust nesting if needed)
+    surfaceIntegrity: {
+        get: (a) => a.resilience.surfaceIntegrity,
+        set: (a, v) => { a.resilience.surfaceIntegrity = v; },
+        max: 10 * SCALE.Q,
+    },
+    bulkIntegrity: {
+        get: (a) => a.resilience.bulkIntegrity,
+        set: (a, v) => { a.resilience.bulkIntegrity = v; },
+        max: 10 * SCALE.Q,
+    },
+    structureIntegrity: {
+        get: (a) => a.resilience.structureIntegrity,
+        set: (a, v) => { a.resilience.structureIntegrity = v; },
+        max: 10 * SCALE.Q,
+    },
+    // Morphology / structure scaling
+    structureScale: {
+        get: (a) => a.morphology.structureScale,
+        set: (a, v) => { a.morphology.structureScale = v; },
+        max: 10 * SCALE.Q,
+    },
+    // Thermoregulation / tolerances
+    heatTolerance: {
+        get: (a) => a.resilience.heatTolerance,
+        set: (a, v) => { a.resilience.heatTolerance = v; },
+        max: 10 * SCALE.Q,
+    },
+    coldTolerance: {
+        get: (a) => a.resilience.coldTolerance,
+        set: (a, v) => { a.resilience.coldTolerance = v; },
+        max: 10 * SCALE.Q,
+    },
+    // Control / coordination quality
+    controlQuality: {
+        get: (a) => a.control.controlQuality,
+        set: (a, v) => { a.control.controlQuality = v; },
+        max: 10 * SCALE.Q,
+    },
+};
+function applyMult(a, key, mult) {
+    const acc = MULT_ACCESSORS[key];
+    const current = acc.get(a);
+    const next = clampQ(qMul(current, mult), 0, acc.max ?? (10 * SCALE.Q));
+    acc.set(a, next);
+}
+export const TRAIT_MUTATORS = (() => {
+    const out = {};
+    for (const id of Object.keys(TRAITS)) {
+        const trait = TRAITS[id];
+        out[id] = (a) => {
+            if (!trait.mult)
+                return;
+            for (const [k, mult] of Object.entries(trait.mult)) {
+                applyMult(a, k, mult);
+            }
+        };
+    }
+    return out;
+})();
+export function buildTraitProfile(traits) {
+    let immuneMask = 0;
+    let resistantMask = 0;
+    for (const id of traits) {
+        const t = TRAITS[id];
+        if (t.immuneTo)
+            immuneMask |= t.immuneTo;
+        if (t.resistantTo)
+            resistantMask |= t.resistantTo;
+    }
+    return { traits: [...traits].sort(), immuneMask, resistantMask };
+}
+export function applyTraitsToAttributes(base, traits) {
+    const out = structuredClone(base);
+    // Deterministic ordering
+    const sorted = [...traits].sort();
+    for (const t of sorted) {
+        const mut = TRAIT_MUTATORS[t];
+        if (!mut)
+            throw new Error(`Unknown trait: ${t}`);
+        mut(out);
+    }
+    return out;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,117 @@
+import type { I32, Q } from "./units.js";
+export interface LanguageCapacity {
+    /** Language identifier (e.g., "common", "elvish", "klingonese"). */
+    languageId: string;
+    /** Fluency level: q(1.0) = native, q(0.50) = conversational, q(0.20) = survival. */
+    fluency_Q: Q;
+}
+export interface CognitiveProfile {
+    /** Language, argument complexity, written/spoken command clarity. */
+    linguistic: Q;
+    /** Deductive reasoning, planning horizon, pattern abstraction. */
+    logicalMathematical: Q;
+    /** 3-D world modelling, navigation, cover identification, targeting lead. */
+    spatial: Q;
+    /** Proprioception, fine motor precision, tool mastery. */
+    bodilyKinesthetic: Q;
+    /** Rhythm, acoustic pattern recognition, sound cue detection. */
+    musical: Q;
+    /** Social reading, empathy, leadership radius, teaching quality. */
+    interpersonal: Q;
+    /** Self-regulation, focus, willpower, fear resistance. */
+    intrapersonal: Q;
+    /** Pattern recognition in living systems, tracking, herbalism, taming. */
+    naturalist: Q;
+    /** Empathy across species boundaries; reading non-human intent. */
+    interSpecies: Q;
+    /** Phase 36: species IDs with which the entity has deep familiarity. */
+    speciesAffinity?: string[];
+    /** Phase 36: map of species ID → comprehension quality for signaling. */
+    signalVocab?: Map<string, Q>;
+}
+export type LocomotionMode = "ground" | "flight" | "swim" | "climb";
+export interface LocomotionCapacity {
+    mode: LocomotionMode;
+    /** Maximum speed in this mode [SCALE.mps]. */
+    maxSpeed_mps: number;
+    /** Energy cost multiplier on peakPower_W per unit distance. */
+    costMul: Q;
+    /** Target altitude maintained during flight [SCALE.m]; ignored for other modes. */
+    cruiseAlt_m?: number;
+}
+export interface Perception {
+    visionRange_m: I32;
+    visionArcDeg: number;
+    halfArcCosQ: Q;
+    hearingRange_m: I32;
+    decisionLatency_s: I32;
+    attentionDepth: number;
+    threatHorizon_m: I32;
+}
+export interface Morphology {
+    stature_m: I32;
+    mass_kg: I32;
+    actuatorMass_kg: I32;
+    actuatorScale: Q;
+    structureScale: Q;
+    reachScale: Q;
+}
+export interface Performance {
+    peakForce_N: I32;
+    peakPower_W: I32;
+    continuousPower_W: I32;
+    reserveEnergy_J: I32;
+    conversionEfficiency: Q;
+}
+export interface Control {
+    controlQuality: Q;
+    reactionTime_s: I32;
+    stability: Q;
+    fineControl: Q;
+}
+export interface Resilience {
+    surfaceIntegrity: Q;
+    bulkIntegrity: Q;
+    structureIntegrity: Q;
+    distressTolerance: Q;
+    shockTolerance: Q;
+    concussionTolerance: Q;
+    heatTolerance: Q;
+    coldTolerance: Q;
+    fatigueRate: Q;
+    recoveryRate: Q;
+    magicResist?: Q;
+    fearResponse?: "flight" | "freeze" | "berserk";
+}
+export type PersonalityId = "berserker" | "coward" | "guardian" | "schemer" | "soldier";
+/**
+ * Four orthogonal behavioural axes that modulate decisions on top of the base AIPolicy.
+ * All fields are Q-coded [0, SCALE.Q]; q(0.50) is neutral (no change from baseline).
+ */
+export interface PersonalityTraits {
+    /** 0 = passive/retreat-prone; q(1.0) = fights to the end, ignores hesitation. */
+    aggression: Q;
+    /** 0 = reckless; q(1.0) = maximises defensive intensity and cover-seeking. */
+    caution: Q;
+    /** 0 = pure self-preservation; q(1.0) = overrides focus target to shield allies. */
+    loyalty: Q;
+    /** 0 = locks onto first target; q(1.0) = hunts the most wounded enemy. */
+    opportunism: Q;
+}
+export interface IndividualAttributes {
+    morphology: Morphology;
+    performance: Performance;
+    control: Control;
+    resilience: Resilience;
+    perception?: Perception;
+    /** Phase 32A: declared locomotion modes (absent = ground-only). */
+    locomotionModes?: LocomotionCapacity[];
+    /** Phase 33: Gardner's multiple intelligences + inter-species. */
+    cognition?: CognitiveProfile;
+    /** Phase 37: Language capacities for multilingual communication. */
+    languages?: LanguageCapacity[];
+}
+export interface EnergyState {
+    reserveEnergy_J: I32;
+    fatigue: Q;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/units.d.ts

@@ -0,0 +1,41 @@
+export type I32 = number;
+export type Q = number;
+export declare const SCALE: {
+    Q: number;
+    m: number;
+    s: number;
+    kg: number;
+    N: number;
+    W: number;
+    J: number;
+    mps: number;
+    mps2: number;
+};
+export declare const G_mps2: I32;
+export declare const q: (x: number) => Q;
+export declare const clampQ: (x: Q, lo?: number, hi?: number) => Q;
+export declare const qMul: (a: Q, b: Q) => Q;
+export declare const qDiv: (a: Q, b: Q) => Q;
+export declare const mulDiv: (a: I32, b: I32, div: I32) => I32;
+export declare const to: {
+    m: (x: number) => I32;
+    s: (x: number) => I32;
+    kg: (x: number) => I32;
+    N: (x: number) => I32;
+    W: (x: number) => I32;
+    J: (x: number) => I32;
+    mps: (x: number) => I32;
+    mps2: (x: number) => I32;
+};
+export declare const from: {
+    m: (x: I32) => number;
+    s: (x: I32) => number;
+    kg: (x: I32) => number;
+    N: (x: I32) => number;
+    W: (x: I32) => number;
+    J: (x: I32) => number;
+    mps: (x: I32) => number;
+    mps2: (x: I32) => number;
+};
+export declare const sqrtQ: (xQ: Q) => Q;
+export declare const cbrtQ: (xQ: Q) => Q;

package/dist/src/units.js

@@ -0,0 +1,64 @@
+export const SCALE = {
+    Q: 10_000, // 1.0 == 10000
+    m: 10_000, // 0.1 mm
+    s: 10_000, // 0.1 ms
+    kg: 1_000, // 1 g
+    N: 100, // 0.01 N
+    W: 1, // 1 W
+    J: 1, // 1 J
+    mps: 10_000, // 0.1 mm/s
+    mps2: 10_000, // 0.1 mm/s^2
+};
+export const G_mps2 = Math.round(9.80665 * SCALE.mps2);
+export const q = (x) => Math.round(x * SCALE.Q);
+export const clampQ = (x, lo = 0, hi = SCALE.Q) => Math.max(lo, Math.min(hi, x));
+export const qMul = (a, b) => Math.trunc((a * b) / SCALE.Q);
+export const qDiv = (a, b) => Math.trunc((a * SCALE.Q) / b);
+export const mulDiv = (a, b, div) => Number((BigInt(a) * BigInt(b)) / BigInt(div));
+export const to = {
+    m: (x) => Math.round(x * SCALE.m),
+    s: (x) => Math.round(x * SCALE.s),
+    kg: (x) => Math.round(x * SCALE.kg),
+    N: (x) => Math.round(x * SCALE.N),
+    W: (x) => Math.round(x * SCALE.W),
+    J: (x) => Math.round(x * SCALE.J),
+    mps: (x) => Math.round(x * SCALE.mps),
+    mps2: (x) => Math.round(x * SCALE.mps2),
+};
+export const from = {
+    m: (x) => x / SCALE.m,
+    s: (x) => x / SCALE.s,
+    kg: (x) => x / SCALE.kg,
+    N: (x) => x / SCALE.N,
+    W: (x) => x / SCALE.W,
+    J: (x) => x / SCALE.J,
+    mps: (x) => x / SCALE.mps,
+    mps2: (x) => x / SCALE.mps2,
+};
+// Deterministic integer roots for Q-scaled values
+export const sqrtQ = (xQ) => {
+    const x = BigInt(Math.max(1, xQ));
+    const X = x * BigInt(SCALE.Q);
+    let r = BigInt(SCALE.Q);
+    for (let i = 0; i < 10; i++) {
+        const rNew = (r + X / r) / 2n;
+        if (rNew === r)
+            break; // Converged
+        r = rNew;
+    }
+    return Number(r);
+};
+export const cbrtQ = (xQ) => {
+    const x = BigInt(Math.max(1, xQ));
+    const X = x * BigInt(SCALE.Q) * BigInt(SCALE.Q);
+    let r = BigInt(SCALE.Q);
+    for (let i = 0; i < 12; i++) {
+        const r2 = r * r;
+        r = (2n * r + X / r2) / 3n;
+        if (r <= 0n) {
+            r = 1n;
+            break;
+        }
+    }
+    return Number(r);
+};

package/dist/src/weapons.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Phase 17: Historical weapons database
+ * Spans six eras with realistic physical properties calibrated to archaeological and
+ * biomechanics literature.  All units follow the project SI fixed-point conventions.
+ */
+import type { Weapon, RangedWeapon } from "./equipment.js";
+export declare const PREHISTORIC_MELEE: Weapon[];
+export declare const CLASSICAL_MELEE: Weapon[];
+export declare const MEDIEVAL_MELEE: Weapon[];
+export declare const RENAISSANCE_MELEE: Weapon[];
+export declare const EARLY_MODERN_MELEE: Weapon[];
+export declare const CONTEMPORARY_MELEE: Weapon[];
+export declare const PREHISTORIC_RANGED: RangedWeapon[];
+export declare const CLASSICAL_RANGED: RangedWeapon[];
+export declare const MEDIEVAL_RANGED: RangedWeapon[];
+export declare const RENAISSANCE_RANGED: RangedWeapon[];
+export declare const EARLY_MODERN_RANGED: RangedWeapon[];
+export declare const CONTEMPORARY_RANGED: RangedWeapon[];
+export declare const ALL_HISTORICAL_MELEE: Weapon[];
+export declare const ALL_HISTORICAL_RANGED: RangedWeapon[];