2309 lines
110 KiB
JavaScript
2309 lines
110 KiB
JavaScript
// Headless verification for Civilization (Civ II-lite).
|
|
// node tools/verifyCivilization.js [--quick]
|
|
// Exits non-zero on any failure.
|
|
//
|
|
// 1. Rules integrity: ids unique, prereqs resolve, tech DAG acyclic & fully
|
|
// reachable, every tech gates something or feeds a later tech, frames sane.
|
|
// 2. Worldgen: determinism, land fraction, continents, start quality/spacing.
|
|
// 3. City fixtures: growth, despotism penalty, corruption, auto-assign, buy math.
|
|
// 4. Combat: deterministic fixtures + Monte Carlo vs analytic model.
|
|
// 5. Research pacing per difficulty.
|
|
// 6. Trade + diplomacy state machine (incl. fuzz).
|
|
// 7. Spaceship: launch gating, countdown, capital-capture loss.
|
|
// 8. Serialization round-trip.
|
|
// 9. AI self-play soak: full games end in victory, invariants hold, perf budget.
|
|
|
|
import { readFileSync } from 'node:fs';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { dirname, join } from 'node:path';
|
|
|
|
import { compileRules, techCost, turnToYear } from '../src/games/civilization/CivilizationRules.js';
|
|
import { generateWorld, siteQuality, shieldGrassAt } from '../src/games/civilization/CivilizationWorldGen.js';
|
|
import * as Logic from '../src/games/civilization/CivilizationLogic.js';
|
|
import * as AI from '../src/games/civilization/CivilizationAI.js';
|
|
import * as Diplo from '../src/games/civilization/CivilizationDiplomacy.js';
|
|
import * as Chat from '../src/games/civilization/CivilizationChat.js';
|
|
// Pure data module (no Phaser) even though its consumers are UI — the city
|
|
// screen's tooltips are checkable headlessly, and worth checking.
|
|
import * as Tooltips from '../src/games/civilization/CivilizationTooltips.js';
|
|
// Icon frame map + the pure run/overflow maths behind the city screen's yield
|
|
// rows (the drawing half needs Phaser, the deciding half doesn't).
|
|
import * as Icons from '../src/games/civilization/CivilizationIcons.js';
|
|
|
|
const QUICK = process.argv.includes('--quick');
|
|
const root = join(dirname(fileURLToPath(import.meta.url)), '..');
|
|
const rulesJson = JSON.parse(readFileSync(join(root, 'data/civilization-rules.json'), 'utf8'));
|
|
|
|
let failures = 0;
|
|
let passes = 0;
|
|
function check(name, cond, detail = '') {
|
|
if (cond) { passes += 1; return; }
|
|
failures += 1;
|
|
console.error(` FAIL ${name}${detail ? ` — ${detail}` : ''}`);
|
|
}
|
|
function section(name) { console.log(`\n== ${name}`); }
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('1. rules integrity');
|
|
|
|
let RULES = null;
|
|
try {
|
|
RULES = compileRules(rulesJson);
|
|
} catch (err) {
|
|
check('rules compile', false, err.message);
|
|
}
|
|
|
|
if (RULES) {
|
|
check('rules compile', true);
|
|
|
|
const techIds = Object.keys(RULES.techs);
|
|
check('tech count sane (80+ incl future tech)', techIds.length >= 80, `${techIds.length}`);
|
|
check('future tech present & repeatable', RULES.techs.futuretech?.repeatable === true);
|
|
|
|
// Cut techs must NOT be present (wonders/happiness/espionage systems removed).
|
|
for (const cut of ['theology', 'espionage', 'fundamentalism', 'environmentalism',
|
|
'geneticengineering', 'recycling']) {
|
|
check(`cut tech absent: ${cut}`, !RULES.techs[cut]);
|
|
}
|
|
|
|
// Every tech is reachable (compileRules ranks all) and matters: it gates a
|
|
// unit/building/government/improvement or is a prereq of another tech.
|
|
for (const t of RULES.techList) {
|
|
check(`tech ranked: ${t.id}`, RULES.techRank[t.id] !== undefined);
|
|
const g = RULES.techGates[t.id];
|
|
const matters = g.units.length + g.buildings.length + g.governments.length
|
|
+ g.improvements.length + g.prereqOf.length > 0 || t.repeatable;
|
|
check(`tech matters: ${t.id}`, matters);
|
|
}
|
|
// Rank must respect prereqs.
|
|
for (const t of RULES.techList) {
|
|
for (const p of t.prereqs) {
|
|
check(`rank order ${p} < ${t.id}`, RULES.techRank[p] < RULES.techRank[t.id]);
|
|
}
|
|
}
|
|
|
|
// Roots: the classic 8 starting techs.
|
|
const roots = RULES.techList.filter((t) => t.prereqs.length === 0).map((t) => t.id).sort();
|
|
check('8 root techs', roots.length === 8, roots.join(','));
|
|
|
|
// Units.
|
|
check('unit count 51', RULES.unitList.length === 51, `${RULES.unitList.length}`);
|
|
const unitFrames = new Set();
|
|
for (const u of RULES.unitList) {
|
|
check(`unit stats sane: ${u.id}`, u.attack >= 0 && u.attack <= 99 && u.defense >= 0
|
|
&& u.move >= 0 && u.hp >= 1 && u.fp >= 1 && u.cost >= 10 && u.cost <= 320);
|
|
check(`unit frame unique: ${u.id}`, !unitFrames.has(u.frame), `${u.frame}`);
|
|
unitFrames.add(u.frame);
|
|
check(`unit frame in sheet: ${u.id}`, u.frame >= 0 && u.frame < 56);
|
|
check(`unit abbr: ${u.id}`, typeof u.abbr === 'string' && u.abbr.length === 2);
|
|
if (u.domain === 'project') check(`ss unit flagged: ${u.id}`, u.flags.includes('spaceship'));
|
|
}
|
|
const ssUnits = RULES.unitList.filter((u) => u.domain === 'project');
|
|
check('3 spaceship parts', ssUnits.length === 3);
|
|
check('spaceship config', RULES.spaceship.structuralNeeded === 8
|
|
&& RULES.spaceship.componentsNeeded === 4 && RULES.spaceship.modulesNeeded === 3
|
|
&& RULES.spaceship.travelTurns > 0);
|
|
|
|
// Terrain + specials.
|
|
check('11 terrains', RULES.terrainList.length === 11);
|
|
check('exactly one water terrain', RULES.terrainList.filter((t) => t.water).length === 1);
|
|
const terrFrames = new Set();
|
|
for (const t of RULES.terrainList) {
|
|
check(`terrain frame unique: ${t.id}`, !terrFrames.has(t.frame));
|
|
terrFrames.add(t.frame);
|
|
check(`terrain frame in sheet: ${t.id}`, t.frame >= 0 && t.frame < 12);
|
|
check(`terrain yields sane: ${t.id}`, t.food >= 0 && t.shield >= 0 && t.trade >= 0
|
|
&& t.move >= 1 && t.defense >= 1);
|
|
check(`terrain color: ${t.id}`, /^#[0-9a-f]{6}$/i.test(t.color));
|
|
}
|
|
check('grassland shield frame distinct', !terrFrames.has(RULES.grasslandShieldFrame)
|
|
&& RULES.grasslandShieldFrame >= 0 && RULES.grasslandShieldFrame < 12);
|
|
check('20 specials', RULES.specialList.length === 20);
|
|
const specFrames = new Set();
|
|
for (const s of RULES.specialList) {
|
|
check(`special frame unique: ${s.id}`, !specFrames.has(s.frame));
|
|
specFrames.add(s.frame);
|
|
check(`special frame in sheet: ${s.id}`, s.frame >= 0 && s.frame < 20);
|
|
}
|
|
const specTerrains = Object.keys(RULES.specialsByTerrain);
|
|
check('specials cover 10 terrains (all but grassland)', specTerrains.length === 10
|
|
&& !specTerrains.includes('grassland'));
|
|
for (const terr of specTerrains) {
|
|
check(`2 specials on ${terr}`, RULES.specialsByTerrain[terr].length === 2);
|
|
}
|
|
|
|
// Buildings.
|
|
check('26 buildings', RULES.buildingList.length === 26, `${RULES.buildingList.length}`);
|
|
for (const cut of ['temple', 'colosseum', 'cathedral', 'policestation', 'masstransit',
|
|
'recyclingcenter', 'solarplant']) {
|
|
check(`cut building absent: ${cut}`, !RULES.buildings[cut]);
|
|
}
|
|
const powerPlants = RULES.buildingList.filter((b) => b.effect === 'power');
|
|
check('3 mutually exclusive power plants', powerPlants.length === 3);
|
|
|
|
// Governments & difficulties.
|
|
check('6 governments', RULES.governmentList.length === 6);
|
|
check('despotism/anarchy need no tech', !RULES.governments.despotism.prereq
|
|
&& !RULES.governments.anarchy.prereq);
|
|
check('5 difficulties', RULES.difficultyList.length === 5);
|
|
check('difficulty ordering', RULES.difficultyList[0].aiProdBonus
|
|
< RULES.difficultyList[4].aiProdBonus);
|
|
|
|
// Leader starting-condition traits.
|
|
check('8 civ traits', RULES.civTraitList.length === 8, `${RULES.civTraitList.length}`);
|
|
for (const id of Object.keys(RULES.civTraits)) {
|
|
const t = RULES.civTraits[id];
|
|
check(`civTrait ${id} mults positive`,
|
|
t.scienceMult > 0 && t.goldMult > 0 && t.shieldMult > 0);
|
|
check(`civTrait ${id} startingGold >= 0`, t.startingGold >= 0);
|
|
for (const techId of t.startingTechs) check(`civTrait ${id} startingTechs ${techId} known tech`, !!RULES.techs[techId]);
|
|
}
|
|
|
|
// World sizes / colors / names.
|
|
check('3 world sizes', RULES.worldSizeList.length === 3);
|
|
for (const w of RULES.worldSizeList) check(`world ${w.id} dims`, w.cols >= 32 && w.rows >= 24);
|
|
check('8 player colors', RULES.playerColors.length === 8
|
|
&& RULES.playerColors.every((c) => /^#[0-9a-f]{6}$/i.test(c)));
|
|
check('city name pool 64', RULES.cityNames.length === 64
|
|
&& new Set(RULES.cityNames).size === 64);
|
|
|
|
// Tech cost + year curve helpers.
|
|
check('tech cost grows', techCost(0) < techCost(10) && techCost(10) < techCost(50));
|
|
check('tech cost difficulty factor', techCost(10, 1.2) > techCost(10, 1.0));
|
|
check('year starts 4000 BC', turnToYear(0, RULES.yearCurve) === -4000);
|
|
const y60 = turnToYear(60, RULES.yearCurve);
|
|
check('year curve reaches ~1000 BC by turn 60', y60 === -1000, `${y60}`);
|
|
let prev = -4000;
|
|
let monotonic = true;
|
|
for (let i = 1; i <= 500; i += 1) {
|
|
const y = turnToYear(i, RULES.yearCurve);
|
|
if (y <= prev) { monotonic = false; break; }
|
|
prev = y;
|
|
}
|
|
check('year curve strictly increasing over 500 turns', monotonic);
|
|
|
|
// Artwork JSON contract <-> assetManifest fields (checked once artwork file exists).
|
|
try {
|
|
const art = JSON.parse(readFileSync(join(root, 'data/civilization-artwork.json'), 'utf8'));
|
|
for (const field of ['terrainSheet', 'resourceSheet', 'improvementSheet', 'unitSheet', 'iconSheet']) {
|
|
check(`artwork field ${field}`, !!art[field] && 'path' in art[field]
|
|
&& art[field].frameWidth > 0 && art[field].frameHeight > 0);
|
|
}
|
|
check('artwork citySheets map', !!art.citySheets && !!art.citySheets.classic
|
|
&& 'path' in art.citySheets.classic);
|
|
} catch {
|
|
console.log(' (data/civilization-artwork.json not present yet — skipping contract checks)');
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('1b. opponents data');
|
|
|
|
const opponentsJson = JSON.parse(readFileSync(join(root, 'data/opponents.json'), 'utf8'));
|
|
check('opponents present', Array.isArray(opponentsJson.opponents) && opponentsJson.opponents.length > 0);
|
|
let cityThemes = null;
|
|
try {
|
|
cityThemes = JSON.parse(readFileSync(join(root, 'data/civilization-artwork.json'), 'utf8')).citySheets;
|
|
} catch { /* checked separately in section 1; opponents citySheet check just skips below */ }
|
|
if (RULES) {
|
|
for (const op of opponentsJson.opponents ?? []) {
|
|
check(`opponent ${op.id} has trait`, typeof op.trait === 'string' && op.trait.length > 0);
|
|
check(`opponent ${op.id} trait resolves`, !!RULES.civTraits[op.trait], op.trait);
|
|
check(`opponent ${op.id} has startingTechs array`, Array.isArray(op.startingTechs));
|
|
for (const techId of op.startingTechs ?? []) {
|
|
check(`opponent ${op.id} startingTechs ${techId} known tech`, !!RULES.techs[techId]);
|
|
}
|
|
if (cityThemes) {
|
|
check(`opponent ${op.id} has citySheet`, typeof op.citySheet === 'string' && op.citySheet.length > 0);
|
|
check(`opponent ${op.id} citySheet resolves`, !!cityThemes[op.citySheet], op.citySheet);
|
|
}
|
|
const traitTechs = RULES.civTraits[op.trait]?.startingTechs ?? [];
|
|
const total = new Set([...traitTechs, ...(op.startingTechs ?? [])]).size;
|
|
check(`opponent ${op.id} has 2-3 total starting techs`, total === 2 || total === 3, `${total}`);
|
|
}
|
|
|
|
// Some variety across leaders — not every leader with the same trait
|
|
// should end up with an identical personal tech list.
|
|
const nonPioneering = opponentsJson.opponents.filter((op) => op.trait !== 'pioneering');
|
|
const distinctLists = new Set(nonPioneering.map((op) => [...op.startingTechs].sort().join(',')));
|
|
check('starting tech lists show variety across leaders', distinctLists.size > 5, `${distinctLists.size}`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('1c. trait application');
|
|
|
|
if (RULES) {
|
|
const leaders = [
|
|
{ id: 'a', name: 'A', trait: 'scientific', startingTechs: ['pottery', 'masonry'] },
|
|
{ id: 'b', name: 'B', trait: 'wealthy' },
|
|
{ id: 'c', name: 'C', trait: 'pioneering' },
|
|
{ id: 'd', name: 'D', trait: undefined },
|
|
// trait's alphabet/bronzeworking overlaps this leader's own list — the
|
|
// union must dedupe, not error or double-grant.
|
|
{ id: 'e', name: 'E', trait: 'pioneering', startingTechs: ['alphabet', 'thewheel'] },
|
|
];
|
|
const st = Logic.createGame(RULES, { sizeId: 'small', seed: 5, difficultyId: 'prince', leaders });
|
|
check('personal startingTechs granted', st.civs[0].known.pottery === true && st.civs[0].known.masonry === true);
|
|
check('wealthy gets +100 starting gold', st.civs[1].gold === 150, `${st.civs[1].gold}`);
|
|
check('pioneering knows alphabet', st.civs[2].known.alphabet === true);
|
|
check('pioneering knows bronzeworking', st.civs[2].known.bronzeworking === true);
|
|
check('no-trait civ unaffected', st.civs[3].gold === 50 && Object.keys(st.civs[3].known).length === 0,
|
|
`${st.civs[3].gold}`);
|
|
check('overlapping trait + personal techs dedupe to 3 known',
|
|
Object.keys(st.civs[4].known).length === 3
|
|
&& st.civs[4].known.alphabet && st.civs[4].known.bronzeworking && st.civs[4].known.thewheel,
|
|
`${Object.keys(st.civs[4].known).join(',')}`);
|
|
|
|
// scienceMult/goldMult/shieldMult actually flow into cityYields: two
|
|
// synthetic cities sharing the exact same tile/buildings/size, differing
|
|
// only in which civ owns them (civ 0 = scientific, civ 3 = no trait). A
|
|
// large fixed trade-route amount swamps any terrain-dependent tile yield,
|
|
// so the only meaningful difference in output is the trait multiplier —
|
|
// deterministic regardless of what terrain worldgen placed at (5,5).
|
|
const baseCity = { x: 5, y: 5, worked: [], routes: [{ amount: 200 }], buildings: {}, size: 1 };
|
|
const sciY = Logic.cityYields(RULES, st, { ...baseCity, civ: 0 });
|
|
const plainY = Logic.cityYields(RULES, st, { ...baseCity, civ: 3 });
|
|
check('scientific trait raises science output', sciY.science > plainY.science,
|
|
`${sciY.science} vs ${plainY.science}`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('2. world generation');
|
|
|
|
if (RULES) {
|
|
const hashWorld = (w) => JSON.stringify([w.terrain, w.special, w.huts, w.starts]);
|
|
for (const sizeId of ['small', 'medium', 'large']) {
|
|
const size = RULES.worldSizes[sizeId];
|
|
let landOk = 0;
|
|
let contOk = 0;
|
|
let startsOk = 0;
|
|
let detOk = 0;
|
|
let qualityOk = 0;
|
|
const seeds = QUICK ? 6 : 20;
|
|
for (let s = 1; s <= seeds; s += 1) {
|
|
const numCivs = 3 + (s % 5); // 3..7
|
|
const w = generateWorld(RULES, { sizeId, seed: s * 31, numCivs });
|
|
const w2 = generateWorld(RULES, { sizeId, seed: s * 31, numCivs });
|
|
if (hashWorld(w) === hashWorld(w2)) detOk += 1;
|
|
if (w.landFraction >= 0.25 && w.landFraction <= 0.38) landOk += 1;
|
|
if (w.largestContinentFrac >= 0.15) contOk += 1;
|
|
const T = {};
|
|
RULES.terrainList.forEach((t, i) => { T[t.id] = i; });
|
|
let good = w.starts.length === numCivs;
|
|
for (let a = 0; a < w.starts.length && good; a += 1) {
|
|
const [x, y] = w.starts[a];
|
|
const terr = RULES.terrainList[w.terrain[y * size.cols + x]];
|
|
if (terr.water || terr.id === 'glacier' || terr.id === 'mountains') good = false;
|
|
for (let b = a + 1; b < w.starts.length; b += 1) {
|
|
const [x2, y2] = w.starts[b];
|
|
if (Math.max(Math.abs(x - x2), Math.abs(y - y2)) < 4) good = false;
|
|
}
|
|
}
|
|
if (good) startsOk += 1;
|
|
const minQ = Math.min(...w.starts.map(([x, y]) => siteQuality(RULES, w, x, y)));
|
|
if (minQ >= 12) qualityOk += 1;
|
|
}
|
|
check(`${sizeId}: deterministic (same seed => same world)`, detOk === seeds, `${detOk}/${seeds}`);
|
|
check(`${sizeId}: land fraction 25-38%`, landOk === seeds, `${landOk}/${seeds}`);
|
|
check(`${sizeId}: largest continent >= 15% of land`, contOk === seeds, `${contOk}/${seeds}`);
|
|
check(`${sizeId}: starts valid & spaced`, startsOk === seeds, `${startsOk}/${seeds}`);
|
|
check(`${sizeId}: start quality floor`, qualityOk === seeds, `${qualityOk}/${seeds}`);
|
|
}
|
|
|
|
// Density checks on one representative map.
|
|
const w = generateWorld(RULES, { sizeId: 'medium', seed: 42, numCivs: 5 });
|
|
const land = w.terrain.filter((t) => !RULES.terrainList[t].water).length;
|
|
const hutCount = w.huts.reduce((a, b) => a + b, 0);
|
|
check('hut density ~1/40 land', hutCount >= Math.floor(land / 40) * 0.6
|
|
&& hutCount <= Math.ceil(land / 40), `${hutCount} huts, ${land} land`);
|
|
const specCount = w.special.filter((s) => s >= 0).length;
|
|
check('specials density 1/64..1/8 of tiles', specCount >= w.terrain.length / 64
|
|
&& specCount <= w.terrain.length / 8, `${specCount}`);
|
|
let specMatch = true;
|
|
for (let i = 0; i < w.terrain.length; i += 1) {
|
|
if (w.special[i] < 0) continue;
|
|
const spec = RULES.specialList[w.special[i]];
|
|
if (spec.terrain !== RULES.terrainList[w.terrain[i]].id) { specMatch = false; break; }
|
|
}
|
|
check('every special sits on its terrain', specMatch);
|
|
let hutsOnLand = true;
|
|
for (let i = 0; i < w.terrain.length; i += 1) {
|
|
if (w.huts[i] && (RULES.terrainList[w.terrain[i]].water
|
|
|| RULES.terrainList[w.terrain[i]].id === 'glacier')) hutsOnLand = false;
|
|
}
|
|
check('huts on land (not glacier)', hutsOnLand);
|
|
check('shield-grass ~50%', (() => {
|
|
let c = 0;
|
|
for (let y = 0; y < 60; y += 1) for (let x = 0; x < 60; x += 1) c += shieldGrassAt(x, y) ? 1 : 0;
|
|
return c > 3600 * 0.45 && c < 3600 * 0.55;
|
|
})());
|
|
|
|
// Placement must look organic: no clumps, no barren regions, no alignment.
|
|
let adjacentSpecials = 0;
|
|
for (let y = 0; y < w.rows; y += 1) {
|
|
for (let x = 0; x < w.cols; x += 1) {
|
|
if (w.special[y * w.cols + x] < 0) continue;
|
|
for (const [dx, dy] of [[1, 0], [0, 1], [1, 1], [1, -1]]) {
|
|
const nx = x + dx;
|
|
const ny = y + dy;
|
|
if (nx < 0 || ny < 0 || nx >= w.cols || ny >= w.rows) continue;
|
|
if (w.special[ny * w.cols + nx] >= 0) adjacentSpecials += 1;
|
|
}
|
|
}
|
|
}
|
|
check('no two specials adjacent', adjacentSpecials === 0, `${adjacentSpecials} pairs`);
|
|
|
|
// Coarse 12x12 windows: every window with land should hold some specials, and
|
|
// none should hoard them. Catches both barren and over-rich regions.
|
|
let minWin = Infinity;
|
|
let maxWin = 0;
|
|
for (let wy = 0; wy + 12 <= w.rows; wy += 12) {
|
|
for (let wx = 0; wx + 12 <= w.cols; wx += 12) {
|
|
let c = 0;
|
|
for (let y = wy; y < wy + 12; y += 1) {
|
|
for (let x = wx; x < wx + 12; x += 1) if (w.special[y * w.cols + x] >= 0) c += 1;
|
|
}
|
|
minWin = Math.min(minWin, c);
|
|
maxWin = Math.max(maxWin, c);
|
|
}
|
|
}
|
|
check('no barren 12x12 region', minWin >= 3, `min ${minWin} per window`);
|
|
check('no over-rich 12x12 region', maxWin <= 14, `max ${maxWin} per window`);
|
|
|
|
// Straightness: a modular lattice puts most specials on a few screen columns
|
|
// (iso screen-x is proportional to x - y). Real jitter spreads them out.
|
|
const byScreenCol = new Map();
|
|
let specTotal = 0;
|
|
for (let y = 0; y < w.rows; y += 1) {
|
|
for (let x = 0; x < w.cols; x += 1) {
|
|
if (w.special[y * w.cols + x] < 0) continue;
|
|
const k = x - y;
|
|
byScreenCol.set(k, (byScreenCol.get(k) ?? 0) + 1);
|
|
specTotal += 1;
|
|
}
|
|
}
|
|
const worstCol = Math.max(...byScreenCol.values());
|
|
check('specials not aligned in screen columns', worstCol <= specTotal * 0.06,
|
|
`worst column holds ${worstCol}/${specTotal}`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Fixture helpers: hand-built flat worlds for deterministic engine tests.
|
|
|
|
function T(id) { return RULES.terrainList.findIndex((t) => t.id === id); }
|
|
|
|
function mkCiv(i, total, human = false) {
|
|
const relations = {};
|
|
const attitude = {};
|
|
for (let j = 0; j < total; j += 1) if (j !== i) { relations[j] = 'contact'; attitude[j] = 0; }
|
|
return {
|
|
id: i, leaderId: `test${i}`, name: `Civ${i}`, color: '#ffffff', human,
|
|
alive: true, government: 'despotism', revolutionTurns: 0, pendingGovernment: null,
|
|
gold: 100, beakers: 0, researching: null, known: {}, futureCount: 0,
|
|
relations, attitude, reputation: 0,
|
|
spaceship: { structural: 0, component: 0, module: 0, launched: false, arrivalTurn: 0 },
|
|
nameCursor: i, nameOrder: Array.from({ length: RULES.cityNames.length }, (_, k) => k),
|
|
score: 0,
|
|
};
|
|
}
|
|
|
|
function makeFlatState({ cols = 16, rows = 16, civs = 2, terrain = 'grassland' } = {}) {
|
|
const n = cols * rows;
|
|
const world = {
|
|
cols, rows,
|
|
terrain: new Array(n).fill(T(terrain)),
|
|
special: new Array(n).fill(-1),
|
|
improvements: new Array(n).fill(0),
|
|
huts: new Array(n).fill(0),
|
|
continent: new Array(n).fill(0),
|
|
starts: [], landFraction: 1, largestContinentFrac: 1, sizeId: 'small', seed: 1,
|
|
};
|
|
const state = {
|
|
version: 1, seed: 1, rngState: 987654321, sizeId: 'small', difficultyId: 'prince',
|
|
turn: 1, current: 0, humanIndex: 0, world,
|
|
civs: Array.from({ length: civs }, (_, i) => mkCiv(i, civs, i === 0)),
|
|
cities: [], units: [], nextUnitId: 1, nextCityId: 1,
|
|
explored: Array.from({ length: civs }, () => new Array(n).fill(1)),
|
|
over: null, events: [],
|
|
};
|
|
return state;
|
|
}
|
|
|
|
function setWar(state, a, b) {
|
|
state.civs[a].relations[b] = 'war';
|
|
state.civs[b].relations[a] = 'war';
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('3. city fixtures');
|
|
|
|
if (RULES) {
|
|
// Founding: settler consumed, size 1, first city gets palace + leader name.
|
|
{
|
|
const st = makeFlatState();
|
|
const settler = Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null);
|
|
const city = Logic.foundCity(RULES, st, settler);
|
|
check('city founded', !!city && city.size === 1);
|
|
check('settler consumed', st.units.length === 0);
|
|
check('first city has palace', !!city.buildings.palace);
|
|
check('capital named for leader', city.name === 'Civ0 City');
|
|
check('min distance blocks adjacent city', !Logic.canFoundCity(RULES, st, 6, 5));
|
|
check('distance 2 allowed', Logic.canFoundCity(RULES, st, 7, 5));
|
|
check('default build is the best available defender, not always warriors',
|
|
city.build.type === 'unit' && city.build.id === 'warriors');
|
|
}
|
|
|
|
// Founding/capturing picks the best available land defender, not a fixed
|
|
// 'warriors' default — a civ that already knows Bronze Working should
|
|
// found (and inherit captured cities) straight onto Phalanx.
|
|
{
|
|
const st = makeFlatState({ civs: 2 });
|
|
st.civs[0].known.bronzeworking = true;
|
|
const settler = Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null);
|
|
const city = Logic.foundCity(RULES, st, settler);
|
|
check('founded city with Bronze Working known defaults to Phalanx',
|
|
city.build.type === 'unit' && city.build.id === 'phalanx');
|
|
|
|
st.civs[1].known.bronzeworking = false;
|
|
const enemySettler = Logic.spawnUnit(RULES, st, 1, 'settlers', 9, 9, null);
|
|
const enemyCity = Logic.foundCity(RULES, st, enemySettler);
|
|
check('enemy without Bronze Working still defaults to Warriors',
|
|
enemyCity.build.type === 'unit' && enemyCity.build.id === 'warriors');
|
|
const attacker = Logic.spawnUnit(RULES, st, 0, 'legion', enemyCity.x, enemyCity.y, null);
|
|
Logic.captureCity(RULES, st, attacker, enemyCity);
|
|
check('captured city re-defaults using the new owner\'s tech (Phalanx)',
|
|
enemyCity.build.type === 'unit' && enemyCity.build.id === 'phalanx');
|
|
}
|
|
|
|
// Growth on flat grassland: foodbox fills, granary keeps half.
|
|
{
|
|
const st = makeFlatState();
|
|
const settler = Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null);
|
|
const city = Logic.foundCity(RULES, st, settler);
|
|
city.build = { type: 'building', id: 'granary' };
|
|
let grewAt = -1;
|
|
for (let t = 0; t < 30 && grewAt < 0; t += 1) {
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
if (city.size >= 2) grewAt = t;
|
|
}
|
|
check('city grows on grassland within 30 turns', grewAt >= 0);
|
|
check('foodbox reset after growth', city.foodBox < (city.size + 1) * Logic.FOODBOX_PER_SIZE);
|
|
// Force a granary growth and check the half-box carryover.
|
|
city.buildings.granary = true;
|
|
city.foodBox = (city.size + 1) * Logic.FOODBOX_PER_SIZE;
|
|
const sizeBefore = city.size;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('granary growth', city.size === sizeBefore + 1);
|
|
check('granary keeps half box', city.foodBox >= Math.floor(((sizeBefore + 1) * Logic.FOODBOX_PER_SIZE) / 2));
|
|
}
|
|
|
|
// Settler-hold: a size-1 city building a settler must not bank shields
|
|
// past cost turn after turn while it waits for the city to spare a
|
|
// citizen (used to show e.g. "60/40 shields (-5 turns)").
|
|
{
|
|
const st = makeFlatState({ terrain: 'plains' });
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
city.build = { type: 'unit', id: 'settlers' };
|
|
const cost = Logic.buildCost(RULES, city);
|
|
city.size = 1;
|
|
city.shieldBox = cost + 20; // as if it had banked well past cost over many stalled turns
|
|
city.foodBox = 0;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('shieldBox re-capped at cost on a stalled turn', city.shieldBox <= cost,
|
|
`${city.shieldBox}/${cost}`);
|
|
|
|
// Once the city can spare a citizen, the stalled build completes
|
|
// immediately. foodBox=2 keeps this turn's -1 deficit (size-2 plains
|
|
// under despotism) from also triggering a famine shrink, which would
|
|
// confound the size assertion below.
|
|
const unitsBefore = st.units.length;
|
|
city.size = 2;
|
|
city.foodBox = 2;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('stalled settler completes once city can spare population',
|
|
st.units.length === unitsBefore + 1 && city.size === 1 && city.shieldBox === 0);
|
|
}
|
|
|
|
// Despotism penalty & government trade bonus on tile yields.
|
|
{
|
|
const st = makeFlatState({ terrain: 'plains' });
|
|
const i = 5 * 16 + 5;
|
|
st.world.special[i] = RULES.specialList.findIndex((s) => s.id === 'wheat'); // 3/1/0
|
|
let y = Logic.tileYield(RULES, st, 0, null, 5, 5);
|
|
check('despotism -1 on 3-food wheat', y.food === 2, `${y.food}`);
|
|
st.civs[0].government = 'monarchy';
|
|
y = Logic.tileYield(RULES, st, 0, null, 5, 5);
|
|
check('monarchy full wheat', y.food === 3);
|
|
st.civs[0].government = 'republic';
|
|
const j = 6 * 16 + 6;
|
|
st.world.improvements[j] = 1; // road on plains: +1 trade, republic: +1 more
|
|
y = Logic.tileYield(RULES, st, 0, null, 6, 6);
|
|
check('road + republic trade', y.trade === 2, `${y.trade}`);
|
|
st.civs[0].government = 'despotism';
|
|
y = Logic.tileYield(RULES, st, 0, null, 6, 6);
|
|
check('road under despotism trade 1', y.trade === 1, `${y.trade}`);
|
|
}
|
|
|
|
// Irrigation / mine / railroad effects.
|
|
{
|
|
const st = makeFlatState({ terrain: 'hills' });
|
|
st.civs[0].government = 'monarchy';
|
|
const i = 5 * 16 + 5;
|
|
st.world.improvements[i] = 16; // mine on hills: +3 shields
|
|
let y = Logic.tileYield(RULES, st, 0, null, 5, 5);
|
|
check('hills mine +3 shields', y.shield === 3, `${y.shield}`);
|
|
st.world.improvements[i] |= 2; // railroad: +1 when shields >= 1
|
|
y = Logic.tileYield(RULES, st, 0, null, 5, 5);
|
|
check('railroad +1 shield', y.shield === 4);
|
|
}
|
|
|
|
// Corruption: distance, courthouse, democracy, communism-flat.
|
|
{
|
|
const st = makeFlatState({ cols: 32, rows: 8 });
|
|
st.civs[0].government = 'monarchy';
|
|
const cap = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 2, 4, null));
|
|
const near = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 6, 4, null));
|
|
const far = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 28, 4, null));
|
|
near.size = 6; far.size = 6;
|
|
// Give both cities identical trade via routes so corruption math is isolated.
|
|
near.routes = [{ cityId: cap.id, amount: 20 }];
|
|
far.routes = [{ cityId: cap.id, amount: 20 }];
|
|
const yNear = Logic.cityYields(RULES, st, near);
|
|
const yFar = Logic.cityYields(RULES, st, far);
|
|
check('corruption grows with distance', yFar.corruption > yNear.corruption,
|
|
`${yNear.corruption} vs ${yFar.corruption}`);
|
|
far.buildings.courthouse = true;
|
|
const yFarCourt = Logic.cityYields(RULES, st, far);
|
|
check('courthouse halves corruption', yFarCourt.corruption === Math.floor(yFar.corruption / 2));
|
|
delete far.buildings.courthouse;
|
|
st.civs[0].government = 'democracy';
|
|
check('democracy zero corruption', Logic.cityYields(RULES, st, far).corruption === 0);
|
|
st.civs[0].government = 'communism';
|
|
const cNear = Logic.cityYields(RULES, st, near).corruption;
|
|
const cFar = Logic.cityYields(RULES, st, far).corruption;
|
|
check('communism flat corruption', cNear === cFar, `${cNear} vs ${cFar}`);
|
|
}
|
|
|
|
// Auto-assign is optimal for the linear emphasis objective.
|
|
{
|
|
const st = makeFlatState();
|
|
// Scatter mixed terrain around a city site.
|
|
const kinds = ['plains', 'forest', 'hills', 'mountains', 'desert', 'ocean', 'swamp'];
|
|
let k = 0;
|
|
for (let y = 3; y <= 7; y += 1) {
|
|
for (let x = 3; x <= 7; x += 1) {
|
|
st.world.terrain[y * 16 + x] = T(kinds[k % kinds.length]);
|
|
k += 3;
|
|
}
|
|
}
|
|
st.world.terrain[5 * 16 + 5] = T('grassland');
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
city.size = 5;
|
|
for (const emphasis of ['balanced', 'food', 'production', 'trade']) {
|
|
city.emphasis = emphasis;
|
|
Logic.autoAssignTiles(RULES, st, city);
|
|
const weights = { balanced: [3, 2, 1], food: [6, 1, 1], production: [1, 5, 1], trade: [1, 1, 5] }[emphasis];
|
|
const wOf = (idx) => {
|
|
const yld = Logic.tileYield(RULES, st, 0, city, idx % 16, (idx / 16) | 0);
|
|
return yld.food * weights[0] + yld.shield * weights[1] + yld.trade * weights[2];
|
|
};
|
|
const chosen = city.worked.reduce((s, idx) => s + wOf(idx), 0);
|
|
// Brute force: weights of every candidate tile, top-5 sum.
|
|
const cand = [];
|
|
for (const [dx, dy] of Logic.CITY_RADIUS) {
|
|
if (dx === 0 && dy === 0) continue;
|
|
cand.push(wOf((5 + dy) * 16 + (5 + dx)));
|
|
}
|
|
cand.sort((a, b) => b - a);
|
|
const best = cand.slice(0, 5).reduce((a, b) => a + b, 0);
|
|
check(`auto-assign optimal (${emphasis})`, chosen === best, `${chosen} vs ${best}`);
|
|
}
|
|
}
|
|
|
|
// Buy math + class-switch penalty + building multipliers.
|
|
{
|
|
const st = makeFlatState();
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
city.build = { type: 'unit', id: 'warriors' };
|
|
check('warriors buy cost 25', Logic.buyCost(RULES, city) === 25);
|
|
Logic.setBuild(RULES, st, city, 'building', 'granary');
|
|
check('granary buy cost 120', Logic.buyCost(RULES, city) === 120);
|
|
city.shieldBox = 40;
|
|
check('partial buy cost', Logic.buyCost(RULES, city) === 40); // (60-40)*2
|
|
Logic.setBuild(RULES, st, city, 'unit', 'warriors');
|
|
check('class switch halves shields', city.shieldBox === 20);
|
|
st.civs[0].gold = 200;
|
|
city.build = { type: 'building', id: 'granary' };
|
|
city.shieldBox = 0;
|
|
check('buy succeeds', Logic.buyBuild(RULES, st, city) && st.civs[0].gold === 80);
|
|
check('no double buy same turn', !Logic.buyBuild(RULES, st, city));
|
|
// Science multiplier: library +50%.
|
|
city.size = 4;
|
|
city.routes = [{ cityId: 99, amount: 12 }];
|
|
st.civs[0].government = 'monarchy';
|
|
const sBefore = Logic.cityYields(RULES, st, city).science;
|
|
city.buildings.library = true;
|
|
const sAfter = Logic.cityYields(RULES, st, city).science;
|
|
check('library +50% science', sAfter === Math.floor(sBefore * 1.5), `${sBefore}->${sAfter}`);
|
|
}
|
|
|
|
// Size caps: 8 without aqueduct, 12 without sewer.
|
|
{
|
|
const st = makeFlatState();
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
city.size = 8;
|
|
city.foodBox = (city.size + 1) * Logic.FOODBOX_PER_SIZE + 5;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('size capped at 8 without aqueduct', city.size === 8);
|
|
city.buildings.aqueduct = true;
|
|
city.foodBox = (city.size + 1) * Logic.FOODBOX_PER_SIZE;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('aqueduct unlocks growth', city.size === 9);
|
|
}
|
|
|
|
// Settler build waits for size 2 and costs a citizen.
|
|
{
|
|
const st = makeFlatState();
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
city.build = { type: 'unit', id: 'settlers' };
|
|
city.shieldBox = 200;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('settler waits at size 1', st.units.length === 0 && city.size === 1);
|
|
city.size = 3;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('settler built at size>=2 costs pop', st.units.length === 1 && city.size === 2);
|
|
}
|
|
|
|
// Research: cost, completion, prereq gating.
|
|
{
|
|
const st = makeFlatState();
|
|
const civ = st.civs[0];
|
|
check('cannot research gated tech', !Logic.setResearch(RULES, st, civ, 'monarchy'));
|
|
check('can research root tech', Logic.setResearch(RULES, st, civ, 'alphabet'));
|
|
civ.beakers = 1000;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('tech completes', !!civ.known.alphabet);
|
|
civ.known.codeoflaws = true;
|
|
civ.known.ceremonialburial = true;
|
|
check('monarchy now available', Logic.setResearch(RULES, st, civ, 'monarchy'));
|
|
const cost3 = Logic.currentResearchCost(RULES, st, civ);
|
|
civ.known.pottery = true;
|
|
check('cost rises with known count', Logic.currentResearchCost(RULES, st, civ) > cost3);
|
|
}
|
|
|
|
// Revolution: anarchy interlude then target government.
|
|
{
|
|
const st = makeFlatState();
|
|
const civ = st.civs[0];
|
|
civ.known.monarchy = true;
|
|
check('revolution starts', Logic.startRevolution(RULES, st, civ, 'monarchy'));
|
|
check('in anarchy', civ.government === 'anarchy');
|
|
for (let i = 0; i < 6; i += 1) Logic.beginCivTurn(RULES, st, 0);
|
|
check('revolution completes', civ.government === 'monarchy');
|
|
check('cannot switch to unknown gov', !Logic.startRevolution(RULES, st, civ, 'democracy'));
|
|
}
|
|
|
|
// Coinage: shields convert straight to gold, 1:1, every turn, no shieldBox growth.
|
|
{
|
|
const st = makeFlatState();
|
|
const settler = Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null);
|
|
const city = Logic.foundCity(RULES, st, settler);
|
|
Logic.setBuild(RULES, st, city, 'gold', 'coinage');
|
|
const civ = st.civs[0];
|
|
civ.gold = 0;
|
|
const y1 = Logic.cityYields(RULES, st, city);
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
const expected = y1.gold - y1.upkeep - y1.supportGold + y1.shield;
|
|
check('coinage pays exactly y.shield gold on top of normal trade income', civ.gold === expected);
|
|
check('coinage leaves shieldBox at 0', city.shieldBox === 0);
|
|
const goldAfter1 = civ.gold;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('coinage keeps paying out turn after turn', civ.gold > goldAfter1);
|
|
}
|
|
|
|
// Public Works: shields convert to food at 2:1, with the odd shield carried
|
|
// in shieldBox instead of lost, and switching build types doesn't halve it.
|
|
{
|
|
const st = makeFlatState();
|
|
const settler = Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null);
|
|
const city = Logic.foundCity(RULES, st, settler);
|
|
Logic.setBuild(RULES, st, city, 'food', 'publicworks');
|
|
const y = Logic.cityYields(RULES, st, city);
|
|
const foodBoxBefore = city.foodBox;
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
const gain1 = Math.floor(y.shield / 2);
|
|
const remainder1 = y.shield - gain1 * 2; // 0 or 1, carried in shieldBox
|
|
check('public works food gain matches floor(shield/2)',
|
|
city.foodBox === foodBoxBefore + y.foodSurplus + gain1);
|
|
check('odd shield is carried in shieldBox rather than lost', city.shieldBox === remainder1);
|
|
const carry = city.shieldBox;
|
|
check('switching away from a special build does not halve the carry',
|
|
(() => { Logic.setBuild(RULES, st, city, 'building', 'granary'); return city.shieldBox === carry; })());
|
|
}
|
|
|
|
// AI fallback: an idle city with nothing left to build picks gold or food
|
|
// instead of endlessly stacking defenders.
|
|
{
|
|
const st = makeFlatState();
|
|
const settler = Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null);
|
|
const city = Logic.foundCity(RULES, st, settler);
|
|
st.civs[0].human = false;
|
|
// Give it a defender so the garrison branch doesn't fire, and mark every
|
|
// building/unit tier as already handled so develop/expand/war all pass.
|
|
Logic.spawnUnit(RULES, st, 0, 'phalanx', 5, 5, city.id);
|
|
for (const b of RULES.buildingList) city.buildings[b.id] = true;
|
|
delete city.buildings.palace; // keep palace semantics untouched
|
|
city.buildings.palace = true;
|
|
AI.runAITurn(RULES, st, 0);
|
|
check('idle AI city settles on Coinage or Public Works',
|
|
city.build.type === 'gold' || city.build.type === 'food');
|
|
}
|
|
|
|
// --- City-screen data layer (the fat-cross map + its tile tooltips).
|
|
//
|
|
// The drawing is Phaser and can't run here, but everything it reads can.
|
|
// The load-bearing check is the first one: the tooltip explains a tile's
|
|
// yields from tileYield's own `notes`, so if those ever stop summing to the
|
|
// returned totals the tooltip starts lying.
|
|
{
|
|
const terrains = ['grassland', 'plains', 'hills', 'mountains', 'forest', 'desert', 'swamp', 'ocean'];
|
|
const impSets = [
|
|
0, Logic.IMP.ROAD, Logic.IMP.IRRIGATION, Logic.IMP.MINE, Logic.IMP.ROAD | Logic.IMP.RAILROAD,
|
|
Logic.IMP.IRRIGATION | Logic.IMP.FARMLAND,
|
|
Logic.IMP.IRRIGATION | Logic.IMP.FARMLAND | Logic.IMP.ROAD | Logic.IMP.RAILROAD,
|
|
Logic.IMP.MINE | Logic.IMP.ROAD | Logic.IMP.FORTRESS,
|
|
];
|
|
let sumOk = true;
|
|
let labelsOk = true;
|
|
let why = '';
|
|
for (const terrId of terrains) {
|
|
for (const gov of ['despotism', 'republic', 'democracy']) {
|
|
for (const imps of impSets) {
|
|
for (const withBuildings of [false, true]) {
|
|
// Grassland everywhere so the city can be founded, with only the
|
|
// measured tile switched to the terrain under test — that keeps
|
|
// the city tile's implicit road out of the measurement too.
|
|
const st = makeFlatState();
|
|
st.civs[0].government = gov;
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
if (withBuildings) {
|
|
city.buildings.supermarket = true;
|
|
city.buildings.harbor = true;
|
|
city.buildings.offshoreplatform = true;
|
|
}
|
|
const tx = 6;
|
|
const ty = 5;
|
|
const i = Logic.tileIndex(st.world, tx, ty);
|
|
st.world.terrain[i] = T(terrId);
|
|
st.world.improvements[i] = imps;
|
|
if (withBuildings && RULES.specialList.length) st.world.special[i] = 0;
|
|
const notes = [];
|
|
const out = Logic.tileYield(RULES, st, 0, city, tx, ty, notes);
|
|
const sum = notes.reduce((a, n) => ({
|
|
food: a.food + n.food, shield: a.shield + n.shield, trade: a.trade + n.trade,
|
|
}), { food: 0, shield: 0, trade: 0 });
|
|
if (sum.food !== out.food || sum.shield !== out.shield || sum.trade !== out.trade) {
|
|
sumOk = false;
|
|
why = `${terrId}/${gov}/imp${imps}: notes ${JSON.stringify(sum)} vs ${JSON.stringify(out)}`;
|
|
}
|
|
if (notes.some((n) => !n.label || (!n.food && !n.shield && !n.trade && notes.indexOf(n) > 0))) {
|
|
labelsOk = false;
|
|
why = why || `${terrId}/${gov}: empty note`;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
check('tile yield notes sum to the yields they explain', sumOk, why);
|
|
check('tile yield notes are labelled and never empty', labelsOk, why);
|
|
}
|
|
|
|
// The city centre's 1-shield/1-trade floor is applied in one place, so the
|
|
// map, the tooltip and the yields panel can't disagree about it.
|
|
{
|
|
// Swamp yields 0 shields and 0 trade, and at move 2 the city tile's
|
|
// implicit road adds no trade either — so both floors have to do work.
|
|
const st = makeFlatState({ terrain: 'swamp' });
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
const raw = Logic.tileYield(RULES, st, 0, city, 5, 5);
|
|
const centre = Logic.cityCentreYield(RULES, st, city);
|
|
check('city centre never yields under 1 shield / 1 trade',
|
|
centre.shield >= 1 && centre.trade >= 1, `${JSON.stringify(centre)}`);
|
|
const notes = [];
|
|
Logic.cityCentreYield(RULES, st, city, notes);
|
|
const sum = notes.reduce((a, n) => ({
|
|
shield: a.shield + n.shield, trade: a.trade + n.trade,
|
|
}), { shield: 0, trade: 0 });
|
|
check('centre floor is itself explained in the breakdown',
|
|
sum.shield === centre.shield && sum.trade === centre.trade,
|
|
`raw ${JSON.stringify(raw)} centre ${JSON.stringify(centre)} notes ${JSON.stringify(sum)}`);
|
|
}
|
|
|
|
// cityTileStatus drives both the map's borders/dimming and the tooltip's
|
|
// closing line — every case a fat cross can actually contain.
|
|
{
|
|
const st = makeFlatState({ cols: 16, rows: 16 });
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
const neighbour = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 8, 5, null));
|
|
city.size = 3;
|
|
Logic.autoAssignTiles(RULES, st, city);
|
|
Logic.autoAssignTiles(RULES, st, neighbour);
|
|
const kindAt = (x, yy) => Logic.cityTileStatus(st, city, x, yy).kind;
|
|
check('centre tile reads as the city itself', kindAt(5, 5) === 'centre');
|
|
check('a tile holding another city is flagged', kindAt(8, 5) === 'city');
|
|
const workedIdx = city.worked[0];
|
|
check('worked tiles read as worked',
|
|
kindAt(workedIdx % st.world.cols, (workedIdx / st.world.cols) | 0) === 'worked');
|
|
const takenIdx = neighbour.worked.find((idx) => {
|
|
const x = idx % st.world.cols;
|
|
const yy = (idx / st.world.cols) | 0;
|
|
return Math.max(Math.abs(x - city.x), Math.abs(yy - city.y)) <= 2;
|
|
});
|
|
if (takenIdx !== undefined) {
|
|
check('a neighbour\'s tile inside our radius is flagged as taken',
|
|
kindAt(takenIdx % st.world.cols, (takenIdx / st.world.cols) | 0) === 'taken');
|
|
}
|
|
// Found at the map edge so part of the fat cross falls off the world.
|
|
const edge = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 0, 0, null));
|
|
check('tiles past the map edge are flagged',
|
|
Logic.cityTileStatus(st, edge, -2, 0).kind === 'offmap');
|
|
}
|
|
|
|
// The tooltip itself: title, the yield line, and the right closing status.
|
|
{
|
|
const st = makeFlatState({ cols: 16, rows: 16 });
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
city.size = 2;
|
|
Logic.autoAssignTiles(RULES, st, city);
|
|
const tip = Tooltips.describeCityTileTooltip(RULES, st, city, 6, 5);
|
|
const out = Logic.tileYield(RULES, st, 0, city, 6, 5);
|
|
check('tile tooltip is titled with its terrain', tip.title === RULES.terrains.grassland.name);
|
|
check('tile tooltip leads with the yields it explains',
|
|
tip.lines[0].text === `Food ${out.food} · Shields ${out.shield} · Trade ${out.trade}`,
|
|
tip.lines[0].text);
|
|
check('tile tooltip closes with a status line', tip.lines.length >= 2
|
|
&& /Worked|Not worked|heart of/.test(tip.lines[tip.lines.length - 1].text),
|
|
tip.lines[tip.lines.length - 1].text);
|
|
check('centre tooltip names the city', /heart of/.test(
|
|
Tooltips.describeCityTileTooltip(RULES, st, city, 5, 5).lines.at(-1).text,
|
|
));
|
|
const off = Tooltips.describeCityTileTooltip(RULES, st, city, -1, 5);
|
|
check('off-map tooltip degrades gracefully', off.title === 'Beyond the map' && off.lines.length > 0);
|
|
// Every template must resolve — a stray {token} would ship to the player.
|
|
let clean = true;
|
|
for (const [dx, dy] of Logic.CITY_RADIUS) {
|
|
const t = Tooltips.describeCityTileTooltip(RULES, st, city, city.x + dx, city.y + dy);
|
|
if (/\{|undefined|NaN/.test(t.title + t.lines.map((l) => l.text).join(''))) clean = false;
|
|
}
|
|
check('no tile tooltip in the fat cross renders a hole', clean);
|
|
}
|
|
|
|
// The build list used to be sliced to 28 rows; a developed city has more
|
|
// options than that, so the scroll window is load-bearing, not decoration.
|
|
{
|
|
const st = makeFlatState();
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
for (const t of RULES.techList) if (!t.repeatable) st.civs[0].known[t.id] = true;
|
|
const total = 2 + Logic.availableUnits(RULES, st, st.civs[0], city).length
|
|
+ Logic.availableBuildings(RULES, st, st.civs[0], city).length;
|
|
check('a fully-teched city offers more builds than the old 28-row cap',
|
|
total > 28, `${total} options`);
|
|
}
|
|
|
|
// --- Icon yield rows (CivilizationIcons.js + the city screen's yields block)
|
|
{
|
|
const cap = 12;
|
|
const runs = [
|
|
[0, { drawn: 0, multiplier: null }],
|
|
[1, { drawn: 1, multiplier: null }],
|
|
[cap - 1, { drawn: cap - 1, multiplier: null }],
|
|
[cap, { drawn: cap, multiplier: null }],
|
|
[cap + 1, { drawn: 1, multiplier: cap + 1 }],
|
|
[99, { drawn: 1, multiplier: 99 }],
|
|
];
|
|
let ok = true;
|
|
let why = '';
|
|
for (const [n, want] of runs) {
|
|
const got = Icons.iconRun(n, cap);
|
|
if (got.drawn !== want.drawn || got.multiplier !== want.multiplier) {
|
|
ok = false;
|
|
why = `iconRun(${n}) = ${JSON.stringify(got)}, wanted ${JSON.stringify(want)}`;
|
|
}
|
|
if (got.drawn > cap) { ok = false; why = `iconRun(${n}) drew ${got.drawn} > cap`; }
|
|
}
|
|
check('iconRun collapses to a multiplier exactly past the cap', ok, why);
|
|
check('iconRun never draws a negative or fractional run', (() => {
|
|
const a = Icons.iconRun(-5, cap);
|
|
const b = Icons.iconRun(3.7, cap);
|
|
return a.drawn === 0 && a.multiplier === null && b.drawn === 3;
|
|
})());
|
|
|
|
// The frame map is duplicated in sprites.md and, for governments, in the
|
|
// rules JSON. Keep all three honest.
|
|
check('every icon frame exists on the 480x96 @ 48x48 sheet',
|
|
Object.values(Icons.ICON_FRAME).every((f) => Number.isInteger(f) && f >= 0 && f < Icons.ICON_FRAMES));
|
|
check('icon frames are unique',
|
|
new Set(Object.values(Icons.ICON_FRAME)).size === Object.keys(Icons.ICON_FRAME).length);
|
|
check('government icon frames agree with governments[].frame in the rules',
|
|
RULES.governmentList.every((g) => Icons.ICON_FRAME[`gov-${g.id}`] === g.frame),
|
|
RULES.governmentList.map((g) => `${g.id}:${g.frame}/${Icons.ICON_FRAME[`gov-${g.id}`]}`).join(' '));
|
|
}
|
|
|
|
// Each row draws a total and then a deduction as though these identities
|
|
// hold. If cityYields is ever reworked they must fail here, rather than the
|
|
// display quietly showing the wrong number of icons.
|
|
{
|
|
let ok = true;
|
|
let why = '';
|
|
for (const govId of ['despotism', 'monarchy', 'communism', 'republic', 'democracy']) {
|
|
for (const size of [1, 4, 12]) {
|
|
for (const extras of [false, true]) {
|
|
const st = makeFlatState({ cols: 24, rows: 24 });
|
|
st.civs[0].government = govId;
|
|
const capital = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 2, 2, null));
|
|
capital.buildings.palace = true;
|
|
// A second city far from the palace, so waste and corruption bite.
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 18, 18, null));
|
|
city.size = size;
|
|
if (extras) {
|
|
city.buildings.courthouse = true;
|
|
city.buildings.marketplace = true;
|
|
city.buildings.library = true;
|
|
for (let k = 0; k < 6; k += 1) Logic.spawnUnit(RULES, st, 0, 'warriors', 18, 18, city.id);
|
|
Logic.spawnUnit(RULES, st, 0, 'settlers', 18, 17, city.id);
|
|
}
|
|
Logic.autoAssignTiles(RULES, st, city);
|
|
const y = Logic.cityYields(RULES, st, city);
|
|
const label = `${govId}/size${size}${extras ? '/extras' : ''}`;
|
|
if (y.foodSurplus !== y.food - y.foodNeed) { ok = false; why = `${label}: food`; }
|
|
if (y.shield !== Math.max(0, y.grossShield - y.waste - y.supportShields)) { ok = false; why = `${label}: shields`; }
|
|
if (y.netTrade !== y.trade - y.corruption) { ok = false; why = `${label}: trade`; }
|
|
if (y.waste > y.grossShield || y.corruption > y.trade) { ok = false; why = `${label}: loss exceeds output`; }
|
|
if ([y.food, y.grossShield, y.trade, y.gold, y.science].some((v) => v < 0 || !Number.isInteger(v))) {
|
|
ok = false;
|
|
why = `${label}: non-integer or negative total`;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
check('yield rows can draw total-minus-loss without lying about the engine', ok, why);
|
|
}
|
|
|
|
// describeYieldRow gives the numbers back that the icons-only rows drop.
|
|
{
|
|
const build = ({ govId = 'despotism', size = 3, starve = false, democracy = false } = {}) => {
|
|
// Bare mountains grow nothing, so a city of any size on them starves no
|
|
// matter how autoAssignTiles reshuffles its citizens.
|
|
const st = makeFlatState({ cols: 24, rows: 24, terrain: starve ? 'mountains' : 'grassland' });
|
|
st.civs[0].government = democracy ? 'democracy' : govId;
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 12, 12, null));
|
|
city.size = starve ? 6 : size;
|
|
if (starve) city.foodBox = 5;
|
|
if (democracy) for (let k = 0; k < 5; k += 1) Logic.spawnUnit(RULES, st, 0, 'warriors', 12, 12, city.id);
|
|
Logic.autoAssignTiles(RULES, st, city);
|
|
return { st, city, y: Logic.cityYields(RULES, st, city) };
|
|
};
|
|
const cases = [
|
|
['ordinary city', build()],
|
|
['size-1 city', build({ size: 1 })],
|
|
['starving city', build({ starve: true })],
|
|
['anarchy (no science)', build({ govId: 'anarchy' })],
|
|
['democracy (gold unit upkeep)', build({ democracy: true })],
|
|
];
|
|
let ok = true;
|
|
let why = '';
|
|
for (const [label, { st, city, y }] of cases) {
|
|
for (const row of Tooltips.YIELD_ROWS) {
|
|
const tip = Tooltips.describeYieldRow(RULES, st, city, y, row);
|
|
const blob = `${tip.title}${tip.lines.map((l) => l.text).join('')}`;
|
|
if (!tip.title || !tip.lines.length) { ok = false; why = `${label}/${row}: empty`; }
|
|
if (/\{|undefined|NaN|Infinity/.test(blob)) { ok = false; why = `${label}/${row}: ${blob}`; }
|
|
}
|
|
}
|
|
check('every yield row tooltip renders for every kind of city', ok, why);
|
|
|
|
const { st, city, y } = build({ starve: true });
|
|
const food = Tooltips.describeYieldRow(RULES, st, city, y, 'food');
|
|
check('a starving city is told how long it has',
|
|
y.foodSurplus < 0 && food.lines.some((l) => /Starves in \d+ turn/.test(l.text)),
|
|
food.lines.map((l) => l.text).join(' | '));
|
|
|
|
const growing = build();
|
|
const growTip = Tooltips.describeYieldRow(RULES, growing.st, growing.city, growing.y, 'food');
|
|
check('a growing city is told when it grows',
|
|
growing.y.foodSurplus > 0 && growTip.lines.some((l) => /Grows in \d+ turn/.test(l.text)),
|
|
growTip.lines.map((l) => l.text).join(' | '));
|
|
}
|
|
|
|
// --- Supported-unit chips. Each chip states what that one unit costs, so
|
|
// the per-entry costs have to add up to the totals the Shields/Gold rows
|
|
// charge — otherwise the strip and the rows above it disagree on screen.
|
|
{
|
|
const stage = (govId) => {
|
|
const st = makeFlatState({ cols: 20, rows: 20 });
|
|
st.civs[0].government = govId;
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 8, 8, null));
|
|
for (let k = 0; k < 5; k += 1) Logic.spawnUnit(RULES, st, 0, 'warriors', 8, 8, city.id);
|
|
Logic.spawnUnit(RULES, st, 0, 'settlers', 9, 8, city.id); // eats food, never shields
|
|
Logic.spawnUnit(RULES, st, 0, 'explorer', 9, 9, city.id); // noncombat, always free
|
|
Logic.spawnUnit(RULES, st, 0, 'warriors', 8, 8, null); // homed nowhere — not ours
|
|
return { st, city, sup: Logic.citySupport(RULES, st, city), y: Logic.cityYields(RULES, st, city) };
|
|
};
|
|
let ok = true;
|
|
let why = '';
|
|
for (const govId of RULES.governmentList.map((g) => g.id)) {
|
|
const { sup, y, city } = stage(govId);
|
|
const sum = (k) => sup.entries.reduce((a, e) => a + e[k], 0);
|
|
if (sum('shield') !== sup.supportShields) { ok = false; why = `${govId}: shield entries`; }
|
|
if (sum('gold') !== sup.supportGold) { ok = false; why = `${govId}: gold entries`; }
|
|
if (sum('food') !== sup.settlerFood) { ok = false; why = `${govId}: food entries`; }
|
|
if (y.supportShields !== sup.supportShields || y.supportGold !== sup.supportGold) {
|
|
ok = false;
|
|
why = `${govId}: cityYields disagrees with citySupport`;
|
|
}
|
|
if (y.foodNeed !== city.size * Logic.FOOD_PER_CITIZEN + sup.settlerFood) {
|
|
ok = false;
|
|
why = `${govId}: settler food missing from foodNeed`;
|
|
}
|
|
if (sup.entries.some((e) => e.shield && e.gold)) { ok = false; why = `${govId}: charged twice`; }
|
|
}
|
|
check('supported-unit chips add up to the upkeep the city is charged', ok, why);
|
|
|
|
// Only the first `freeUnits` COMBATANTS ride free, in state.units order.
|
|
{
|
|
const { sup } = stage('despotism'); // freeUnits 3, shield upkeep
|
|
const combatants = sup.entries.filter((e) => e.def.domain !== 'project'
|
|
&& !e.def.flags.includes('noncombat'));
|
|
const freeCount = combatants.filter((e) => !e.shield && !e.gold).length;
|
|
check('the free allowance covers the first combatants only',
|
|
freeCount === 3 && combatants.slice(0, 3).every((e) => !e.shield)
|
|
&& combatants.slice(3).every((e) => e.shield === 1),
|
|
`${freeCount} free of ${combatants.length}`);
|
|
check('noncombat and settler units never cost shields',
|
|
sup.entries.filter((e) => e.def.flags.includes('noncombat')).every((e) => !e.shield && !e.gold));
|
|
check('settlers in the field eat food',
|
|
sup.entries.some((e) => e.def.flags.includes('settler') && e.food > 0));
|
|
}
|
|
{
|
|
const { sup } = stage('democracy'); // pays units in gold, 0 free
|
|
check('Democracy charges gold for units, not shields',
|
|
sup.supportGold > 0 && sup.supportShields === 0, `${sup.supportGold}g/${sup.supportShields}s`);
|
|
}
|
|
|
|
// Every chip's tooltip must render — including the wounded, the veteran,
|
|
// the fortified and the far-from-home.
|
|
{
|
|
const { st, city, sup } = stage('monarchy');
|
|
sup.entries[1].unit.vet = true;
|
|
sup.entries[2].unit.fortified = true;
|
|
sup.entries[3].unit.hp = 3;
|
|
let clean = true;
|
|
let bad = '';
|
|
for (const entry of sup.entries) {
|
|
const tip = Tooltips.describeSupportedUnitTooltip(RULES, st, city, entry, sup.freeUnits);
|
|
const blob = `${tip.title}${tip.lines.map((l) => l.text).join('')}`;
|
|
if (!tip.title || tip.lines.length < 2 || /\{|undefined|NaN/.test(blob)) { clean = false; bad = blob; }
|
|
}
|
|
check('every supported-unit tooltip renders', clean, bad);
|
|
const vetTip = Tooltips.describeSupportedUnitTooltip(RULES, st, city, sup.entries[1], sup.freeUnits);
|
|
check('a veteran chip says so', vetTip.lines.some((l) => l.text.includes('Veteran')));
|
|
const paid = sup.entries.find((e) => e.shield || e.gold);
|
|
const paidTip = Tooltips.describeSupportedUnitTooltip(RULES, st, city, paid, sup.freeUnits);
|
|
check('a chip that costs upkeep names the cost',
|
|
paidTip.lines.some((l) => /Costs .* per turn/.test(l.text)),
|
|
paidTip.lines.map((l) => l.text).join(' | '));
|
|
const free = sup.entries.find((e) => !e.shield && !e.gold && !e.food);
|
|
const freeTip = Tooltips.describeSupportedUnitTooltip(RULES, st, city, free, sup.freeUnits);
|
|
check('a free chip explains the allowance',
|
|
freeTip.lines.some((l) => /Supported free/.test(l.text)));
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('4. combat');
|
|
|
|
if (RULES) {
|
|
// Deterministic strength modifiers.
|
|
{
|
|
const st = makeFlatState({ terrain: 'mountains' });
|
|
setWar(st, 0, 1);
|
|
st.world.terrain[5 * 16 + 4] = T('grassland');
|
|
const attacker = Logic.spawnUnit(RULES, st, 0, 'warriors', 4, 5, null);
|
|
const defender = Logic.spawnUnit(RULES, st, 1, 'phalanx', 5, 5, null);
|
|
let d = Logic.defenderStrength(RULES, st, defender, attacker);
|
|
check('mountain phalanx D=6', Math.abs(d - 6) < 1e-9, `${d}`);
|
|
defender.fortified = true;
|
|
d = Logic.defenderStrength(RULES, st, defender, attacker);
|
|
check('fortified adds x1.5', Math.abs(d - 9) < 1e-9, `${d}`);
|
|
}
|
|
{
|
|
// Walls x3 vs land; howitzer ignores them.
|
|
const st = makeFlatState();
|
|
setWar(st, 0, 1);
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 1, 'settlers', 8, 8, null));
|
|
city.buildings.citywalls = true;
|
|
const defender = Logic.spawnUnit(RULES, st, 1, 'musketeers', 8, 8, null);
|
|
const rifle = Logic.spawnUnit(RULES, st, 0, 'riflemen', 7, 8, null);
|
|
const how = Logic.spawnUnit(RULES, st, 0, 'howitzer', 7, 8, null);
|
|
const dWalls = Logic.defenderStrength(RULES, st, defender, rifle);
|
|
const dHow = Logic.defenderStrength(RULES, st, defender, how);
|
|
check('walls triple defense vs land', Math.abs(dWalls - 9) < 1e-9, `${dWalls}`);
|
|
check('howitzer ignores walls (city base applies)', Math.abs(dHow - 4.5) < 1e-9, `${dHow}`);
|
|
}
|
|
{
|
|
// Pikemen double vs mounted only.
|
|
const st = makeFlatState();
|
|
setWar(st, 0, 1);
|
|
const pike = Logic.spawnUnit(RULES, st, 1, 'pikemen', 5, 5, null);
|
|
const knight = Logic.spawnUnit(RULES, st, 0, 'knights', 4, 5, null);
|
|
const legion = Logic.spawnUnit(RULES, st, 0, 'legion', 4, 5, null);
|
|
const dVsKnight = Logic.defenderStrength(RULES, st, pike, knight);
|
|
const dVsLegion = Logic.defenderStrength(RULES, st, pike, legion);
|
|
check('pikemen x2 vs mounted', Math.abs(dVsKnight - 2 * dVsLegion) < 1e-9);
|
|
}
|
|
{
|
|
// Veteran and hp scaling on attack.
|
|
const st = makeFlatState();
|
|
const u = Logic.spawnUnit(RULES, st, 0, 'legion', 5, 5, null);
|
|
const a0 = Logic.attackerStrength(RULES, st, u);
|
|
u.vet = true;
|
|
check('vet x1.5 attack', Math.abs(Logic.attackerStrength(RULES, st, u) - a0 * 1.5) < 1e-9);
|
|
u.hp = 5;
|
|
check('hp halves attack', Math.abs(Logic.attackerStrength(RULES, st, u) - a0 * 1.5 * 0.5) < 1e-9);
|
|
}
|
|
|
|
// Monte Carlo: duel win rates track the analytic single-round model.
|
|
{
|
|
const st = makeFlatState();
|
|
const trials = QUICK ? 2000 : 10000;
|
|
// Equal units: expect ~50%.
|
|
let wins = 0;
|
|
for (let i = 0; i < trials; i += 1) {
|
|
if (Logic.simulateDuel(st, 4, 20, 1, 4, 20, 1, 20).attackerWon) wins += 1;
|
|
}
|
|
const even = wins / trials;
|
|
check('equal duel ~50%', even > 0.46 && even < 0.54, `${even.toFixed(3)}`);
|
|
// 2:1 attacker: p(round)=2/3; 10-round-to-kill race strongly favours attacker.
|
|
wins = 0;
|
|
for (let i = 0; i < trials; i += 1) {
|
|
if (Logic.simulateDuel(st, 8, 20, 1, 4, 20, 1, 20).attackerWon) wins += 1;
|
|
}
|
|
const strong = wins / trials;
|
|
check('2:1 duel > 85%', strong > 0.85, `${strong.toFixed(3)}`);
|
|
// Higher firepower shortens the race for the attacker.
|
|
wins = 0;
|
|
for (let i = 0; i < trials; i += 1) {
|
|
if (Logic.simulateDuel(st, 4, 20, 2, 4, 20, 1, 20).attackerWon) wins += 1;
|
|
}
|
|
const fp = wins / trials;
|
|
check('fp advantage wins > 65%', fp > 0.65, `${fp.toFixed(3)}`);
|
|
check('duel ordering sane', strong > fp && fp > even);
|
|
}
|
|
|
|
// Difficulty combat handicap: Chieftain/Warlord ease combat for the human
|
|
// side and soften the AI side; Prince/King/Emperor stay neutral (1.0/1.0).
|
|
{
|
|
const stPrince = makeFlatState();
|
|
const humanP = Logic.spawnUnit(RULES, stPrince, 0, 'legion', 5, 5, null);
|
|
const aiP = Logic.spawnUnit(RULES, stPrince, 1, 'legion', 5, 5, null);
|
|
const humanAtkPrince = Logic.attackerStrength(RULES, stPrince, humanP);
|
|
const aiAtkPrince = Logic.attackerStrength(RULES, stPrince, aiP);
|
|
const humanDefPrince = Logic.defenderStrength(RULES, stPrince, humanP, aiP);
|
|
const aiDefPrince = Logic.defenderStrength(RULES, stPrince, aiP, humanP);
|
|
|
|
for (const [diffId, expectHuman, expectAi] of [
|
|
['chieftain', 1.25, 0.8],
|
|
['warlord', 1.1, 0.9],
|
|
]) {
|
|
const st = makeFlatState();
|
|
st.difficultyId = diffId;
|
|
const human = Logic.spawnUnit(RULES, st, 0, 'legion', 5, 5, null);
|
|
const ai = Logic.spawnUnit(RULES, st, 1, 'legion', 5, 5, null);
|
|
const humanAtk = Logic.attackerStrength(RULES, st, human);
|
|
const aiAtk = Logic.attackerStrength(RULES, st, ai);
|
|
const humanDef = Logic.defenderStrength(RULES, st, human, ai);
|
|
const aiDef = Logic.defenderStrength(RULES, st, ai, human);
|
|
check(`${diffId} human attack x${expectHuman}`,
|
|
Math.abs(humanAtk - humanAtkPrince * expectHuman) < 1e-9, `${humanAtk}`);
|
|
check(`${diffId} ai attack x${expectAi}`,
|
|
Math.abs(aiAtk - aiAtkPrince * expectAi) < 1e-9, `${aiAtk}`);
|
|
check(`${diffId} human defense x${expectHuman}`,
|
|
Math.abs(humanDef - humanDefPrince * expectHuman) < 1e-9, `${humanDef}`);
|
|
check(`${diffId} ai defense x${expectAi}`,
|
|
Math.abs(aiDef - aiDefPrince * expectAi) < 1e-9, `${aiDef}`);
|
|
}
|
|
|
|
for (const diffId of ['king', 'emperor']) {
|
|
const st = makeFlatState();
|
|
st.difficultyId = diffId;
|
|
const human = Logic.spawnUnit(RULES, st, 0, 'legion', 5, 5, null);
|
|
const ai = Logic.spawnUnit(RULES, st, 1, 'legion', 5, 5, null);
|
|
check(`${diffId} human attack unchanged from prince`,
|
|
Math.abs(Logic.attackerStrength(RULES, st, human) - humanAtkPrince) < 1e-9);
|
|
check(`${diffId} ai attack unchanged from prince`,
|
|
Math.abs(Logic.attackerStrength(RULES, st, ai) - aiAtkPrince) < 1e-9);
|
|
}
|
|
}
|
|
|
|
// Veteran-promotion odds: elevated for the human side on Chieftain, flat
|
|
// 50% for AI regardless of difficulty, flat 50% for everyone at Prince+.
|
|
{
|
|
const trials = QUICK ? 1500 : 6000;
|
|
function vetRate(difficultyId, civIdx) {
|
|
let promos = 0;
|
|
for (let i = 0; i < trials; i += 1) {
|
|
const st = makeFlatState();
|
|
st.difficultyId = difficultyId;
|
|
st.rngState = (i * 2654435761) | 0;
|
|
const attacker = Logic.spawnUnit(RULES, st, civIdx, 'armor', 4, 5, null);
|
|
const defender = Logic.spawnUnit(RULES, st, 1 - civIdx, 'warriors', 5, 5, null);
|
|
Logic.resolveAttack(RULES, st, attacker, 5, 5);
|
|
if (attacker.vet) promos += 1;
|
|
}
|
|
return promos / trials;
|
|
}
|
|
const chieftainHuman = vetRate('chieftain', 0);
|
|
const princeHuman = vetRate('prince', 0);
|
|
const chieftainAi = vetRate('chieftain', 1);
|
|
check('chieftain human vet rate ~0.75', chieftainHuman > 0.7 && chieftainHuman < 0.8,
|
|
`${chieftainHuman.toFixed(3)}`);
|
|
check('prince human vet rate ~0.5', princeHuman > 0.46 && princeHuman < 0.54,
|
|
`${princeHuman.toFixed(3)}`);
|
|
check('chieftain ai vet rate unchanged ~0.5', chieftainAi > 0.46 && chieftainAi < 0.54,
|
|
`${chieftainAi.toFixed(3)}`);
|
|
}
|
|
|
|
// Stack death outside cities/fortresses, survival inside.
|
|
{
|
|
const st = makeFlatState();
|
|
setWar(st, 0, 1);
|
|
// Cityless civs with no settler are auto-eliminated by checkVictory (run
|
|
// at the end of resolveAttack) — give each side a settler elsewhere so
|
|
// wiping out the other's stack doesn't also eliminate the attacker's own
|
|
// civ (and remove the tank) as a side effect of this fixture.
|
|
Logic.spawnUnit(RULES, st, 0, 'settlers', 0, 0, null);
|
|
Logic.spawnUnit(RULES, st, 1, 'settlers', 15, 15, null);
|
|
Logic.spawnUnit(RULES, st, 1, 'warriors', 5, 5, null);
|
|
Logic.spawnUnit(RULES, st, 1, 'warriors', 5, 5, null);
|
|
Logic.spawnUnit(RULES, st, 1, 'warriors', 5, 5, null);
|
|
const tank = Logic.spawnUnit(RULES, st, 0, 'armor', 4, 5, null);
|
|
tank.vet = true;
|
|
let out = { result: '' };
|
|
for (let i = 0; i < 10 && Logic.unitsAt(st, 5, 5).length; i += 1) {
|
|
tank.mp = 9; tank.hp = 30;
|
|
out = Logic.resolveAttack(RULES, st, tank, 5, 5);
|
|
if (out.won) break;
|
|
}
|
|
// Winner advances onto an open-ground tile it just cleared entirely
|
|
// (matches the victory-glide the UI plays for an unopposed win).
|
|
check('stack dies on open ground', out.won === true);
|
|
check('attacker advances onto the now-empty tile',
|
|
tank.x === 5 && tank.y === 5 && Logic.unitsAt(st, 5, 5).length === 1
|
|
&& Logic.unitsAt(st, 5, 5)[0].id === tank.id);
|
|
|
|
const combatEvt = st.events.filter((e) => e.type === 'combat').pop();
|
|
check('combat event carries attacker/defender snapshot for the UI',
|
|
!!combatEvt && combatEvt.ax === 4 && combatEvt.ay === 5 && combatEvt.x === 5 && combatEvt.y === 5
|
|
&& combatEvt.attackerId === tank.id && combatEvt.attackerCiv === 0 && combatEvt.attackerType === 'armor'
|
|
&& combatEvt.defenderCiv === 1 && combatEvt.defenderType === 'warriors'
|
|
&& combatEvt.attackerWon === true && combatEvt.advanced === true);
|
|
|
|
const st2 = makeFlatState();
|
|
setWar(st2, 0, 1);
|
|
const city = Logic.foundCity(RULES, st2, Logic.spawnUnit(RULES, st2, 1, 'settlers', 5, 5, null));
|
|
Logic.spawnUnit(RULES, st2, 1, 'warriors', 5, 5, null);
|
|
Logic.spawnUnit(RULES, st2, 1, 'warriors', 5, 5, null);
|
|
const tank2 = Logic.spawnUnit(RULES, st2, 0, 'armor', 4, 5, null);
|
|
tank2.vet = true;
|
|
let won2 = false;
|
|
for (let i = 0; i < 10 && !won2; i += 1) {
|
|
tank2.mp = 9; tank2.hp = 30;
|
|
const o = Logic.resolveAttack(RULES, st2, tank2, 5, 5);
|
|
won2 = o.won === true;
|
|
}
|
|
check('city stack loses only defender', won2 && Logic.unitsAt(st2, 5, 5).length === 1,
|
|
`${Logic.unitsAt(st2, 5, 5).length} left, city ${!!city}`);
|
|
// A win against a protected (city) stack that still has defenders left
|
|
// does NOT advance the attacker onto the tile.
|
|
check('attacker does not advance into a still-defended city',
|
|
!(tank2.x === 5 && tank2.y === 5));
|
|
const combatEvt2 = st2.events.filter((e) => e.type === 'combat').pop();
|
|
check('non-advancing combat event says so', !!combatEvt2 && combatEvt2.advanced === false);
|
|
}
|
|
|
|
// City capture: pop loss, loot, palace relocation, elimination.
|
|
{
|
|
const st = makeFlatState();
|
|
setWar(st, 0, 1);
|
|
const cityA = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 1, 'settlers', 5, 5, null));
|
|
const cityB = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 1, 'settlers', 10, 10, null));
|
|
cityA.size = 4;
|
|
st.civs[1].gold = 200;
|
|
const tank = Logic.spawnUnit(RULES, st, 0, 'armor', 4, 5, null);
|
|
const out = Logic.tryMove(RULES, st, tank, 1, 0);
|
|
check('undefended city captured', out.result === 'captured');
|
|
check('captured city loses a pop', cityA.size === 3);
|
|
check('capturer moves in', tank.x === 5 && tank.y === 5);
|
|
check('loot transferred', st.civs[0].gold > 100);
|
|
check('palace relocates', !!cityB.buildings.palace && !cityA.buildings.palace);
|
|
check('civ still alive with one city', st.civs[1].alive);
|
|
const tank2 = Logic.spawnUnit(RULES, st, 0, 'armor', 9, 10, null);
|
|
Logic.tryMove(RULES, st, tank2, 1, 0);
|
|
check('last city falls => civ eliminated', !st.civs[1].alive);
|
|
check('conquest victory declared', st.over?.type === 'conquest' && st.over.winner === 0);
|
|
}
|
|
|
|
// Attacks require war; nukes and SDI.
|
|
{
|
|
const st = makeFlatState({ civs: 3 });
|
|
const u0 = Logic.spawnUnit(RULES, st, 0, 'legion', 4, 5, null);
|
|
Logic.spawnUnit(RULES, st, 1, 'legion', 5, 5, null);
|
|
const blocked = Logic.tryMove(RULES, st, u0, 1, 0);
|
|
check('attack blocked without war', blocked.result === 'blocked' && blocked.needsWar === 1);
|
|
|
|
setWar(st, 0, 1);
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 1, 'settlers', 10, 5, null));
|
|
city.size = 8;
|
|
Logic.spawnUnit(RULES, st, 1, 'riflemen', 10, 5, null);
|
|
Logic.spawnUnit(RULES, st, 1, 'riflemen', 10, 5, null);
|
|
const nuke = Logic.spawnUnit(RULES, st, 0, 'nuclearmsl', 9, 5, null);
|
|
const out = Logic.resolveAttack(RULES, st, nuke, 10, 5);
|
|
check('nuke clears stack', out.result === 'nuked' && Logic.unitsAt(st, 10, 5).length === 0);
|
|
check('nuke halves city pop', city.size === 4);
|
|
check('nuke consumed', !st.units.some((u) => u.type === 'nuclearmsl'));
|
|
|
|
city.buildings.sdidefense = true;
|
|
Logic.spawnUnit(RULES, st, 1, 'riflemen', 10, 5, null);
|
|
const nuke2 = Logic.spawnUnit(RULES, st, 0, 'nuclearmsl', 9, 5, null);
|
|
const out2 = Logic.resolveAttack(RULES, st, nuke2, 10, 5);
|
|
check('SDI blocks nuke', out2.result === 'nukeBlocked'
|
|
&& Logic.unitsAt(st, 10, 5).length === 1 && city.size === 4);
|
|
}
|
|
|
|
// Missiles are consumed even on a won conventional attack.
|
|
{
|
|
const st = makeFlatState();
|
|
setWar(st, 0, 1);
|
|
Logic.spawnUnit(RULES, st, 1, 'warriors', 5, 5, null);
|
|
const cm = Logic.spawnUnit(RULES, st, 0, 'cruisemsl', 4, 5, null);
|
|
const out = Logic.resolveAttack(RULES, st, cm, 5, 5);
|
|
check('cruise missile consumed', !st.units.some((u) => u.type === 'cruisemsl'), out.result);
|
|
}
|
|
|
|
// Movement: roads, rails, boarding, disembark, trireme coast rule.
|
|
{
|
|
const st = makeFlatState();
|
|
const u = Logic.spawnUnit(RULES, st, 0, 'warriors', 5, 5, null);
|
|
check('grass step costs full move', (() => { Logic.tryMove(RULES, st, u, 1, 0); return u.mp === 0; })());
|
|
const i1 = 5 * 16 + 6;
|
|
const i2 = 5 * 16 + 7;
|
|
st.world.improvements[i1] = 1; st.world.improvements[i2] = 1;
|
|
u.mp = 3;
|
|
Logic.tryMove(RULES, st, u, 1, 0);
|
|
check('road step costs 1/3', u.mp === 2, `${u.mp}`);
|
|
st.world.improvements[i2] |= 2;
|
|
const i3 = 5 * 16 + 8;
|
|
st.world.improvements[i3] = 3;
|
|
Logic.tryMove(RULES, st, u, 1, 0);
|
|
check('rail step free', u.mp === 2, `${u.mp}`);
|
|
|
|
// Boarding & disembark.
|
|
const st2 = makeFlatState();
|
|
for (let y = 0; y < 16; y += 1) st2.world.terrain[y * 16 + 8] = T('ocean');
|
|
const boat = Logic.spawnUnit(RULES, st2, 0, 'transport', 8, 5, null);
|
|
const inf = Logic.spawnUnit(RULES, st2, 0, 'riflemen', 7, 5, null);
|
|
const bOut = Logic.tryMove(RULES, st2, inf, 1, 0);
|
|
check('boards transport', bOut.result === 'boarded' && inf.carriedBy === boat.id);
|
|
boat.mp = 15;
|
|
Logic.tryMove(RULES, st2, boat, 0, 1);
|
|
check('cargo rides along', inf.x === 8 && inf.y === 6);
|
|
inf.mp = 3;
|
|
const dOut = Logic.disembark(RULES, st2, inf, 1, 0);
|
|
check('disembarks ashore', dOut.result === 'moved' && inf.carriedBy === null && inf.x === 9);
|
|
|
|
// Trireme must hug the coast.
|
|
const st3 = makeFlatState();
|
|
for (let y = 0; y < 16; y += 1) {
|
|
for (let x = 6; x < 16; x += 1) st3.world.terrain[y * 16 + x] = T('ocean');
|
|
}
|
|
const tri = Logic.spawnUnit(RULES, st3, 0, 'trireme', 6, 5, null);
|
|
check('trireme coast tile ok', Logic.canOccupy(RULES, st3, tri, 6, 8));
|
|
check('trireme open sea blocked', !Logic.canOccupy(RULES, st3, tri, 12, 8));
|
|
const dd = Logic.spawnUnit(RULES, st3, 0, 'destroyer', 8, 5, null);
|
|
check('destroyer open sea ok', Logic.canOccupy(RULES, st3, dd, 12, 8));
|
|
check('land unit cannot walk on water', !Logic.canOccupy(RULES, st3,
|
|
Logic.spawnUnit(RULES, st3, 0, 'warriors', 3, 3, null), 8, 8));
|
|
}
|
|
|
|
// Pathfinding: prefers roads, avoids blocked tiles, respects domains.
|
|
{
|
|
const st = makeFlatState();
|
|
for (let x = 3; x <= 12; x += 1) st.world.improvements[7 * 16 + x] |= 1;
|
|
const u = Logic.spawnUnit(RULES, st, 0, 'warriors', 3, 7, null);
|
|
const path = Logic.findPath(RULES, st, u, 12, 7);
|
|
check('path found', !!path && path.length === 9);
|
|
check('path follows road', path.every(([, y]) => y === 7));
|
|
const sea = Logic.findPath(RULES, st, u, 12, 7);
|
|
check('path deterministic', JSON.stringify(sea) === JSON.stringify(path));
|
|
}
|
|
|
|
// Air crash rule at end of turn.
|
|
{
|
|
const st = makeFlatState();
|
|
Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 5, 5, null));
|
|
const f1 = Logic.spawnUnit(RULES, st, 0, 'fighter', 5, 5, null);
|
|
const f2 = Logic.spawnUnit(RULES, st, 0, 'fighter', 10, 10, null);
|
|
Logic.endCivTurn(RULES, st, 0);
|
|
check('fighter in city survives', st.units.includes(f1));
|
|
check('fighter in the field crashes', !st.units.includes(f2));
|
|
}
|
|
|
|
// Work orders: road, irrigation water rule, mine/irrigation exclusivity, transform.
|
|
{
|
|
const st = makeFlatState();
|
|
const eng = Logic.spawnUnit(RULES, st, 0, 'engineers', 5, 5, null);
|
|
st.civs[0].known.explosives = true;
|
|
check('can start road', Logic.startWork(RULES, st, eng, 'road'));
|
|
Logic.beginCivTurn(RULES, st, 0); // 2 work points (engineer) = road done
|
|
const idx = 5 * 16 + 5;
|
|
check('road built', (st.world.improvements[idx] & 1) === 1);
|
|
check('irrigation needs water', !Logic.canWork(RULES, st, eng, 'irrigation'));
|
|
st.world.terrain[5 * 16 + 6] = T('ocean');
|
|
check('irrigation ok next to ocean', Logic.canWork(RULES, st, eng, 'irrigation'));
|
|
Logic.startWork(RULES, st, eng, 'irrigation');
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
Logic.beginCivTurn(RULES, st, 0);
|
|
check('irrigation built', (st.world.improvements[idx] & 4) === 4);
|
|
// Mining hills clears irrigation.
|
|
const st2 = makeFlatState({ terrain: 'hills' });
|
|
const eng2 = Logic.spawnUnit(RULES, st2, 0, 'engineers', 5, 5, null);
|
|
st2.world.improvements[idx] = 4;
|
|
Logic.startWork(RULES, st2, eng2, 'mine');
|
|
Logic.beginCivTurn(RULES, st2, 0);
|
|
Logic.beginCivTurn(RULES, st2, 0);
|
|
check('mine replaces irrigation', (st2.world.improvements[idx] & (16 | 4)) === 16);
|
|
// Transform swamp -> grassland (engineer only).
|
|
const st3 = makeFlatState({ terrain: 'swamp' });
|
|
st3.civs[0].known.explosives = true;
|
|
const sett = Logic.spawnUnit(RULES, st3, 0, 'settlers', 4, 4, null);
|
|
check('settler cannot transform', !Logic.canWork(RULES, st3, sett, 'transform'));
|
|
const eng3 = Logic.spawnUnit(RULES, st3, 0, 'engineers', 5, 5, null);
|
|
Logic.startWork(RULES, st3, eng3, 'transform');
|
|
for (let i = 0; i < 5; i += 1) Logic.beginCivTurn(RULES, st3, 0);
|
|
check('swamp transformed to grassland', st3.world.terrain[idx] === T('grassland'));
|
|
}
|
|
|
|
// Huts: all outcomes reachable, ambush can kill.
|
|
{
|
|
const st = makeFlatState();
|
|
const seen = new Set();
|
|
for (let i = 0; i < 200; i += 1) {
|
|
st.world.huts[5 * 16 + 6] = 1;
|
|
const u = Logic.spawnUnit(RULES, st, 0, 'legion', 5, 5, null);
|
|
const out = Logic.tryMove(RULES, st, u, 1, 0);
|
|
if (out.hut) seen.add(out.hut.outcome);
|
|
for (const un of [...st.units]) Logic.removeUnit(st, un);
|
|
}
|
|
check('hut outcomes cover gold/tech/unit/ambush', seen.has('gold') && seen.has('tech')
|
|
&& seen.has('unit') && (seen.has('ambushWon') || seen.has('ambushLost')), [...seen].join(','));
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('6. trade & diplomacy');
|
|
|
|
if (RULES) {
|
|
// Trade routes: distance gate, bonus math, max-3 replacement.
|
|
{
|
|
const st = makeFlatState({ cols: 32, rows: 8 });
|
|
const home = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 2, 4, null));
|
|
const near = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 6, 4, null));
|
|
const far = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 0, 'settlers', 20, 4, null));
|
|
const cv1 = Logic.spawnUnit(RULES, st, 0, 'caravan', 6, 4, home.id);
|
|
check('route needs 8+ distance', Logic.canEstablishRoute(RULES, st, cv1) === null);
|
|
const cv2 = Logic.spawnUnit(RULES, st, 0, 'caravan', 20, 4, home.id);
|
|
const goldBefore = st.civs[0].gold;
|
|
const out = Logic.establishTradeRoute(RULES, st, cv2);
|
|
check('route established', !!out && out.bonus > 0);
|
|
check('caravan consumed', !st.units.some((u) => u.type === 'caravan' && u.x === 20));
|
|
check('bonus paid in gold+beakers', st.civs[0].gold === goldBefore + out.bonus
|
|
&& st.civs[0].beakers >= out.bonus);
|
|
check('both cities got the route', home.routes.length === 1 && far.routes.length === 1
|
|
&& home.routes[0].cityId === far.id);
|
|
check('route trade feeds yields', Logic.cityYields(RULES, st, far).routeTrade === out.amount);
|
|
// Max 3: pile on routes, weakest is dropped.
|
|
home.routes = [{ cityId: 90, amount: 2 }, { cityId: 91, amount: 3 }, { cityId: 92, amount: 4 }];
|
|
const cv3 = Logic.spawnUnit(RULES, st, 0, 'caravan', 20, 4, home.id);
|
|
Logic.establishTradeRoute(RULES, st, cv3);
|
|
check('max 3 routes, worst replaced', home.routes.length === 3
|
|
&& !home.routes.some((r) => r.cityId === 90));
|
|
// Foreign routes pay double.
|
|
const st2 = makeFlatState({ cols: 32, rows: 8, civs: 2 });
|
|
const h2 = Logic.foundCity(RULES, st2, Logic.spawnUnit(RULES, st2, 0, 'settlers', 2, 4, null));
|
|
Logic.foundCity(RULES, st2, Logic.spawnUnit(RULES, st2, 1, 'settlers', 20, 4, null));
|
|
const cvF = Logic.spawnUnit(RULES, st2, 0, 'caravan', 20, 4, h2.id);
|
|
const outF = Logic.establishTradeRoute(RULES, st2, cvF);
|
|
check('foreign route pays roughly double', !!outF && outF.bonus >= out.bonus * 1.5,
|
|
`${out.bonus} vs ${outF?.bonus}`);
|
|
}
|
|
|
|
// Diplomacy state machine: legal steps only.
|
|
{
|
|
const st = makeFlatState({ civs: 3 });
|
|
check('contact->peace legal', Logic.canPropose(st, 0, 1, 'peace'));
|
|
check('contact->alliance illegal', !Logic.canPropose(st, 0, 1, 'alliance'));
|
|
check('contact->ceasefire illegal', !Logic.canPropose(st, 0, 1, 'ceasefire'));
|
|
check('apply peace', Logic.applyTreaty(st, 0, 1, 'peace')
|
|
&& st.civs[1].relations[0] === 'peace');
|
|
check('peace->alliance legal', Logic.applyTreaty(st, 0, 1, 'alliance'));
|
|
check('sneak attack scars reputation', (() => {
|
|
const rep = st.civs[0].reputation;
|
|
Logic.declareWar(RULES, st, 0, 1);
|
|
return st.civs[0].reputation < rep && st.civs[0].relations[1] === 'war';
|
|
})());
|
|
check('war->peace illegal (need ceasefire)', !Logic.canPropose(st, 0, 1, 'peace'));
|
|
check('war->ceasefire->peace', Logic.applyTreaty(st, 0, 1, 'ceasefire')
|
|
&& Logic.applyTreaty(st, 0, 1, 'peace'));
|
|
check('third party attitude fell on sneak attack', st.civs[2].attitude[0] < 0);
|
|
check('cancel treaty back to contact', Logic.cancelTreaty(st, 0, 1)
|
|
&& st.civs[0].relations[1] === 'contact');
|
|
check('war on nocontact illegal', (() => {
|
|
st.civs[0].relations[2] = 'nocontact';
|
|
return !Logic.declareWar(RULES, st, 0, 2);
|
|
})());
|
|
}
|
|
|
|
// Gifts, exchanges, tribute.
|
|
{
|
|
const st = makeFlatState({ civs: 2 });
|
|
st.civs[0].gold = 100;
|
|
check('gift gold', Logic.giftGold(st, 0, 1, 50) && st.civs[1].gold === 150);
|
|
check('gift beyond means fails', !Logic.giftGold(st, 0, 1, 500));
|
|
check('gift raises attitude', st.civs[1].attitude[0] > 0);
|
|
st.civs[0].known.alphabet = true;
|
|
st.civs[1].known.pottery = true;
|
|
check('tech exchange', Logic.exchangeTechs(RULES, st, 0, 1, 'alphabet', 'pottery')
|
|
&& st.civs[0].known.pottery && st.civs[1].known.alphabet);
|
|
check('re-exchange fails', !Logic.exchangeTechs(RULES, st, 0, 1, 'alphabet', 'pottery'));
|
|
const paid = Logic.payTribute(st, 1, 0, 75);
|
|
check('tribute paid', paid === 75 && st.civs[1].attitude[0] < 0);
|
|
}
|
|
|
|
// Fuzz: random diplomacy actions never reach an illegal state and
|
|
// attitudes stay bounded.
|
|
{
|
|
const st = makeFlatState({ civs: 4 });
|
|
st.rngState = 424242;
|
|
const legalStates = new Set(['nocontact', 'contact', 'war', 'ceasefire', 'peace', 'alliance']);
|
|
let legal = true;
|
|
let bounded = true;
|
|
const actions = QUICK ? 300 : 1000;
|
|
for (let i = 0; i < actions; i += 1) {
|
|
const a = Logic.randInt(st, 4);
|
|
let b = Logic.randInt(st, 4);
|
|
if (a === b) b = (b + 1) % 4;
|
|
const roll = Logic.rand(st);
|
|
if (roll < 0.25) Logic.declareWar(RULES, st, a, b);
|
|
else if (roll < 0.5) {
|
|
const kinds = ['ceasefire', 'peace', 'alliance'];
|
|
Logic.applyTreaty(st, a, b, kinds[Logic.randInt(st, 3)]);
|
|
} else if (roll < 0.65) Logic.cancelTreaty(st, a, b);
|
|
else if (roll < 0.8) { st.civs[a].gold = 50; Logic.giftGold(st, a, b, 25); }
|
|
else Logic.updateAttitudes(RULES, st, a);
|
|
for (const civ of st.civs) {
|
|
for (const [other, rel] of Object.entries(civ.relations)) {
|
|
if (!legalStates.has(rel)) legal = false;
|
|
if (st.civs[other].relations[civ.id] !== rel) legal = false; // symmetry
|
|
}
|
|
for (const v of Object.values(civ.attitude)) {
|
|
if (v < -100 || v > 100 || Number.isNaN(v)) bounded = false;
|
|
}
|
|
}
|
|
if (!legal || !bounded) break;
|
|
}
|
|
check('fuzz: relations stay legal & symmetric', legal);
|
|
check('fuzz: attitudes bounded', bounded);
|
|
}
|
|
|
|
// Attitude -> portrait mood mapping.
|
|
check('mood mapping', Logic.attitudeMood(-60) === 'upset' && Logic.attitudeMood(0) === 'idle'
|
|
&& Logic.attitudeMood(60) === 'happy');
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('6b. AI-initiated diplomacy');
|
|
|
|
// Note: makeFlatState/mkCiv deliberately DON'T carry frustration,
|
|
// requestCooldown, lastRequestTurn, pledges or pendingRequests — they're
|
|
// shaped like a save written before this feature existed, so every check below
|
|
// doubles as an old-save compatibility test.
|
|
if (RULES) {
|
|
// considerRequest rolls a random gate and picks among eligible kinds, so
|
|
// sample it repeatedly with the throttles cleared to see what a setup can
|
|
// actually produce.
|
|
const collect = (st, from, to, attempts = 200) => {
|
|
const kinds = new Set();
|
|
for (let i = 0; i < attempts; i += 1) {
|
|
st.civs[from].lastRequestTurn = {};
|
|
st.civs[from].requestCooldown = {};
|
|
const req = Diplo.considerRequest(RULES, st, from, to);
|
|
if (req) kinds.add(req.kind);
|
|
}
|
|
return kinds;
|
|
};
|
|
|
|
// --- join-my-war eligibility
|
|
{
|
|
const st = makeFlatState({ civs: 3 });
|
|
setWar(st, 1, 2);
|
|
st.civs[1].relations[0] = 'peace';
|
|
st.civs[0].relations[1] = 'peace';
|
|
st.civs[1].attitude[0] = 40;
|
|
check('joinWar offered to a friendly treaty partner', collect(st, 1, 0).has('joinWar'));
|
|
|
|
st.civs[1].attitude[0] = 10; // below goodStandingAttitude
|
|
check('joinWar withheld from a lukewarm partner', !collect(st, 1, 0).has('joinWar'));
|
|
|
|
st.civs[1].attitude[0] = 40;
|
|
st.civs[1].relations[0] = 'contact';
|
|
st.civs[0].relations[1] = 'contact';
|
|
check('joinWar needs a treaty, not mere contact', !collect(st, 1, 0).has('joinWar'));
|
|
|
|
st.civs[1].relations[0] = 'peace';
|
|
st.civs[0].relations[1] = 'peace';
|
|
setWar(st, 0, 2); // already fighting the proposed target
|
|
check('joinWar withheld when you already fight the target', !collect(st, 1, 0).has('joinWar'));
|
|
|
|
st.civs[0].relations[2] = 'nocontact';
|
|
st.civs[2].relations[0] = 'nocontact';
|
|
check('joinWar withheld against a civ you have never met', !collect(st, 1, 0).has('joinWar'));
|
|
}
|
|
|
|
// --- accepting a call to arms
|
|
{
|
|
const st = makeFlatState({ civs: 3 });
|
|
setWar(st, 1, 2);
|
|
Logic.applyTreaty(st, 0, 1, 'peace');
|
|
Logic.applyTreaty(st, 0, 2, 'peace');
|
|
const rep = st.civs[0].reputation;
|
|
const req = { kind: 'joinWar', from: 1, to: 0, target: 2, turn: st.turn };
|
|
check('joinWar accepted declares war', Diplo.resolveRequest(RULES, st, req, true)
|
|
&& st.civs[0].relations[2] === 'war');
|
|
check('breaking a treaty to answer a call to arms still scars reputation',
|
|
st.civs[0].reputation < rep);
|
|
check('answering the call earns real goodwill', st.civs[1].attitude[0] >= 30);
|
|
}
|
|
|
|
// --- refusal builds frustration, which decays and drags attitude down
|
|
{
|
|
const st = makeFlatState({ civs: 3 });
|
|
setWar(st, 1, 2);
|
|
Logic.applyTreaty(st, 0, 1, 'peace');
|
|
const cfg = RULES.requestKinds.joinWar;
|
|
const attBefore = st.civs[1].attitude[0];
|
|
const req = { kind: 'joinWar', from: 1, to: 0, target: 2, turn: st.turn };
|
|
Diplo.resolveRequest(RULES, st, req, false);
|
|
check('refusal builds frustration', Logic.frustrationOf(st, 1, 0) === cfg.refuseFrustration);
|
|
check('refusal costs attitude', st.civs[1].attitude[0] === attBefore + cfg.refuseAttitude);
|
|
|
|
check('an ignored request costs half of a refusal', (() => {
|
|
const st2 = makeFlatState({ civs: 3 });
|
|
Diplo.resolveRequest(RULES, st2, { kind: 'joinWar', from: 1, to: 0, target: 2, turn: 1 }, false, 0.5);
|
|
return Logic.frustrationOf(st2, 1, 0) === Math.round(cfg.refuseFrustration * 0.5);
|
|
})());
|
|
|
|
const before = Logic.frustrationOf(st, 1, 0);
|
|
Logic.updateAttitudes(RULES, st, 1);
|
|
check('frustration decays each turn',
|
|
Logic.frustrationOf(st, 1, 0) === before - RULES.diplomacy.frustrationDecay);
|
|
|
|
// Sustained frustration should pull attitude well below zero on its own.
|
|
st.civs[1].frustration[0] = 80;
|
|
for (let i = 0; i < 30; i += 1) {
|
|
st.civs[1].frustration[0] = 80; // hold it there against the decay
|
|
Logic.updateAttitudes(RULES, st, 1);
|
|
}
|
|
check('frustration drags attitude toward hostility', st.civs[1].attitude[0] <= -30,
|
|
`${st.civs[1].attitude[0]}`);
|
|
}
|
|
|
|
// --- cooldowns and the per-leader gap
|
|
{
|
|
const st = makeFlatState({ civs: 3 });
|
|
setWar(st, 1, 2);
|
|
Logic.applyTreaty(st, 0, 1, 'peace');
|
|
st.civs[1].attitude[0] = 60;
|
|
Diplo.resolveRequest(RULES, st, { kind: 'joinWar', from: 1, to: 0, target: 2, turn: st.turn }, false);
|
|
check('kind is on cooldown right after asking',
|
|
!Diplo.cooldownReady(RULES, st, 1, 0, 'joinWar'));
|
|
check('same kind not re-offered while on cooldown', (() => {
|
|
for (let i = 0; i < 200; i += 1) {
|
|
st.civs[1].lastRequestTurn = {}; // clear only the per-leader gap
|
|
const req = Diplo.considerRequest(RULES, st, 1, 0);
|
|
if (req && req.kind === 'joinWar') return false;
|
|
}
|
|
return true;
|
|
})());
|
|
check('a different leader is unaffected by the cooldown',
|
|
Diplo.cooldownReady(RULES, st, 2, 0, 'joinWar'));
|
|
st.turn += RULES.requestKinds.joinWar.cooldown;
|
|
check('cooldown expires on schedule', Diplo.cooldownReady(RULES, st, 1, 0, 'joinWar'));
|
|
|
|
// The per-leader gap throttles a leader across ALL kinds.
|
|
st.civs[1].lastRequestTurn = { 0: st.turn };
|
|
let asked = false;
|
|
for (let i = 0; i < 200; i += 1) if (Diplo.considerRequest(RULES, st, 1, 0)) asked = true;
|
|
check('per-leader gap silences a leader who just spoke', !asked);
|
|
st.turn += RULES.diplomacy.perLeaderGap;
|
|
check('leader speaks again once the gap has passed', (() => {
|
|
for (let i = 0; i < 200; i += 1) {
|
|
st.civs[1].requestCooldown = {};
|
|
if (Diplo.considerRequest(RULES, st, 1, 0)) return true;
|
|
}
|
|
return false;
|
|
})());
|
|
}
|
|
|
|
// --- frustrated leaders switch from favours to compensation demands
|
|
{
|
|
const st = makeFlatState({ civs: 3 });
|
|
setWar(st, 1, 2);
|
|
Logic.applyTreaty(st, 0, 1, 'peace');
|
|
st.civs[1].attitude[0] = 60;
|
|
st.civs[0].gold = 400;
|
|
st.civs[0].known.alphabet = true;
|
|
st.civs[1].frustration = { 0: RULES.diplomacy.frustrationDemandThreshold };
|
|
const kinds = collect(st, 1, 0);
|
|
check('a frustrated leader only demands compensation',
|
|
kinds.size > 0 && [...kinds].every((k) => k === 'demandGold' || k === 'demandTech'),
|
|
[...kinds].join(','));
|
|
|
|
const goldReq = { kind: 'demandGold', from: 1, to: 0, gold: 100, turn: st.turn };
|
|
const purse = st.civs[0].gold;
|
|
Diplo.resolveRequest(RULES, st, goldReq, true);
|
|
check('paying a demand moves the gold', st.civs[0].gold === purse - 100
|
|
&& st.civs[1].gold === 200);
|
|
check('paying a demand clears the grudge', Logic.frustrationOf(st, 1, 0) === 0);
|
|
|
|
st.civs[1].frustration[0] = 50;
|
|
Diplo.resolveRequest(RULES, st, { kind: 'demandTech', from: 1, to: 0, techId: 'alphabet', turn: st.turn }, true);
|
|
check('handing over a demanded tech transfers it', st.civs[1].known.alphabet === true);
|
|
}
|
|
|
|
// --- escalation: renounce the treaty, then let ordinary hostility take over
|
|
{
|
|
const st = makeFlatState({ civs: 2 });
|
|
Logic.applyTreaty(st, 0, 1, 'peace');
|
|
st.civs[1].frustration = { 0: RULES.diplomacy.frustrationBreakThreshold };
|
|
check('breaking point renounces the treaty', Diplo.escalateFrustration(RULES, st, 1, 0)
|
|
&& st.civs[1].relations[0] === 'contact');
|
|
check('renouncing is announced', st.events.some((e) => e.type === 'treatyRenounced' && e.from === 1));
|
|
check('renouncing vents some frustration',
|
|
Logic.frustrationOf(st, 1, 0) < RULES.diplomacy.frustrationBreakThreshold);
|
|
st.civs[1].frustration[0] = 100;
|
|
check('nothing left to renounce', !Diplo.escalateFrustration(RULES, st, 1, 0));
|
|
check('below the threshold nothing breaks', (() => {
|
|
const st2 = makeFlatState({ civs: 2 });
|
|
Logic.applyTreaty(st2, 0, 1, 'peace');
|
|
st2.civs[1].frustration = { 0: RULES.diplomacy.frustrationBreakThreshold - 1 };
|
|
return !Diplo.escalateFrustration(RULES, st2, 1, 0) && st2.civs[1].relations[0] === 'peace';
|
|
})());
|
|
}
|
|
|
|
// --- break-your-treaty-with-X. No war between 1 and 2 here, just loathing:
|
|
// that keeps joinWar (a higher-urgency tier) out of the way AND exercises
|
|
// the "hostile but not yet fighting" branch.
|
|
{
|
|
const st = makeFlatState({ civs: 3 });
|
|
Logic.applyTreaty(st, 0, 1, 'peace');
|
|
Logic.applyTreaty(st, 0, 2, 'peace');
|
|
st.civs[1].attitude[0] = 40;
|
|
st.civs[1].attitude[2] = -50;
|
|
check('breakTreaty offered against a rival you are friendly with',
|
|
collect(st, 1, 0).has('breakTreaty'));
|
|
check('accepting breaks the treaty with the third party',
|
|
Diplo.resolveRequest(RULES, st, { kind: 'breakTreaty', from: 1, to: 0, target: 2, turn: st.turn }, true)
|
|
&& st.civs[0].relations[2] === 'contact');
|
|
check('breakTreaty needs a treaty to break',
|
|
!collect(st, 1, 0).has('breakTreaty'));
|
|
}
|
|
|
|
// --- border ultimatum and the promise it creates
|
|
{
|
|
const st = makeFlatState({ civs: 2 });
|
|
const city = Logic.foundCity(RULES, st, Logic.spawnUnit(RULES, st, 1, 'settlers', 8, 8, null));
|
|
Logic.spawnUnit(RULES, st, 0, 'warriors', 9, 8, null);
|
|
check('one unit nearby is not an ultimatum', !collect(st, 1, 0).has('borderUltimatum'));
|
|
Logic.spawnUnit(RULES, st, 0, 'warriors', 10, 9, null);
|
|
check('massed units draw an ultimatum', collect(st, 1, 0).has('borderUltimatum'));
|
|
check('settlers alone do not count', (() => {
|
|
const st2 = makeFlatState({ civs: 2 });
|
|
Logic.foundCity(RULES, st2, Logic.spawnUnit(RULES, st2, 1, 'settlers', 8, 8, null));
|
|
Logic.spawnUnit(RULES, st2, 0, 'settlers', 9, 8, null);
|
|
Logic.spawnUnit(RULES, st2, 0, 'settlers', 10, 9, null);
|
|
return !collect(st2, 1, 0).has('borderUltimatum');
|
|
})());
|
|
|
|
const req = { kind: 'borderUltimatum', from: 1, to: 0, cityId: city.id, cityName: city.name, turn: st.turn };
|
|
Diplo.resolveRequest(RULES, st, req, true);
|
|
check('accepting records a promise', !!st.civs[1].pledges[0]);
|
|
Diplo.checkPledges(RULES, st, 1);
|
|
check('the promise is not judged before it comes due', !!st.civs[1].pledges[0]);
|
|
|
|
st.turn += 20;
|
|
const cfg = RULES.requestKinds.borderUltimatum;
|
|
Diplo.checkPledges(RULES, st, 1);
|
|
check('a broken promise costs double a refusal',
|
|
Logic.frustrationOf(st, 1, 0) === cfg.refuseFrustration * 2);
|
|
check('a broken promise is announced', st.events.some((e) => e.type === 'pledgeBroken'));
|
|
|
|
// Keeping it: units gone by the time the pledge expires.
|
|
const st2 = makeFlatState({ civs: 2 });
|
|
const city2 = Logic.foundCity(RULES, st2, Logic.spawnUnit(RULES, st2, 1, 'settlers', 8, 8, null));
|
|
Diplo.resolveRequest(RULES, st2, {
|
|
kind: 'borderUltimatum', from: 1, to: 0, cityId: city2.id, cityName: city2.name, turn: st2.turn,
|
|
}, true);
|
|
st2.turn += 20;
|
|
const att = st2.civs[1].attitude[0];
|
|
Diplo.checkPledges(RULES, st2, 1);
|
|
check('a kept promise is rewarded', st2.civs[1].attitude[0] > att
|
|
&& st2.events.some((e) => e.type === 'pledgeKept'));
|
|
check('the promise is cleared either way', !st2.civs[1].pledges[0]);
|
|
}
|
|
|
|
// --- tech trades and unprompted gifts
|
|
{
|
|
const st = makeFlatState({ civs: 2 });
|
|
st.civs[0].known.pottery = true;
|
|
st.civs[1].known.alphabet = true;
|
|
st.civs[1].attitude[0] = 20;
|
|
check('techTrade offered when both sides have something', collect(st, 1, 0).has('techTrade'));
|
|
check('techTrade swaps both ways', Diplo.resolveRequest(RULES, st, {
|
|
kind: 'techTrade', from: 1, to: 0, giveId: 'alphabet', getId: 'pottery', turn: st.turn,
|
|
}, true) && st.civs[0].known.alphabet === true && st.civs[1].known.pottery === true);
|
|
|
|
const stG = makeFlatState({ civs: 2 });
|
|
Logic.applyTreaty(stG, 0, 1, 'peace');
|
|
stG.civs[1].attitude[0] = 90;
|
|
stG.civs[1].gold = 300;
|
|
stG.civs[1].known.alphabet = true;
|
|
check('a devoted leader sends an unprompted gift', Diplo.considerGift(RULES, stG, 1, 0)
|
|
&& stG.events.some((e) => e.type === 'aiGift' && e.to === 0));
|
|
check('gifts have their own long cooldown', !Diplo.considerGift(RULES, stG, 1, 0));
|
|
check('an indifferent leader sends nothing', (() => {
|
|
const st2 = makeFlatState({ civs: 2 });
|
|
Logic.applyTreaty(st2, 0, 1, 'peace');
|
|
st2.civs[1].attitude[0] = 20;
|
|
st2.civs[1].gold = 300;
|
|
return !Diplo.considerGift(RULES, st2, 1, 0);
|
|
})());
|
|
}
|
|
|
|
// --- staleness: the world moves on between the AI round and the audience
|
|
{
|
|
const st = makeFlatState({ civs: 3 });
|
|
setWar(st, 1, 2);
|
|
Logic.applyTreaty(st, 0, 1, 'peace');
|
|
const req = { kind: 'joinWar', from: 1, to: 0, target: 2, turn: st.turn };
|
|
check('a live request validates', Diplo.requestValid(RULES, st, req));
|
|
st.civs[2].alive = false;
|
|
check('a request against a dead civ is dropped', !Diplo.requestValid(RULES, st, req));
|
|
|
|
st.civs[0].gold = 30;
|
|
check('a demand you can no longer afford is dropped',
|
|
!Diplo.requestValid(RULES, st, { kind: 'demandGold', from: 1, to: 0, gold: 100, turn: st.turn }));
|
|
st.civs[0].known.alphabet = true;
|
|
st.civs[1].known.alphabet = true;
|
|
check('a demand for a tech they now have is dropped',
|
|
!Diplo.requestValid(RULES, st, { kind: 'demandTech', from: 1, to: 0, techId: 'alphabet', turn: st.turn }));
|
|
}
|
|
|
|
// --- data integrity: every kind is tunable and has something to say
|
|
{
|
|
let complete = true;
|
|
let missing = '';
|
|
for (const kind of Diplo.REQUEST_KINDS) {
|
|
const ok = !!RULES.requestKinds[kind]
|
|
&& Array.isArray(Chat.REQUESTS[kind]) && Chat.REQUESTS[kind].length >= 2
|
|
&& Chat.REQUEST_REPLIES[kind]?.accept?.length >= 2
|
|
&& Chat.REQUEST_REPLIES[kind]?.refuse?.length >= 2;
|
|
if (!ok) { complete = false; missing += `${kind} `; }
|
|
}
|
|
check('every request kind has rules + chat lines', complete, missing);
|
|
check('request lines fill every token they use', (() => {
|
|
const st = makeFlatState({ civs: 3 });
|
|
const reqs = [
|
|
{ kind: 'joinWar', from: 1, to: 0, target: 2 },
|
|
{ kind: 'breakTreaty', from: 1, to: 0, target: 2 },
|
|
{ kind: 'borderUltimatum', from: 1, to: 0, cityName: 'Testopolis' },
|
|
{ kind: 'demandGold', from: 1, to: 0, gold: 100 },
|
|
{ kind: 'demandTech', from: 1, to: 0, techId: 'alphabet' },
|
|
{ kind: 'techTrade', from: 1, to: 0, giveId: 'alphabet', getId: 'pottery' },
|
|
{ kind: 'ceasefire', from: 1, to: 0 }, { kind: 'peace', from: 1, to: 0 },
|
|
{ kind: 'alliance', from: 1, to: 0 },
|
|
];
|
|
for (const req of reqs) {
|
|
const vars = { you: 'Civ0', me: 'Civ1', ...Diplo.requestVars(RULES, st, req) };
|
|
for (const pool of [Chat.REQUESTS[req.kind],
|
|
Chat.REQUEST_REPLIES[req.kind].accept, Chat.REQUEST_REPLIES[req.kind].refuse]) {
|
|
for (const template of pool) {
|
|
if (/\{\w+\}/.test(Chat.pickLine([template], vars))) return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
})());
|
|
check('consequence hints exist for the costly kinds', (() => {
|
|
const st = makeFlatState({ civs: 3 });
|
|
Logic.applyTreaty(st, 0, 2, 'peace');
|
|
st.civs[0].known.alphabet = true;
|
|
return ['joinWar', 'breakTreaty', 'demandGold', 'demandTech'].every((kind) => {
|
|
const req = {
|
|
kind, from: 1, to: 0, target: 2, gold: 50, techId: 'alphabet',
|
|
};
|
|
const hint = Diplo.requestConsequence(RULES, st, req);
|
|
return typeof hint === 'string' && hint.length > 10 && !/\{|undefined|NaN/.test(hint);
|
|
});
|
|
})());
|
|
}
|
|
|
|
// --- serialization
|
|
{
|
|
const st = makeFlatState({ civs: 2 });
|
|
st.civs[1].frustration = { 0: 42 };
|
|
st.civs[1].requestCooldown = { 0: { joinWar: 60 } };
|
|
st.civs[1].pledges = { 0: { kind: 'withdraw', cityId: 3, untilTurn: 9 } };
|
|
st.pendingRequests = [{ kind: 'joinWar', from: 1, to: 0, target: 0, turn: 1 }];
|
|
const back = Logic.deserialize(Logic.serialize(st));
|
|
check('frustration survives a save', back.civs[1].frustration[0] === 42);
|
|
check('cooldowns survive a save', back.civs[1].requestCooldown[0].joinWar === 60);
|
|
check('pledges survive a save', back.civs[1].pledges[0].untilTurn === 9);
|
|
check('pending requests survive a save', back.pendingRequests.length === 1
|
|
&& back.pendingRequests[0].kind === 'joinWar');
|
|
}
|
|
|
|
// --- the whole arc, driven by real AI turns: an ally who is refused over
|
|
// and over stops asking favours, starts demanding compensation, tears up the
|
|
// treaty, and finally declares war. This is the feature's headline behaviour,
|
|
// and it is easy to tune it into never firing (the grudge decays between
|
|
// requests), so pin it down.
|
|
{
|
|
const leaders = ['steve', 'gerome', 'jerry'].map((id) => ({ id, name: id[0].toUpperCase() + id.slice(1) }));
|
|
const play = (policy) => {
|
|
const st = Logic.createGame(RULES, { sizeId: 'small', seed: 77, difficultyId: 'prince', leaders, humanIndex: 0 });
|
|
const setRel = (a, b, r) => { st.civs[a].relations[b] = r; st.civs[b].relations[a] = r; };
|
|
setRel(0, 1, 'alliance');
|
|
setRel(0, 2, 'peace');
|
|
setRel(1, 2, 'war');
|
|
st.civs[1].attitude[0] = 45;
|
|
st.civs[0].gold = 2000;
|
|
st.civs[0].known.alphabet = true;
|
|
const log = { kinds: new Set(), renounced: false, war: false };
|
|
for (let t = 0; t < 300 && !st.over; t += 1) {
|
|
for (let c = 0; c < st.civs.length; c += 1) {
|
|
if (!st.civs[c].alive) continue;
|
|
st.current = c;
|
|
Logic.beginCivTurn(RULES, st, c);
|
|
if (c !== 0) AI.runAITurn(RULES, st, c);
|
|
Logic.endCivTurn(RULES, st, c);
|
|
}
|
|
// Stand in for the scene: answer one audience per human turn.
|
|
const req = (st.pendingRequests ?? []).shift();
|
|
if (req && Diplo.requestValid(RULES, st, req)) {
|
|
if (req.from === 1) log.kinds.add(req.kind);
|
|
Diplo.resolveRequest(RULES, st, req, policy === 'accept');
|
|
}
|
|
for (const e of st.events) {
|
|
if (e.type === 'treatyRenounced' && e.from === 1) log.renounced = true;
|
|
if (e.type === 'war' && e.a === 1 && e.b === 0) log.war = true;
|
|
}
|
|
}
|
|
return { st, log };
|
|
};
|
|
|
|
const refused = play('refuse');
|
|
check('a spurned ally asks for favours first', refused.log.kinds.has('joinWar'));
|
|
check('refusals eventually turn into compensation demands',
|
|
refused.log.kinds.has('demandGold') || refused.log.kinds.has('demandTech'),
|
|
[...refused.log.kinds].join(','));
|
|
check('a leader pushed far enough renounces the treaty', refused.log.renounced);
|
|
check('and follows it to war', refused.log.war
|
|
|| refused.st.civs[1].relations[0] === 'war');
|
|
|
|
const obliged = play('accept');
|
|
check('an obliging partner is never driven to demands',
|
|
!obliged.log.kinds.has('demandGold') && !obliged.log.kinds.has('demandTech'),
|
|
[...obliged.log.kinds].join(','));
|
|
check('an obliging partner keeps the alliance', obliged.st.civs[1].relations[0] === 'alliance'
|
|
&& !obliged.log.renounced);
|
|
}
|
|
|
|
// --- fuzz: issuing and resolving requests never corrupts the diplomatic state
|
|
{
|
|
const st = makeFlatState({ civs: 4 });
|
|
st.rngState = 909090;
|
|
st.civs.forEach((c) => { c.human = false; });
|
|
for (const c of st.civs) { c.gold = 200; c.known.alphabet = c.id % 2 === 0; c.known.pottery = c.id % 2 === 1; }
|
|
const legalStates = new Set(['nocontact', 'contact', 'war', 'ceasefire', 'peace', 'alliance']);
|
|
let ok = true;
|
|
let why = '';
|
|
const rounds = QUICK ? 200 : 800;
|
|
for (let i = 0; i < rounds && ok; i += 1) {
|
|
const a = Logic.randInt(st, 4);
|
|
let b = Logic.randInt(st, 4);
|
|
if (a === b) b = (b + 1) % 4;
|
|
const roll = Logic.rand(st);
|
|
if (roll < 0.15) Logic.declareWar(RULES, st, a, b);
|
|
else if (roll < 0.3) Logic.applyTreaty(st, a, b, ['ceasefire', 'peace', 'alliance'][Logic.randInt(st, 3)]);
|
|
else if (roll < 0.4) Diplo.escalateFrustration(RULES, st, a, b);
|
|
else if (roll < 0.5) Diplo.checkPledges(RULES, st, a);
|
|
else if (roll < 0.6) Logic.updateAttitudes(RULES, st, a);
|
|
else if (roll < 0.7) { st.turn += 1; Diplo.considerGift(RULES, st, a, b); } else {
|
|
const req = Diplo.considerRequest(RULES, st, a, b);
|
|
if (req) Diplo.resolveRequest(RULES, st, req, Diplo.aiWouldAccept(RULES, st, req));
|
|
}
|
|
for (const civ of st.civs) {
|
|
for (const [other, rel] of Object.entries(civ.relations)) {
|
|
if (!legalStates.has(rel)) { ok = false; why = `illegal relation ${rel}`; }
|
|
if (st.civs[other].relations[civ.id] !== rel) { ok = false; why = 'asymmetric relations'; }
|
|
}
|
|
for (const v of Object.values(civ.frustration ?? {})) {
|
|
if (!(v >= 0 && v <= 100)) { ok = false; why = `frustration ${v}`; }
|
|
}
|
|
for (const v of Object.values(civ.attitude)) {
|
|
if (!(v >= -100 && v <= 100)) { ok = false; why = `attitude ${v}`; }
|
|
}
|
|
if (civ.gold < 0) { ok = false; why = 'negative gold'; }
|
|
}
|
|
}
|
|
check('fuzz: request traffic keeps diplomacy consistent', ok, why);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('7. spaceship');
|
|
|
|
if (RULES) {
|
|
const st = makeFlatState({ civs: 2 });
|
|
const civ = st.civs[0];
|
|
check('launch blocked without parts', !Logic.launchSpaceship(RULES, st, civ));
|
|
civ.spaceship.structural = 8;
|
|
civ.spaceship.component = 4;
|
|
civ.spaceship.module = 2;
|
|
check('launch blocked missing modules', !Logic.launchSpaceship(RULES, st, civ));
|
|
civ.spaceship.module = 3;
|
|
check('launch succeeds with full parts', Logic.launchSpaceship(RULES, st, civ));
|
|
check('arrival scheduled', civ.spaceship.arrivalTurn === st.turn + RULES.spaceship.travelTurns);
|
|
check('double launch blocked', !Logic.launchSpaceship(RULES, st, civ));
|
|
|
|
// Countdown to victory via endCivTurn wrapping.
|
|
for (let i = 0; i < RULES.spaceship.travelTurns + 1 && !st.over; i += 1) {
|
|
Logic.endCivTurn(RULES, st, 0);
|
|
Logic.endCivTurn(RULES, st, 1);
|
|
}
|
|
check('spaceship arrival wins', st.over?.type === 'spaceship' && st.over.winner === 0);
|
|
|
|
// Capital capture kills the ship.
|
|
{
|
|
const st2 = makeFlatState({ civs: 2 });
|
|
setWar(st2, 0, 1);
|
|
const cap = Logic.foundCity(RULES, st2, Logic.spawnUnit(RULES, st2, 1, 'settlers', 5, 5, null));
|
|
Logic.foundCity(RULES, st2, Logic.spawnUnit(RULES, st2, 1, 'settlers', 10, 10, null));
|
|
const civ1 = st2.civs[1];
|
|
civ1.spaceship = { structural: 8, component: 4, module: 3, launched: false, arrivalTurn: 0 };
|
|
Logic.launchSpaceship(RULES, st2, civ1);
|
|
const tank = Logic.spawnUnit(RULES, st2, 0, 'armor', 4, 5, null);
|
|
Logic.tryMove(RULES, st2, tank, 1, 0);
|
|
check('capital captured', cap.civ === 0);
|
|
check('spaceship lost with capital', !civ1.spaceship.launched
|
|
&& civ1.spaceship.structural === 0);
|
|
check('game continues (civ lives on)', civ1.alive && !st2.over);
|
|
}
|
|
|
|
// Spaceship parts respect their caps in the build list.
|
|
{
|
|
const st3 = makeFlatState();
|
|
const civ0 = st3.civs[0];
|
|
civ0.known.spaceflight = true;
|
|
const city = Logic.foundCity(RULES, st3, Logic.spawnUnit(RULES, st3, 0, 'settlers', 5, 5, null));
|
|
let avail = Logic.availableUnits(RULES, st3, civ0, city).map((u) => u.id);
|
|
check('structural buildable with tech', avail.includes('ssstructural'));
|
|
check('component gated on plastics', !avail.includes('sscomponent'));
|
|
civ0.spaceship.structural = 8;
|
|
avail = Logic.availableUnits(RULES, st3, civ0, city).map((u) => u.id);
|
|
check('structural capped at 8', !avail.includes('ssstructural'));
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('8. serialization');
|
|
|
|
if (RULES) {
|
|
const leaders = [{ id: 'steve', name: 'Steve' }, { id: 'gerome', name: 'Gerome' },
|
|
{ id: 'jerry', name: 'Jerry' }];
|
|
const st = Logic.createGame(RULES, { sizeId: 'small', seed: 11, difficultyId: 'prince', leaders });
|
|
// Play a few scripted turns.
|
|
for (let t = 0; t < 5; t += 1) {
|
|
for (let c = 0; c < st.civs.length; c += 1) {
|
|
Logic.beginCivTurn(RULES, st, c);
|
|
for (const u of Logic.civUnits(st, c)) {
|
|
if (u.type === 'settlers' && Logic.canFoundCity(RULES, st, u.x, u.y)) {
|
|
Logic.foundCity(RULES, st, u);
|
|
} else if (u.mp > 0) {
|
|
Logic.tryMove(RULES, st, u, (t + c) % 3 - 1, (t * c) % 3 - 1);
|
|
}
|
|
}
|
|
Logic.endCivTurn(RULES, st, c);
|
|
}
|
|
}
|
|
const json = Logic.serialize(st);
|
|
const st2 = Logic.deserialize(json);
|
|
check('round trip parses', !!st2);
|
|
check('round trip identical', Logic.serialize(st2) === json);
|
|
check('hash stable', Logic.hashState(st) === Logic.hashState(st2));
|
|
check('version mismatch rejected', Logic.deserialize(JSON.stringify({ version: 99 })) === null);
|
|
|
|
// Determinism: same seed + same script => same hash.
|
|
const stA = Logic.createGame(RULES, { sizeId: 'small', seed: 77, difficultyId: 'king', leaders });
|
|
const stB = Logic.createGame(RULES, { sizeId: 'small', seed: 77, difficultyId: 'king', leaders });
|
|
check('createGame deterministic', Logic.hashState(stA) === Logic.hashState(stB));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('5+9. AI self-play soak (+ research pacing)');
|
|
|
|
if (RULES) {
|
|
const LEADER_POOL = ['steve', 'gerome', 'jerry', 'aiko', 'natasha', 'brad', 'cybro']
|
|
.map((id) => ({ id, name: id[0].toUpperCase() + id.slice(1) }));
|
|
|
|
function checkInvariants(st, label) {
|
|
for (const civ of st.civs) {
|
|
if (civ.gold < 0 || Number.isNaN(civ.gold)) return `${label}: negative/NaN gold civ ${civ.id}`;
|
|
if (civ.beakers < 0) return `${label}: negative beakers`;
|
|
}
|
|
for (const c of st.cities) {
|
|
if (c.size < 1) return `${label}: city size ${c.size}`;
|
|
if (!st.civs[c.civ].alive) return `${label}: city owned by dead civ`;
|
|
const seen = new Set();
|
|
for (const t of c.worked) {
|
|
if (seen.has(t)) return `${label}: duplicate worked tile`;
|
|
seen.add(t);
|
|
}
|
|
}
|
|
for (const u of st.units) {
|
|
if (!Logic.inBounds(st.world, u.x, u.y)) return `${label}: unit off map`;
|
|
if (u.hp <= 0) return `${label}: dead unit alive`;
|
|
const def = RULES.units[u.type];
|
|
const terr = Logic.terrainAt(RULES, st.world, u.x, u.y);
|
|
if (def.domain === 'land' && terr.water && !u.carriedBy) return `${label}: land unit swimming`;
|
|
if (def.domain === 'sea' && !terr.water && !Logic.cityAt(st, u.x, u.y)) return `${label}: ship aground`;
|
|
if (!st.civs[u.civ].alive) return `${label}: unit of dead civ`;
|
|
}
|
|
// Worked tiles disjoint across cities.
|
|
const workedAll = new Set();
|
|
for (const c of st.cities) {
|
|
for (const t of c.worked) {
|
|
if (workedAll.has(t)) return `${label}: worked tile shared between cities`;
|
|
workedAll.add(t);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Raised from 600 (2026-07-16) after wiring aiProdBonus into AI shield
|
|
// output: Chieftain/Warlord's genuine <1.0 production handicap now slows
|
|
// self-play pacing enough that many mixed-difficulty games needed more
|
|
// runway to reach any victory within the cap (confirmed via a scratchpad
|
|
// diagnostic: 8/30 decided at 600 vs 24/30 at 1000).
|
|
function runGame(gameIdx, { sizeId, numCivs, difficultyId, seed, turnCap = 1000 }) {
|
|
const leaders = LEADER_POOL.slice(0, numCivs);
|
|
const st = Logic.createGame(RULES, { sizeId, seed, difficultyId, leaders, humanIndex: -1 });
|
|
let invariantErr = null;
|
|
let aiTime = 0;
|
|
let aiTurns = 0;
|
|
let firstSpaceflight = null;
|
|
while (!st.over && st.turn < turnCap) {
|
|
const c = st.current;
|
|
Logic.beginCivTurn(RULES, st, c);
|
|
const t0 = performance.now();
|
|
AI.runAITurn(RULES, st, c);
|
|
aiTime += performance.now() - t0;
|
|
aiTurns += 1;
|
|
Logic.endCivTurn(RULES, st, c);
|
|
if (!firstSpaceflight && st.civs.some((cv) => cv.known.spaceflight)) {
|
|
firstSpaceflight = st.turn;
|
|
}
|
|
if (st.turn % 50 === 0 && !invariantErr) {
|
|
invariantErr = checkInvariants(st, `game ${gameIdx} turn ${st.turn}`);
|
|
}
|
|
}
|
|
if (!invariantErr) invariantErr = checkInvariants(st, `game ${gameIdx} final`);
|
|
return { st, invariantErr, avgAiMs: aiTime / Math.max(1, aiTurns), firstSpaceflight };
|
|
}
|
|
|
|
const games = [];
|
|
const N = QUICK ? 6 : 28;
|
|
const sizes = ['small', 'medium', 'small', 'medium'];
|
|
const diffs = ['chieftain', 'warlord', 'prince', 'king', 'emperor'];
|
|
const configs = [];
|
|
for (let g = 0; g < N; g += 1) {
|
|
configs.push({
|
|
sizeId: sizes[g % sizes.length],
|
|
numCivs: 3 + (g % 3),
|
|
difficultyId: diffs[g % diffs.length],
|
|
seed: 1000 + g * 17,
|
|
});
|
|
}
|
|
// Pinned seeds known to end in conquest (deterministic engine), so the
|
|
// victory-mix coverage below cannot flake on an all-peaceful draw. Re-picked
|
|
// 2026-07-16 after wiring aiProdBonus into AI shield output (previously a
|
|
// dead field) changed game pacing enough to shift the old 7077/8088 seeds
|
|
// off a conquest outcome within turnCap.
|
|
configs.push({ sizeId: 'small', numCivs: 4, difficultyId: 'emperor', seed: 7017 });
|
|
configs.push({ sizeId: 'small', numCivs: 4, difficultyId: 'king', seed: 8033 });
|
|
configs.forEach((cfg, g) => {
|
|
const out = runGame(g, cfg);
|
|
games.push({ cfg, ...out });
|
|
check(`game ${g} (${cfg.sizeId}/${cfg.numCivs}civ/${cfg.difficultyId}) no invariant breaks`,
|
|
out.invariantErr === null, out.invariantErr ?? '');
|
|
});
|
|
|
|
const finished = games.filter((g) => g.st.over);
|
|
const conquest = finished.filter((g) => g.st.over.type === 'conquest');
|
|
const space = finished.filter((g) => g.st.over.type === 'spaceship');
|
|
console.log(` ${finished.length}/${games.length} games decided `
|
|
+ `(${conquest.length} conquest, ${space.length} spaceship); `
|
|
+ `avg AI turn ${(games.reduce((a, g) => a + g.avgAiMs, 0) / games.length).toFixed(2)}ms`);
|
|
check('a healthy share of games reach a victory (>=30%)',
|
|
finished.length >= Math.ceil(games.length * 0.3), `${finished.length}/${games.length}`);
|
|
check('conquest victories occur', conquest.length > 0);
|
|
if (QUICK) {
|
|
console.log(' (--quick: spaceship coverage check runs in the full suite only)');
|
|
} else {
|
|
check('spaceship victories occur', space.length > 0, 'no spaceship win in suite');
|
|
}
|
|
check('AI turn time budget (<=50ms avg)', games.every((g) => g.avgAiMs <= 50),
|
|
`worst ${Math.max(...games.map((g) => g.avgAiMs)).toFixed(1)}ms`);
|
|
|
|
// Research pacing: someone should reach Space Flight in a sensible window.
|
|
const sfTurns = games.map((g) => g.firstSpaceflight).filter((t) => t !== null);
|
|
check('space flight reached in some games', sfTurns.length > 0);
|
|
if (sfTurns.length) {
|
|
const median = sfTurns.sort((a, b) => a - b)[Math.floor(sfTurns.length / 2)];
|
|
check('space flight window turn 150-600', median >= 150 && median <= 600, `median ${median}`);
|
|
}
|
|
|
|
// Determinism: replaying the same seed produces the same final hash.
|
|
{
|
|
const cfg = { sizeId: 'small', numCivs: 3, difficultyId: 'prince', seed: 4242, turnCap: 120 };
|
|
const a = runGame(-1, cfg);
|
|
const b = runGame(-2, cfg);
|
|
check('soak replay deterministic', Logic.hashState(a.st) === Logic.hashState(b.st));
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
console.log(`\n${passes} passed, ${failures} failed`);
|
|
if (failures > 0) process.exit(1);
|