Spaces:
Paused
Paused
| /* ============================================================ | |
| AI STRATEGY (engine/aiStrategy.js): a player-picked overlay, orthogonal to the | |
| archetype, that sets aggression rather than flavor — see the module header for | |
| the full design. These tests cover: the table/resolution itself, the skirmish | |
| offense-timing multipliers, the Odyssey diplomacy compose, the standing-army | |
| throttle (Economic's fixed cap + war-footing surge, Force Parity's dynamic | |
| mirror), and Economic's push into the deep industry chain regardless of | |
| archetype. engine/aiSuperweapon.js (the Helium Bomb) has its own file. | |
| ============================================================ */ | |
| import { test } from "node:test"; | |
| import assert from "node:assert/strict"; | |
| import { readFileSync } from "node:fs"; | |
| import { fileURLToPath } from "node:url"; | |
| import { createGameState, makeBuilding, makeUnit } from "../engine/state.js"; | |
| import { runAI } from "../engine/ai.js"; | |
| import { tick } from "../engine/sim.js"; | |
| import { mulberry32 } from "../engine/rng.js"; | |
| import { STRATEGIES, strategyFor } from "../engine/aiStrategy.js"; | |
| import { DIFFICULTY_OPTIONS } from "../engine/aiDifficulty.js"; | |
| import { createDiplomacy, updateDiplomacy } from "../engine/diplomacy.js"; | |
| const THINK_INTERVAL = 1.5; // must match ai.js's own THINK_INTERVAL to force a fresh think cycle each call | |
| function stockedBarracks(state, dy = -100) { | |
| const b = makeBuilding("barracks", "ai", state.map.bases.ai.x, state.map.bases.ai.y + dy); | |
| state.buildings.set(b.id, b); | |
| return b; | |
| } | |
| function fundAll(state) { | |
| Object.assign(state.players.ai.resources, { ore: 100000, crystals: 100000, radioactives: 100000 }); | |
| } | |
| function homeSkiffs(state, n) { | |
| const units = []; | |
| for (let i = 0; i < n; i++) { | |
| const u = makeUnit("skiff", "ai", state.map.bases.ai.x, state.map.bases.ai.y); | |
| state.units.set(u.id, u); | |
| units.push(u); | |
| } | |
| return units; | |
| } | |
| /* ---------- the table + resolution ---------- */ | |
| test("STRATEGIES.default carries no overriding fields — a genuine no-op overlay", () => { | |
| const d = STRATEGIES.default; | |
| for (const field of ["attackTimeoutMult", "armyAttackSizeMult", "garrisonMult", "graceMult", "grievanceMult", | |
| "neverInitiates", "standingArmyCap", "matchEnemyForce", "wantsIndustryAlways", "useBombOffensively"]) { | |
| assert.equal(d[field], undefined, `default.${field} should be unset`); | |
| } | |
| }); | |
| test("every strategy names itself, and only Economic/Force Parity opt out of ever initiating", () => { | |
| for (const [key, st] of Object.entries(STRATEGIES)) { | |
| assert.ok(st.name, `${key} should have a display name`); | |
| assert.ok(st.desc, `${key} should have a setup-screen description`); | |
| } | |
| assert.equal(STRATEGIES.economic.neverInitiates, true); | |
| assert.equal(STRATEGIES.matching.neverInitiates, true); | |
| assert.ok(!STRATEGIES.aggressive.neverInitiates); | |
| assert.ok(!STRATEGIES.default.neverInitiates); | |
| }); | |
| test("Aggressive funds its aggression: a worker economy, sized so Hard's own multiplier can compose onto it", () => { | |
| // Head-to-head self-play (tools/ailab.js duel, the shipped four over 6 worlds x 2 seeds x both | |
| // owner slots) put Aggressive LAST at Medium, 25W-47L, and its own offense dials could not fix | |
| // it — the missing piece was an economy to follow up with, which is what the tournament winner | |
| // (Economic) actually had. See engine/aiStrategy.js for the full numbers. | |
| assert.ok(STRATEGIES.aggressive.workerTargetMult > 1, | |
| "Aggressive invests in workers — early pressure it cannot reinforce just feeds units"); | |
| // The ceiling is the real lesson and the reason this is pinned: aiDifficulty.js's Hard row | |
| // carries its OWN workerTargetMult, and engine/aiEconomy.js multiplies the two together. At 1.4 | |
| // the composed Hard value turned a +3-point Hard result into a -7-point one. Keep the composed | |
| // product inside the band the tournament actually verified. | |
| const hard = DIFFICULTY_OPTIONS.find(o => o.mult === "hard"); | |
| assert.ok(STRATEGIES.aggressive.workerTargetMult * (hard.workerTargetMult || 1) <= 1.6, | |
| `Aggressive x Hard composes to ${(STRATEGIES.aggressive.workerTargetMult * hard.workerTargetMult).toFixed(2)}x — ` + | |
| `past ~1.6x it over-invests and loses the Hard bracket it used to win`); | |
| }); | |
| test("strategyFor falls back to default for an unset or unrecognised state.ai.strategy", () => { | |
| const s = createGameState({ planetId: "ferros" }); | |
| assert.equal(strategyFor(s), STRATEGIES.default, "unset ⇒ default"); | |
| s.ai.strategy = "not-a-real-strategy"; | |
| assert.equal(strategyFor(s), STRATEGIES.default, "unrecognised ⇒ default, never throws"); | |
| }); | |
| test("createGameState wires opts.aiStrategy onto state.ai.strategy", () => { | |
| const s = createGameState({ planetId: "ferros", aiStrategy: "aggressive" }); | |
| assert.equal(s.ai.strategy, "aggressive"); | |
| assert.equal(strategyFor(s), STRATEGIES.aggressive); | |
| }); | |
| // setup.js pulls in boot.js -> hud.js, which touches real DOM elements at module load time — it | |
| // can never be `import`ed from a headless test (see static-integrity.test.js's own DIFFICULTY_OPTIONS | |
| // guard for the same constraint). So this reads it as plain text instead, the same technique. | |
| test("setup.js's STRATEGY_OPTIONS (the splash-screen picker) matches STRATEGIES exactly — no orphaned key either side", () => { | |
| const setupSrc = readFileSync(fileURLToPath(new URL("../setup.js", import.meta.url)), "utf8"); | |
| const optionsBlock = setupSrc.match(/export const STRATEGY_OPTIONS\s*=\s*\[([\s\S]*?)\n\];/); | |
| assert.ok(optionsBlock, "setup.js must export STRATEGY_OPTIONS"); | |
| const optionKeys = [...optionsBlock[1].matchAll(/mult:\s*"([a-z]+)"/g)].map(m => m[1]); | |
| assert.ok(optionKeys.length >= Object.keys(STRATEGIES).length, "expected at least one picker option per strategy"); | |
| for (const key of optionKeys) assert.ok(STRATEGIES[key], `setup.js offers "${key}", which isn't a real strategy`); | |
| for (const key of Object.keys(STRATEGIES)) assert.ok(optionKeys.includes(key), `STRATEGIES.${key} has no picker option in setup.js`); | |
| }); | |
| /* ---------- Aggressive: skirmish offense timing ---------- */ | |
| test("Aggressive commits an all-in wave on its (stretched-shorter) timeout well before Adaptive would", () => { | |
| // Economist (ferros): attackTimeout 200. Aggressive's attackTimeoutMult 0.55 ⇒ 110. | |
| // state.time=150 sits between the two — only Aggressive should have timed out. | |
| const mk = strategy => { | |
| const s = createGameState({ planetId: "ferros", aiStrategy: strategy }); | |
| s.time = 150; | |
| homeSkiffs(s, 2); // far below either archetype's own armyAttackSize (9) — timeout is the only lever in play | |
| return s; | |
| }; | |
| const aggro = mk("aggressive"), base = mk("default"); | |
| runAI(aggro, THINK_INTERVAL); | |
| runAI(base, THINK_INTERVAL); | |
| const attacking = s => [...s.units.values()].some(u => u.owner === "ai" && u.order?.type === "attack-move"); | |
| assert.ok(attacking(aggro), "Aggressive's shortened desperation timeout has already elapsed at t=150"); | |
| assert.ok(!attacking(base), "Adaptive's full 200s timeout has not, and the army is too small to threshold-commit"); | |
| }); | |
| test("Aggressive also commits with a smaller muster than Adaptive would accept, well before any timeout", () => { | |
| // effArmyAttackSize under Aggressive: 9 * 0.6 = 5.4. Seed 7: with >=4 in the army, updateScout | |
| // (ai.js) lends ONE of them out as a scout before aiOffense ever sees the rest, so only 6 count | |
| // toward the muster — still clears Aggressive's 5.4, but short of Adaptive's full 9. | |
| const mk = strategy => { | |
| const s = createGameState({ planetId: "ferros", aiStrategy: strategy }); | |
| s.time = 0; // nowhere near either timeout (110 / 200) — only the army-size threshold can fire | |
| homeSkiffs(s, 7); | |
| return s; | |
| }; | |
| const aggro = mk("aggressive"), base = mk("default"); | |
| runAI(aggro, THINK_INTERVAL); | |
| runAI(base, THINK_INTERVAL); | |
| const attacking = s => [...s.units.values()].some(u => u.owner === "ai" && u.order?.type === "attack-move"); | |
| assert.ok(attacking(aggro), "6 non-scout skiffs clears Aggressive's scaled-down muster (5.4)"); | |
| assert.ok(!attacking(base), "the same 6 non-scout skiffs falls short of Adaptive's full muster (9)"); | |
| }); | |
| /* ---------- Aggressive: Odyssey diplomacy ---------- */ | |
| test("Aggressive strategy sours an Odyssey neighbour faster than Adaptive, on the identical (Balanced) archetype", () => { | |
| // vesper -> Balanced, which carries no odyssey overlay of its own (ai-odyssey.test.js), isolating | |
| // the strategy's effect from any archetype-driven grace/grievance difference. | |
| const mk = strategy => { | |
| const s = createGameState({ planetId: "vesper", rng: () => 0.5, aiStrategy: strategy }); | |
| s.diplomacy = createDiplomacy(); | |
| s.endless = true; | |
| return s; | |
| }; | |
| const aggro = mk("aggressive"), base = mk("default"); | |
| for (const s of [aggro, base]) { | |
| s.time = 300; | |
| for (const n of s.map.nodes) n.amount = n.max * 0.5; // identical scarcity on both worlds | |
| for (let i = 0; i < 60; i++) updateDiplomacy(s, 0.5); | |
| } | |
| assert.ok(aggro.diplomacy.stance < base.diplomacy.stance, | |
| `Aggressive is more hostile at identical time & scarcity (aggro ${aggro.diplomacy.stance.toFixed(3)} vs default ${base.diplomacy.stance.toFixed(3)})`); | |
| }); | |
| /* ---------- Economic: the standing-army throttle + war footing ---------- */ | |
| test("Economic strategy stops training combat units once it reaches its small standing-army cap", () => { | |
| const state = createGameState({ planetId: "ferros", aiStrategy: "economic" }); | |
| const barracks = stockedBarracks(state); | |
| fundAll(state); | |
| homeSkiffs(state, 3); // exactly STRATEGIES.economic.standingArmyCap | |
| runAI(state, THINK_INTERVAL); | |
| assert.equal(barracks.queue.length, 0, "at the cap, Economic banks its ore instead of training a 4th combat unit"); | |
| }); | |
| test("...but resumes production immediately once it's actually attacked (war footing), and still defends", () => { | |
| const state = createGameState({ planetId: "ferros", aiStrategy: "economic" }); | |
| const barracks = stockedBarracks(state); | |
| fundAll(state); | |
| const guards = homeSkiffs(state, 3); | |
| const raider = makeUnit("skiff", "player", state.map.bases.ai.x - 40, state.map.bases.ai.y); | |
| state.units.set(raider.id, raider); | |
| runAI(state, THINK_INTERVAL); | |
| assert.ok(guards.every(u => u.order?.type === "attack-move"), "the standing guard still rushes to defend — strategy never suppresses it"); | |
| assert.ok(barracks.queue.length > 0, "war footing lifts the cap the same cycle the threat is seen"); | |
| }); | |
| test("Economic never volunteers an attack from army size alone, however large the standing army", () => { | |
| const state = createGameState({ planetId: "ferros", aiStrategy: "economic" }); | |
| state.time = 50; | |
| homeSkiffs(state, 20); // far past the archetype's own armyAttackSize (9) | |
| runAI(state, THINK_INTERVAL); | |
| const attacking = [...state.units.values()].some(u => u.owner === "ai" && u.order?.type === "attack-move"); | |
| assert.ok(!attacking, "a big standing army alone never triggers Economic's offense"); | |
| }); | |
| // Regression test for a real player report: an Economic AI "raided" a player who had built | |
| // nothing but a scout, purely because enough real time had passed — the OLD design still threw | |
| // an all-in wave off a stretched-but-finite desperation timeout even under neverInitiates. There | |
| // is no timeout any more for this strategy: it must mean "never attacks unprovoked" literally, on | |
| // any elapsed time, not just "not for a good while". | |
| test("Economic still never attacks even long past where the old desperation timeout used to fire", () => { | |
| const state = createGameState({ planetId: "ferros", aiStrategy: "economic" }); | |
| state.time = state.ai.archetype.attackTimeout * 20; // comfortably past the old 7x-stretched clock | |
| homeSkiffs(state, 1); | |
| runAI(state, THINK_INTERVAL); | |
| const attacking = [...state.units.values()].some(u => u.owner === "ai" && u.order?.type === "attack-move"); | |
| assert.ok(!attacking, "no amount of elapsed time alone triggers Economic's offense"); | |
| }); | |
| // The safety net a never-initiates strategy actually relies on: not a forced combat commit, but | |
| // victory.js's pre-existing score-based match time limit — a mutual-turtle skirmish (an Economic | |
| // AI facing a genuinely passive player, matching sim.test.js's own convention) still terminates. | |
| test("an all-turtle mirror match (Economic AI, fully passive player) resolves by score at the match time limit, not combat", () => { | |
| const state = createGameState({ planetId: "ferros", aiStrategy: "economic" }); | |
| const dt = 1; | |
| for (let i = 0; i < 2401 && !state.over; i++) tick(state, dt); | |
| assert.ok(state.over, "the match still terminates without either side ever fighting"); | |
| assert.ok(["player", "ai"].includes(state.winner)); | |
| // Neither Command Center fell to combat — this was decided by score, not conquest. | |
| const hasCC = owner => [...state.buildings.values()].some(b => b.owner === owner && b.type === "command"); | |
| assert.ok(hasCC("player") && hasCC("ai"), "both bases are still standing — the finish was the score tiebreak, not a raze"); | |
| }); | |
| test("Economic never launches an Odyssey offensive wave off hostility alone, even fully hostile", () => { | |
| const state = createGameState({ planetId: "ferros", rng: () => 0.5, aiStrategy: "economic" }); | |
| state.diplomacy = createDiplomacy(); | |
| state.diplomacy.stance = -1; // fully hostile | |
| state.endless = true; | |
| homeSkiffs(state, 20); | |
| runAI(state, THINK_INTERVAL); | |
| const attacking = [...state.units.values()].some(u => u.owner === "ai" && u.order?.type === "attack-move"); | |
| assert.ok(!attacking, "hostility alone never triggers a wave under a never-initiates strategy — Odyssey has no desperation clock to fall back on"); | |
| }); | |
| /* ---------- Force Parity: the dynamic mirror ---------- */ | |
| test("Force Parity throttles production once its army matches the enemy force it's actually seen", () => { | |
| // 4 visible enemy skiffs -> target = max(matchFloor 3, round(4 * matchBuffer 1.15)) = max(3, 5) = 5. | |
| const state = createGameState({ planetId: "ferros", aiStrategy: "matching" }); | |
| const barracks = stockedBarracks(state); | |
| fundAll(state); | |
| homeSkiffs(state, 5); // at the computed target | |
| for (let i = 0; i < 4; i++) { | |
| // Tucked right at the AI's own doorstep, inside the seeded Command Center's sight, so the | |
| // initial fog pass (createGameState) already marks it visible — no live updateFog needed. | |
| const s = makeUnit("skiff", "player", state.map.bases.ai.x - 150, state.map.bases.ai.y + i * 6); | |
| state.units.set(s.id, s); | |
| } | |
| runAI(state, THINK_INTERVAL); | |
| assert.equal(barracks.queue.length, 0, "5 skiffs already matches (with buffer) the 4 seen enemy skiffs"); | |
| }); | |
| test("...and resumes once it's short of that same target", () => { | |
| const state = createGameState({ planetId: "ferros", aiStrategy: "matching" }); | |
| const barracks = stockedBarracks(state); | |
| fundAll(state); | |
| homeSkiffs(state, 4); // one short of the target of 5 | |
| for (let i = 0; i < 4; i++) { | |
| const s = makeUnit("skiff", "player", state.map.bases.ai.x - 150, state.map.bases.ai.y + i * 6); | |
| state.units.set(s.id, s); | |
| } | |
| runAI(state, THINK_INTERVAL); | |
| assert.ok(barracks.queue.length > 0, "short of the mirrored target, Force Parity keeps training"); | |
| }); | |
| test("Force Parity keeps a minimal floor even with no enemy in sight yet", () => { | |
| const state = createGameState({ planetId: "ferros", aiStrategy: "matching" }); | |
| const barracks = stockedBarracks(state); | |
| fundAll(state); | |
| homeSkiffs(state, 3); // exactly matchFloor, no enemy scouted at all | |
| runAI(state, THINK_INTERVAL); | |
| assert.equal(barracks.queue.length, 0, "an unscouted enemy still leaves the floor in force"); | |
| }); | |
| /* ---------- Economic: leans into every economic capability, regardless of archetype ---------- */ | |
| function aiBase(planetId, opts = {}) { | |
| const seed = 4242; | |
| const s = createGameState({ planetId, endless: true, seed, rng: mulberry32(seed), ...opts }); | |
| const cc = makeBuilding("command", "ai", 600, 500); s.buildings.set(cc.id, cc); | |
| const bar = makeBuilding("barracks", "ai", 664, 500); s.buildings.set(bar.id, bar); | |
| for (let i = 0; i < 5; i++) { const w = makeUnit("worker", "ai", 610 + i * 12, 552); s.units.set(w.id, w); } | |
| s.players.ai.resources.ore = 3000; | |
| return s; | |
| } | |
| const aiTypes = s => new Set([...s.buildings.values()].filter(b => b.owner === "ai").map(b => b.type)); | |
| test("Economic strategy pushes even a Rusher archetype into the deep industry chain (Smelter + Datacenter)", () => { | |
| const s = aiBase("korrath", { aiStrategy: "economic" }); // Rusher -> archetype.wantsRefinery is false | |
| const r = makeBuilding("reactor", "ai", 540, 560); s.buildings.set(r.id, r); | |
| Object.assign(s.players.ai.resources, { crystals: 3000, radioactives: 3000, ore: 3000 }); | |
| for (let i = 0; i < 10; i++) runAI(s, THINK_INTERVAL); | |
| assert.ok(aiTypes(s).has("smelter"), "Economic strategy opens the industrial chain even on a Rusher world"); | |
| assert.ok(aiTypes(s).has("datacenter"), "…and researches, same as any other patient developer"); | |
| }); | |
| test("...while the default (Adaptive) strategy still leaves that same Rusher world's chain alone", () => { | |
| const s = aiBase("korrath"); // no aiStrategy -> "default" | |
| const r = makeBuilding("reactor", "ai", 540, 560); s.buildings.set(r.id, r); | |
| Object.assign(s.players.ai.resources, { crystals: 3000, radioactives: 3000, ore: 3000 }); | |
| for (let i = 0; i < 10; i++) runAI(s, THINK_INTERVAL); | |
| assert.ok(!aiTypes(s).has("smelter"), "regression guard: Adaptive Rusher keeps its lean, no-chain temperament"); | |
| }); | |
| /* ---------- Odyssey PROVOCATION: neverInitiates means "unprovoked", not "never" ---------- */ | |
| // neverInitiates was made absolute to fix a real player report (see the regression test above), and | |
| // in a SKIRMISH that's exactly right — the match resolves on score, so a passive player never needs | |
| // to be attacked. But Odyssey has no clock and no score: a neighbour whose stance had been dragged | |
| // all the way to fully Hostile still sat there forever, so half a galaxy's worlds (neighbourAiProfile | |
| // samples strategies uniformly, and two of four never initiate) read "Hostile" in the HUD and never | |
| // sent anything — 0 waves in all 22 such runs of a full-roster soak, docs/odyssey-ai-review.md §2.1. | |
| // The flag now means what it says: this AI does not START fights, but it does answer one. Provocation | |
| // is strictly things the PLAYER did — destroyed its ships, or is charging a galaxy-winning Gate — | |
| // never mere elapsed time, which is what the original bug was. | |
| // A fully hostile Odyssey world with a real home army for a never-initiating AI to commit. | |
| function hostileOdyssey(strategy) { | |
| const state = createGameState({ planetId: "ferros", endless: true, aiStrategy: strategy, | |
| seed: 4242, rng: mulberry32(4242) }); | |
| const cc = makeBuilding("command", "ai", state.map.bases.ai.x, state.map.bases.ai.y); | |
| state.buildings.set(cc.id, cc); | |
| state.diplomacy = createDiplomacy(); | |
| state.diplomacy.stance = -1; // fully hostile: hostility() === 1 | |
| homeSkiffs(state, 14); // comfortably past the Economist's 9-unit muster | |
| fundAll(state); | |
| return state; | |
| } | |
| const aiAttacking = state => | |
| [...state.units.values()].some(u => u.owner === "ai" && u.order?.type === "attack-move"); | |
| for (const strategy of ["economic", "matching"]) { | |
| test(`an unprovoked ${strategy} neighbour still never attacks, however hostile the world has become`, () => { | |
| const state = hostileOdyssey(strategy); | |
| for (let i = 0; i < 5; i++) { state.ai.think = 0; runAI(state, THINK_INTERVAL); } | |
| assert.ok(!aiAttacking(state), "a player who has done nothing to it is still left alone — the original fix holds"); | |
| }); | |
| test(`a ${strategy} neighbour DOES answer once the player has destroyed its ships`, () => { | |
| const state = hostileOdyssey(strategy); | |
| state.diplomacy.provokedAt = state.time; // stamped by updateDiplomacy on a grievance — see diplomacy.test.js | |
| for (let i = 0; i < 5; i++) { state.ai.think = 0; runAI(state, THINK_INTERVAL); } | |
| assert.ok(aiAttacking(state), "a fully hostile neighbour that has been bled must eventually answer"); | |
| }); | |
| } | |
| test("a charging player Gate provokes a never-initiating neighbour — the finale can't be waited out", () => { | |
| const state = hostileOdyssey("economic"); | |
| const gate = makeBuilding("antimatter_gate", "player", state.map.bases.player.x, state.map.bases.player.y - 80); | |
| gate.charge = 0.5; | |
| state.buildings.set(gate.id, gate); | |
| for (let i = 0; i < 5; i++) { state.ai.think = 0; runAI(state, THINK_INTERVAL); } | |
| assert.ok(aiAttacking(state), "a bid to win the whole galaxy is provocation on its own"); | |
| }); | |
| test("provocation is ODYSSEY-only — a skirmish Economic AI stays absolutely non-initiating", () => { | |
| // No state.diplomacy at all in a skirmish, so there is nothing to be provoked BY: the flag keeps | |
| // its original, literal meaning on the path where the player report came from. | |
| const state = createGameState({ planetId: "ferros", aiStrategy: "economic" }); | |
| state.time = state.ai.archetype.attackTimeout * 20; | |
| homeSkiffs(state, 14); | |
| fundAll(state); | |
| for (let i = 0; i < 5; i++) { state.ai.think = 0; runAI(state, THINK_INTERVAL); } | |
| assert.ok(!aiAttacking(state), "the skirmish desperation-timeout escape hatch stays closed"); | |
| }); | |