@its-not-rocket-science/ananke 0.1.14 → 0.1.16

package/dist/as/push.wat

@@ -0,0 +1,326 @@
+(module
+ (type $0 (func (param i32) (result i32)))
+ (type $1 (func (param i32 i32 i32 i32)))
+ (type $2 (func (param i32 i32) (result i32)))
+ (type $3 (func (param i32 i32 i32)))
+ (global $as/push/MAX_ENTITIES i32 (i32.const 64))
+ (global $as/push/OFFSET_POS_X i32 (i32.const 0))
+ (global $as/push/OFFSET_POS_Y i32 (i32.const 256))
+ (global $as/push/OFFSET_ALIVE i32 (i32.const 512))
+ (global $as/push/OFFSET_DV_X i32 (i32.const 768))
+ (global $as/push/OFFSET_DV_Y i32 (i32.const 1024))
+ (memory $0 1)
+ (export "MAX_ENTITIES" (global $as/push/MAX_ENTITIES))
+ (export "OFFSET_POS_X" (global $as/push/OFFSET_POS_X))
+ (export "OFFSET_POS_Y" (global $as/push/OFFSET_POS_Y))
+ (export "OFFSET_ALIVE" (global $as/push/OFFSET_ALIVE))
+ (export "OFFSET_DV_X" (global $as/push/OFFSET_DV_X))
+ (export "OFFSET_DV_Y" (global $as/push/OFFSET_DV_Y))
+ (export "writeEntity" (func $as/push/writeEntity))
+ (export "readDvX" (func $as/push/readDvX))
+ (export "readDvY" (func $as/push/readDvY))
+ (export "approxDist" (func $as/push/approxDist))
+ (export "stepRepulsionPairs" (func $as/push/stepRepulsionPairs))
+ (export "memory" (memory $0))
+ (func $as/push/writeEntity (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32)
+  local.get $0
+  i32.const 2
+  i32.shl
+  local.tee $0
+  local.get $1
+  i32.store
+  local.get $0
+  local.get $2
+  i32.store offset=256
+  local.get $0
+  local.get $3
+  i32.store offset=512
+ )
+ (func $as/push/readDvX (param $0 i32) (result i32)
+  local.get $0
+  i32.const 2
+  i32.shl
+  i32.load offset=768
+ )
+ (func $as/push/readDvY (param $0 i32) (result i32)
+  local.get $0
+  i32.const 2
+  i32.shl
+  i32.const 1024
+  i32.add
+  i32.load
+ )
+ (func $as/push/approxDist (param $0 i32) (param $1 i32) (result i32)
+  i32.const 0
+  local.get $0
+  i32.sub
+  local.get $0
+  local.get $0
+  i32.const 0
+  i32.lt_s
+  select
+  local.tee $0
+  i32.const 0
+  local.get $1
+  i32.sub
+  local.get $1
+  local.get $1
+  i32.const 0
+  i32.lt_s
+  select
+  local.tee $1
+  i32.const 1
+  i32.shr_s
+  i32.add
+  local.get $1
+  local.get $0
+  i32.const 1
+  i32.shr_s
+  i32.add
+  local.get $0
+  local.get $1
+  i32.gt_s
+  select
+ )
+ (func $as/push/stepRepulsionPairs (param $0 i32) (param $1 i32) (param $2 i32)
+  (local $3 i32)
+  (local $4 i64)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  (local $8 i64)
+  (local $9 i32)
+  (local $10 i32)
+  (local $11 i64)
+  (local $12 i32)
+  (local $13 i64)
+  (local $14 i64)
+  (local $15 i32)
+  loop $for-loop|0
+   local.get $0
+   local.get $3
+   i32.gt_s
+   if
+    local.get $3
+    i32.const 2
+    i32.shl
+    local.tee $5
+    i32.const 0
+    i32.store offset=768
+    local.get $5
+    i32.const 1024
+    i32.add
+    i32.const 0
+    i32.store
+    local.get $3
+    i32.const 1
+    i32.add
+    local.set $3
+    br $for-loop|0
+   end
+  end
+  local.get $1
+  i64.extend_i32_s
+  local.tee $4
+  local.get $4
+  i64.mul
+  local.set $4
+  i32.const 0
+  local.set $3
+  loop $for-loop|1
+   local.get $3
+   local.get $0
+   i32.const 1
+   i32.sub
+   i32.lt_s
+   if
+    local.get $3
+    i32.const 2
+    i32.shl
+    local.tee $5
+    i32.load offset=512
+    if
+     local.get $5
+     i32.load
+     local.set $6
+     local.get $5
+     i32.load offset=256
+     local.set $7
+     local.get $3
+     i32.const 1
+     i32.add
+     local.set $5
+     loop $for-loop|2
+      local.get $0
+      local.get $5
+      i32.gt_s
+      if
+       block $for-continue|2
+        local.get $5
+        i32.const 2
+        i32.shl
+        local.tee $9
+        i32.load offset=512
+        i32.eqz
+        br_if $for-continue|2
+        local.get $9
+        i32.load
+        local.get $6
+        i32.sub
+        local.tee $10
+        i64.extend_i32_s
+        local.tee $11
+        local.get $11
+        i64.mul
+        local.get $9
+        i32.load offset=256
+        local.get $7
+        i32.sub
+        local.tee $12
+        i64.extend_i32_s
+        local.tee $13
+        local.get $13
+        i64.mul
+        i64.add
+        local.tee $8
+        i64.eqz
+        local.get $4
+        local.get $8
+        i64.le_s
+        i32.or
+        br_if $for-continue|2
+        local.get $1
+        i32.const 0
+        local.get $10
+        i32.sub
+        local.get $10
+        local.get $10
+        i32.const 0
+        i32.lt_s
+        select
+        local.tee $10
+        i32.const 0
+        local.get $12
+        i32.sub
+        local.get $12
+        local.get $12
+        i32.const 0
+        i32.lt_s
+        select
+        local.tee $12
+        i32.const 1
+        i32.shr_s
+        i32.add
+        local.get $12
+        local.get $10
+        i32.const 1
+        i32.shr_s
+        i32.add
+        local.get $10
+        local.get $12
+        i32.gt_s
+        select
+        local.tee $10
+        i32.sub
+        local.tee $12
+        i32.const 0
+        i32.le_s
+        br_if $for-continue|2
+        i32.const 10000
+        local.get $12
+        i32.const 10000
+        i32.mul
+        local.get $1
+        i32.div_s
+        local.tee $12
+        local.get $12
+        i32.const 10000
+        i32.gt_s
+        select
+        local.tee $12
+        i32.const 0
+        local.get $12
+        i32.const 0
+        i32.ge_s
+        select
+        i64.extend_i32_s
+        local.tee $14
+        local.get $2
+        i64.extend_i32_s
+        local.tee $8
+        local.get $11
+        i64.mul
+        i64.mul
+        i32.const 1
+        local.get $10
+        local.get $10
+        i32.const 0
+        i32.le_s
+        select
+        i64.extend_i32_s
+        i64.const 10000
+        i64.mul
+        local.tee $11
+        i64.div_s
+        i32.wrap_i64
+        local.set $10
+        local.get $8
+        local.get $13
+        i64.mul
+        local.get $14
+        i64.mul
+        local.get $11
+        i64.div_s
+        i32.wrap_i64
+        local.set $12
+        local.get $3
+        i32.const 2
+        i32.shl
+        local.tee $15
+        local.get $15
+        i32.load offset=768
+        local.get $10
+        i32.sub
+        i32.store offset=768
+        local.get $15
+        i32.const 1024
+        i32.add
+        local.tee $15
+        local.get $15
+        i32.load
+        local.get $12
+        i32.sub
+        i32.store
+        local.get $9
+        local.get $9
+        i32.load offset=768
+        local.get $10
+        i32.add
+        i32.store offset=768
+        local.get $9
+        i32.const 1024
+        i32.add
+        local.tee $9
+        local.get $9
+        i32.load
+        local.get $12
+        i32.add
+        i32.store
+       end
+       local.get $5
+       i32.const 1
+       i32.add
+       local.set $5
+       br $for-loop|2
+      end
+     end
+    end
+    local.get $3
+    i32.const 1
+    i32.add
+    local.set $3
+    br $for-loop|1
+   end
+  end
+ )
+)

