@its-not-rocket-science/ananke 0.1.44 → 0.1.47

package/dist/src/wonders.js

@@ -0,0 +1,264 @@
+// src/wonders.ts — Phase 100: Wonders & Monuments
+//
+// Unique prestige constructions that define great civilisations — pyramids,
+// colosseums, grand libraries, great walls, harbours, aqueducts, temples.
+// Unlike Phase-89 functional infrastructure (roads, markets, apothecaries),
+// wonders are one-of-a-kind, take years to complete, and give civilisation-
+// level bonuses to stability, morale, research, defence, trade, and health.
+//
+// Design:
+//   - Pure data layer — no Entity fields, no kernel changes.
+//   - `WonderProject` tracks construction progress; `Wonder` is the completed record.
+//   - Progress = investedCost_cu / WONDER_BASE_COST_CU; completion when progress_Q = SCALE.Q.
+//   - `WonderEffects` is an advisory bundle; callers pass fields into Phases 88–93.
+//   - Damaged wonders (Phase-96 earthquake / Phase-93 siege) provide half effects
+//     until repaired at half the base cost.
+//   - Only one wonder of each type per polity (enforced by naming convention;
+//     host is responsible for uniqueness).
+//
+// Integration:
+//   Phase 88 (Epidemic):      epidemicResistance_Q adds to healthCapacity_Q (aqueduct).
+//   Phase 90 (Unrest):        unrestReduction_Q reduces computeUnrestLevel (colosseum, temple).
+//   Phase 91 (Research):      researchPointBonus adds daily research points (library).
+//   Phase 92 (Taxation):      tradeIncomeBonus_Q scales trade income (harbour).
+//   Phase 93 (Military Camp): defenseBonus_Q adds to defender strength (great_wall).
+//   Phase 96 (Climate):       earthquake → caller calls damageWonder().
+import { q, SCALE, clampQ, mulDiv } from "./units.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/**
+ * Total treasury cost to construct each wonder type [cu].
+ * Grand library is fastest; great pyramid is a generational project.
+ */
+export const WONDER_BASE_COST_CU = {
+    grand_library: 150_000,
+    aqueduct_system: 200_000,
+    grand_temple: 250_000,
+    grand_harbour: 300_000,
+    colosseum: 500_000,
+    great_wall: 600_000,
+    great_pyramid: 1_000_000,
+};
+/**
+ * Estimated build time in days at average investment rate.
+ * Informational only — actual duration depends on how fast the host invests.
+ */
+export const WONDER_TYPICAL_DAYS = {
+    grand_library: 180,
+    aqueduct_system: 365,
+    grand_temple: 365,
+    grand_harbour: 365,
+    colosseum: 730,
+    great_wall: 1095,
+    great_pyramid: 3650,
+};
+/**
+ * Full effects for each wonder type at q(1.0) effectiveness.
+ * Damaged wonders multiply each field by `WONDER_DAMAGED_EFFECT_MUL`.
+ */
+export const WONDER_BASE_EFFECTS = {
+    great_pyramid: {
+        stabilityBonus_Q: q(0.08), // generational prestige
+        moraleBonus_Q: q(0.05),
+        researchPointBonus: 0,
+        unrestReduction_Q: 0,
+        tradeIncomeBonus_Q: 0,
+        defenseBonus_Q: 0,
+        epidemicResistance_Q: 0,
+    },
+    colosseum: {
+        stabilityBonus_Q: q(0.03),
+        moraleBonus_Q: q(0.10), // entertainment
+        researchPointBonus: 0,
+        unrestReduction_Q: q(0.12), // bread and circuses
+        tradeIncomeBonus_Q: 0,
+        defenseBonus_Q: 0,
+        epidemicResistance_Q: 0,
+    },
+    grand_library: {
+        stabilityBonus_Q: q(0.03),
+        moraleBonus_Q: q(0.02),
+        researchPointBonus: 3, // +3 RP/day
+        unrestReduction_Q: 0,
+        tradeIncomeBonus_Q: 0,
+        defenseBonus_Q: 0,
+        epidemicResistance_Q: 0,
+    },
+    great_wall: {
+        stabilityBonus_Q: q(0.05),
+        moraleBonus_Q: 0,
+        researchPointBonus: 0,
+        unrestReduction_Q: 0,
+        tradeIncomeBonus_Q: 0,
+        defenseBonus_Q: q(0.20), // major defensive advantage
+        epidemicResistance_Q: 0,
+    },
+    grand_harbour: {
+        stabilityBonus_Q: 0,
+        moraleBonus_Q: q(0.03),
+        researchPointBonus: 0,
+        unrestReduction_Q: 0,
+        tradeIncomeBonus_Q: q(0.25), // major trade multiplier
+        defenseBonus_Q: 0,
+        epidemicResistance_Q: 0,
+    },
+    aqueduct_system: {
+        stabilityBonus_Q: q(0.02),
+        moraleBonus_Q: q(0.04), // quality of life
+        researchPointBonus: 0,
+        unrestReduction_Q: 0,
+        tradeIncomeBonus_Q: 0,
+        defenseBonus_Q: 0,
+        epidemicResistance_Q: q(0.15), // clean water reduces disease
+    },
+    grand_temple: {
+        stabilityBonus_Q: q(0.06), // divine legitimacy
+        moraleBonus_Q: q(0.08),
+        researchPointBonus: 0,
+        unrestReduction_Q: q(0.08),
+        tradeIncomeBonus_Q: 0,
+        defenseBonus_Q: 0,
+        epidemicResistance_Q: 0,
+    },
+};
+/**
+ * Effect multiplier for a damaged wonder [0, SCALE.Q].
+ * Damaged wonders still provide partial benefit; repair restores full effects.
+ */
+export const WONDER_DAMAGED_EFFECT_MUL = q(0.50);
+/**
+ * Treasury cost to repair a damaged wonder, as a fraction of `WONDER_BASE_COST_CU`.
+ * Repair = `round(baseCost × WONDER_REPAIR_COST_FRAC / SCALE.Q)`.
+ */
+export const WONDER_REPAIR_COST_FRAC = q(0.25);
+// ── Factory ───────────────────────────────────────────────────────────────────
+/** Create a new wonder construction project. */
+export function createWonderProject(projectId, polityId, type, startTick) {
+    return {
+        projectId,
+        polityId,
+        type,
+        progress_Q: 0,
+        investedCost_cu: 0,
+        startTick,
+    };
+}
+// ── Construction ──────────────────────────────────────────────────────────────
+/**
+ * Invest treasury into a wonder project.
+ *
+ * Deducts up to `contribution_cu` from `polity.treasury_cu` (capped by available
+ * treasury and remaining cost), advances `progress_Q`, and returns the new progress.
+ *
+ * Does not auto-complete — call `isWonderProjectComplete` then `completeWonder`.
+ */
+export function contributeToWonder(project, polity, contribution_cu) {
+    const totalCost = WONDER_BASE_COST_CU[project.type];
+    const remaining = Math.max(0, totalCost - project.investedCost_cu);
+    const actual = Math.min(contribution_cu, polity.treasury_cu, remaining);
+    polity.treasury_cu -= actual;
+    project.investedCost_cu += actual;
+    project.progress_Q = clampQ(Math.round(project.investedCost_cu * SCALE.Q / totalCost), 0, SCALE.Q);
+    return project.progress_Q;
+}
+/** Return `true` when the project has reached full completion. */
+export function isWonderProjectComplete(project) {
+    return project.progress_Q >= SCALE.Q;
+}
+/**
+ * Finalise a completed project into a standing `Wonder`.
+ *
+ * The caller is responsible for checking `isWonderProjectComplete` first.
+ */
+export function completeWonder(project, tick) {
+    return {
+        wonderId: project.projectId,
+        polityId: project.polityId,
+        type: project.type,
+        completedAtTick: tick,
+        damaged: false,
+    };
+}
+// ── Damage & repair ───────────────────────────────────────────────────────────
+/**
+ * Mark a wonder as damaged (earthquake, siege).
+ * Damaged wonders yield `WONDER_DAMAGED_EFFECT_MUL` fraction of full effects.
+ */
+export function damageWonder(wonder) {
+    wonder.damaged = true;
+}
+/**
+ * Repair a damaged wonder, spending `WONDER_REPAIR_COST_FRAC` of base cost.
+ *
+ * Mutates `polity.treasury_cu` and clears `wonder.damaged`.
+ * Returns `true` if repaired; `false` if the polity lacked funds.
+ * No-op if wonder is not damaged.
+ */
+export function repairWonder(wonder, polity) {
+    if (!wonder.damaged)
+        return true;
+    const baseCost = WONDER_BASE_COST_CU[wonder.type];
+    const repairCost = Math.round(mulDiv(baseCost, WONDER_REPAIR_COST_FRAC, SCALE.Q));
+    if (polity.treasury_cu < repairCost)
+        return false;
+    polity.treasury_cu -= repairCost;
+    wonder.damaged = false;
+    return true;
+}
+// ── Effect computation ────────────────────────────────────────────────────────
+/**
+ * Compute the `WonderEffects` advisory bundle for a single wonder.
+ *
+ * Damaged wonders: each numeric field is scaled by `WONDER_DAMAGED_EFFECT_MUL / SCALE.Q`.
+ */
+export function computeWonderEffects(wonder) {
+    const base = WONDER_BASE_EFFECTS[wonder.type];
+    if (!wonder.damaged)
+        return { ...base };
+    const m = WONDER_DAMAGED_EFFECT_MUL;
+    return {
+        stabilityBonus_Q: mulDiv(base.stabilityBonus_Q, m, SCALE.Q),
+        moraleBonus_Q: mulDiv(base.moraleBonus_Q, m, SCALE.Q),
+        researchPointBonus: Math.round(base.researchPointBonus * m / SCALE.Q),
+        unrestReduction_Q: mulDiv(base.unrestReduction_Q, m, SCALE.Q),
+        tradeIncomeBonus_Q: mulDiv(base.tradeIncomeBonus_Q, m, SCALE.Q),
+        defenseBonus_Q: mulDiv(base.defenseBonus_Q, m, SCALE.Q),
+        epidemicResistance_Q: mulDiv(base.epidemicResistance_Q, m, SCALE.Q),
+    };
+}
+/**
+ * Aggregate effects from multiple wonders.
+ *
+ * Q fields are summed and clamped to SCALE.Q.
+ * `researchPointBonus` is summed without capping.
+ */
+export function aggregateWonderEffects(wonders) {
+    let stab = 0, morale = 0, rp = 0, unrest = 0, trade = 0, def = 0, epi = 0;
+    for (const w of wonders) {
+        const fx = computeWonderEffects(w);
+        stab += fx.stabilityBonus_Q;
+        morale += fx.moraleBonus_Q;
+        rp += fx.researchPointBonus;
+        unrest += fx.unrestReduction_Q;
+        trade += fx.tradeIncomeBonus_Q;
+        def += fx.defenseBonus_Q;
+        epi += fx.epidemicResistance_Q;
+    }
+    return {
+        stabilityBonus_Q: clampQ(stab, 0, SCALE.Q),
+        moraleBonus_Q: clampQ(morale, 0, SCALE.Q),
+        researchPointBonus: rp,
+        unrestReduction_Q: clampQ(unrest, 0, SCALE.Q),
+        tradeIncomeBonus_Q: clampQ(trade, 0, SCALE.Q),
+        defenseBonus_Q: clampQ(def, 0, SCALE.Q),
+        epidemicResistance_Q: clampQ(epi, 0, SCALE.Q),
+    };
+}
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/** Return `true` when the wonder is standing and undamaged. */
+export function isWonderIntact(wonder) {
+    return !wonder.damaged;
+}
+/** Compute treasury cost to repair a damaged wonder [cu]. */
+export function computeRepairCost(type) {
+    return Math.round(mulDiv(WONDER_BASE_COST_CU[type], WONDER_REPAIR_COST_FRAC, SCALE.Q));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@its-not-rocket-science/ananke",
-  "version": "0.1.44",
+  "version": "0.1.47",
   "type": "module",
   "description": "Deterministic lockstep-friendly SI-units RPG/physics core (fixed-point TS)",
   "license": "MIT",
@@ -162,6 +162,14 @@
     "./mercenaries": {
       "import": "./dist/src/mercenaries.js",
       "types": "./dist/src/mercenaries.d.ts"
+    },
+    "./wonders": {
+      "import": "./dist/src/wonders.js",
+      "types": "./dist/src/wonders.d.ts"
+    },
+    "./monetary": {
+      "import": "./dist/src/monetary.js",
+      "types": "./dist/src/monetary.d.ts"
     }
   },
   "files": [