@its-not-rocket-science/ananke 0.1.0

package/dist/src/quest.js

@@ -0,0 +1,520 @@
+// src/quest.ts — Phase 41: Quest & Mission System
+//
+// Structured quest system with objectives, state tracking, and simulation event hooks.
+// Integrates with Phase 40 (Competence), Phase 24 (Factions), Phase 23 (Dialogue).
+/** Create a new empty quest registry. */
+export function createQuestRegistry() {
+    return {
+        templates: new Map(),
+        logs: new Map(),
+        history: [],
+    };
+}
+/** Get or create a quest log for an entity. */
+export function getQuestLog(registry, entityId) {
+    let log = registry.logs.get(entityId);
+    if (!log) {
+        log = {
+            entityId,
+            active: new Map(),
+            completed: new Map(),
+            failed: new Map(),
+        };
+        registry.logs.set(entityId, log);
+    }
+    return log;
+}
+// ── Quest Lifecycle ───────────────────────────────────────────────────────────
+/** Register a quest template in the registry. */
+export function registerQuestTemplate(registry, quest) {
+    registry.templates.set(quest.questId, quest);
+}
+/**
+ * Offer a quest to an entity.
+ * Returns false if entity already has this quest (in any state).
+ */
+export function offerQuest(registry, entityId, questTemplateId, tick) {
+    const template = registry.templates.get(questTemplateId);
+    if (!template) {
+        return { accepted: false, reason: `Unknown quest template: ${questTemplateId}` };
+    }
+    const log = getQuestLog(registry, entityId);
+    // Check if already has this quest
+    if (log.active.has(questTemplateId) ||
+        log.completed.has(questTemplateId) ||
+        log.failed.has(questTemplateId)) {
+        return { accepted: false, reason: "Quest already in log" };
+    }
+    // Deep clone the quest
+    const quest = {
+        ...template,
+        objectives: template.objectives.map((o) => ({ ...o })),
+        state: "active",
+        acceptedAtTick: tick,
+    };
+    // Initialize objective states
+    for (const obj of quest.objectives) {
+        if (!obj.requires || obj.requires.length === 0) {
+            obj.state = "available";
+            obj.activatedAtTick = tick;
+        }
+        else {
+            obj.state = "locked";
+        }
+    }
+    log.active.set(quest.questId, quest);
+    registry.history.push({
+        questId: quest.questId,
+        oldState: "inactive",
+        newState: "active",
+        trigger: { type: "accepted", entityId },
+        tick,
+    });
+    return { accepted: true, quest };
+}
+/** Abandon an active quest (moves to failed). */
+export function abandonQuest(registry, entityId, questId, tick) {
+    const log = getQuestLog(registry, entityId);
+    const quest = log.active.get(questId);
+    if (!quest)
+        return false;
+    const oldState = quest.state;
+    quest.state = "failed";
+    log.active.delete(questId);
+    log.failed.set(questId, quest);
+    registry.history.push({
+        questId,
+        oldState,
+        newState: "failed",
+        trigger: { type: "manual", reason: "abandoned" },
+        tick,
+    });
+    return true;
+}
+// ── Objective Progression ─────────────────────────────────────────────────────
+/**
+ * Check if an objective is complete based on its type and progress.
+ */
+export function checkObjectiveComplete(objective) {
+    if (objective.state === "completed" || objective.state === "failed") {
+        return true;
+    }
+    switch (objective.type) {
+        case "reach_location":
+        case "dialogue_choice":
+        case "escort_entity":
+        case "use_competence":
+        case "deliver_item":
+        case "wait_duration":
+            // Boolean completion - state must be "completed"
+            return false; // Not yet completed
+        case "defeat_entity":
+        case "collect_item":
+            // Count-based completion
+            if (objective.count !== undefined) {
+                return objective.progress >= objective.count;
+            }
+            return false;
+        default:
+            return false;
+    }
+}
+/**
+ * Unlock objectives whose prerequisites are met.
+ */
+export function unlockObjectives(quest, tick) {
+    const unlocked = [];
+    for (const obj of quest.objectives) {
+        if (obj.state !== "locked")
+            continue;
+        if (!obj.requires || obj.requires.length === 0)
+            continue;
+        const allPrereqsComplete = obj.requires.every((reqId) => {
+            const prereq = quest.objectives.find((o) => o.objectiveId === reqId);
+            return prereq?.state === "completed";
+        });
+        if (allPrereqsComplete) {
+            obj.state = "available";
+            obj.activatedAtTick = tick;
+            unlocked.push(obj);
+        }
+    }
+    return unlocked;
+}
+/**
+ * Check if quest is complete (all non-hidden objectives completed).
+ */
+export function checkQuestComplete(quest) {
+    const requiredObjectives = quest.objectives.filter((o) => !o.hidden);
+    if (requiredObjectives.length === 0)
+        return false;
+    return requiredObjectives.every((o) => o.state === "completed");
+}
+/**
+ * Check if any objective has failed.
+ */
+/**
+ * Check if any objective has failed.
+ */
+export function checkQuestFailed(quest) {
+    return quest.objectives.some((o) => o.state === "failed");
+}
+/**
+ * Handle location reached event.
+ */
+export function handleLocationReached(quest, entityId, position, tick) {
+    for (const obj of quest.objectives) {
+        if (obj.state !== "available" && obj.state !== "in_progress")
+            continue;
+        if (obj.type !== "reach_location")
+            continue;
+        if (!obj.target?.location)
+            continue;
+        const dx = position.x - obj.target.location.x;
+        const dy = position.y - obj.target.location.y;
+        const distSq = dx * dx + dy * dy;
+        const radius = obj.target.location.radius_m;
+        if (distSq <= radius * radius) {
+            const oldState = obj.state;
+            obj.state = "completed";
+            // Check for quest completion
+            unlockObjectives(quest, tick);
+            const complete = checkQuestComplete(quest);
+            if (complete) {
+                quest.state = "completed";
+            }
+            return {
+                updated: true,
+                questId: quest.questId,
+                objectiveId: obj.objectiveId,
+                oldState,
+                newState: "completed",
+                questComplete: complete,
+            };
+        }
+    }
+    return { updated: false };
+}
+/**
+ * Handle entity defeated event (from combat).
+ */
+export function handleEntityDefeated(quest, impact, tick) {
+    for (const obj of quest.objectives) {
+        if (obj.state !== "available" && obj.state !== "in_progress")
+            continue;
+        if (obj.type !== "defeat_entity")
+            continue;
+        // Check if this is the target entity
+        if (obj.target?.entityId !== undefined) {
+            if (obj.target.entityId !== impact.targetId)
+                continue;
+        }
+        obj.progress++;
+        if (obj.state === "available") {
+            obj.state = "in_progress";
+        }
+        const complete = checkObjectiveComplete(obj);
+        if (complete) {
+            const oldState = obj.state;
+            obj.state = "completed";
+            unlockObjectives(quest, tick);
+            const questComplete = checkQuestComplete(quest);
+            if (questComplete) {
+                quest.state = "completed";
+            }
+            return {
+                updated: true,
+                questId: quest.questId,
+                objectiveId: obj.objectiveId,
+                oldState,
+                newState: "completed",
+                questComplete,
+            };
+        }
+        return {
+            updated: true,
+            questId: quest.questId,
+            objectiveId: obj.objectiveId,
+            oldState: "in_progress",
+            newState: "in_progress",
+        };
+    }
+    return { updated: false };
+}
+/**
+ * Handle competence use event (from Phase 40).
+ */
+export function handleCompetenceUsed(quest, domain, quality_Q, taskId, tick) {
+    for (const obj of quest.objectives) {
+        if (obj.state !== "available" && obj.state !== "in_progress")
+            continue;
+        if (obj.type !== "use_competence")
+            continue;
+        if (!obj.target?.competence)
+            continue;
+        const req = obj.target.competence;
+        // Check domain match
+        if (req.domain !== domain)
+            continue;
+        // Check task match if specified
+        if (req.taskId && req.taskId !== taskId)
+            continue;
+        // Check quality threshold
+        if (quality_Q < req.minQuality_Q) {
+            // Quality too low - doesn't count but doesn't fail
+            continue;
+        }
+        const oldState = obj.state;
+        obj.state = "completed";
+        unlockObjectives(quest, tick);
+        const complete = checkQuestComplete(quest);
+        if (complete) {
+            quest.state = "completed";
+        }
+        return {
+            updated: true,
+            questId: quest.questId,
+            objectiveId: obj.objectiveId,
+            oldState,
+            newState: "completed",
+            questComplete: complete,
+        };
+    }
+    return { updated: false };
+}
+/**
+ * Handle item collection.
+ */
+export function handleItemCollected(quest, itemId, quantity, tick) {
+    for (const obj of quest.objectives) {
+        if (obj.state !== "available" && obj.state !== "in_progress")
+            continue;
+        if (obj.type !== "collect_item")
+            continue;
+        if (obj.target?.itemId !== itemId)
+            continue;
+        obj.progress += quantity;
+        if (obj.state === "available") {
+            obj.state = "in_progress";
+        }
+        const complete = checkObjectiveComplete(obj);
+        if (complete) {
+            const oldState = obj.state;
+            obj.state = "completed";
+            unlockObjectives(quest, tick);
+            const questComplete = checkQuestComplete(quest);
+            if (questComplete) {
+                quest.state = "completed";
+            }
+            return {
+                updated: true,
+                questId: quest.questId,
+                objectiveId: obj.objectiveId,
+                oldState,
+                newState: "completed",
+                questComplete,
+            };
+        }
+        return {
+            updated: true,
+            questId: quest.questId,
+            objectiveId: obj.objectiveId,
+            oldState: "in_progress",
+            newState: "in_progress",
+        };
+    }
+    return { updated: false };
+}
+/**
+ * Handle dialogue choice selection (Phase 23 integration).
+ */
+export function handleDialogueChoice(quest, choiceId, tick) {
+    for (const obj of quest.objectives) {
+        if (obj.state !== "available" && obj.state !== "in_progress")
+            continue;
+        if (obj.type !== "dialogue_choice")
+            continue;
+        if (obj.target?.dialogueChoice !== choiceId)
+            continue;
+        const oldState = obj.state;
+        obj.state = "completed";
+        unlockObjectives(quest, tick);
+        const complete = checkQuestComplete(quest);
+        if (complete) {
+            quest.state = "completed";
+        }
+        return {
+            updated: true,
+            questId: quest.questId,
+            objectiveId: obj.objectiveId,
+            oldState,
+            newState: "completed",
+            questComplete: complete,
+        };
+    }
+    return { updated: false };
+}
+// ── Time-based Objectives ─────────────────────────────────────────────────────
+/**
+ * Check time limits and update wait_duration objectives.
+ * Call this periodically (e.g., once per second or per tick).
+ */
+export function processTimeBasedObjectives(quest, currentTick, tickHz) {
+    const results = [];
+    const elapsed_s = (currentTick - (quest.acceptedAtTick ?? 0)) / tickHz;
+    // Check overall quest time limit
+    if (quest.timeLimit_s && elapsed_s >= quest.timeLimit_s) {
+        if (quest.state === "active") {
+            const oldState = quest.state;
+            quest.state = "failed";
+            quest.objectives.forEach((o) => {
+                if (o.state === "available" || o.state === "in_progress") {
+                    o.state = "failed";
+                }
+            });
+            return [
+                {
+                    updated: true,
+                    questId: quest.questId,
+                    oldState,
+                    newState: "failed",
+                    questFailed: true,
+                },
+            ];
+        }
+    }
+    // Check individual objective time limits and wait_duration
+    for (const obj of quest.objectives) {
+        if (obj.state !== "available" && obj.state !== "in_progress")
+            continue;
+        // Check objective time limit
+        if (obj.timeLimit_s && obj.activatedAtTick !== undefined) {
+            const objElapsed_s = (currentTick - obj.activatedAtTick) / tickHz;
+            if (objElapsed_s > obj.timeLimit_s) {
+                const oldState = obj.state;
+                obj.state = "failed";
+                // Fail the quest if a required objective fails
+                if (!obj.hidden) {
+                    quest.state = "failed";
+                    results.push({
+                        updated: true,
+                        questId: quest.questId,
+                        objectiveId: obj.objectiveId,
+                        oldState,
+                        newState: "failed",
+                        questFailed: true,
+                    });
+                    continue;
+                }
+                results.push({
+                    updated: true,
+                    questId: quest.questId,
+                    objectiveId: obj.objectiveId,
+                    oldState,
+                    newState: "failed",
+                });
+                continue;
+            }
+        }
+        // Handle wait_duration
+        if (obj.type === "wait_duration" && obj.activatedAtTick !== undefined) {
+            const objElapsed_s = (currentTick - obj.activatedAtTick) / tickHz;
+            if (objElapsed_s >= (obj.count ?? 0)) {
+                const oldState = obj.state;
+                obj.state = "completed";
+                unlockObjectives(quest, currentTick);
+                const complete = checkQuestComplete(quest);
+                if (complete) {
+                    quest.state = "completed";
+                }
+                results.push({
+                    updated: true,
+                    questId: quest.questId,
+                    objectiveId: obj.objectiveId,
+                    oldState,
+                    newState: "completed",
+                    questComplete: complete,
+                });
+            }
+        }
+    }
+    return results;
+}
+// ── Utility Functions ─────────────────────────────────────────────────────────
+/** Get all active quests for an entity. */
+export function getActiveQuests(registry, entityId) {
+    const log = registry.logs.get(entityId);
+    if (!log)
+        return [];
+    return Array.from(log.active.values());
+}
+/** Get quest by ID from any category. */
+export function getQuest(log, questId) {
+    if (log.active.has(questId)) {
+        return { quest: log.active.get(questId), category: "active" };
+    }
+    if (log.completed.has(questId)) {
+        return { quest: log.completed.get(questId), category: "completed" };
+    }
+    if (log.failed.has(questId)) {
+        return { quest: log.failed.get(questId), category: "failed" };
+    }
+    return undefined;
+}
+/** Get progress summary for a quest. */
+export function getQuestProgress(quest) {
+    const visible = quest.objectives.filter((o) => !o.hidden);
+    const total = visible.length;
+    const completed = visible.filter((o) => o.state === "completed").length;
+    const failed = visible.filter((o) => o.state === "failed").length;
+    return {
+        total,
+        completed,
+        failed,
+        percentage: total > 0 ? Math.round((completed / total) * 100) : 0,
+    };
+}
+/** Serialize quest registry to JSON-friendly format. */
+export function serializeQuestRegistry(registry) {
+    return {
+        templates: Array.from(registry.templates.entries()),
+        logs: Array.from(registry.logs.entries()).map(([entityId, log]) => [
+            entityId,
+            {
+                entityId: log.entityId,
+                active: Array.from(log.active.entries()),
+                completed: Array.from(log.completed.entries()),
+                failed: Array.from(log.failed.entries()),
+            },
+        ]),
+        history: registry.history,
+    };
+}
+/** Deserialize quest registry. */
+export function deserializeQuestRegistry(data) {
+    const registry = createQuestRegistry();
+    if (typeof data !== "object" || data === null) {
+        return registry;
+    }
+    const d = data;
+    if (Array.isArray(d.templates)) {
+        for (const [id, quest] of d.templates) {
+            registry.templates.set(id, quest);
+        }
+    }
+    if (Array.isArray(d.logs)) {
+        for (const [entityId, logData] of d.logs) {
+            const log = logData;
+            registry.logs.set(entityId, {
+                entityId: log.entityId,
+                active: new Map(log.active),
+                completed: new Map(log.completed),
+                failed: new Map(log.failed),
+            });
+        }
+    }
+    if (Array.isArray(d.history)) {
+        registry.history = d.history;
+    }
+    return registry;
+}

