@its-not-rocket-science/ananke 0.1.0

package/dist/src/settlement.js

@@ -0,0 +1,419 @@
+// src/settlement.ts — Phase 44: Settlement & Base Building
+//
+// Persistent locations that can be constructed, upgraded, and populated.
+// Settlements provide services, storage, and serve as quest hubs.
+import { q, clampQ, SCALE, mulDiv } from "./units.js";
+import { createInventory } from "./inventory.js";
+export const SETTLEMENT_TIER_NAMES = {
+    0: "Camp",
+    1: "Hamlet",
+    2: "Village",
+    3: "Town",
+    4: "City",
+};
+// ── Settlement Creation ───────────────────────────────────────────────────────
+/** Create a new settlement. */
+export function createSettlement(settlementId, name, position, tick, tier = 0, factionId) {
+    const settlement = {
+        settlementId,
+        name,
+        position,
+        tier,
+        facilities: {
+            forge: 0,
+            medical: tier >= 1 ? 1 : 0,
+            market: tier >= 1 ? 1 : 0,
+            barracks: 0,
+            temple: 0,
+        },
+        population: tier === 0 ? 5 : tier * 50,
+        populationCap: calculatePopulationCap(tier, { forge: 0, medical: 0, market: 0, barracks: 0, temple: 0 }),
+        factionId,
+        sharedStorage: undefined,
+        activeProjects: [],
+        history: [{
+                tick,
+                type: "founded",
+                description: `${name} was founded as a ${SETTLEMENT_TIER_NAMES[tier]}`,
+            }],
+        safetyStatus: {
+            ticksSinceLastRaid: 1000,
+            hasDefenses: false,
+            recentCasualties: 0,
+        },
+        foodSurplus_Q: q(0.5),
+        foundedAtTick: tick,
+        lastUpdateTick: tick,
+    };
+    // Add shared storage for villages and above
+    if (tier >= 2) {
+        settlement.sharedStorage = createInventory(-1); // -1 indicates shared/npc inventory
+    }
+    return settlement;
+}
+/** Calculate population cap based on tier and facilities. */
+export function calculatePopulationCap(tier, facilities) {
+    // Base capacity by tier
+    const baseCap = {
+        0: 10, // Camp
+        1: 50, // Hamlet
+        2: 200, // Village
+        3: 1000, // Town
+        4: 5000, // City
+    };
+    let cap = baseCap[tier];
+    // Barracks increases cap (housing)
+    cap += facilities.barracks * 50;
+    // Medical facility allows healthier population density
+    cap += facilities.medical * 25;
+    return cap;
+}
+// ── Settlement Registry ───────────────────────────────────────────────────────
+/** Create a new settlement registry. */
+export function createSettlementRegistry() {
+    return {
+        settlements: new Map(),
+        byPosition: new Map(),
+        byFaction: new Map(),
+    };
+}
+/** Register a settlement in the registry. */
+export function registerSettlement(registry, settlement) {
+    registry.settlements.set(settlement.settlementId, settlement);
+    const posKey = `${settlement.position.x},${settlement.position.y}`;
+    registry.byPosition.set(posKey, settlement.settlementId);
+    if (settlement.factionId !== undefined) {
+        let factionSet = registry.byFaction.get(settlement.factionId);
+        if (!factionSet) {
+            factionSet = new Set();
+            registry.byFaction.set(settlement.factionId, factionSet);
+        }
+        factionSet.add(settlement.settlementId);
+    }
+}
+/** Remove a settlement from the registry. */
+export function unregisterSettlement(registry, settlementId) {
+    const settlement = registry.settlements.get(settlementId);
+    if (!settlement)
+        return false;
+    registry.settlements.delete(settlementId);
+    const posKey = `${settlement.position.x},${settlement.position.y}`;
+    registry.byPosition.delete(posKey);
+    if (settlement.factionId !== undefined) {
+        const factionSet = registry.byFaction.get(settlement.factionId);
+        if (factionSet) {
+            factionSet.delete(settlementId);
+        }
+    }
+    return true;
+}
+/** Get settlement by position. */
+export function getSettlementAtPosition(registry, x, y) {
+    const posKey = `${x},${y}`;
+    const settlementId = registry.byPosition.get(posKey);
+    if (settlementId) {
+        return registry.settlements.get(settlementId);
+    }
+    return undefined;
+}
+/** Get all settlements for a faction. */
+export function getFactionSettlements(registry, factionId) {
+    const settlementIds = registry.byFaction.get(factionId);
+    if (!settlementIds)
+        return [];
+    return Array.from(settlementIds)
+        .map((id) => registry.settlements.get(id))
+        .filter((s) => s !== undefined);
+}
+/** Find nearest settlement to a position. */
+export function findNearestSettlement(registry, x, y) {
+    let nearest;
+    let nearestDist = Infinity;
+    for (const settlement of registry.settlements.values()) {
+        const dx = settlement.position.x - x;
+        const dy = settlement.position.y - y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        if (dist < nearestDist) {
+            nearest = settlement;
+            nearestDist = dist;
+        }
+    }
+    if (!nearest)
+        return undefined;
+    return { settlement: nearest, distance: nearestDist };
+}
+// ── Construction Projects ──────────────────────────────────────────────────────
+/** Facility upgrade costs and requirements. */
+export const FACILITY_UPGRADE_COSTS = {
+    forge: {
+        0: { materials: {}, laborHours: 0 },
+        1: { materials: { stone: 50, wood: 100 }, laborHours: 100 },
+        2: { materials: { stone: 150, iron: 50, wood: 200 }, laborHours: 300 },
+        3: { materials: { stone: 400, iron: 150, steel: 50 }, laborHours: 800 },
+        4: { materials: { stone: 1000, steel: 200, mithril: 20 }, laborHours: 2000 },
+    },
+    medical: {
+        0: { materials: {}, laborHours: 0 },
+        1: { materials: { wood: 50, cloth: 30 }, laborHours: 80 },
+        2: { materials: { wood: 150, stone: 100, cloth: 100 }, laborHours: 250 },
+        3: { materials: { stone: 300, glass: 100, iron: 50 }, laborHours: 600 },
+        4: { materials: { stone: 800, glass: 300, steel: 100 }, laborHours: 1500 },
+    },
+    market: {
+        0: { materials: {}, laborHours: 0 },
+        1: { materials: { wood: 80 }, laborHours: 60 },
+        2: { materials: { wood: 200, stone: 100 }, laborHours: 200 },
+        3: { materials: { stone: 400, wood: 300, iron: 30 }, laborHours: 500 },
+        4: { materials: { stone: 1200, marble: 200, steel: 50 }, laborHours: 1200 },
+    },
+    barracks: {
+        0: { materials: {}, laborHours: 0 },
+        1: { materials: { wood: 100 }, laborHours: 80 },
+        2: { materials: { wood: 300, stone: 100 }, laborHours: 250 },
+        3: { materials: { stone: 500, wood: 200, iron: 50 }, laborHours: 600 },
+        4: { materials: { stone: 1500, steel: 200 }, laborHours: 1500 },
+    },
+    temple: {
+        0: { materials: {}, laborHours: 0 },
+        1: { materials: { wood: 60, cloth: 20 }, laborHours: 100 },
+        2: { materials: { stone: 200, wood: 100, cloth: 50 }, laborHours: 300 },
+        3: { materials: { stone: 600, glass: 100, gold: 10 }, laborHours: 800 },
+        4: { materials: { stone: 2000, marble: 500, gold: 100, crystal: 50 }, laborHours: 2500 },
+    },
+};
+/** Start a construction project. */
+export function startConstructionProject(settlement, facility, targetLevel, tick) {
+    const currentLevel = settlement.facilities[facility];
+    if (targetLevel <= currentLevel) {
+        return { success: false, reason: "already_at_or_above_level" };
+    }
+    if (targetLevel > currentLevel + 1) {
+        return { success: false, reason: "must_upgrade_sequentially" };
+    }
+    // Check if project already exists for this facility
+    const existing = settlement.activeProjects.find((p) => p.targetFacility === facility);
+    if (existing) {
+        return { success: false, reason: "project_already_active" };
+    }
+    const costs = FACILITY_UPGRADE_COSTS[facility][targetLevel];
+    if (!costs) {
+        return { success: false, reason: "invalid_target_level" };
+    }
+    const project = {
+        projectId: `${settlement.settlementId}_${facility}_${targetLevel}_${tick}`,
+        targetFacility: facility,
+        targetLevel,
+        requiredResources: { ...costs.materials },
+        progress_Q: q(0),
+        contributors: [],
+        startedAtTick: tick,
+    };
+    settlement.activeProjects.push(project);
+    settlement.history.push({
+        tick,
+        type: "project_started",
+        description: `Started construction of ${facility} level ${targetLevel}`,
+        data: { facility, targetLevel, projectId: project.projectId },
+    });
+    return { success: true, project };
+}
+/** Contribute work to a construction project. */
+export function contributeToProject(settlement, projectId, entityId, competenceQuality_Q, // From Phase 40 competence system
+hoursWorked, tick) {
+    const project = settlement.activeProjects.find((p) => p.projectId === projectId);
+    if (!project) {
+        return { success: false, reason: "project_not_found" };
+    }
+    // Add contributor
+    if (!project.contributors.includes(entityId)) {
+        project.contributors.push(entityId);
+    }
+    // Calculate progress contribution
+    // Total required = laborHours from costs
+    const costs = FACILITY_UPGRADE_COSTS[project.targetFacility][project.targetLevel];
+    const totalLaborRequired = costs.laborHours * SCALE.Q;
+    // Progress = competenceQuality * hoursWorked / totalRequired
+    const contribution = mulDiv(competenceQuality_Q, Math.round(hoursWorked * SCALE.Q), totalLaborRequired);
+    project.progress_Q = clampQ((project.progress_Q + contribution), q(0), SCALE.Q);
+    // Check completion
+    if (project.progress_Q >= SCALE.Q) {
+        completeConstructionProject(settlement, project, tick);
+        return { success: true, completed: true };
+    }
+    return { success: true, completed: false };
+}
+/** Complete a construction project. */
+function completeConstructionProject(settlement, project, tick) {
+    // Upgrade the facility
+    settlement.facilities[project.targetFacility] = project.targetLevel;
+    // Recalculate population cap
+    settlement.populationCap = calculatePopulationCap(settlement.tier, settlement.facilities);
+    // Remove from active projects
+    const idx = settlement.activeProjects.indexOf(project);
+    if (idx >= 0) {
+        settlement.activeProjects.splice(idx, 1);
+    }
+    // Record history
+    settlement.history.push({
+        tick,
+        type: "facility_upgraded",
+        description: `Completed ${project.targetFacility} level ${project.targetLevel}`,
+        entityIds: project.contributors,
+        data: { facility: project.targetFacility, level: project.targetLevel },
+    });
+    // Check for tier upgrade
+    checkTierUpgrade(settlement, tick);
+}
+/** Check if settlement qualifies for tier upgrade. */
+function checkTierUpgrade(settlement, tick) {
+    const facilitySum = Object.values(settlement.facilities).reduce((a, b) => a + b, 0);
+    const requiredFacilities = (settlement.tier + 1) * 2;
+    if (facilitySum >= requiredFacilities && settlement.population >= settlement.populationCap * 0.8) {
+        const oldTier = settlement.tier;
+        settlement.tier = Math.min(4, (settlement.tier + 1));
+        if (settlement.tier > oldTier) {
+            settlement.populationCap = calculatePopulationCap(settlement.tier, settlement.facilities);
+            settlement.history.push({
+                tick,
+                type: "tier_upgraded",
+                description: `${settlement.name} has grown from ${SETTLEMENT_TIER_NAMES[oldTier]} to ${SETTLEMENT_TIER_NAMES[settlement.tier]}`,
+                data: { oldTier, newTier: settlement.tier },
+            });
+            // Add shared storage if newly qualified
+            if (settlement.tier >= 2 && !settlement.sharedStorage) {
+                settlement.sharedStorage = createInventory(-1);
+            }
+        }
+    }
+}
+// ── Population Dynamics ───────────────────────────────────────────────────────
+/** Update settlement population based on conditions. */
+export function updateSettlementPopulation(settlement, tick) {
+    if (settlement.population >= settlement.populationCap) {
+        return { growth: 0, reason: "at_capacity" };
+    }
+    // Base growth rate
+    let growthChance = 0.001; // 0.1% per update
+    // Modifiers
+    if (settlement.foodSurplus_Q > q(0.5)) {
+        growthChance *= 1.5; // Food surplus bonus
+    }
+    else if (settlement.foodSurplus_Q < q(0.2)) {
+        growthChance *= 0.5; // Food shortage penalty
+    }
+    if (settlement.facilities.medical >= 2) {
+        growthChance *= 1.3; // Good medical facilities
+    }
+    if (settlement.safetyStatus.ticksSinceLastRaid < 100) {
+        growthChance *= 0.3; // Recent raid penalty
+    }
+    if (settlement.safetyStatus.hasDefenses) {
+        growthChance *= 1.2; // Defenses provide security
+    }
+    // Apply growth
+    const growthRoll = Math.random(); // In real system, use seeded RNG
+    if (growthRoll < growthChance) {
+        const growth = Math.max(1, Math.floor(settlement.population * 0.01));
+        const actualGrowth = Math.min(growth, settlement.populationCap - settlement.population);
+        if (actualGrowth > 0) {
+            settlement.population += actualGrowth;
+            settlement.history.push({
+                tick,
+                type: "population_changed",
+                description: `Population grew by ${actualGrowth} to ${settlement.population}`,
+                data: { change: actualGrowth, newPopulation: settlement.population },
+            });
+            return { growth: actualGrowth, reason: "natural_growth" };
+        }
+    }
+    return { growth: 0, reason: "no_growth" };
+}
+/** Get available services for a settlement. */
+export function getAvailableServices(settlement) {
+    return {
+        repair: settlement.facilities.forge >= 1,
+        repairQualityBonus_Q: (settlement.facilities.forge * 500), // +5% per level
+        medicalCare: getMedicalCareLevel(settlement.facilities.medical),
+        training: settlement.facilities.barracks >= 1,
+        trainingBonus_Q: (settlement.facilities.barracks * 500),
+        market: settlement.facilities.market >= 1,
+        marketDiscount_Q: (settlement.facilities.market * 300), // -3% per level
+        questGeneration: settlement.tier >= 1,
+    };
+}
+function getMedicalCareLevel(level) {
+    switch (level) {
+        case 0: return "none";
+        case 1: return "basic";
+        case 2: return "skilled";
+        case 3: return "expert";
+        case 4: return "master";
+        default: return "none";
+    }
+}
+// ── Settlement Defense ─────────────────────────────────────────────────────────
+/** Record a raid/siege on a settlement. */
+export function recordRaid(settlement, attackerFactionId, casualties, tick) {
+    settlement.safetyStatus.ticksSinceLastRaid = 0;
+    settlement.safetyStatus.recentCasualties = casualties;
+    settlement.history.push({
+        tick,
+        type: "raid",
+        description: `Raid by faction ${attackerFactionId}, ${casualties} casualties`,
+        data: { attackerFactionId, casualties },
+    });
+    // Population loss from casualties
+    if (casualties > 0) {
+        settlement.population = Math.max(0, settlement.population - casualties);
+    }
+}
+/** Update settlement defenses. */
+export function updateDefenses(settlement, hasDefenses) {
+    settlement.safetyStatus.hasDefenses = hasDefenses;
+}
+// ── Serialization ─────────────────────────────────────────────────────────────
+/** Serialize settlement to JSON-friendly format. */
+export function serializeSettlement(settlement) {
+    return {
+        settlementId: settlement.settlementId,
+        name: settlement.name,
+        position: settlement.position,
+        tier: settlement.tier,
+        facilities: settlement.facilities,
+        population: settlement.population,
+        populationCap: settlement.populationCap,
+        factionId: settlement.factionId,
+        sharedStorage: settlement.sharedStorage ? undefined : undefined, // Simplified
+        activeProjects: settlement.activeProjects,
+        history: settlement.history,
+        safetyStatus: settlement.safetyStatus,
+        foodSurplus_Q: settlement.foodSurplus_Q,
+        foundedAtTick: settlement.foundedAtTick,
+        lastUpdateTick: settlement.lastUpdateTick,
+    };
+}
+/** Deserialize settlement. */
+export function deserializeSettlement(data) {
+    const d = data;
+    return {
+        settlementId: d.settlementId ?? "",
+        name: d.name ?? "Unknown",
+        position: d.position ?? { x: 0, y: 0 },
+        tier: d.tier ?? 0,
+        facilities: d.facilities ?? {
+            forge: 0, medical: 0, market: 0, barracks: 0, temple: 0,
+        },
+        population: d.population ?? 0,
+        populationCap: d.populationCap ?? 0,
+        factionId: d.factionId,
+        sharedStorage: undefined,
+        activeProjects: Array.isArray(d.activeProjects) ? d.activeProjects : [],
+        history: Array.isArray(d.history) ? d.history : [],
+        safetyStatus: d.safetyStatus ?? {
+            ticksSinceLastRaid: 1000, hasDefenses: false, recentCasualties: 0,
+        },
+        foodSurplus_Q: d.foodSurplus_Q ?? q(0.5),
+        foundedAtTick: d.foundedAtTick ?? 0,
+        lastUpdateTick: d.lastUpdateTick ?? 0,
+    };
+}

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