package/dist/as/units.wat

@@ -0,0 +1,290 @@
+(module
+ (type $0 (func (param f64) (result i32)))
+ (type $1 (func (param i32) (result f64)))
+ (type $2 (func (param i32 i32 i32) (result i32)))
+ (type $3 (func (param i32 i32) (result i32)))
+ (type $4 (func (param i32) (result i32)))
+ (global $as/units/SCALE_Q i32 (i32.const 10000))
+ (global $as/units/SCALE_m i32 (i32.const 10000))
+ (global $as/units/SCALE_s i32 (i32.const 10000))
+ (global $as/units/SCALE_kg i32 (i32.const 1000))
+ (global $as/units/SCALE_N i32 (i32.const 100))
+ (global $as/units/SCALE_W i32 (i32.const 1))
+ (global $as/units/SCALE_J i32 (i32.const 1))
+ (global $as/units/SCALE_mps i32 (i32.const 10000))
+ (global $as/units/SCALE_mps2 i32 (i32.const 10000))
+ (global $as/units/G_mps2 i32 (i32.const 98067))
+ (memory $0 0)
+ (export "SCALE_Q" (global $as/units/SCALE_Q))
+ (export "SCALE_m" (global $as/units/SCALE_m))
+ (export "SCALE_s" (global $as/units/SCALE_s))
+ (export "SCALE_kg" (global $as/units/SCALE_kg))
+ (export "SCALE_N" (global $as/units/SCALE_N))
+ (export "SCALE_W" (global $as/units/SCALE_W))
+ (export "SCALE_J" (global $as/units/SCALE_J))
+ (export "SCALE_mps" (global $as/units/SCALE_mps))
+ (export "SCALE_mps2" (global $as/units/SCALE_mps2))
+ (export "G_mps2" (global $as/units/G_mps2))
+ (export "q" (func $as/units/q))
+ (export "clampQ" (func $as/units/clampQ))
+ (export "qMul" (func $as/units/qMul))
+ (export "qDiv" (func $as/units/qDiv))
+ (export "mulDiv" (func $as/units/mulDiv))
+ (export "to_m" (func $as/units/q))
+ (export "to_s" (func $as/units/q))
+ (export "to_kg" (func $as/units/to_kg))
+ (export "to_N" (func $as/units/to_N))
+ (export "to_W" (func $as/units/to_W))
+ (export "to_J" (func $as/units/to_W))
+ (export "to_mps" (func $as/units/q))
+ (export "to_mps2" (func $as/units/q))
+ (export "from_m" (func $as/units/from_m))
+ (export "from_s" (func $as/units/from_m))
+ (export "from_kg" (func $as/units/from_kg))
+ (export "from_N" (func $as/units/from_N))
+ (export "from_W" (func $as/units/from_W))
+ (export "from_J" (func $as/units/from_W))
+ (export "from_mps" (func $as/units/from_m))
+ (export "from_mps2" (func $as/units/from_m))
+ (export "sqrtQ" (func $as/units/sqrtQ))
+ (export "cbrtQ" (func $as/units/cbrtQ))
+ (export "memory" (memory $0))
+ (func $as/units/q (param $0 f64) (result i32)
+  (local $1 f64)
+  local.get $0
+  f64.const 1e4
+  f64.mul
+  local.tee $1
+  f64.ceil
+  local.tee $0
+  local.get $0
+  f64.const -1
+  f64.add
+  local.get $0
+  f64.const -0.5
+  f64.add
+  local.get $1
+  f64.le
+  select
+  i32.trunc_sat_f64_s
+ )
+ (func $as/units/clampQ (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+  local.get $1
+  local.get $2
+  local.get $0
+  local.get $0
+  local.get $2
+  i32.gt_s
+  select
+  local.tee $0
+  local.get $0
+  local.get $1
+  i32.lt_s
+  select
+ )
+ (func $as/units/qMul (param $0 i32) (param $1 i32) (result i32)
+  local.get $0
+  i64.extend_i32_s
+  local.get $1
+  i64.extend_i32_s
+  i64.mul
+  i64.const 10000
+  i64.div_s
+  i32.wrap_i64
+ )
+ (func $as/units/qDiv (param $0 i32) (param $1 i32) (result i32)
+  local.get $0
+  i64.extend_i32_s
+  i64.const 10000
+  i64.mul
+  local.get $1
+  i64.extend_i32_s
+  i64.div_s
+  i32.wrap_i64
+ )
+ (func $as/units/mulDiv (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+  local.get $0
+  i64.extend_i32_s
+  local.get $1
+  i64.extend_i32_s
+  i64.mul
+  local.get $2
+  i64.extend_i32_s
+  i64.div_s
+  i32.wrap_i64
+ )
+ (func $as/units/to_kg (param $0 f64) (result i32)
+  (local $1 f64)
+  local.get $0
+  f64.const 1e3
+  f64.mul
+  local.tee $1
+  f64.ceil
+  local.tee $0
+  local.get $0
+  f64.const -1
+  f64.add
+  local.get $0
+  f64.const -0.5
+  f64.add
+  local.get $1
+  f64.le
+  select
+  i32.trunc_sat_f64_s
+ )
+ (func $as/units/to_N (param $0 f64) (result i32)
+  (local $1 f64)
+  local.get $0
+  f64.const 100
+  f64.mul
+  local.tee $1
+  f64.ceil
+  local.tee $0
+  local.get $0
+  f64.const -1
+  f64.add
+  local.get $0
+  f64.const -0.5
+  f64.add
+  local.get $1
+  f64.le
+  select
+  i32.trunc_sat_f64_s
+ )
+ (func $as/units/to_W (param $0 f64) (result i32)
+  (local $1 f64)
+  local.get $0
+  f64.ceil
+  local.tee $1
+  local.get $1
+  f64.const -1
+  f64.add
+  local.get $1
+  f64.const -0.5
+  f64.add
+  local.get $0
+  f64.le
+  select
+  i32.trunc_sat_f64_s
+ )
+ (func $as/units/from_m (param $0 i32) (result f64)
+  local.get $0
+  f64.convert_i32_s
+  f64.const 1e4
+  f64.div
+ )
+ (func $as/units/from_kg (param $0 i32) (result f64)
+  local.get $0
+  f64.convert_i32_s
+  f64.const 1e3
+  f64.div
+ )
+ (func $as/units/from_N (param $0 i32) (result f64)
+  local.get $0
+  f64.convert_i32_s
+  f64.const 100
+  f64.div
+ )
+ (func $as/units/from_W (param $0 i32) (result f64)
+  local.get $0
+  f64.convert_i32_s
+ )
+ (func $as/units/sqrtQ (param $0 i32) (result i32)
+  (local $1 i64)
+  (local $2 i64)
+  (local $3 i32)
+  (local $4 i64)
+  i32.const 1
+  local.get $0
+  local.get $0
+  i32.const 0
+  i32.le_s
+  select
+  i64.extend_i32_s
+  i64.const 10000
+  i64.mul
+  local.set $4
+  i64.const 10000
+  local.set $1
+  loop $for-loop|0
+   local.get $3
+   i32.const 10
+   i32.lt_s
+   if
+    local.get $1
+    local.get $1
+    local.get $4
+    local.get $1
+    i64.div_s
+    i64.add
+    i64.const 2
+    i64.div_s
+    local.tee $2
+    i64.ne
+    if
+     local.get $2
+     local.set $1
+     local.get $3
+     i32.const 1
+     i32.add
+     local.set $3
+     br $for-loop|0
+    end
+   end
+  end
+  local.get $1
+  i32.wrap_i64
+ )
+ (func $as/units/cbrtQ (param $0 i32) (result i32)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 1
+  local.get $0
+  local.get $0
+  i32.const 0
+  i32.le_s
+  select
+  i64.extend_i32_s
+  i64.const 100000000
+  i64.mul
+  local.set $3
+  i64.const 10000
+  local.set $1
+  loop $for-loop|0
+   local.get $2
+   i32.const 12
+   i32.lt_s
+   if
+    block $for-break0
+     local.get $3
+     local.get $1
+     local.get $1
+     i64.mul
+     i64.div_s
+     local.get $1
+     i64.const 1
+     i64.shl
+     i64.add
+     i64.const 3
+     i64.div_s
+     local.tee $1
+     i64.const 0
+     i64.le_s
+     if
+      i64.const 1
+      local.set $1
+      br $for-break0
+     end
+     local.get $2
+     i32.const 1
+     i32.add
+     local.set $2
+     br $for-loop|0
+    end
+   end
+  end
+  local.get $1
+  i32.wrap_i64
+ )
+)

package/dist/src/battle-bridge.d.ts

@@ -0,0 +1,94 @@
+import { TechEra } from "./sim/tech.js";
+import type { Polity } from "./polity.js";
+/** Equipment loadout inferred from a polity's tech era. */
+export interface EraLoadout {
+    archetype: string;
+    weaponId: string;
+    armourId: string;
+}
+/** Configuration for a single tactical battle between two polities. */
+export interface BattleConfig {
+    /** Deterministic seed: combines world seed + day + polity ids. */
+    seed: number;
+    polityAId: string;
+    polityBId: string;
+    teamASize: number;
+    teamBSize: number;
+    loadoutA: EraLoadout;
+    loadoutB: EraLoadout;
+    /** Tick limit — battle is a draw if neither side wins by this tick. */
+    maxTicks: number;
+}
+/** Result reported by the caller after the battle completes. */
+export interface BattleOutcome {
+    /** 1 = team A won, 2 = team B won, 0 = draw (timeout or mutual annihilation). */
+    winner: 0 | 1 | 2;
+    ticksElapsed: number;
+    teamACasualties: number;
+    teamBCasualties: number;
+}
+/** Per-polity state changes to apply after a battle. */
+export interface PolityImpact {
+    polityId: string;
+    moraleDelta_Q: number;
+    stabilityDelta_Q: number;
+    populationLost: number;
+}
+/** Summary record written to the battle log. */
+export interface BattleRecord {
+    day: number;
+    polityAId: string;
+    polityBId: string;
+    winner: 0 | 1 | 2;
+    teamACasualties: number;
+    teamBCasualties: number;
+    ticksElapsed: number;
+}
+/** Minimum and maximum combatants per side. */
+export declare const MIN_TEAM_SIZE = 2;
+export declare const MAX_TEAM_SIZE = 16;
+/** Battle ends after this many ticks regardless of outcome (prevents infinite loops). */
+export declare const DEFAULT_MAX_TICKS = 6000;
+/** Morale bonus for winning a battle (Q units). */
+export declare const WIN_MORALE_BONUS: number;
+/** Morale penalty for losing a battle (Q units). */
+export declare const LOSS_MORALE_PENALTY: number;
+/** Stability penalty per 10% casualties above 20% casualty rate. */
+export declare const CASUALTY_STABILITY_RATE: number;
+/** Population lost per combatant casualty (polity headcount, not Q). */
+export declare const POP_PER_CASUALTY = 50;
+/**
+ * Returns the best available weapon and armour for a given tech era.
+ * Prehistoric → club + none; Ancient → knife + leather; Medieval+ → longsword + mail/plate.
+ */
+export declare function techEraToLoadout(era: TechEra): EraLoadout;
+/**
+ * Converts a polity's military strength (Q) to a team size.
+ * q(0) → MIN_TEAM_SIZE; q(1.0) → MAX_TEAM_SIZE.  Linear interpolation.
+ */
+export declare function militaryStrengthToTeamSize(militaryStrength_Q: number): number;
+/**
+ * Produces a deterministic battle seed from the world seed, day, and polity ids.
+ * Ensures each polity pair on each day gets a unique, reproducible seed.
+ */
+export declare function battleSeed(worldSeed: number, day: number, polityAId: string, polityBId: string): number;
+/**
+ * Builds a BattleConfig for a war between two polities.
+ * Team sizes scale with militaryStrength_Q; loadouts reflect each side's tech era.
+ */
+export declare function battleConfigFromPolities(polityA: Polity, polityB: Polity, worldSeed: number, day: number, maxTicks?: number): BattleConfig;
+/**
+ * Derives the per-polity state changes to apply after a battle.
+ *
+ * Win:  +WIN_MORALE_BONUS morale.
+ * Loss: −LOSS_MORALE_PENALTY morale.
+ * Draw: no morale change.
+ * Both sides: stability penalty proportional to casualties above 20%.
+ * Population: POP_PER_CASUALTY headcount lost per casualty.
+ */
+export declare function polityImpactFromBattle(outcome: BattleOutcome, config: BattleConfig): PolityImpact[];
+/**
+ * Apply a PolityImpact to a polity in-place.
+ * Clamps morale and stability to [0, SCALE.Q].
+ */
+export declare function applyPolityImpact(polity: Polity, impact: PolityImpact): void;