package/dist/src/relationships-effects.d.ts

@@ -0,0 +1,75 @@
+import type { Q } from "./units.js";
+import type { WorldState } from "./sim/world.js";
+import type { ImpactEvent } from "./sim/events.js";
+import type { RelationshipGraph } from "./relationships.js";
+/** Morale impact when witnessing an event involving someone you know. */
+export interface MoraleImpact {
+    observerId: number;
+    targetId: number;
+    event: "friend_injured" | "friend_killed" | "enemy_defeated" | "enemy_injured" | "betrayal";
+    delta_Q: Q;
+}
+/**
+ * Compute morale impacts for all observers of a combat event.
+ */
+export declare function computeCombatMoraleImpacts(graph: RelationshipGraph, world: WorldState, impact: ImpactEvent): MoraleImpact[];
+/**
+ * Compute morale impact from betrayal detection.
+ */
+export declare function computeBetrayalMoraleImpacts(graph: RelationshipGraph, world: WorldState, attackerId: number, victimId: number, tick: number): MoraleImpact[];
+/**
+ * Compute total teaching effectiveness multiplier.
+ * Combines base skill with relationship factors.
+ */
+export declare function computeTeachingEffectiveness(graph: RelationshipGraph, teacherId: number, learnerId: number, baseEffectiveness: number): number;
+/** Factors affecting combat AI decisions. */
+export interface CombatDecisionFactors {
+    /** Whether entity will protect the target */
+    willProtect: boolean;
+    /** Whether entity will avoid harming the target */
+    willAvoidHarm: boolean;
+    /** Aggression modifier toward target */
+    aggressionModifier: number;
+    /** Coordination bonus when fighting alongside */
+    coordinationBonus: number;
+}
+/**
+ * Compute combat decision factors based on relationship.
+ */
+export declare function getCombatDecisionFactors(graph: RelationshipGraph, entityId: number, targetId: number): CombatDecisionFactors;
+/**
+ * Determine if entity should switch targets to protect an ally.
+ */
+export declare function shouldProtectAlly(graph: RelationshipGraph, protectorId: number, allyId: number, threatId: number): boolean;
+/** Dialogue availability based on relationship. */
+export interface DialogueAvailability {
+    canAskFavors: boolean;
+    canNegotiate: boolean;
+    canIntimidate: boolean;
+    persuasionBonus: number;
+}
+/**
+ * Compute what dialogue options are available.
+ */
+export declare function getDialogueAvailability(graph: RelationshipGraph, speakerId: number, listenerId: number): DialogueAvailability;
+/**
+ * Record events from combat resolution.
+ */
+export declare function recordCombatOutcome(graph: RelationshipGraph, impact: ImpactEvent, outcome: "hit" | "blocked" | "parried" | "missed", tick: number): void;
+/**
+ * Record cooperation between entities.
+ */
+export declare function recordCooperation(graph: RelationshipGraph, entityA: number, entityB: number, success: boolean, tick: number): void;
+/**
+ * Record that one entity saved another.
+ */
+export declare function recordRescue(graph: RelationshipGraph, rescuerId: number, rescuedId: number, tick: number): void;
+/** Find entities that form a cohesive group based on relationships. */
+export declare function findCohesiveGroup(graph: RelationshipGraph, seedEntityId: number, minAffinity_Q?: Q): number[];
+/**
+ * Check if a group of entities can work together effectively.
+ */
+export declare function computeGroupCohesion(graph: RelationshipGraph, groupIds: number[]): {
+    cohesion_Q: Q;
+    trust_Q: Q;
+};