@@ -0,0 +1,28 @@
+import type { I32, Q } from "../units.js";
+export interface ActionState {
+    attackCooldownTicks: I32;
+    defenceCooldownTicks: I32;
+    grappleCooldownTicks: I32;
+    facingDirQ: {
+        x: I32;
+        y: I32;
+        z: I32;
+    };
+    weaponBindPartnerId: number;
+    weaponBindTicks: number;
+    swingMomentumQ: Q;
+    shootCooldownTicks: I32;
+    aimTicks: number;
+    aimTargetId: number;
+    roundsInMag?: number;
+    capabilityCooldowns?: Map<string, number>;
+    lastCellKey?: string;
+    staggerTicks?: number;
+    sustainedEmission?: {
+        sourceId: string;
+        effectId: string;
+        targetId?: number;
+        remainingTicks: number;
+    };
+}
+export declare const defaultAction: () => ActionState;

package/dist/src/sim/action.js

@@ -0,0 +1,12 @@
+export const defaultAction = () => ({
+    attackCooldownTicks: 0,
+    defenceCooldownTicks: 0,
+    grappleCooldownTicks: 0,
+    facingDirQ: { x: 10_000, y: 0, z: 0 },
+    weaponBindPartnerId: 0,
+    weaponBindTicks: 0,
+    swingMomentumQ: 0,
+    shootCooldownTicks: 0,
+    aimTicks: 0,
+    aimTargetId: 0,
+});

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

