1844 lines
73 KiB
JavaScript
1844 lines
73 KiB
JavaScript
// Master of Vega — the engine. Headless: no Phaser, importable by Node, so
|
|
// tools/verifyMasterOfVega.js can play whole games without a browser.
|
|
//
|
|
// Every function takes (rules, state, ...). `state` is plain JSON with the RNG
|
|
// cursor inside it, so serialising the state serialises the future too: replay
|
|
// a seed and you get the same galaxy, the same battles, the same winner.
|
|
//
|
|
// Economy model: MOO1's five allocation sliders, with MOO2 colony buildings
|
|
// acting as multipliers on the channel they name. The "Construction" channel
|
|
// funds the colony build queue (ships AND buildings); Industry builds factories;
|
|
// Ecology cleans industrial waste; Defence raises planetary defences; Research
|
|
// splits into the six tech fields.
|
|
|
|
import { generateGalaxy, parsecs } from './VegaGalaxyGen.js';
|
|
import { techCost } from './VegaRules.js';
|
|
import { designFor, bestComponents, markFor, refitCost } from './VegaShips.js';
|
|
import { createBattle, runBattle, resolveInvasion } from './VegaCombat.js';
|
|
import { breakStalemate, declareWar } from './VegaDiplomacy.js';
|
|
|
|
export const CHANNELS = ['ships', 'defense', 'industry', 'ecology', 'research'];
|
|
|
|
// --------------------------------------------------------------------------
|
|
// RNG — explicit state so it serialises with the game.
|
|
|
|
export function rand(state) {
|
|
let a = state.rngState | 0;
|
|
a = (a + 0x6d2b79f5) | 0;
|
|
state.rngState = a;
|
|
let t = Math.imul(a ^ (a >>> 15), 1 | a);
|
|
t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
|
|
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
|
|
}
|
|
export function randInt(state, n) { return Math.floor(rand(state) * n); }
|
|
|
|
export function attachRules(state, rules) { state.rules = rules; return state; }
|
|
|
|
const pushEvent = (state, ev) => {
|
|
state.events.push(ev);
|
|
if (state.events.length > 600) state.events = state.events.slice(-300);
|
|
};
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Lookups
|
|
|
|
export const empireColonies = (state, e) => state.colonies.filter((c) => c.empireIdx === e);
|
|
export const empireFleets = (state, e) => state.fleets.filter((f) => f.empireIdx === e);
|
|
export const colonyAt = (state, starIdx) => state.colonies.find((c) => c.starIdx === starIdx);
|
|
export const coloniesAt = (state, starIdx) => state.colonies.filter((c) => c.starIdx === starIdx);
|
|
export const fleetsAt = (state, starIdx) => state.fleets.filter((f) => f.starIdx === starIdx);
|
|
export const starOf = (state, i) => state.galaxy.stars[i];
|
|
export const planetOf = (state, colony) => state.galaxy.stars[colony.starIdx].planets[colony.orbit];
|
|
|
|
// designFor() runs a knapsack per call. The AI, the upkeep pass and the fleet
|
|
// panel all ask for the same handful of designs many times per turn, so they
|
|
// are memoised per empire and invalidated whenever a tech lands.
|
|
export function empireDesign(rules, state, e, hullId, skills = null) {
|
|
const emp = state.empires[e];
|
|
if (skills) return designFor(rules, emp.known, hullId, rules.species[emp.speciesId].traits, skills);
|
|
if (!emp._designs || emp._designsAt !== emp.techsKnown) {
|
|
emp._designs = {};
|
|
emp._designsAt = emp.techsKnown;
|
|
}
|
|
if (!emp._designs[hullId]) {
|
|
emp._designs[hullId] = designFor(rules, emp.known, hullId, rules.species[emp.speciesId].traits);
|
|
}
|
|
return emp._designs[hullId];
|
|
}
|
|
|
|
export function empireComponents(rules, state, e) {
|
|
const emp = state.empires[e];
|
|
if (!emp._comps || emp._compsAt !== emp.techsKnown) {
|
|
emp._comps = bestComponents(rules, emp.known);
|
|
emp._compsAt = emp.techsKnown;
|
|
}
|
|
return emp._comps;
|
|
}
|
|
|
|
// Leader skill bags, merged. Admins bind to one colony; captains bind to a
|
|
// fleet. Anything unassigned still costs upkeep but does nothing, which is the
|
|
// player's problem.
|
|
export function colonyLeaderSkills(rules, state, colony) {
|
|
const emp = state.empires[colony.empireIdx];
|
|
const l = emp.leaders.find((x) => x.assignKind === 'colony' && x.assignId === colony.id);
|
|
return l ? rules.leaders[l.leaderId].skills : {};
|
|
}
|
|
export function fleetLeaderSkills(rules, state, fleet) {
|
|
const emp = state.empires[fleet.empireIdx];
|
|
const l = emp.leaders.find((x) => x.assignKind === 'fleet' && x.assignId === fleet.id);
|
|
return l ? rules.leaders[l.leaderId].skills : {};
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Colony derived numbers
|
|
|
|
export function buildingMult(rules, colony, channel) {
|
|
let m = 1;
|
|
for (const bid of colony.buildings) {
|
|
const b = rules.buildings[bid];
|
|
if (b && b.channel === channel) m *= b.mult;
|
|
}
|
|
return m;
|
|
}
|
|
function buildingEffect(rules, colony, key) {
|
|
let total = 0;
|
|
for (const bid of colony.buildings) {
|
|
const v = rules.buildings[bid]?.effects?.[key];
|
|
if (typeof v === 'number') total += v;
|
|
}
|
|
return total;
|
|
}
|
|
function buildingEffectMult(rules, colony, key) {
|
|
let m = 1;
|
|
for (const bid of colony.buildings) {
|
|
const v = rules.buildings[bid]?.effects?.[key];
|
|
if (typeof v === 'number') m *= v;
|
|
}
|
|
return m;
|
|
}
|
|
|
|
export function colonyMaxPop(rules, state, colony) {
|
|
const emp = state.empires[colony.empireIdx];
|
|
const spec = rules.species[emp.speciesId];
|
|
const planet = planetOf(state, colony);
|
|
const comps = empireComponents(rules, state, colony.empireIdx);
|
|
const skills = colonyLeaderSkills(rules, state, colony);
|
|
const base = planet.basePop * spec.traits.maxPopMult;
|
|
const bonus = comps.maxPopBonus + buildingEffect(rules, colony, 'maxPopBonus') + (skills.maxPopBonus ?? 0);
|
|
const raw = base + bonus;
|
|
// Uncleaned industrial waste poisons the biosphere; Lithox never generate any.
|
|
const penalty = Math.min(0.75, colony.waste / Math.max(1, planet.basePop * 2));
|
|
return Math.max(1, Math.round(raw * (1 - penalty)));
|
|
}
|
|
|
|
export function colonyFactoryCap(rules, state, colony) {
|
|
const emp = state.empires[colony.empireIdx];
|
|
const spec = rules.species[emp.speciesId];
|
|
return Math.round(colony.pop * spec.traits.factoriesPerPop);
|
|
}
|
|
|
|
// Population runs a colony's factories, so a colony that shrinks cannot work
|
|
// all of them. The surplus is mothballed rather than demolished — it neither
|
|
// produces nor pollutes, and comes back if the population recovers. Without
|
|
// this, a colony that loses population keeps generating waste from factories
|
|
// nobody is left to staff, which is a death spiral it can never escape.
|
|
export function effectiveFactories(rules, state, colony) {
|
|
return Math.min(colony.factories, colonyFactoryCap(rules, state, colony));
|
|
}
|
|
|
|
export function colonyProduction(rules, state, colony) {
|
|
const emp = state.empires[colony.empireIdx];
|
|
const spec = rules.species[emp.speciesId];
|
|
const planet = planetOf(state, colony);
|
|
const rich = rules.richness[planet.richId]?.industryMult ?? 1;
|
|
const skills = colonyLeaderSkills(rules, state, colony);
|
|
const eco = rules.economy;
|
|
const fromPop = colony.pop * eco.popOutput;
|
|
const fromFactories = effectiveFactories(rules, state, colony) * eco.factoryOutput * rich
|
|
* spec.traits.industryMult
|
|
* buildingMult(rules, colony, 'industry')
|
|
* (skills.industryMult ?? 1);
|
|
return fromPop + fromFactories;
|
|
}
|
|
|
|
export function colonyDefenseCap(rules, state, colony) {
|
|
const comps = empireComponents(rules, state, colony.empireIdx);
|
|
return Math.round((100 + comps.planetaryShield * 30) * buildingMult(rules, colony, 'defense'));
|
|
}
|
|
|
|
/**
|
|
* BC per turn actually reaching the build queue, used for the "N turns" figures
|
|
* the colony screen quotes. That is the `ships` share PLUS the two spillovers
|
|
* `processColony` folds in: industry whose factories are already capped, and
|
|
* defence whose batteries are already topped up.
|
|
*
|
|
* It has to live here rather than in a view because two different screens quote
|
|
* the same ETA and they must agree. It is an estimate by nature — mandatory
|
|
* ecology cleanup is taken pro-rata off every channel first, and how much that
|
|
* costs depends on waste generated during the turn — so it is deliberately
|
|
* quoted before cleanup rather than trying to predict it.
|
|
*/
|
|
export function colonyBuildRate(rules, state, colony) {
|
|
const prod = colonyProduction(rules, state, colony);
|
|
let rate = prod * (colony.sliders.ships ?? 0);
|
|
if (colony.factories >= colonyFactoryCap(rules, state, colony)) {
|
|
rate += prod * (colony.sliders.industry ?? 0);
|
|
}
|
|
if (colony.defenseHp >= colonyDefenseCap(rules, state, colony)) {
|
|
rate += prod * (colony.sliders.defense ?? 0);
|
|
}
|
|
return Math.max(0, rate);
|
|
}
|
|
|
|
/** Turns for a queue item to finish at the current rate, or Infinity if idle. */
|
|
export function queueItemEta(rules, state, colony, item, alreadyQueued = 0) {
|
|
const rate = colonyBuildRate(rules, state, colony);
|
|
if (rate <= 0) return Infinity;
|
|
const remaining = queueItemCost(rules, state, colony, item) - (item.progress ?? 0);
|
|
return Math.max(1, Math.ceil((alreadyQueued + remaining) / rate));
|
|
}
|
|
|
|
/**
|
|
* Turns until each queue entry finishes, CUMULATIVE down the queue — the engine
|
|
* spends on `queue[0]` alone, so an item's ETA includes everything ahead of it.
|
|
* Indexed to match `colony.queue`, so a collapsed run reads its figure off its
|
|
* own `lastIndex`. Both the colony screen and the system view quote these and
|
|
* they have to agree, which is why it is here rather than in either view.
|
|
*/
|
|
export function queueEtas(rules, state, colony) {
|
|
const rate = colonyBuildRate(rules, state, colony);
|
|
let acc = 0;
|
|
return colony.queue.map((item) => {
|
|
acc += Math.max(0, queueItemCost(rules, state, colony, item) - (item.progress ?? 0));
|
|
return rate > 0 ? Math.max(1, Math.ceil(acc / rate)) : Infinity;
|
|
});
|
|
}
|
|
|
|
export function colonyTrade(rules, state, colony) {
|
|
const emp = state.empires[colony.empireIdx];
|
|
const spec = rules.species[emp.speciesId];
|
|
const skills = colonyLeaderSkills(rules, state, colony);
|
|
const eco = rules.economy;
|
|
return colony.pop * eco.tradePerPop
|
|
* spec.traits.tradeMult
|
|
* buildingEffectMult(rules, colony, 'tradeMult')
|
|
* (skills.tradeMult ?? 1)
|
|
+ buildingEffect(rules, colony, 'tradeBonus');
|
|
}
|
|
|
|
export function colonyGroundDefense(rules, state, colony) {
|
|
const emp = state.empires[colony.empireIdx];
|
|
const spec = rules.species[emp.speciesId];
|
|
const comps = empireComponents(rules, state, colony.empireIdx);
|
|
const skills = colonyLeaderSkills(rules, state, colony);
|
|
const planet = planetOf(state, colony);
|
|
const grav = rules.gravity[planet.gravId];
|
|
// High gravity punishes attackers and defenders alike unless you were born
|
|
// on a heavy world.
|
|
const gravMod = spec.traits.highGravityOk ? 0 : (grav?.combatMod ?? 0);
|
|
return (spec.traits.groundDefense ?? 0)
|
|
+ (comps.groundDefense ?? 0)
|
|
+ buildingEffect(rules, colony, 'groundDefense')
|
|
+ (skills.groundDefense ?? 0)
|
|
+ gravMod;
|
|
}
|
|
|
|
// Can this empire settle this planet at all?
|
|
export function canColonize(rules, state, e, starIdx, orbit) {
|
|
if (colonyAt(state, starIdx) && coloniesAt(state, starIdx).some((c) => c.orbit === orbit)) return false;
|
|
return habitableForEmpire(rules, state, e, starIdx, orbit);
|
|
}
|
|
|
|
// Whether this planet is within an empire's current colonisation reach —
|
|
// type + hostility vs. current planetology tech — regardless of whether it is
|
|
// already settled. Split out of canColonize so the star map and tooltip's "N
|
|
// habitable" readout can match what the colony screen actually offers instead
|
|
// of just the planet type's static colonizable flag (which ignores tech and
|
|
// made "1 habitable" show even for worlds too hostile to settle yet).
|
|
export function habitableForEmpire(rules, state, e, starIdx, orbit) {
|
|
const planet = state.galaxy.stars[starIdx]?.planets?.[orbit];
|
|
if (!planet) return false;
|
|
const type = rules.planetTypes[planet.typeId];
|
|
if (!type.colonizable) return false;
|
|
const emp = state.empires[e];
|
|
const spec = rules.species[emp.speciesId];
|
|
if (spec.traits.colonizeAnything) return true;
|
|
const comps = empireComponents(rules, state, e);
|
|
return type.hostility <= comps.colonizeHostility;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Range — the star map's "range as light", and the engine's movement rule.
|
|
|
|
// Every star within fuel range of a colony or star base. Recomputed lazily and
|
|
// cached per turn; the AI asks for it constantly.
|
|
export function reachableStars(rules, state, e) {
|
|
const emp = state.empires[e];
|
|
if (emp._rangeAt === state.turn && emp._range) return emp._range;
|
|
const comps = empireComponents(rules, state, e);
|
|
let range = comps.fuelRange;
|
|
const sources = [];
|
|
for (const c of empireColonies(state, e)) {
|
|
sources.push(c.starIdx);
|
|
if (c.buildings.includes('starbase')) range = Math.max(range, comps.fuelRange + (rules.economy.starbaseRangeBonus ?? 3));
|
|
}
|
|
for (const f of empireFleets(state, e)) {
|
|
if (f.starIdx >= 0 && f.ships.some((s) => s.hullId === 'starbase')) sources.push(f.starIdx);
|
|
}
|
|
const out = {};
|
|
for (const src of sources) {
|
|
for (let i = 0; i < state.galaxy.stars.length; i += 1) {
|
|
if (out[i]) continue;
|
|
if (parsecs(state.galaxy, src, i) <= range + 1e-9) out[i] = true;
|
|
}
|
|
}
|
|
emp._range = out;
|
|
emp._rangeAt = state.turn;
|
|
return out;
|
|
}
|
|
|
|
export function fleetSpeed(rules, state, fleet) {
|
|
const emp = state.empires[fleet.empireIdx];
|
|
const spec = rules.species[emp.speciesId];
|
|
const skills = fleetLeaderSkills(rules, state, fleet);
|
|
// Immobile hulls (star bases) are SKIPPED, not disqualifying.
|
|
//
|
|
// Returning 0 for any fleet containing a star base looked reasonable and was
|
|
// catastrophic: a completed Star Base joins the fleet sitting over its own
|
|
// colony, that fleet is the empire's main battle fleet, and from that moment
|
|
// canSendFleet refused every order it was ever given. Measured over one game,
|
|
// 338 of 338 valid attacks — in range, strong enough, at war — were refused
|
|
// for this reason alone. No colony could ever be attacked, so no war could be
|
|
// won and conquest was unreachable. sendFleet() leaves the bases behind.
|
|
let speed = Infinity;
|
|
let mobile = 0;
|
|
for (const s of fleet.ships) {
|
|
if (s.count <= 0) continue;
|
|
const d = empireDesign(rules, state, fleet.empireIdx, s.hullId, Object.keys(skills).length ? skills : null);
|
|
if (d.immobile) continue;
|
|
mobile += 1;
|
|
speed = Math.min(speed, d.speed);
|
|
}
|
|
if (!mobile) return 0;
|
|
return Number.isFinite(speed) ? Math.max(1, speed) : 0;
|
|
}
|
|
|
|
export function fleetPower(rules, state, fleet) {
|
|
const emp = state.empires[fleet.empireIdx];
|
|
const spec = rules.species[emp.speciesId];
|
|
const skills = fleetLeaderSkills(rules, state, fleet);
|
|
let p = 0;
|
|
for (const s of fleet.ships) {
|
|
if (s.count <= 0) continue;
|
|
const d = empireDesign(rules, state, fleet.empireIdx, s.hullId, Object.keys(skills).length ? skills : null);
|
|
if (d.role !== 'warship' && d.role !== 'base') continue;
|
|
p += s.count * (d.hp + d.damage * 4);
|
|
}
|
|
return Math.round(p);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Game creation
|
|
|
|
function rollTechAvailability(state, rules, emp, spec) {
|
|
const available = {};
|
|
// A species that "can research anything" gets the whole tree; everyone else
|
|
// rolls per tech, weighted by how naturally the field comes to them. Because
|
|
// the chains are linear, an unavailable tech does NOT block the rest of its
|
|
// field — research simply skips it (see nextResearchTarget), and the only way
|
|
// to ever own it is trade, conquest or espionage. That is MOO1's rule and it
|
|
// is what makes tech trading matter.
|
|
const openAll = spec.traits.researchMult >= 2;
|
|
for (const t of rules.techList) {
|
|
if (t.tier === 0 || openAll) { available[t.id] = true; continue; }
|
|
const affinity = spec.techAffinity[t.field] ?? 1;
|
|
const chance = Math.max(0.3, Math.min(1, 0.55 * affinity + 0.2));
|
|
available[t.id] = rand(state) < chance;
|
|
}
|
|
return available;
|
|
}
|
|
|
|
export function createGame(rules, opts) {
|
|
const {
|
|
sizeId = 'medium', shapeId = 'spiral', seed = 1, difficultyId = 'normal',
|
|
speciesIds = ['human', 'kkrix', 'rrashaa'], humanIndex = 0,
|
|
} = opts;
|
|
|
|
const state = {
|
|
version: 1,
|
|
rules: null,
|
|
seed,
|
|
rngState: (seed * 2654435761) | 0,
|
|
sizeId, shapeId, difficultyId,
|
|
turn: 0,
|
|
current: 0,
|
|
humanIndex,
|
|
galaxy: null,
|
|
empires: [],
|
|
colonies: [],
|
|
fleets: [],
|
|
nextColonyId: 0,
|
|
nextFleetId: 0,
|
|
events: [],
|
|
council: { nextTurn: rules.council.firstTurn, lastResult: null, history: [] },
|
|
over: false,
|
|
winnerIdx: -1,
|
|
victoryKind: null,
|
|
};
|
|
|
|
state.galaxy = generateGalaxy(rules, { sizeId, shapeId, seed, speciesIds });
|
|
const diff = rules.difficulties[difficultyId];
|
|
|
|
speciesIds.forEach((sid, e) => {
|
|
const spec = rules.species[sid];
|
|
const emp = {
|
|
idx: e,
|
|
speciesId: sid,
|
|
name: spec.name,
|
|
color: spec.color,
|
|
alive: true,
|
|
isHuman: e === humanIndex,
|
|
homeStar: state.galaxy.homeIdx[e],
|
|
known: {},
|
|
available: {},
|
|
techsKnown: 0,
|
|
knownInField: { computers: 0, construction: 0, forcefields: 0, planetology: 0, propulsion: 0, weapons: 0 },
|
|
researching: {},
|
|
alloc: {},
|
|
beakers: {},
|
|
bc: rules.economy.startingBC,
|
|
leaders: [],
|
|
contacted: {},
|
|
treaties: {},
|
|
attitude: {},
|
|
pendingOffers: {},
|
|
explored: {},
|
|
spyPoints: 0,
|
|
totalPop: 0,
|
|
_comps: null, _compsAt: -1, _range: null, _rangeAt: -1, _designs: null, _designsAt: -1,
|
|
};
|
|
// Research starts spread evenly across the six fields.
|
|
const fields = Object.keys(rules.techFields);
|
|
for (const f of fields) { emp.alloc[f] = 1 / fields.length; emp.beakers[f] = 0; emp.researching[f] = null; }
|
|
emp.available = rollTechAvailability(state, rules, emp, spec);
|
|
state.empires.push(emp);
|
|
});
|
|
|
|
// Mutual ignorance to start; attitudes are neutral except where a species is
|
|
// simply disliked on sight.
|
|
for (const a of state.empires) {
|
|
for (const b of state.empires) {
|
|
if (a.idx === b.idx) continue;
|
|
a.treaties[b.idx] = 'none';
|
|
const spec = rules.species[a.speciesId];
|
|
a.attitude[b.idx] = Math.round((spec.traits.diplomacy ?? 0) / 4);
|
|
}
|
|
}
|
|
|
|
// Homeworlds.
|
|
speciesIds.forEach((sid, e) => {
|
|
const starIdx = state.galaxy.homeIdx[e];
|
|
const colony = foundColony(rules, state, e, starIdx, 0, rules.economy.startingPop);
|
|
colony.factories = rules.economy.startingFactories;
|
|
colony.capital = true;
|
|
state.empires[e].explored[starIdx] = true;
|
|
checkContactAt(rules, state, starIdx);
|
|
// Everything else starts unexplored — a scout has to physically arrive
|
|
// (see moveFleets' `explored[f.starIdx] = true`) before its details show.
|
|
// Starting fleet: a scout and a colony ship, plus difficulty handicap ships.
|
|
const bonus = e === humanIndex ? 0 : diff.aiStartBonus;
|
|
addFleet(rules, state, e, starIdx, [
|
|
{ hullId: 'scout', mark: 1, count: 1 + bonus },
|
|
{ hullId: 'colonyship', mark: 1, count: 1 },
|
|
...(bonus > 0 ? [{ hullId: 'frigate', mark: 1, count: bonus * 2 }] : []),
|
|
]);
|
|
});
|
|
|
|
recomputeTotals(rules, state);
|
|
return state;
|
|
}
|
|
|
|
export function foundColony(rules, state, e, starIdx, orbit, pop) {
|
|
const colony = {
|
|
id: state.nextColonyId += 1,
|
|
empireIdx: e,
|
|
starIdx,
|
|
orbit,
|
|
pop,
|
|
factories: 0,
|
|
waste: 0,
|
|
defenseHp: 0,
|
|
buildings: [],
|
|
queue: [],
|
|
capital: false,
|
|
sliders: { ships: 0.2, defense: 0.1, industry: 0.4, ecology: 0.1, research: 0.2 },
|
|
locked: {},
|
|
founded: state.turn,
|
|
};
|
|
state.colonies.push(colony);
|
|
state.empires[e].explored[starIdx] = true;
|
|
return colony;
|
|
}
|
|
|
|
export function addFleet(rules, state, e, starIdx, ships) {
|
|
// Merge into an existing fleet at the same star rather than littering the map
|
|
// with one-ship fleets.
|
|
const existing = state.fleets.find((f) => f.empireIdx === e && f.starIdx === starIdx && f.toStar < 0);
|
|
if (existing) {
|
|
for (const s of ships) {
|
|
const m = existing.ships.find((x) => x.hullId === s.hullId && x.mark === s.mark);
|
|
if (m) m.count += s.count;
|
|
else existing.ships.push({ ...s });
|
|
}
|
|
return existing;
|
|
}
|
|
const fleet = {
|
|
id: state.nextFleetId += 1,
|
|
empireIdx: e,
|
|
starIdx,
|
|
fromStar: -1,
|
|
toStar: -1,
|
|
progress: 0,
|
|
total: 0,
|
|
ships: ships.map((s) => ({ ...s })),
|
|
};
|
|
state.fleets.push(fleet);
|
|
return fleet;
|
|
}
|
|
|
|
function cleanFleets(state) {
|
|
for (const f of state.fleets) f.ships = f.ships.filter((s) => s.count > 0);
|
|
state.fleets = state.fleets.filter((f) => f.ships.length > 0);
|
|
}
|
|
|
|
// Merge every idle fleet an empire has sitting in the same system. Ships
|
|
// completing while the local fleet happens to be in transit each spawn a new
|
|
// fleet, and over a long game that compounds into hundreds of one-ship stacks —
|
|
// which is both unreadable on the star map and quadratic work for the AI.
|
|
function consolidateFleets(rules, state, e) {
|
|
const byStar = new Map();
|
|
for (const f of state.fleets) {
|
|
if (f.empireIdx !== e || f.starIdx < 0 || f.toStar >= 0) continue;
|
|
// Key on mobility as well as location, so a star-base garrison never gets
|
|
// folded back into the battle fleet it was just split out of.
|
|
const mobile = fleetSpeed(rules, state, f) > 0;
|
|
const key = `${f.starIdx}|${mobile ? 'm' : 'g'}`;
|
|
const head = byStar.get(key);
|
|
if (!head) { byStar.set(key, f); continue; }
|
|
for (const s of f.ships) {
|
|
const m = head.ships.find((x) => x.hullId === s.hullId && x.mark === s.mark);
|
|
if (m) m.count += s.count;
|
|
else head.ships.push({ ...s });
|
|
}
|
|
f.ships = [];
|
|
}
|
|
cleanFleets(state);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Research
|
|
|
|
export function canResearch(rules, state, e, tech) {
|
|
const emp = state.empires[e];
|
|
if (emp.known[tech.id] || !emp.available[tech.id]) return false;
|
|
// Every lower tier in the field must be resolved — known, or rolled
|
|
// unavailable and therefore skipped.
|
|
for (const t of rules.techsByField[tech.field]) {
|
|
if (t.tier >= tech.tier) break;
|
|
if (!emp.known[t.id] && emp.available[t.id]) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
export function nextResearchTarget(rules, state, e, field) {
|
|
for (const t of rules.techsByField[field]) {
|
|
if (canResearch(rules, state, e, t)) return t.id;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
export function grantTech(rules, state, e, techId, source = 'research') {
|
|
const emp = state.empires[e];
|
|
if (emp.known[techId]) return false;
|
|
const tech = rules.techs[techId];
|
|
emp.known[techId] = true;
|
|
emp.available[techId] = true;
|
|
emp.techsKnown += 1;
|
|
emp.knownInField[tech.field] += 1;
|
|
emp._comps = null;
|
|
emp._compsAt = -1;
|
|
emp._range = null;
|
|
emp._rangeAt = -1;
|
|
emp._designs = null;
|
|
emp._designsAt = -1;
|
|
pushEvent(state, { type: 'techDone', empire: e, techId, source, turn: state.turn });
|
|
return true;
|
|
}
|
|
|
|
function processResearch(rules, state, e, beakers) {
|
|
const emp = state.empires[e];
|
|
const spec = rules.species[emp.speciesId];
|
|
for (const field of Object.keys(rules.techFields)) {
|
|
if (!emp.researching[field]) emp.researching[field] = nextResearchTarget(rules, state, e, field);
|
|
const targetId = emp.researching[field];
|
|
if (!targetId) continue;
|
|
emp.beakers[field] += beakers * (emp.alloc[field] ?? 0);
|
|
const tech = rules.techs[targetId];
|
|
const cost = techCost(rules, tech, emp.knownInField[field]);
|
|
if (emp.beakers[field] >= cost) {
|
|
emp.beakers[field] -= cost;
|
|
grantTech(rules, state, e, targetId);
|
|
emp.researching[field] = nextResearchTarget(rules, state, e, field);
|
|
}
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Colony turn
|
|
|
|
// Allocation with MOO1 spillover: a channel that cannot use its share passes it
|
|
// on rather than burning it. Industry that has maxed its factories feeds the
|
|
// build queue; a clean colony's ecology money becomes research. Without this,
|
|
// a developed colony quietly wastes most of its output.
|
|
function processColony(rules, state, colony) {
|
|
const e = colony.empireIdx;
|
|
const emp = state.empires[e];
|
|
const spec = rules.species[emp.speciesId];
|
|
const comps = empireComponents(rules, state, e);
|
|
const skills = colonyLeaderSkills(rules, state, colony);
|
|
const eco = rules.economy;
|
|
const prod = colonyProduction(rules, state, colony);
|
|
|
|
const share = {};
|
|
for (const ch of CHANNELS) share[ch] = prod * (colony.sliders[ch] ?? 0);
|
|
|
|
// --- Ecology: clean this turn's waste plus any backlog.
|
|
//
|
|
// Cleanup is MANDATORY. If the ecology slider does not cover it, the
|
|
// shortfall is taken pro-rata out of the other four channels — exactly the
|
|
// way MOO1's eco slider snaps up to the minimum on its own. Letting a colony
|
|
// simply not pay is a death spiral with no exit: unpaid waste cuts maximum
|
|
// population, the smaller population mothballs factories and produces less,
|
|
// which leaves even less to spend on the waste that is still there.
|
|
const wasteGen = effectiveFactories(rules, state, colony) * eco.wastePerFactory * spec.traits.ecologyMult;
|
|
const needUnits = colony.waste + wasteGen;
|
|
const costPerUnit = eco.wasteCleanupCost * comps.wasteMult
|
|
* buildingMult(rules, colony, 'ecology') * (skills.ecologyMult ?? 1);
|
|
let ecoSpill = 0;
|
|
if (needUnits <= 0 || costPerUnit <= 0) {
|
|
colony.waste = 0;
|
|
ecoSpill = share.ecology;
|
|
} else {
|
|
const cleanupCost = needUnits * costPerUnit;
|
|
if (share.ecology >= cleanupCost) {
|
|
colony.waste = 0;
|
|
ecoSpill = share.ecology - cleanupCost;
|
|
} else {
|
|
let shortfall = cleanupCost - share.ecology;
|
|
const donors = ['industry', 'ships', 'defense', 'research'];
|
|
const pool = donors.reduce((t, ch) => t + share[ch], 0);
|
|
if (pool > 0) {
|
|
const take = Math.min(shortfall, pool);
|
|
for (const ch of donors) {
|
|
share[ch] -= take * (share[ch] / pool);
|
|
}
|
|
shortfall -= take;
|
|
}
|
|
const paid = cleanupCost - shortfall;
|
|
colony.waste = Math.max(0, needUnits - paid / costPerUnit);
|
|
colony.ecoForced = Math.round(paid - share.ecology > 0 ? paid - Math.min(paid, prod * (colony.sliders.ecology ?? 0)) : 0);
|
|
}
|
|
}
|
|
|
|
// --- Industry: factories, capped by population.
|
|
const factoryCost = eco.factoryCost * comps.factoryCostMult;
|
|
const capF = colonyFactoryCap(rules, state, colony);
|
|
let indSpill = 0;
|
|
if (colony.factories >= capF) {
|
|
indSpill = share.industry;
|
|
} else {
|
|
const built = Math.min(capF - colony.factories, share.industry / factoryCost);
|
|
colony.factories += built;
|
|
indSpill = Math.max(0, share.industry - built * factoryCost);
|
|
}
|
|
|
|
// --- Defence: planetary batteries, capped by tech.
|
|
const capD = colonyDefenseCap(rules, state, colony);
|
|
let defSpill = 0;
|
|
if (colony.defenseHp >= capD) {
|
|
defSpill = share.defense;
|
|
} else {
|
|
const added = Math.min(capD - colony.defenseHp, share.defense);
|
|
colony.defenseHp += added;
|
|
defSpill = Math.max(0, share.defense - added);
|
|
}
|
|
|
|
// --- Construction: the build queue (ships and buildings).
|
|
let build = share.ships + indSpill + defSpill;
|
|
let buildSpill = 0;
|
|
let guard = 0;
|
|
while (build > 0 && colony.queue.length > 0 && guard < 20) {
|
|
guard += 1;
|
|
const item = colony.queue[0];
|
|
const cost = queueItemCost(rules, state, colony, item);
|
|
const need = cost - item.progress;
|
|
if (build >= need) {
|
|
build -= need;
|
|
completeQueueItem(rules, state, colony, item);
|
|
colony.queue.shift();
|
|
} else {
|
|
item.progress += build;
|
|
build = 0;
|
|
}
|
|
}
|
|
if (colony.queue.length === 0) buildSpill = build;
|
|
|
|
// --- Research absorbs everything left over.
|
|
const research = share.research + ecoSpill + buildSpill;
|
|
|
|
// --- Population.
|
|
const maxPop = colonyMaxPop(rules, state, colony);
|
|
const growth = colony.pop * eco.growthRateBase
|
|
* (1 - colony.pop / Math.max(1, maxPop))
|
|
* spec.traits.growthMult
|
|
* buildingEffectMult(rules, colony, 'growthMult')
|
|
* (skills.growthMult ?? 1);
|
|
colony.pop = Math.max(0.5, Math.min(maxPop, colony.pop + growth));
|
|
|
|
return { research, trade: colonyTrade(rules, state, colony) };
|
|
}
|
|
|
|
export function queueItemCost(rules, state, colony, item) {
|
|
const emp = state.empires[colony.empireIdx];
|
|
const spec = rules.species[emp.speciesId];
|
|
if (item.kind === 'building') return rules.buildings[item.id].cost;
|
|
return empireDesign(rules, state, colony.empireIdx, item.id).cost;
|
|
}
|
|
|
|
function completeQueueItem(rules, state, colony, item) {
|
|
const e = colony.empireIdx;
|
|
if (item.kind === 'building') {
|
|
if (!colony.buildings.includes(item.id)) colony.buildings.push(item.id);
|
|
pushEvent(state, { type: 'buildingDone', empire: e, colonyId: colony.id, buildingId: item.id, starIdx: colony.starIdx, turn: state.turn });
|
|
return;
|
|
}
|
|
const emp = state.empires[e];
|
|
const mark = markFor(rules, emp.known);
|
|
if (item.id === 'starbase') {
|
|
if (!colony.buildings.includes('starbase')) colony.buildings.push('starbase');
|
|
emp._range = null; emp._rangeAt = -1;
|
|
}
|
|
addFleet(rules, state, e, colony.starIdx, [{ hullId: item.id, mark, count: 1 }]);
|
|
pushEvent(state, { type: 'shipDone', empire: e, colonyId: colony.id, hullId: item.id, starIdx: colony.starIdx, turn: state.turn });
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Empire turn
|
|
|
|
export function beginEmpireTurn(rules, state, e) {
|
|
const emp = state.empires[e];
|
|
if (!emp.alive) return;
|
|
const spec = rules.species[emp.speciesId];
|
|
const diff = rules.difficulties[state.difficultyId];
|
|
const comps = empireComponents(rules, state, e);
|
|
|
|
let research = 0;
|
|
let trade = 0;
|
|
let upkeep = 0;
|
|
for (const colony of empireColonies(state, e)) {
|
|
const r = processColony(rules, state, colony);
|
|
research += r.research;
|
|
trade += r.trade;
|
|
for (const bid of colony.buildings) upkeep += rules.buildings[bid]?.upkeep ?? 0;
|
|
}
|
|
// Fleets cost a fraction of their build cost every turn.
|
|
for (const f of empireFleets(state, e)) {
|
|
for (const s of f.ships) {
|
|
upkeep += empireDesign(rules, state, e, s.hullId).cost
|
|
* (rules.economy.shipUpkeepFraction ?? 0.02) * s.count;
|
|
}
|
|
}
|
|
for (const l of emp.leaders) upkeep += rules.leaders[l.leaderId].upkeep;
|
|
|
|
emp.bc = Math.max(0, emp.bc + trade - upkeep);
|
|
emp.lastIncome = trade - upkeep;
|
|
|
|
const researchMult = spec.traits.researchMult
|
|
* comps.researchMult
|
|
* (emp.isHuman ? diff.humanResearchMult : diff.aiResearchMult);
|
|
processResearch(rules, state, e, research * researchMult);
|
|
|
|
consolidateFleets(rules, state, e);
|
|
autoRefit(rules, state, e);
|
|
runEspionage(rules, state, e);
|
|
recomputeTotals(rules, state);
|
|
}
|
|
|
|
// Ships sitting over a friendly colony are brought up to the current Mark, paid
|
|
// for out of the reserve. This is the whole reason preset hulls still feel
|
|
// connected to the tech tree: research a better gun and your existing fleet
|
|
// visibly improves, with a report line to say so.
|
|
function autoRefit(rules, state, e) {
|
|
const emp = state.empires[e];
|
|
const spec = rules.species[emp.speciesId];
|
|
const mark = markFor(rules, emp.known);
|
|
for (const f of empireFleets(state, e)) {
|
|
if (f.starIdx < 0 || f.toStar >= 0) continue;
|
|
const colony = state.colonies.find((c) => c.starIdx === f.starIdx && c.empireIdx === e);
|
|
if (!colony) continue;
|
|
for (const s of f.ships) {
|
|
if (s.mark >= mark) continue;
|
|
const cost = refitCost(rules, emp.known, s.hullId, s.mark, spec.traits) * s.count;
|
|
if (emp.bc < cost) continue;
|
|
emp.bc -= cost;
|
|
const from = s.mark;
|
|
s.mark = mark;
|
|
pushEvent(state, {
|
|
type: 'refit', empire: e, starIdx: f.starIdx, hullId: s.hullId,
|
|
count: s.count, fromMark: from, toMark: mark, cost: Math.round(cost), turn: state.turn,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// Espionage is passive: a species with spies gets periodic attempts against
|
|
// empires it has met, and steals a tech it could not research itself.
|
|
function runEspionage(rules, state, e) {
|
|
const emp = state.empires[e];
|
|
const spec = rules.species[emp.speciesId];
|
|
const comps = empireComponents(rules, state, e);
|
|
let power = (spec.traits.espionage ?? 0) + comps.espionage;
|
|
for (const c of empireColonies(state, e)) power += buildingEffect(rules, c, 'espionage');
|
|
if (power <= 0) return;
|
|
|
|
// Only the surplus over a baseline counts. A Battle-Scanner-and-nothing-else
|
|
// empire is not a spy agency: crediting its raw score let EVERY empire steal
|
|
// its way to the full tech tree over a long game, which made the per-species
|
|
// availability roll — the whole reason tech trading exists — meaningless.
|
|
const net = power - 25;
|
|
if (net <= 0) return;
|
|
emp.spyPoints += net / 300;
|
|
if (emp.spyPoints < 1) return;
|
|
emp.spyPoints -= 1;
|
|
|
|
const targets = state.empires.filter((o) => o.alive && o.idx !== e
|
|
&& emp.contacted[o.idx] && emp.treaties[o.idx] !== 'alliance');
|
|
if (!targets.length) return;
|
|
const target = targets[randInt(state, targets.length)];
|
|
const tspec = rules.species[target.speciesId];
|
|
let defence = (tspec.traits.counterEspionage ?? 0) + empireComponents(rules, state, target.idx).counterEspionage;
|
|
for (const c of empireColonies(state, target.idx)) defence += buildingEffect(rules, c, 'espionage');
|
|
|
|
const odds = Math.max(0.05, Math.min(0.8, 0.4 + (power - defence) / 200));
|
|
if (rand(state) > odds) {
|
|
pushEvent(state, { type: 'spyCaught', empire: e, target: target.idx, turn: state.turn });
|
|
target.attitude[e] = (target.attitude[e] ?? 0) - 12;
|
|
return;
|
|
}
|
|
const stealable = rules.techList.filter((t) => target.known[t.id] && !emp.known[t.id]);
|
|
if (!stealable.length) return;
|
|
const tech = stealable[randInt(state, stealable.length)];
|
|
grantTech(rules, state, e, tech.id, 'espionage');
|
|
pushEvent(state, { type: 'techStolen', empire: e, target: target.idx, techId: tech.id, turn: state.turn });
|
|
target.attitude[e] = (target.attitude[e] ?? 0) - 8;
|
|
}
|
|
|
|
function recomputeTotals(rules, state) {
|
|
for (const emp of state.empires) emp.totalPop = 0;
|
|
for (const c of state.colonies) state.empires[c.empireIdx].totalPop += c.pop;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Movement, arrival, combat
|
|
|
|
export function canSendFleet(rules, state, fleet, toStar) {
|
|
if (fleet.toStar >= 0) return false;
|
|
if (fleet.starIdx === toStar) return false;
|
|
if (fleetSpeed(rules, state, fleet) <= 0) return false;
|
|
const reach = reachableStars(rules, state, fleet.empireIdx);
|
|
return !!reach[toStar];
|
|
}
|
|
|
|
export function sendFleet(rules, state, fleet, toStar) {
|
|
if (!canSendFleet(rules, state, fleet, toStar)) return false;
|
|
// Star bases defend the system they were built in and do not sail with the
|
|
// fleet; split them into a garrison that stays put.
|
|
const garrison = [];
|
|
fleet.ships = fleet.ships.filter((s) => {
|
|
const d = empireDesign(rules, state, fleet.empireIdx, s.hullId);
|
|
if (!d.immobile) return true;
|
|
garrison.push(s);
|
|
return false;
|
|
});
|
|
if (garrison.length) {
|
|
state.fleets.push({
|
|
id: state.nextFleetId += 1,
|
|
empireIdx: fleet.empireIdx,
|
|
starIdx: fleet.starIdx,
|
|
fromStar: -1, toStar: -1, progress: 0, total: 0,
|
|
ships: garrison,
|
|
});
|
|
}
|
|
fleet.fromStar = fleet.starIdx;
|
|
fleet.toStar = toStar;
|
|
fleet.total = parsecs(state.galaxy, fleet.starIdx, toStar);
|
|
fleet.progress = 0;
|
|
fleet.starIdx = -1;
|
|
return true;
|
|
}
|
|
|
|
export function fleetEta(rules, state, fleet) {
|
|
if (fleet.toStar < 0) return 0;
|
|
const speed = fleetSpeed(rules, state, fleet);
|
|
if (speed <= 0) return Infinity;
|
|
return Math.max(1, Math.ceil((fleet.total - fleet.progress) / speed));
|
|
}
|
|
|
|
// How long an order WOULD take, asked before it is given — the number the star
|
|
// map's order panel shows next to Accept. `ships` scopes it to a detachment the
|
|
// player has selected, whose speed is the slowest hull in the selection rather
|
|
// than the slowest in the whole fleet: leaving the colony ships at home is how
|
|
// you make a raid arrive this decade, so the ETA has to react to the selection.
|
|
export function etaTo(rules, state, fleet, toStar, ships = null) {
|
|
const from = fleet.starIdx >= 0 ? fleet.starIdx : fleet.toStar;
|
|
if (from < 0 || from === toStar) return 0;
|
|
const speed = fleetSpeed(rules, state, ships ? { ...fleet, ships } : fleet);
|
|
if (speed <= 0) return Infinity;
|
|
return Math.max(1, Math.ceil(parsecs(state.galaxy, from, toStar) / speed));
|
|
}
|
|
|
|
// Fold a [{hullId, mark, count}] request into one entry per stack, so asking
|
|
// for the same stack twice cannot slip past the "do you have this many?" check.
|
|
function normaliseTake(take) {
|
|
const out = new Map();
|
|
for (const t of take ?? []) {
|
|
const n = Math.floor(t.count ?? 0);
|
|
if (n <= 0) continue;
|
|
const key = `${t.hullId}|${t.mark}`;
|
|
const prev = out.get(key);
|
|
if (prev) prev.count += n;
|
|
else out.set(key, { hullId: t.hullId, mark: t.mark, count: n });
|
|
}
|
|
return [...out.values()];
|
|
}
|
|
|
|
const takeTotal = (take) => take.reduce((t, s) => t + s.count, 0);
|
|
const fleetTotal = (fleet) => fleet.ships.reduce((t, s) => t + Math.max(0, s.count), 0);
|
|
|
|
/**
|
|
* Detach part of an idle fleet into a fleet of its own, parked at the same star.
|
|
* Returns the new fleet, or null if the request was not satisfiable.
|
|
*
|
|
* Two idle fleets in one system are merged again by consolidateFleets at the
|
|
* start of the owner's next turn, which is MOO1's rule and deliberate — so the
|
|
* only splitting the UI offers is "send some of these ships somewhere"
|
|
* (sendDetachment below), where the detachment leaves the same instant.
|
|
*
|
|
* The detachment gets a fresh fleet id and therefore does NOT inherit the
|
|
* parent's fleet leader; the leader stays with the fleet they were posted to.
|
|
*/
|
|
export function splitFleet(rules, state, fleet, take) {
|
|
if (!fleet || fleet.starIdx < 0 || fleet.toStar >= 0) return null;
|
|
const wanted = normaliseTake(take);
|
|
const taken = takeTotal(wanted);
|
|
if (taken <= 0 || taken >= fleetTotal(fleet)) return null;
|
|
|
|
// Verify the whole request before mutating anything, or a request that is
|
|
// half-satisfiable leaves the fleet carved up and the order refused.
|
|
const pairs = [];
|
|
for (const t of wanted) {
|
|
const src = fleet.ships.find((s) => s.hullId === t.hullId && s.mark === t.mark);
|
|
if (!src || src.count < t.count) return null;
|
|
pairs.push([src, t.count]);
|
|
}
|
|
|
|
const ships = [];
|
|
for (const [src, n] of pairs) {
|
|
src.count -= n;
|
|
ships.push({ ...src, count: n });
|
|
}
|
|
fleet.ships = fleet.ships.filter((s) => s.count > 0);
|
|
|
|
const detachment = {
|
|
id: state.nextFleetId += 1,
|
|
empireIdx: fleet.empireIdx,
|
|
starIdx: fleet.starIdx,
|
|
fromStar: -1, toStar: -1, progress: 0, total: 0,
|
|
ships,
|
|
};
|
|
state.fleets.push(detachment);
|
|
return detachment;
|
|
}
|
|
|
|
/**
|
|
* Send some of a fleet's ships to a star: the selection departs, the rest stay
|
|
* behind. Selecting everything is just sendFleet. Returns the fleet that is now
|
|
* under way, or null if the order was refused.
|
|
*/
|
|
export function sendDetachment(rules, state, fleet, toStar, take) {
|
|
if (!fleet) return null;
|
|
const wanted = normaliseTake(take);
|
|
const taken = takeTotal(wanted);
|
|
if (taken <= 0) return null;
|
|
// Check the request against the actual stacks BEFORE comparing totals, or
|
|
// asking for nine of a stack of three reads as "all of them" and quietly
|
|
// sends the whole fleet instead of refusing.
|
|
for (const t of wanted) {
|
|
const src = fleet.ships.find((s) => s.hullId === t.hullId && s.mark === t.mark);
|
|
if (!src || src.count < t.count) return null;
|
|
}
|
|
if (taken === fleetTotal(fleet)) {
|
|
return sendFleet(rules, state, fleet, toStar) ? fleet : null;
|
|
}
|
|
|
|
// Ask whether the DETACHMENT could fly before splitting it out, so a refused
|
|
// order never leaves the fleet in pieces.
|
|
const probe = { ...fleet, ships: wanted.map((t) => ({ ...t })) };
|
|
if (!canSendFleet(rules, state, probe, toStar)) return null;
|
|
|
|
const detachment = splitFleet(rules, state, fleet, wanted);
|
|
if (!detachment) return null;
|
|
if (!sendFleet(rules, state, detachment, toStar)) {
|
|
// Unreachable given the probe, but a half-split fleet would be a silent
|
|
// loss of ships, so put them back rather than trust the reasoning.
|
|
for (const s of detachment.ships) {
|
|
const m = fleet.ships.find((x) => x.hullId === s.hullId && x.mark === s.mark);
|
|
if (m) m.count += s.count;
|
|
else fleet.ships.push({ ...s });
|
|
}
|
|
state.fleets = state.fleets.filter((f) => f !== detachment);
|
|
return null;
|
|
}
|
|
return detachment;
|
|
}
|
|
|
|
function moveFleets(rules, state, e) {
|
|
for (const f of empireFleets(state, e)) {
|
|
if (f.toStar < 0) continue;
|
|
f.progress += fleetSpeed(rules, state, f);
|
|
if (f.progress >= f.total - 1e-9) {
|
|
f.starIdx = f.toStar;
|
|
f.toStar = -1;
|
|
f.fromStar = -1;
|
|
f.progress = 0;
|
|
f.total = 0;
|
|
const wasExplored = !!state.empires[e].explored[f.starIdx];
|
|
state.empires[e].explored[f.starIdx] = true;
|
|
pushEvent(state, { type: 'arrive', empire: e, starIdx: f.starIdx, fleetId: f.id, turn: state.turn });
|
|
if (!wasExplored) {
|
|
pushEvent(state, { type: 'discovered', empire: e, starIdx: f.starIdx, turn: state.turn });
|
|
}
|
|
checkContactAt(rules, state, f.starIdx);
|
|
deliverPopulation(rules, state, f);
|
|
}
|
|
}
|
|
cleanFleets(state);
|
|
}
|
|
|
|
// Empires meet by sharing a system — a ship or colony of one sitting where a
|
|
// ship or colony of another already is, for the first time. Contact used to
|
|
// be proximity-based (any two empires' colonies within N parsecs), which met
|
|
// everyone quietly and gave the human no sense that first contact was an
|
|
// event. Star-scoped and all-pairs so it is agnostic to *why* two empires
|
|
// ended up sharing a star (a fleet arriving, a colony founded onto an
|
|
// already-occupied system) — every caller just says "check this star."
|
|
export function checkContactAt(rules, state, starIdx) {
|
|
const present = new Set();
|
|
for (const c of coloniesAt(state, starIdx)) present.add(c.empireIdx);
|
|
for (const f of fleetsAt(state, starIdx)) present.add(f.empireIdx);
|
|
const list = [...present];
|
|
for (let i = 0; i < list.length; i += 1) {
|
|
for (let j = i + 1; j < list.length; j += 1) {
|
|
const a = list[i];
|
|
const b = list[j];
|
|
if (state.empires[a].contacted[b]) continue;
|
|
state.empires[a].contacted[b] = true;
|
|
state.empires[b].contacted[a] = true;
|
|
pushEvent(state, { type: 'contact', empire: a, other: b, starIdx, turn: state.turn });
|
|
}
|
|
}
|
|
}
|
|
|
|
export function atWar(state, a, b) {
|
|
return state.empires[a]?.treaties?.[b] === 'war';
|
|
}
|
|
|
|
// Resolve every star where hostile forces now share orbit. Called once per
|
|
// empire turn after movement, so a fleet that arrives is engaged immediately.
|
|
export function resolveCombats(rules, state) {
|
|
const results = [];
|
|
const byStar = new Map();
|
|
for (const f of state.fleets) {
|
|
if (f.starIdx < 0) continue;
|
|
if (!byStar.has(f.starIdx)) byStar.set(f.starIdx, []);
|
|
byStar.get(f.starIdx).push(f);
|
|
}
|
|
for (const [starIdx, fleets] of byStar) {
|
|
const empires = [...new Set(fleets.map((f) => f.empireIdx))];
|
|
const colony = colonyAt(state, starIdx);
|
|
const defenderIdx = colony ? colony.empireIdx : null;
|
|
|
|
for (const a of empires) {
|
|
for (const b of empires) {
|
|
if (a >= b) continue;
|
|
if (!atWar(state, a, b)) continue;
|
|
const result = fightAt(rules, state, starIdx, a, b);
|
|
if (result) results.push(result);
|
|
}
|
|
}
|
|
// A hostile fleet in orbit of a defended colony must also fight the planet.
|
|
if (colony) {
|
|
for (const a of empires) {
|
|
if (a === defenderIdx) continue;
|
|
if (!atWar(state, a, defenderIdx)) continue;
|
|
if (state.fleets.some((f) => f.starIdx === starIdx && f.empireIdx === defenderIdx && f.ships.length)) continue;
|
|
if (colony.defenseHp <= 0) continue;
|
|
const result = fightAt(rules, state, starIdx, a, defenderIdx);
|
|
if (result) results.push(result);
|
|
}
|
|
}
|
|
}
|
|
cleanFleets(state);
|
|
return results;
|
|
}
|
|
|
|
function collectShips(rules, state, starIdx, e) {
|
|
const ships = [];
|
|
for (const f of state.fleets) {
|
|
if (f.starIdx !== starIdx || f.empireIdx !== e) continue;
|
|
for (const s of f.ships) {
|
|
const m = ships.find((x) => x.hullId === s.hullId && x.mark === s.mark);
|
|
if (m) m.count += s.count;
|
|
else ships.push({ hullId: s.hullId, mark: s.mark, count: s.count });
|
|
}
|
|
}
|
|
return ships;
|
|
}
|
|
|
|
function applyBattleLosses(rules, state, starIdx, e, survivors) {
|
|
const want = new Map();
|
|
for (const s of survivors) want.set(`${s.hullId}|${s.mark}`, s.count);
|
|
for (const f of state.fleets) {
|
|
if (f.starIdx !== starIdx || f.empireIdx !== e) continue;
|
|
for (const s of f.ships) {
|
|
const key = `${s.hullId}|${s.mark}`;
|
|
const left = want.get(key) ?? 0;
|
|
const keep = Math.min(s.count, left);
|
|
want.set(key, left - keep);
|
|
s.count = keep;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Build the battle object for a pair at a system, WITHOUT resolving it.
|
|
// Split out of fightAt so the player can drive a battle round by round through
|
|
// VegaCombatView and then hand the outcome back — the interactive battle and
|
|
// auto-resolve therefore run the same engine and cannot diverge.
|
|
export function prepareBattleAt(rules, state, starIdx, a, b) {
|
|
const colony = colonyAt(state, starIdx);
|
|
const defenderIdx = colony && (colony.empireIdx === a || colony.empireIdx === b) ? colony.empireIdx : b;
|
|
const attackerIdx = defenderIdx === a ? b : a;
|
|
|
|
const mkSide = (idx) => {
|
|
const emp = state.empires[idx];
|
|
return {
|
|
empireIdx: idx,
|
|
name: emp.name,
|
|
empire: { known: emp.known, traits: rules.species[emp.speciesId].traits },
|
|
ships: collectShips(rules, state, starIdx, idx),
|
|
};
|
|
};
|
|
const attacker = mkSide(attackerIdx);
|
|
const defender = mkSide(defenderIdx);
|
|
const defColony = colony && colony.empireIdx === defenderIdx ? colony : null;
|
|
if (!attacker.ships.length) return null;
|
|
if (!defender.ships.length && !(defColony && defColony.defenseHp > 0)) return null;
|
|
|
|
const battle = createBattle(rules, {
|
|
attacker,
|
|
defender,
|
|
colony: defColony ? { defenseHp: defColony.defenseHp, shieldBonus: 0 } : null,
|
|
starIdx,
|
|
rnd: () => rand(state),
|
|
});
|
|
return { battle, starIdx, attackerIdx, defenderIdx, colony: defColony };
|
|
}
|
|
|
|
// Write a finished battle's result back into the game state.
|
|
export function applyBattleOutcome(rules, state, prepared, result) {
|
|
const { starIdx, attackerIdx, defenderIdx, colony } = prepared;
|
|
applyBattleLosses(rules, state, starIdx, attackerIdx, result.attackerSurvivors);
|
|
applyBattleLosses(rules, state, starIdx, defenderIdx, result.defenderSurvivors);
|
|
if (colony) colony.defenseHp = result.planetDefenseLeft;
|
|
|
|
const loser = result.winner === 'attacker' ? defenderIdx : attackerIdx;
|
|
if (result.winner !== 'draw') retreatFrom(rules, state, starIdx, loser);
|
|
|
|
pushEvent(state, {
|
|
type: 'combat', starIdx, attacker: attackerIdx, defender: defenderIdx,
|
|
winner: result.winner, rounds: result.rounds,
|
|
attackerLosses: result.attackerLosses, defenderLosses: result.defenderLosses,
|
|
turn: state.turn,
|
|
});
|
|
cleanFleets(state);
|
|
return result;
|
|
}
|
|
|
|
// Systems where `e` is about to fight this turn. The scene calls this after
|
|
// movement so it can hand the player's own battles to the tactical view.
|
|
export function pendingBattlesFor(rules, state, e) {
|
|
const out = [];
|
|
const seen = new Set();
|
|
for (const f of state.fleets) {
|
|
if (f.starIdx < 0 || f.empireIdx !== e) continue;
|
|
if (seen.has(f.starIdx)) continue;
|
|
seen.add(f.starIdx);
|
|
const foes = new Set();
|
|
for (const g of state.fleets) {
|
|
if (g.starIdx === f.starIdx && g.empireIdx !== e && atWar(state, e, g.empireIdx)) foes.add(g.empireIdx);
|
|
}
|
|
const colony = colonyAt(state, f.starIdx);
|
|
if (colony && colony.empireIdx !== e && atWar(state, e, colony.empireIdx) && colony.defenseHp > 0) {
|
|
foes.add(colony.empireIdx);
|
|
}
|
|
for (const other of foes) out.push({ starIdx: f.starIdx, other });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function fightAt(rules, state, starIdx, a, b) {
|
|
const prepared = prepareBattleAt(rules, state, starIdx, a, b);
|
|
if (!prepared) return null;
|
|
return applyBattleOutcome(rules, state, prepared, runBattle(prepared.battle));
|
|
}
|
|
|
|
function retreatFrom(rules, state, starIdx, e) {
|
|
const own = empireColonies(state, e);
|
|
if (!own.length) {
|
|
for (const f of state.fleets) {
|
|
if (f.starIdx === starIdx && f.empireIdx === e) f.ships = [];
|
|
}
|
|
return;
|
|
}
|
|
let best = own[0].starIdx;
|
|
let bestD = Infinity;
|
|
for (const c of own) {
|
|
const d = parsecs(state.galaxy, starIdx, c.starIdx);
|
|
if (d < bestD) { bestD = d; best = c.starIdx; }
|
|
}
|
|
for (const f of state.fleets) {
|
|
if (f.starIdx !== starIdx || f.empireIdx !== e) continue;
|
|
if (best === starIdx) continue;
|
|
f.fromStar = starIdx;
|
|
f.toStar = best;
|
|
f.total = bestD;
|
|
f.progress = 0;
|
|
f.starIdx = -1;
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Colonisation and invasion
|
|
|
|
export function colonize(rules, state, e, starIdx, orbit) {
|
|
if (!canColonize(rules, state, e, starIdx, orbit)) return false;
|
|
const fleet = state.fleets.find((f) => f.starIdx === starIdx && f.empireIdx === e
|
|
&& f.ships.some((s) => s.hullId === 'colonyship' && s.count > 0));
|
|
if (!fleet) return false;
|
|
const stack = fleet.ships.find((s) => s.hullId === 'colonyship' && s.count > 0);
|
|
stack.count -= 1;
|
|
cleanFleets(state);
|
|
const colony = foundColony(rules, state, e, starIdx, orbit, 5);
|
|
checkContactAt(rules, state, starIdx);
|
|
pushEvent(state, { type: 'colonised', empire: e, starIdx, orbit, colonyId: colony.id, turn: state.turn });
|
|
state.empires[e]._range = null;
|
|
state.empires[e]._rangeAt = -1;
|
|
return true;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Population transport — MOO1's "send N population from one of your colonies
|
|
// to another." Unlike colonize()'s colony ship, this never sits in a build
|
|
// queue: the 'poptransport' hull (data/mastervega-rules.json) is dispatched
|
|
// directly, in transit already, the instant the order is given, carrying
|
|
// whatever amount was chosen as a payload on its own ship stack rather than a
|
|
// fixed per-hull capacity. It rides the same movement/fuel-range/combat
|
|
// machinery as any other fleet, so an unescorted transport crossing hostile
|
|
// space is exactly as vulnerable as a colony ship would be.
|
|
|
|
// A colony can never be fully emptied this way — same floor colony growth
|
|
// itself never goes below (see the `Math.max(0.5, ...)` in processColony).
|
|
const MIN_POP_LEFT_BEHIND = 0.5;
|
|
|
|
export function maxSendablePopulation(colony) {
|
|
return Math.max(0, colony.pop - MIN_POP_LEFT_BEHIND);
|
|
}
|
|
|
|
export function sendPopulation(rules, state, e, fromStarIdx, toStarIdx, amount) {
|
|
if (fromStarIdx === toStarIdx) return false;
|
|
const colony = colonyAt(state, fromStarIdx);
|
|
if (!colony || colony.empireIdx !== e) return false;
|
|
const dest = colonyAt(state, toStarIdx);
|
|
if (!dest || dest.empireIdx !== e) return false;
|
|
const send = Math.min(amount, maxSendablePopulation(colony));
|
|
if (send <= 0) return false;
|
|
|
|
// Built directly in transit — see the module comment above for why this
|
|
// does not go through addFleet()/sendFleet() (which would first have to
|
|
// land in an idle fleet at the source, risking a merge with whatever is
|
|
// garrisoned there before it could be split back out).
|
|
const probe = { empireIdx: e, starIdx: fromStarIdx, toStar: -1, ships: [{ hullId: 'poptransport', mark: 1, count: 1 }] };
|
|
if (!canSendFleet(rules, state, probe, toStarIdx)) return false;
|
|
|
|
state.fleets.push({
|
|
id: state.nextFleetId += 1,
|
|
empireIdx: e,
|
|
starIdx: -1,
|
|
fromStar: fromStarIdx,
|
|
toStar: toStarIdx,
|
|
progress: 0,
|
|
total: parsecs(state.galaxy, fromStarIdx, toStarIdx),
|
|
ships: [{ hullId: 'poptransport', mark: 1, count: 1, popPayload: send }],
|
|
});
|
|
colony.pop -= send;
|
|
pushEvent(state, {
|
|
type: 'populationSent', empire: e, starIdx: fromStarIdx, toStarIdx, amount: send, turn: state.turn,
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// Called from moveFleets the instant a poptransport fleet arrives. Delivers
|
|
// to a still-friendly colony there and consumes the stack; if the star no
|
|
// longer has a colony of ours (captured, or the fleet was mis-sent), the
|
|
// payload just sits inert in orbit rather than being silently discarded, in
|
|
// case the player wants to redirect it by hand later.
|
|
function deliverPopulation(rules, state, f) {
|
|
const stack = f.ships.find((s) => s.hullId === 'poptransport' && s.popPayload > 0);
|
|
if (!stack) return;
|
|
const colony = colonyAt(state, f.starIdx);
|
|
if (!colony || colony.empireIdx !== f.empireIdx) return;
|
|
const maxPop = colonyMaxPop(rules, state, colony);
|
|
colony.pop = Math.min(maxPop, colony.pop + stack.popPayload);
|
|
pushEvent(state, {
|
|
type: 'populationDelivered', empire: f.empireIdx, starIdx: f.starIdx,
|
|
colonyId: colony.id, amount: stack.popPayload, turn: state.turn,
|
|
});
|
|
stack.count = 0;
|
|
stack.popPayload = 0;
|
|
}
|
|
|
|
// Orbital superiority at a system: our combat power there exceeds theirs.
|
|
// Bombardment and invasion both require it.
|
|
export function holdsOrbit(rules, state, e, starIdx, defenderIdx) {
|
|
const defPower = state.fleets
|
|
.filter((f) => f.starIdx === starIdx && f.empireIdx === defenderIdx)
|
|
.reduce((t, f) => t + fleetPower(rules, state, f), 0);
|
|
const attPower = state.fleets
|
|
.filter((f) => f.starIdx === starIdx && f.empireIdx === e)
|
|
.reduce((t, f) => t + fleetPower(rules, state, f), 0);
|
|
if (attPower <= 0) return false;
|
|
return defPower <= 0 || attPower > defPower;
|
|
}
|
|
|
|
// Bombard a colony from orbit, killing population.
|
|
//
|
|
// This is MOO1's answer to a cornered empire, and without it conquest is
|
|
// literally unreachable: an empire reduced to one fortified homeworld survives
|
|
// forever, because its beaten fleet always retreats back to that same world and
|
|
// denies the attacker the clean orbit an invasion needs. Soaked to 2500 turns,
|
|
// not one empire in eight games was ever eliminated. Bombing also thins the
|
|
// defenders for a subsequent landing, so the two mechanics work together.
|
|
export function bombard(rules, state, e, starIdx) {
|
|
const colony = colonyAt(state, starIdx);
|
|
if (!colony || colony.empireIdx === e) return null;
|
|
if (!atWar(state, e, colony.empireIdx)) return null;
|
|
if (!holdsOrbit(rules, state, e, starIdx, colony.empireIdx)) return null;
|
|
|
|
const emp = state.empires[e];
|
|
const spec = rules.species[emp.speciesId];
|
|
let damage = 0;
|
|
let cracker = false;
|
|
for (const f of state.fleets) {
|
|
if (f.starIdx !== starIdx || f.empireIdx !== e) continue;
|
|
for (const st of f.ships) {
|
|
const d = empireDesign(rules, state, e, st.hullId);
|
|
if (d.role !== 'warship') continue;
|
|
damage += d.damage * st.count;
|
|
if (d.planetCracker) cracker = true;
|
|
}
|
|
}
|
|
if (damage <= 0) return null;
|
|
|
|
const comps = empireComponents(rules, state, e);
|
|
const shield = colony.buildings.includes('planetaryshield')
|
|
? comps.planetaryShield + 5 : comps.planetaryShield;
|
|
const kill = (damage * (rules.combat.bombardPopKill ?? 0.5)) / (1 + shield * 0.15);
|
|
const before = colony.pop;
|
|
colony.pop = Math.max(0, colony.pop - kill);
|
|
// A Stellar Converter cracks the crust; nothing is left to invade.
|
|
if (cracker) colony.pop = Math.max(0, colony.pop - kill);
|
|
|
|
pushEvent(state, {
|
|
type: 'bombard', empire: e, target: colony.empireIdx, starIdx,
|
|
killed: Math.round(before - colony.pop), cracker, turn: state.turn,
|
|
});
|
|
|
|
if (colony.pop < 1) {
|
|
const owner = colony.empireIdx;
|
|
state.colonies = state.colonies.filter((c) => c !== colony);
|
|
pushEvent(state, { type: 'colonyDestroyed', empire: e, target: owner, starIdx, turn: state.turn });
|
|
recomputeTotals(rules, state);
|
|
checkElimination(rules, state, owner);
|
|
return { destroyed: true, killed: Math.round(before) };
|
|
}
|
|
recomputeTotals(rules, state);
|
|
return { destroyed: false, killed: Math.round(before - colony.pop) };
|
|
}
|
|
|
|
// What a landing at this system would look like right now. Exported because
|
|
// both the AI and the human's invade button need the same forecast — the AI
|
|
// was committing every transport it had to hopeless landings (1971 failures
|
|
// against 130 successes) purely because nothing told it the odds.
|
|
export function invasionForecast(rules, state, e, starIdx) {
|
|
const colony = colonyAt(state, starIdx);
|
|
if (!colony || colony.empireIdx === e) return null;
|
|
const troops = state.fleets
|
|
.filter((f) => f.starIdx === starIdx && f.empireIdx === e)
|
|
.reduce((t, f) => t + f.ships
|
|
.filter((s) => s.hullId === 'transport')
|
|
.reduce((n, s) => n + s.count, 0), 0) * (rules.hulls.transport.troops ?? 4);
|
|
if (troops <= 0) return { troops: 0, defenders: 0, odds: 0, favourable: false };
|
|
|
|
const spec = rules.species[state.empires[e].speciesId];
|
|
const comps = empireComponents(rules, state, e);
|
|
const attackBonus = (spec.traits.groundAttack ?? 0) + (comps.groundAttack ?? 0);
|
|
const defenceBonus = colonyGroundDefense(rules, state, colony) + colony.defenseHp / 45;
|
|
const defenders = Math.max(1, Math.round(colony.pop / 8)) + Math.round(defenceBonus / 10);
|
|
const odds = Math.max(0.1, Math.min(0.9,
|
|
0.5 + (attackBonus - defenceBonus) * (rules.combat.groundOddsScale ?? 0.01)));
|
|
// Each round is one duel; the attacker needs `defenders` wins before it takes
|
|
// `troops` losses. Expected exchange favours the landing when this holds.
|
|
const favourable = troops * odds > defenders * (1 - odds) * 1.25;
|
|
return { troops, defenders, odds, favourable };
|
|
}
|
|
|
|
export function invade(rules, state, e, starIdx) {
|
|
const colony = colonyAt(state, starIdx);
|
|
if (!colony || colony.empireIdx === e) return null;
|
|
if (!atWar(state, e, colony.empireIdx)) return null;
|
|
// Holding orbit means orbital SUPERIORITY, not an empty sky.
|
|
//
|
|
// Two versions of this check killed conquest outright. Requiring defenceHp to
|
|
// be zero never opened a window at all — combat resolves on the attacker's
|
|
// turn, and the defender's own turn rebuilds the batteries before the
|
|
// attacker acts again. Requiring literally no enemy hull present failed the
|
|
// same way for the same reason: a besieged colony finishes a ship every few
|
|
// turns, and that one fresh hull blocked the landing indefinitely. Measured
|
|
// over six games there were 1268 colony-turns under hostile orbit and exactly
|
|
// two invasion attempts.
|
|
const defPower = state.fleets
|
|
.filter((f) => f.starIdx === starIdx && f.empireIdx === colony.empireIdx)
|
|
.reduce((t, f) => t + fleetPower(rules, state, f), 0);
|
|
const attPower = state.fleets
|
|
.filter((f) => f.starIdx === starIdx && f.empireIdx === e)
|
|
.reduce((t, f) => t + fleetPower(rules, state, f), 0);
|
|
if (defPower > 0 && attPower <= defPower) return null;
|
|
|
|
const fleet = state.fleets.find((f) => f.starIdx === starIdx && f.empireIdx === e
|
|
&& f.ships.some((s) => s.hullId === 'transport' && s.count > 0));
|
|
if (!fleet) return null;
|
|
const stack = fleet.ships.find((s) => s.hullId === 'transport' && s.count > 0);
|
|
|
|
const emp = state.empires[e];
|
|
const spec = rules.species[emp.speciesId];
|
|
const comps = empireComponents(rules, state, e);
|
|
const troops = stack.count * (rules.hulls.transport.troops ?? 4);
|
|
const attackBonus = (spec.traits.groundAttack ?? 0) + (comps.groundAttack ?? 0);
|
|
// Intact orbital batteries shell the landing zones, but only as a modifier —
|
|
// at a twelfth of their hit points they alone drove the attacker's odds to
|
|
// the 10% floor and only 21 of 268 landings succeeded.
|
|
const defenceBonus = colonyGroundDefense(rules, state, colony) + colony.defenseHp / 45;
|
|
|
|
const result = resolveInvasion(rules, () => rand(state), troops, attackBonus,
|
|
{ groundDefense: defenceBonus }, defenceBonus, colony.pop);
|
|
|
|
stack.count = 0;
|
|
cleanFleets(state);
|
|
|
|
if (result.captured) {
|
|
const from = colony.empireIdx;
|
|
colony.empireIdx = e;
|
|
colony.capital = false;
|
|
colony.pop = Math.max(1, colony.pop * 0.5);
|
|
colony.queue = [];
|
|
colony.defenseHp = 0;
|
|
pushEvent(state, { type: 'captured', empire: e, from, starIdx, colonyId: colony.id, turn: state.turn });
|
|
state.empires[from].attitude[e] = (state.empires[from].attitude[e] ?? 0) - 40;
|
|
state.empires[e]._range = null; state.empires[e]._rangeAt = -1;
|
|
checkElimination(rules, state, from);
|
|
} else {
|
|
pushEvent(state, { type: 'invasionFailed', empire: e, starIdx, turn: state.turn });
|
|
}
|
|
recomputeTotals(rules, state);
|
|
return result;
|
|
}
|
|
|
|
function checkElimination(rules, state, e) {
|
|
const emp = state.empires[e];
|
|
if (!emp.alive) return;
|
|
if (empireColonies(state, e).length > 0) return;
|
|
emp.alive = false;
|
|
// An empire with no colonies has nothing to resupply from, so its ships are
|
|
// scuttled. Leaving them on the map produced fleets belonging to a dead
|
|
// empire that nothing would ever clean up.
|
|
state.fleets = state.fleets.filter((f) => f.empireIdx !== e);
|
|
pushEvent(state, { type: 'eliminated', empire: e, turn: state.turn });
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Galactic Council
|
|
|
|
// Share of the SETTLEABLE galaxy that is settled. Measuring against every star
|
|
// made the Council unreachable: a third of systems hold nothing but gas giants
|
|
// and asteroid belts, so "half the galaxy colonised" could never be true no
|
|
// matter how completely the map was carved up.
|
|
export function colonizedFraction(state) {
|
|
const rules = state.rules;
|
|
let habitable = 0;
|
|
for (const star of state.galaxy.stars) {
|
|
const ok = star.planets.some((p) => (rules
|
|
? rules.planetTypes[p.typeId].colonizable
|
|
: true));
|
|
if (ok) habitable += 1;
|
|
}
|
|
const owned = new Set(state.colonies.map((c) => c.starIdx));
|
|
return owned.size / Math.max(1, habitable);
|
|
}
|
|
|
|
export function runCouncil(rules, state) {
|
|
const alive = state.empires.filter((e) => e.alive);
|
|
if (alive.length < 2) return null;
|
|
const totalPop = alive.reduce((t, e) => t + e.totalPop, 0);
|
|
if (totalPop <= 0) return null;
|
|
|
|
// MOO1's rule: the two largest empires stand for High Guardian and everyone
|
|
// else votes between them. Letting every empire stand meant every empire
|
|
// simply voted for itself, so the Council convened forever and elected nobody
|
|
// — thirty sessions in an 800-turn game, all of them null.
|
|
const candidates = alive.slice().sort((a, b) => b.totalPop - a.totalPop || a.idx - b.idx).slice(0, 2);
|
|
const votes = {};
|
|
for (const c of candidates) votes[c.idx] = 0;
|
|
let abstained = 0;
|
|
|
|
for (const voter of alive) {
|
|
const weight = voter.totalPop;
|
|
const own = candidates.find((c) => c.idx === voter.idx);
|
|
if (own) { votes[own.idx] += weight; continue; }
|
|
let best = null;
|
|
let bestScore = -Infinity;
|
|
for (const cand of candidates) {
|
|
// Being at war with a candidate is disqualifying on its own.
|
|
const score = (voter.attitude[cand.idx] ?? 0) - (atWar(state, voter.idx, cand.idx) ? 60 : 0);
|
|
if (score > bestScore) { bestScore = score; best = cand; }
|
|
}
|
|
if (!best || bestScore < (rules.council.abstainAttitude ?? -20)) { abstained += weight; continue; }
|
|
votes[best.idx] += weight;
|
|
}
|
|
|
|
let winner = -1;
|
|
for (const c of candidates) {
|
|
if (votes[c.idx] / totalPop >= rules.council.winFraction) winner = c.idx;
|
|
}
|
|
|
|
// MOO1's rule: the defeated candidate may REFUSE TO SUBMIT. An empire that is
|
|
// at war with the winner, or simply hates them, walks out of the chamber and
|
|
// the election is void — and everyone who refused is now at war with the
|
|
// presumptive High Guardian.
|
|
//
|
|
// This is what keeps conquest reachable. Without it a dominant empire always
|
|
// won its own council vote a hundred turns before it could finish a war, and
|
|
// no game in a 24-game soak ever ended by conquest.
|
|
let refused = false;
|
|
if (winner >= 0) {
|
|
const loser = candidates.find((c) => c.idx !== winner);
|
|
const bitter = loser && (atWar(state, loser.idx, winner)
|
|
|| (loser.attitude[winner] ?? 0) < (rules.council.submitAttitude ?? -25));
|
|
if (bitter) {
|
|
refused = true;
|
|
pushEvent(state, { type: 'councilRefused', empire: loser.idx, winner, turn: state.turn });
|
|
if (!atWar(state, loser.idx, winner)) declareWar(rules, state, loser.idx, winner);
|
|
// Everyone who withheld their vote resents the near-coronation.
|
|
for (const o of alive) {
|
|
if (o.idx === winner) continue;
|
|
o.attitude[winner] = Math.max(-100, (o.attitude[winner] ?? 0) - 15);
|
|
}
|
|
winner = -1;
|
|
}
|
|
}
|
|
|
|
const result = { turn: state.turn, votes, totalPop, abstained, winner, refused, candidates: candidates.map((c) => c.idx) };
|
|
state.council.lastResult = result;
|
|
state.council.history.push(result);
|
|
state.council.nextTurn = state.turn + rules.council.interval;
|
|
pushEvent(state, { type: 'council', ...result });
|
|
if (winner >= 0) {
|
|
state.over = true;
|
|
state.winnerIdx = winner;
|
|
state.victoryKind = 'council';
|
|
pushEvent(state, { type: 'victory', empire: winner, kind: 'council', turn: state.turn });
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function checkVictory(rules, state) {
|
|
if (state.over) return;
|
|
const alive = state.empires.filter((e) => e.alive);
|
|
if (alive.length <= 1) {
|
|
state.over = true;
|
|
state.winnerIdx = alive.length ? alive[0].idx : -1;
|
|
state.victoryKind = 'conquest';
|
|
pushEvent(state, { type: 'victory', empire: state.winnerIdx, kind: 'conquest', turn: state.turn });
|
|
return;
|
|
}
|
|
if (state.turn >= (rules.victory.turnCap ?? 800)) {
|
|
// Out of time: the largest empire is declared dominant so a game always
|
|
// terminates. The soak relies on this.
|
|
const best = alive.reduce((x, y) => (y.totalPop > x.totalPop ? y : x), alive[0]);
|
|
state.over = true;
|
|
state.winnerIdx = best.idx;
|
|
state.victoryKind = 'timeout';
|
|
pushEvent(state, { type: 'victory', empire: best.idx, kind: 'timeout', turn: state.turn });
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Turn sequencing
|
|
|
|
export function moveFleetsFor(rules, state, e) { moveFleets(rules, state, e); }
|
|
|
|
export function endEmpireTurn(rules, state, e, { skipMove = false } = {}) {
|
|
if (state.empires[e].alive) {
|
|
if (!skipMove) moveFleets(rules, state, e);
|
|
resolveCombats(rules, state);
|
|
for (const emp of state.empires) checkElimination(rules, state, emp.idx);
|
|
}
|
|
|
|
let next = e;
|
|
for (let i = 0; i < state.empires.length; i += 1) {
|
|
next = (next + 1) % state.empires.length;
|
|
if (next === 0) {
|
|
state.turn += 1;
|
|
state.rules = rules;
|
|
if (rules.council.council !== false
|
|
&& state.turn >= state.council.nextTurn
|
|
&& colonizedFraction(state) >= rules.council.minColonizedFraction) {
|
|
runCouncil(rules, state);
|
|
}
|
|
// A galaxy where nobody ever fights and no Council vote carries will run
|
|
// to the turn cap and be decided by a tiebreak, which is the least
|
|
// interesting outcome available. Past a point, force the issue.
|
|
const nudge = rules.victory.stalemateTurn ?? 150;
|
|
if (!state.over && state.turn > nudge && state.turn % 40 === 0) breakStalemate(rules, state);
|
|
checkVictory(rules, state);
|
|
}
|
|
if (state.empires[next].alive) break;
|
|
}
|
|
state.current = next;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Player actions
|
|
|
|
export function setSlider(rules, state, colony, channel, value) {
|
|
const v = Math.max(0, Math.min(1, value));
|
|
const others = CHANNELS.filter((c) => c !== channel && !colony.locked[c]);
|
|
const lockedSum = CHANNELS.filter((c) => c !== channel && colony.locked[c])
|
|
.reduce((t, c) => t + colony.sliders[c], 0);
|
|
const room = Math.max(0, 1 - lockedSum);
|
|
const target = Math.min(v, room);
|
|
colony.sliders[channel] = target;
|
|
const rest = room - target;
|
|
const otherSum = others.reduce((t, c) => t + colony.sliders[c], 0);
|
|
if (others.length === 0) return;
|
|
if (otherSum <= 0) {
|
|
for (const c of others) colony.sliders[c] = rest / others.length;
|
|
} else {
|
|
for (const c of others) colony.sliders[c] = (colony.sliders[c] / otherSum) * rest;
|
|
}
|
|
}
|
|
|
|
export function setResearchAlloc(rules, state, e, field, value) {
|
|
const emp = state.empires[e];
|
|
const fields = Object.keys(rules.techFields);
|
|
const v = Math.max(0, Math.min(1, value));
|
|
emp.alloc[field] = v;
|
|
const others = fields.filter((f) => f !== field);
|
|
const rest = 1 - v;
|
|
const sum = others.reduce((t, f) => t + emp.alloc[f], 0);
|
|
if (sum <= 0) for (const f of others) emp.alloc[f] = rest / others.length;
|
|
else for (const f of others) emp.alloc[f] = (emp.alloc[f] / sum) * rest;
|
|
}
|
|
|
|
export function enqueue(rules, state, colony, kind, id) {
|
|
if (kind === 'building') {
|
|
if (colony.buildings.includes(id)) return false;
|
|
if (colony.queue.some((q) => q.kind === 'building' && q.id === id)) return false;
|
|
const b = rules.buildings[id];
|
|
const emp = state.empires[colony.empireIdx];
|
|
if (b.prereq && !emp.known[b.prereq]) return false;
|
|
}
|
|
colony.queue.push({ kind, id, progress: 0 });
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Queue `n` copies of the same thing — the repeat-count button on the colony
|
|
* screen. They are stored as n SEPARATE entries rather than one entry with a
|
|
* count, so `processColony` and the save format need no knowledge of repeats at
|
|
* all; the view is what collapses a run of identical ships into a "x N" row.
|
|
* Buildings are unique per colony, so `enqueue` refuses every copy after the
|
|
* first and this returns 1. Returns how many were actually added.
|
|
*/
|
|
export function enqueueMany(rules, state, colony, kind, id, n) {
|
|
let added = 0;
|
|
for (let i = 0; i < Math.max(0, Math.floor(n)); i += 1) {
|
|
if (!enqueue(rules, state, colony, kind, id)) break;
|
|
added += 1;
|
|
}
|
|
return added;
|
|
}
|
|
|
|
export function dequeue(rules, state, colony, index) {
|
|
if (index < 0 || index >= colony.queue.length) return false;
|
|
colony.queue.splice(index, 1);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Reorder the queue. `progress` is a property of the item object, so it travels
|
|
* with the move for free — demoting the half-built head item banks its BC
|
|
* rather than losing them, and promoting something else does not hand it the
|
|
* head's progress. `processColony` only ever looks at `queue[0]`, so a splice
|
|
* between turns is safe.
|
|
*/
|
|
export function moveQueueItem(rules, state, colony, from, to) {
|
|
const n = colony.queue.length;
|
|
if (from < 0 || from >= n) return false;
|
|
const dest = Math.max(0, Math.min(n - 1, to));
|
|
if (dest === from) return true;
|
|
const [item] = colony.queue.splice(from, 1);
|
|
colony.queue.splice(dest, 0, item);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Collapse the queue into display runs: consecutive identical ships become one
|
|
* `{ index, lastIndex, item, count }` row. `enqueueMany` stores a repeat as N
|
|
* separate entries so the turn processor and the save format never learn about
|
|
* repeats, and this is what folds them back up for a UI.
|
|
*
|
|
* A part-built entry never joins a run — its progress has to stay individually
|
|
* legible, and it is always at the head anyway, since slot 0 is the only one
|
|
* the engine ever spends on.
|
|
*/
|
|
export function collapseQueue(colony) {
|
|
const rows = [];
|
|
colony.queue.forEach((item, index) => {
|
|
const last = rows[rows.length - 1];
|
|
const runnable = item.kind === 'ship' && (item.progress ?? 0) === 0;
|
|
if (last && runnable && last.item.kind === 'ship' && last.item.id === item.id
|
|
&& (last.item.progress ?? 0) === 0) {
|
|
last.count += 1;
|
|
last.lastIndex = index;
|
|
return;
|
|
}
|
|
rows.push({ index, lastIndex: index, item, count: 1 });
|
|
});
|
|
return rows;
|
|
}
|
|
|
|
/**
|
|
* Move a whole collapsed run one row up (dir -1) or down (dir +1), where `rows`
|
|
* came from `collapseQueue`. A "x 5" row is five queue entries, so this is five
|
|
* splices — and the two directions do NOT use the same indices, because every
|
|
* splice shifts what comes after it:
|
|
*
|
|
* up — the copies still waiting behind keep their original slots, so both
|
|
* ends of the move advance together (`+ k`).
|
|
* down — pulling the head copy out slides the rest of the run down into the
|
|
* slot it just vacated, so the SAME pair of indices moves every copy.
|
|
*
|
|
* Getting this wrong does not throw; it silently interleaves the run with its
|
|
* neighbour, which is why it is here in the headless tier and checked in the
|
|
* verifier rather than left in the view.
|
|
*/
|
|
export function moveQueueRun(rules, state, colony, rows, ri, dir) {
|
|
const run = rows[ri];
|
|
const neighbour = rows[ri + dir];
|
|
if (!run || !neighbour) return false;
|
|
for (let k = 0; k < run.count; k += 1) {
|
|
if (dir < 0) moveQueueItem(rules, state, colony, run.index + k, neighbour.index + k);
|
|
else moveQueueItem(rules, state, colony, run.index, neighbour.lastIndex);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
export function hireLeader(rules, state, e, leaderId) {
|
|
const emp = state.empires[e];
|
|
const leader = rules.leaders[leaderId];
|
|
if (!leader || emp.leaders.some((l) => l.leaderId === leaderId)) return false;
|
|
if (emp.bc < leader.hireCost) return false;
|
|
emp.bc -= leader.hireCost;
|
|
emp.leaders.push({ leaderId, assignKind: null, assignId: -1 });
|
|
pushEvent(state, { type: 'leaderHired', empire: e, leaderId, turn: state.turn });
|
|
return true;
|
|
}
|
|
|
|
export function assignLeader(rules, state, e, leaderId, kind, id) {
|
|
const emp = state.empires[e];
|
|
const l = emp.leaders.find((x) => x.leaderId === leaderId);
|
|
if (!l) return false;
|
|
const leader = rules.leaders[leaderId];
|
|
if (leader.kind === 'admin' && kind !== 'colony') return false;
|
|
if (leader.kind === 'captain' && kind !== 'fleet') return false;
|
|
// One leader per posting.
|
|
for (const other of emp.leaders) {
|
|
if (other !== l && other.assignKind === kind && other.assignId === id) other.assignId = -1, other.assignKind = null;
|
|
}
|
|
l.assignKind = kind;
|
|
l.assignId = id;
|
|
return true;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Serialisation
|
|
|
|
export function serialize(state) {
|
|
const { rules, ...rest } = state;
|
|
// Every underscore-prefixed field is a derived memo cache (component bags,
|
|
// range sets and the turn stamps that invalidate them). Dropping the values
|
|
// but keeping the stamps would make a reloaded game serialise differently
|
|
// from the one it was saved from, so the whole prefix goes.
|
|
return JSON.stringify(rest, (key, value) => (key.startsWith('_') ? undefined : value));
|
|
}
|
|
|
|
export function deserialize(json) {
|
|
const state = JSON.parse(json);
|
|
if (state.version !== 1) return null;
|
|
for (const emp of state.empires) {
|
|
emp._comps = null; emp._compsAt = -1; emp._range = null; emp._rangeAt = -1;
|
|
emp._designs = null; emp._designsAt = -1;
|
|
}
|
|
return state;
|
|
}
|
|
|
|
export function hashState(state) {
|
|
const str = serialize(state);
|
|
let h = 2166136261;
|
|
for (let i = 0; i < str.length; i += 1) {
|
|
h ^= str.charCodeAt(i);
|
|
h = Math.imul(h, 16777619);
|
|
}
|
|
return (h >>> 0).toString(16);
|
|
}
|