@@ -0,0 +1,95 @@
+import { type Q } from "../units.js";
+import type { IndividualAttributes } from "../types.js";
+import type { Entity } from "./entity.js";
+/**
+ * Life-stage classification derived from normalized age fraction.
+ * Species-agnostic: boundaries are proportional to lifespan, not absolute years.
+ */
+export type AgePhase = "infant" | "child" | "adolescent" | "young_adult" | "adult" | "elder" | "ancient";
+/** Q-valued multipliers for each aging dimension. */
+export interface AgeMultipliers {
+    /** Multiplier for peakForce_N, peakPower_W, continuousPower_W [Q]. */
+    muscularStrength_Q: Q;
+    /** Multiplier on reactionTime_s — > q(1.0) means slower reaction [Q]. */
+    reactionTime_Q: Q;
+    /** Multiplier for controlQuality, stability, fineControl [Q]. */
+    motorControl_Q: Q;
+    /** Multiplier for stature_m [Q]. */
+    stature_Q: Q;
+    /** Multiplier for logicalMathematical, spatial, bodilyKinesthetic, musical [Q]. */
+    cognitionFluid_Q: Q;
+    /** Multiplier for linguistic, interpersonal, intrapersonal [Q]. */
+    cognitionCrystal_Q: Q;
+    /** Multiplier for distressTolerance [Q]. */
+    distressTolerance_Q: Q;
+}
+/** Per-entity age accumulator stored on `entity.age`. */
+export interface AgeState {
+    /** Elapsed seconds of this entity's life (from birth). */
+    ageSeconds: number;
+}
+/** Seconds in one year (non-leap). */
+export declare const SECONDS_PER_YEAR: number;
+/** Default lifespan for entities without a species override [years]. */
+export declare const HUMAN_LIFESPAN_YEARS = 80;
+/**
+ * Compute normalized age fraction [0..SCALE.Q] for a given age and lifespan.
+ *
+ * A 25-year-old human (lifespan 80) → q(0.3125).
+ * A 187-year-old elf (lifespan 600) → q(0.312) — effectively the same developmental stage.
+ *
+ * @param ageYears      Current age in years.
+ * @param lifespanYears Expected lifespan (default: HUMAN_LIFESPAN_YEARS).
+ */
+export declare function computeAgeFrac(ageYears: number, lifespanYears?: number): Q;
+/**
+ * Classify the entity's life stage from their normalized age fraction.
+ *
+ * Boundaries (ageFrac):
+ *   infant 0–0.05 | child 0.05–0.15 | adolescent 0.15–0.22 |
+ *   young_adult 0.22–0.38 | adult 0.38–0.62 | elder 0.62–0.88 | ancient 0.88+
+ */
+export declare function getAgePhase(ageYears: number, lifespanYears?: number): AgePhase;
+/**
+ * Derive age-based attribute multipliers from normalized age and lifespan.
+ *
+ * All returned Q values except `reactionTime_Q` are in [0, SCALE.Q].
+ * `reactionTime_Q` may exceed SCALE.Q (values > q(1.0) indicate slower reaction
+ * than the archetype baseline).
+ */
+export declare function deriveAgeMultipliers(ageYears: number, lifespanYears?: number): AgeMultipliers;
+/**
+ * Apply age multipliers to a base attribute set, returning a new object.
+ *
+ * The input `base` is treated as the archetype peak (typically from `generateIndividual`).
+ * The caller is responsible for caching the base and recomputing aged attributes when
+ * age advances (e.g. once per in-game month for campaign simulation).
+ *
+ * Attributes affected:
+ *   - morphology.stature_m
+ *   - performance.peakForce_N, peakPower_W, continuousPower_W
+ *   - control.reactionTime_s, controlQuality, stability, fineControl
+ *   - resilience.distressTolerance
+ *   - cognition (if present): fluid dims + crystal dims scaled independently
+ *
+ * All Q outputs are clamped to [0, SCALE.Q]; reactionTime_s is clamped to ≥ 1.
+ *
+ * @param base          Archetype-peak attributes (unmodified).
+ * @param ageYears      Current age in years.
+ * @param lifespanYears Expected lifespan (default: HUMAN_LIFESPAN_YEARS).
+ */
+export declare function applyAgingToAttributes(base: IndividualAttributes, ageYears: number, lifespanYears?: number): IndividualAttributes;
+/**
+ * Advance an entity's age by `elapsedSeconds`.
+ *
+ * Initializes `entity.age` if absent. Does NOT recompute attributes — the host
+ * should call `applyAgingToAttributes` when it needs current aged stats.
+ *
+ * Mutates: `entity.age`.
+ */
+export declare function stepAging(entity: Entity, elapsedSeconds: number): void;
+/**
+ * Convenience helper: return the current age in fractional years from entity.age.
+ * Returns 0 if `entity.age` is absent.
+ */
+export declare function entityAgeYears(entity: Entity): number;