Spaces:
Paused
Paused
| /* ============================================================ | |
| Unit & building definitions for the first skirmish slice. | |
| Costs are in the planet's own deposit commodities (see engine/map.js) | |
| so the resources you gather are the resources you spend — no separate | |
| RTS-only currency. | |
| ============================================================ */ | |
| ; | |
| import { RECIPES } from "../data.js"; | |
| export const BUILDINGS = { | |
| command: { | |
| id: "command", name: "Command Center", hp: 1000, radius: 26, | |
| cost: { ore: 400 }, buildTime: 30, // steep + slow: an expansion is a long-game commitment | |
| // The starting CC is still seeded finished by state.js's seedPlayer — | |
| // makeBuilding without { constructing: true } spawns complete regardless | |
| // of buildTime. cost/buildTime only gate the issueBuild path. | |
| produces: ["worker", "ranger", "colonyship", "hauler", "heavyhauler", "bulkfreighter"], // the Odyssey-only ones are gated by queueProduction (def.odysseyOnly) | |
| isCommandCenter: true, | |
| supplyGrants: 10, // the seeded CC already houses the starting 3 workers with room to grow | |
| sight: 220, | |
| category: "infrastructure", | |
| }, | |
| barracks: { | |
| id: "barracks", name: "Barracks", hp: 500, radius: 20, | |
| cost: { ore: 150 }, buildTime: 20, | |
| produces: ["skiff", "bastion", "lancer", "breacher", "dreadnought", "mender", "wraith", "aegis", "colossus"], | |
| sight: 150, | |
| category: "military", | |
| }, | |
| refinery: { | |
| id: "refinery", name: "Refinery", hp: 400, radius: 18, | |
| cost: { ore: 200 }, buildTime: 16, | |
| sight: 140, | |
| // No `produces` — it researches upgrades instead of building units, | |
| // which is also what keeps it out of the rally-point UI (input.js | |
| // only offers that for buildings with a `produces` list). | |
| category: "industrial", | |
| }, | |
| turret: { | |
| id: "turret", name: "Sentinel Turret", hp: 350, radius: 12, | |
| cost: { ore: 150, crystals: 100 }, buildTime: 12, | |
| sight: 170, | |
| // Static defense: same combat stat names units use, so combat.js's | |
| // acquireTarget/attackDamage apply verbatim. aggroRange === range on | |
| // purpose — a turret can't chase, so acquiring beyond range is useless. | |
| attack: 20, range: 130, cooldown: 1, aggroRange: 130, | |
| category: "military", | |
| }, | |
| // ---- Static-defense ladder, tiers 2-3 (docs/improvement-proposals.md). One turret type used | |
| // to serve all four tiers; these two round it out into a real ladder, each rationalized against | |
| // the SAME invariant: every siege unit (Breacher 150, Colossus 185, Leviathan 200) must still | |
| // strictly outrange every static defense structure here — static defense holds ground by hp and | |
| // attrition, never by out-ranging siege. See the Torpedo Battery below (Strategic tier) for the | |
| // one deliberate, documented narrowing of that rule. | |
| bastille: { | |
| id: "bastille", name: "Bastille", hp: 600, radius: 16, | |
| cost: { ore: 200, crystals: 150, radioactives: 60 }, buildTime: 22, | |
| sight: 150, | |
| // A second, Foundry-gated static-defense tier: a TANKIER, SHORTER-ranged brawler than the | |
| // Sentinel Turret (115 vs 130) — deliberately not a longer-ranged sniper, so the "outranging | |
| // the turret" siege identity (and the cracksBase balance invariant) survives intact even | |
| // though this hits harder and soaks more. Same combat stat field NAMES the turret uses, so | |
| // combat.js's updateBuildingCombat works on it verbatim, zero changes to that function. | |
| // Crystals + radioactives priced (same rare goods an attacker spends on Breachers/doctrines), | |
| // so the defender's fortification investment scales with the same economy the Foundry gates. | |
| attack: 32, range: 115, cooldown: 1.4, aggroRange: 115, | |
| requires: ["foundry"], | |
| category: "military", | |
| }, | |
| aegisbastion: { | |
| id: "aegisbastion", name: "Aegis Bastion", hp: 500, radius: 16, | |
| cost: { ore: 250, crystals: 180 }, buildTime: 26, | |
| sight: 150, | |
| // Arsenal-gated static guard-aura projector: no `attack` of its own — it never fires, and | |
| // combat.js's updateBuildingCombat is already a no-op for any building without one. Instead it | |
| // projects the SAME kind of cryo-armour bubble the Aegis UNIT's guardAura does (see UNITS.aegis | |
| // above): every friendly unit AND building inside `range` takes `damageTakenMult` less damage | |
| // (engine/sim.js collectAnvils' buildings pass feeds engine/combat.js's anvilAura). It defends | |
| // by ATTRITION MATH, never by out-ranging siege — Breacher/Colossus/Leviathan can all still | |
| // shell it (or anything it shields) with impunity from outside its 130-range bubble; it just | |
| // buys the defender time for an army to answer. No `produces`/`supplyGrants`, so | |
| // isElectrifiable already excludes it, same as the Refinery/Foundry/Arsenal above. | |
| guardAura: { range: 130, damageTakenMult: 0.8 }, | |
| requires: ["arsenal"], | |
| category: "military", | |
| }, | |
| habitat: { | |
| id: "habitat", name: "Habitat", hp: 250, radius: 14, | |
| cost: { ore: 75 }, buildTime: 10, | |
| supplyGrants: 8, // ~one economist mix cycle's worth of headroom per dome | |
| sight: 100, | |
| // No `produces` — like the Refinery, this keeps it out of the | |
| // rally-point UI and rally rendering automatically. Softest building | |
| // on the roster (hp 250): a legitimate raid target to choke supply. | |
| category: "infrastructure", | |
| }, | |
| foundry: { | |
| id: "foundry", name: "Foundry", hp: 450, radius: 18, | |
| cost: { ore: 175 }, buildTime: 22, sight: 140, | |
| // The military tech gate: a pure prerequisite building (no `produces`, so | |
| // it stays out of the rally UI). It unlocks the Tier-2 combat units | |
| // (Lancer, Breacher) — the Barracks still trains them. Ore-only on purpose, | |
| // so the Tier-2 units stay reachable on every world (ore is guaranteed near | |
| // every base) rather than being walled off on a crystal-poor map. | |
| requires: ["barracks"], | |
| // Category is "industrial" (not "military") despite gating Tier-2 combat units — | |
| // it groups with the other production-tech buildings in the build menu. | |
| category: "industrial", | |
| // Standing bonus: while a COMPLETED Foundry stands, military unit production runs ~8% | |
| // faster — not just the Lancer/Breacher it gates, so razing it costs an ongoing tempo edge, | |
| // not just access to Tier-2 units. Live-scanned (structureMult below, mirroring | |
| // committedDoctrine's own live scan) — production.js's updateProductionQueue applies it only | |
| // to role:"combat" jobs, so economy production (Workers, Rangers, freighters, …) is untouched. | |
| produceTimeMult: 0.92, | |
| }, | |
| arsenal: { | |
| id: "arsenal", name: "Arsenal", hp: 550, radius: 18, | |
| cost: { ore: 220 }, buildTime: 26, sight: 140, | |
| // The Tier-3 gate, one step past the Foundry: unlocks the Dreadnought | |
| // capital unit. Also a pure gate (no `produces`), ore-only so the tech path | |
| // stays reachable on every world. | |
| requires: ["foundry"], | |
| category: "industrial", // same reasoning as the Foundry above | |
| // A standing Arsenal stacks a SECOND ~8% step atop a standing Foundry's — structureMult | |
| // multiplies every standing structure's own field, so both apply together if both stand. | |
| produceTimeMult: 0.92, | |
| }, | |
| spaceport: { | |
| id: "spaceport", name: "Spaceport", hp: 600, radius: 22, | |
| cost: { ore: 300 }, buildTime: 30, sight: 160, | |
| // Odyssey only (offered in the Odyssey build menu): the interplanetary launch | |
| // pad. Selecting a finished Spaceport lets you relocate your single Command | |
| // Center — plus the units staged nearby — to another world (engine/galaxy.js). | |
| // Gated behind the Foundry so leaving the planet is a mid-game milestone. | |
| requires: ["foundry"], | |
| category: "infrastructure", | |
| }, | |
| market: { | |
| id: "market", name: "Market", hp: 150, radius: 12, | |
| cost: { ore: 40 }, buildTime: 6, sight: 90, | |
| // The cheapest, fastest building on the roster — Odyssey's on-ramp into trading, and | |
| // meant to be the first thing a worker raises. A finished Market opens the commodity | |
| // trade panel (hudSelection.js renderMarket) — buy/sell local goods for galaxy credits | |
| // (engine/market.js) — which used to sit on the Command Center; it's moved here so a | |
| // destroyed/absent CC doesn't strand a colony without a market. No `produces`/`recipe`: | |
| // a pure UI gate, so it stays out of the rally-point UI and updateProduction | |
| // (engine/industry.js) skips it like any other non-recipe building. | |
| odysseyOnly: true, | |
| category: "infrastructure", | |
| }, | |
| /* ---- INDUSTRY (Odyssey only) — the production chain that turns raw hauls into | |
| refined goods worth real credits. All ore-costed (ore is guaranteed near every | |
| base, so the chain is reachable on any world) and flagged `odysseyOnly`: they | |
| never appear in a skirmish build menu, the skirmish AI never builds one, and | |
| engine/industry.js's updateProduction is a no-op for any building without a | |
| `recipe` — so a skirmish match never instantiates one and its byte-identical | |
| replay is untouched. A building's `recipe` names an entry in data.js RECIPES; | |
| `prodRate` is how many batches/sec it runs at full power. `energyGrants` is | |
| industrial Power capacity (a per-tick flow, like supply — see engine/industry.js). ---- */ | |
| reactor: { | |
| id: "reactor", name: "Reactor", hp: 400, radius: 16, | |
| cost: { ore: 120 }, buildTime: 16, sight: 130, | |
| energyGrants: 30, // the power that runs the factories below; short power throttles them all | |
| powerRange: 1, // the reference grid reach — a consumer's efficiency tier is its distance / this (industry.js) | |
| // The original power station burns radioactives too — a real fission reactor runs on fissile | |
| // material, not free once built. Its own local fuel larder (entities.js inputCapOf), filled by | |
| // a worker SERVICE run (engine/haul.js), same mechanism as its smaller combust siblings below — | |
| // just at double their burn rate (0.12/s vs 0.06/s), matching its double energyGrants and reach. | |
| // Out of fuel (or paused) it grants nothing, same as them. See engine/industry.js updateCombustors. | |
| combust: { fuels: ["radioactives"], rate: 0.12 }, | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| combustor: { | |
| id: "combustor", name: "Combustion Generator", hp: 300, radius: 13, | |
| cost: { ore: 70 }, buildTime: 12, sight: 110, | |
| // A cheap, fuel-burning alternative to the Reactor: it GRANTS less Power (energyGrants 15 vs 30) | |
| // over a SMALLER grid (powerRange 0.55 shrinks its efficiency zones — industry.js) and burns fuel | |
| // at half the Reactor's rate too — cheaper to raise and run, just less of a grid. It burns gas | |
| // (Helium-3) from its own local fuel buffer — a real WORKER hauls it in from the treasury, same | |
| // as a factory's input larder (engine/haul.js SERVICE), same mechanism the Reactor now uses. Out | |
| // of fuel (or paused) it grants nothing. See engine/industry.js updateCombustors. Its | |
| // biomass-burning sibling is the Biomass Reactor below. | |
| energyGrants: 15, powerRange: 0.55, | |
| combust: { fuels: ["gas"], rate: 0.06 }, | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| biomassreactor: { | |
| id: "biomassreactor", name: "Biomass Reactor", hp: 300, radius: 13, | |
| cost: { ore: 70 }, buildTime: 12, sight: 110, | |
| // The Combustion Generator's sibling, for a claim rich in biomass instead of Helium-3 — same | |
| // cheap-but-fed deal (energyGrants/powerRange/rate all match), just its own single fuel and a | |
| // worker hauling it in the same way (engine/haul.js SERVICE, engine/industry.js updateCombustors). | |
| energyGrants: 15, powerRange: 0.55, | |
| combust: { fuels: ["biomass"], rate: 0.06 }, | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| substation: { | |
| id: "substation", name: "Grid Substation", hp: 180, radius: 11, | |
| cost: { ore: 60, crystals: 30 }, buildTime: 10, sight: 90, | |
| // A passive one-hop RELAY, not a power station — no `energyGrants` (it grants zero Power | |
| // capacity of its own) and no `combust` (it burns no fuel). Every base otherwise collapses | |
| // into one dense blob around its Reactors, because the only remedy for grid tax used to be | |
| // ANOTHER fuel-burning station; this is the cheap alternative: while it stands within the | |
| // 'linked' band of one of the owner's own ACTIVE power sources, it counts as a second, | |
| // shorter-range virtual source point for GRID-TIER purposes (engine/industry.js bestGridDist's | |
| // relay pass) — so a factory too far from the Reactor to be worth powering directly can | |
| // huddle near a cheap relay instead. One hop only: a relay never extends through another | |
| // relay, so the grid-distance scan stays O(sources × relays), trivially deterministic. | |
| // `powerRange` here is the relay's OWN (shorter) reach for whoever measures distance TO it — | |
| // unrelated to the reach it itself needs to reach a real source (POWER_TIERS[0], fixed). | |
| powerRelay: true, powerRange: 0.8, | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| smelter: { | |
| id: "smelter", name: "Smelter", hp: 420, radius: 16, | |
| cost: { ore: 160 }, buildTime: 18, sight: 140, | |
| dropOff: true, // an industrial building doubles as a resource drop-off | |
| recipe: "smelt", prodRate: 2, // ore + power → metals (data.js RECIPES.smelt) | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| assembler: { | |
| id: "assembler", name: "Assembly Plant", hp: 440, radius: 17, | |
| cost: { ore: 180 }, buildTime: 20, sight: 140, | |
| dropOff: true, | |
| recipe: "alloy", prodRate: 1.5, // metals + power → alloys (data.js RECIPES.alloy) | |
| // The chain reads as a chain (needs a Smelter for metals) AND is the first | |
| // thing the tech tree gates: Metallurgy research (engine/techtree.js) unlocks | |
| // it, so the free tier (Smelter → metals) gives an immediate payoff while | |
| // deeper refining is an investment. `metallurgy` is a tech-node token that | |
| // prereqsMet resolves out of player.upgrades, exactly like a building token. | |
| requires: ["smelter", "metallurgy"], | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| /* ---- Phase 2 research + deeper industry (Odyssey only). The Datacenter hosts | |
| the tech tree (engine/techtree.js); the Chip Fab and Machine Works are the | |
| next two hops of the chain, each gated behind a research node so unlocking a | |
| node visibly unlocks new production. All ore-costed and odysseyOnly, like the | |
| Phase-1 factories. ---- */ | |
| datacenter: { | |
| id: "datacenter", name: "Datacenter", hp: 420, radius: 17, | |
| cost: { ore: 200 }, buildTime: 22, sight: 140, | |
| odysseyOnly: true, | |
| // Hosts research — no `recipe` (updateProduction ignores it) and no `produces` | |
| // (stays out of the rally UI). Selecting it opens the research panel (hud.js). | |
| category: "infrastructure", | |
| }, | |
| chipfab: { | |
| id: "chipfab", name: "Chip Fab", hp: 440, radius: 17, | |
| cost: { ore: 190 }, buildTime: 20, sight: 140, dropOff: true, | |
| recipe: "chipfab", prodRate: 1.5, // crystals + metals + power → electronics | |
| requires: ["smelter", "electronics"], // needs the metals chain + Microelectronics research | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| machineworks: { | |
| id: "machineworks", name: "Machine Works", hp: 460, radius: 18, | |
| cost: { ore: 220 }, buildTime: 24, sight: 140, dropOff: true, | |
| recipe: "machine", prodRate: 1, // alloys + electronics + power → machinery | |
| requires: ["assembler", "chipfab", "machining"], // the capstone: the whole chain + Precision Machining | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| /* ---- Phase 3: the Strategic tier + the endgame (Odyssey only). The Antimatter | |
| Forge tops the chain (machinery → antimatter), and the Antimatter Gate is the | |
| WONDER that consumes antimatter to WIN the galaxy — Odyssey's first victory | |
| condition (engine/wonder.js + engine/victory.js checkEndlessWin). ---- */ | |
| antimatterforge: { | |
| id: "antimatterforge", name: "Antimatter Forge", hp: 460, radius: 18, | |
| cost: { ore: 240 }, buildTime: 26, sight: 140, dropOff: true, | |
| recipe: "antifab", prodRate: 0.7, // machinery + radioactives + power → antimatter (RTS-recost recipe) | |
| requires: ["machineworks", "antimatter"], // needs the full chain + Antimatter Containment research | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| aifoundry: { | |
| id: "aifoundry", name: "AI Foundry", hp: 460, radius: 18, | |
| cost: { ore: 240 }, buildTime: 26, sight: 140, dropOff: true, | |
| recipe: "aifab", prodRate: 0.7, // electronics + crystals + power → AI Cores | |
| requires: ["chipfab", "aicores"], | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| torpedoworks: { | |
| id: "torpedoworks", name: "Torpedo Works", hp: 460, radius: 18, | |
| cost: { ore: 240 }, buildTime: 26, sight: 140, dropOff: true, | |
| recipe: "plasmafab", prodRate: 0.7, // antimatter + alloys + radioactives + power → Plasma Torpedoes | |
| requires: ["antimatterforge", "aicores"], | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| plasmarig: { | |
| id: "plasmarig", name: "Plasma Rig", hp: 560, radius: 18, | |
| // Expensive and high-tech: MANUFACTURED materials to build (machinery + electronics) and an | |
| // installed AI to pilot it (ai cores), on top of a big ore frame. | |
| cost: { ore: 500, machinery: 8, electronics: 5, ai: 3 }, | |
| buildTime: 46, sight: 130, | |
| requires: ["aifoundry", "reactor"], // needs the AI (pilot) and a Reactor (the plasma/power grid) | |
| odysseyOnly: true, | |
| // Deep-core extraction: an UNLIMITED source of one raw commodity (its "vein", fixed by where | |
| // you place it), dug in cycles at a PROBABILISTIC yield tier (low → overwhelming) whose odds | |
| // rise with the spot's + planet's richness. Draws heavy Power (the plasma arc — taxes the grid | |
| // like a factory, so digs slow when power is short) and burns radioactives per dig ("nuclear to | |
| // exploit"). See engine/rig.js. | |
| rig: { power: 16, nuclear: 1.4, digTime: 6, base: 6 }, | |
| // Its dug ore doesn't teleport into your treasury: it piles up in a FINITE output buffer | |
| // (storeCap) that workers must haul to a Command Center. Full buffer → the rig stalls until | |
| // it's cleared — logistics, not free money. See engine/haul.js. | |
| storeCap: 120, | |
| category: "industrial", | |
| }, | |
| stardock: { | |
| id: "stardock", name: "Star Dock", hp: 600, radius: 22, | |
| cost: { ore: 350 }, buildTime: 40, sight: 160, | |
| produces: ["leviathan", "heliumbomb"], // the strategic-good capital ship, and the doomsday device beside it | |
| requires: ["aifoundry", "torpedoworks"], // building it proves you've teched the whole Strategic tree | |
| odysseyOnly: true, | |
| category: "military", | |
| }, | |
| torpedobattery: { | |
| id: "torpedobattery", name: "Plasma Torpedo Battery", hp: 420, radius: 14, | |
| cost: { ore: 250, alloys: 10 }, buildTime: 24, sight: 210, | |
| // The static-defense ladder's Strategic-tier rung: the Sentinel Turret is wallpaper by | |
| // this point, exactly when the player needs to hold ground for the Antimatter Gate's 150s | |
| // charge. Real ammo-fed logistics, not a free-fire structure: `ammo` joins recipe/combust as | |
| // a real haulable input commodity (realInputComs/inputCapOf below), so engine/haul.js's | |
| // existing SERVICE machinery delivers plasma torpedoes into building.input the same way a | |
| // Reactor's fuel larder gets fed — engine/combat.js's updateBuildingCombat then requires | |
| // input[ammo.com] >= ammo.perShot before firing, decrementing on every shot; a dry battery | |
| // holds fire rather than shooting for free. | |
| attack: 55, range: 180, cooldown: 2.5, aggroRange: 180, | |
| ammo: { com: "plasmatorp", perShot: 0.25 }, | |
| // Deliberately out-ranges the Breacher (150) — by the Strategic tier the early siege tool | |
| // stops being enough on its own — but the Colossus (185) and Leviathan (200) both still | |
| // out-range it, so sieging a battery line stays the intended top-tier answer. | |
| requires: ["torpedoworks"], | |
| odysseyOnly: true, | |
| category: "military", | |
| }, | |
| antimatter_gate: { | |
| id: "antimatter_gate", name: "Antimatter Gate", hp: 1200, radius: 28, | |
| cost: { ore: 800 }, buildTime: 60, sight: 200, | |
| requires: ["antimatterforge", "aifoundry", "torpedoworks"], // the true capstone: the whole Strategic tier | |
| odysseyOnly: true, | |
| // The wonder: charges by consuming `feed` goods over `chargeTime` seconds of | |
| // full-power charging (engine/wonder.js), clamped to the scarcest one — so the | |
| // win demands the WHOLE Strategic tier flowing, not just antimatter. At full | |
| // charge the player wins the galaxy. Razed mid-charge, the whole investment is | |
| // lost with it. The Leviathan (below) draws on the same strategic goods — feed | |
| // the Gate or build the fleet. | |
| wonder: true, feed: { ai: 0.2, antimatter: 0.3, plasmatorp: 0.1 }, chargeTime: 150, | |
| powerDraw: 8, // a charging Gate loads the grid — it competes with your factories for Reactor Power | |
| category: "infrastructure", | |
| }, | |
| /* ---- TRADE INDUSTRY (Odyssey only): a genuinely SEPARATE branch off the Datacenter, not a | |
| continuation of the ore -> metals -> alloys -> machinery -> antimatter spine above (docs/ | |
| improvement-proposals.md "Promote the legacy consumer-goods recipes into a trade-industry | |
| branch"). data.js RECIPES documents 'chem'/'consumer' as legacy — "no producer" — reserved | |
| for exactly this promotion; the recipes themselves are untouched, only wired here (see | |
| engine/techtree.js TECHS.chemistry/consumerfab for the tech-gate half). | |
| The Chemical Plant needs NO metallurgy/Smelter prereq at all — `chemistry` is a second ROOT | |
| tech, the same shape as `metallurgy` itself — so a biomass/spice world that never touches | |
| ore/crystals still gets a real industrial identity of its own. The Fabricator is where the | |
| two spines actually MEET: its recipe (alloys + chemicals -> goods) needs an Assembly Plant's | |
| alloys the same way the Machine Works needs one for its own alloys+electronics merge, so it | |
| converges on the metallurgy branch without ever touching the antimatter/military one — no | |
| Foundry, Arsenal, Barracks, machining, or antimatter token anywhere in this branch. A | |
| genuinely different way up the tree: a credits engine for fuel/tribute/freight (finished | |
| goods sell dear on a low-industry world, engine/aiArchetypes.js "Verdani the low-industry | |
| agri contrast") rather than strategic goods. Ore-costed like every other factory (the | |
| reachability convention — ore is guaranteed near every base, regardless of what the recipe | |
| itself consumes), odysseyOnly, and dropOff/recipe/prodRate follow the Smelter/Assembly Plant | |
| idiom exactly. ---- */ | |
| chemplant: { | |
| id: "chemplant", name: "Chemical Plant", hp: 420, radius: 16, | |
| cost: { ore: 165 }, buildTime: 18, sight: 140, | |
| dropOff: true, | |
| recipe: "chem", prodRate: 2, // biomass + power → chemicals (data.js RECIPES.chem) | |
| requires: ["chemistry"], // tech-gated only — no Smelter, no metallurgy: a true off-spine root | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| fabricator: { | |
| id: "fabricator", name: "Fabricator", hp: 450, radius: 17, | |
| cost: { ore: 200 }, buildTime: 21, sight: 140, | |
| dropOff: true, | |
| recipe: "consumer", prodRate: 1, // alloys + chemicals + power → goods (data.js RECIPES.consumer) | |
| // The merge point: needs the metallurgy branch's Assembly Plant (alloys) AND this branch's own | |
| // Chemical Plant (chemicals), plus its own unlock tech — the same two-supplying-buildings- | |
| // plus-tech shape Machine Works uses for its own alloys+electronics merge. | |
| requires: ["assembler", "chemplant", "consumerfab"], | |
| odysseyOnly: true, | |
| category: "industrial", | |
| }, | |
| }; | |
| // Prerequisites are satisfied for `owner` when: every building-type token in | |
| // `def.requires` has a COMPLETED (non-constructing) building of that type, and | |
| // every other token is a researched upgrade id. No `requires` field ⇒ always | |
| // available. Pure and state-reading — the single source of truth shared by the | |
| // production gate, the build gate, the AI, and the UI's locked buttons. | |
| export function prereqsMet(state, owner, def) { | |
| const reqs = def.requires; | |
| if (!reqs || reqs.length === 0) return true; | |
| const player = state.players[owner]; | |
| return reqs.every(req => { | |
| if (BUILDINGS[req]) { | |
| for (const b of state.buildings.values()) | |
| if (b.owner === owner && b.type === req && !b.constructing) return true; | |
| return false; | |
| } | |
| return !!(player && player.upgrades && player.upgrades[req]); | |
| }); | |
| } | |
| // A building is a resource drop-off if it's the Command Center or a building flagged | |
| // `dropOff` in its def (the Odyssey-only factory chain — smelter, assembler, chipfab, | |
| // etc. — flags this; no skirmish building besides the Command Center does). Workers | |
| // deposit their haul at the NEAREST drop-off (see gather.js). Single source of truth | |
| // for the routing, tests, and any future UI. | |
| export function isDropOff(type) { | |
| const def = BUILDINGS[type]; | |
| return !!(def && (def.isCommandCenter || def.dropOff)); | |
| } | |
| // Where a gatherer may DEPOSIT a raw haul: the Command Center, or a `dropOff` building | |
| // with no `recipe` — NOT a factory, which drops its raws-as-inputs elsewhere and whose | |
| // `store` is its refined OUTPUT buffer, not a raw-intake bin. In practice every `dropOff` | |
| // building in the roster carries a `recipe` (the Odyssey factory chain), so this resolves | |
| // to the Command Center alone — there is no forward/decentralized collection point. | |
| export function isGatherDropOff(type) { | |
| const def = BUILDINGS[type]; | |
| return !!(def && (def.isCommandCenter || (def.dropOff && !def.recipe))); | |
| } | |
| // ---- Worker capability: which unit types may found/assist-build a building category, gather a | |
| // raw node, or run a haul/service/ferry job — end to end through recycling (recycling itself | |
| // stays universal, see recycle.js: it's the target tearing itself down, not a worker action, so | |
| // it needs no gate here). Mirrors isDropOff/isGatherDropOff's shape: a small pure predicate over a | |
| // def flag. `UNITS[type].buildCategories` lists which of BUILDINGS[type].category values that | |
| // unit may found/assist-build; `canGather`/`canLogistics` gate gathering and haul/service/ferry | |
| // the same way. Worker is the one generalist that carries all three (every category, gather, | |
| // logistics). Repair (Mender, role:"support") is intentionally untouched by all of this — it's | |
| // its own separate specialist, ungated by any of these three. | |
| export function canBuildCategory(unitType, category) { | |
| return !!category && !!UNITS[unitType]?.buildCategories?.includes(category); | |
| } | |
| /** Whether `unitType` may found/assist-build `buildingType` (its BUILDINGS[type].category). */ | |
| export function canBuildType(unitType, buildingType) { | |
| return canBuildCategory(unitType, BUILDINGS[buildingType]?.category); | |
| } | |
| /** Whether `unitType` may be issued a gather order (mine a raw resource node). */ | |
| export function canGatherType(unitType) { | |
| return !!UNITS[unitType]?.canGather; | |
| } | |
| /** Whether `unitType` may be offered/issued a haul, service, or ferry job (engine/haul.js). */ | |
| export function canLogisticsType(unitType) { | |
| return !!UNITS[unitType]?.canLogistics; | |
| } | |
| // Whether a building type can be ELECTRIFIED (Odyssey): wired into the power grid to run 30% | |
| // better — a producer (Command Center / Barracks / Star Dock) trains faster, a Habitat houses | |
| // more (engine/industry.js electrifyBoost; production.js, supply.js apply it). Eligible = a | |
| // building that doesn't ALREADY live on the power economy (no recipe to run, no Power to grant, | |
| // no rig/wonder draw) and has something worth boosting (`produces` a unit, or `supplyGrants`). | |
| // So the factories (already power-hungry), Reactors/Generators (they GRANT power), turrets and | |
| // other non-producers (Refinery, Foundry, Arsenal, Datacenter) are all excluded. Pure def | |
| // predicate — deterministic, shared by the draw math, the boost application, and the HUD toggle. | |
| export function isElectrifiable(type) { | |
| const def = BUILDINGS[type]; | |
| if (!def) return false; | |
| if (def.recipe || def.energyGrants || def.rig || def.wonder || def.combust) return false; | |
| return !!(def.produces || def.supplyGrants); | |
| } | |
| // ---- Finite storage (Odyssey logistics) --------------------------------------- | |
| // A producing building banks its OUTPUT into a finite `building.store` buffer, and a | |
| // factory OR a fuel-burning power station draws its INPUTS (a recipe's ingredients, or a | |
| // Combustion Generator's / Biomass Reactor's fuel) from a finite `building.input` buffer — | |
| // both commodity→qty maps, capped by the def. Goods aren't spendable (or consumable) until a | |
| // worker moves them (engine/haul.js): output is hauled to a Command Center, inputs are | |
| // carried in from the treasury. So storage is a real, mindful constraint, not an infinite sink. | |
| // | |
| // Caps: a def can pin `storeCap` / `inputCap` explicitly (the Plasma Rig pins a big storeCap | |
| // and has no input buffer — it digs its own raw ore, nothing to feed it); any building with a | |
| // `recipe` (the factories) OR a `combust` (the fuel-burning power stations) otherwise gets the | |
| // shared default. Everything else has no buffer (cap 0), so these helpers are no-ops for the | |
| // whole skirmish roster. | |
| const DEFAULT_FACTORY_STORE = 80; // a factory's output backlog before it stalls, ~tens of batches | |
| const DEFAULT_FACTORY_INPUT = 80; // a factory's WHOLE input larder before it starves — split evenly | |
| // per real input commodity below, NOT one pool every commodity races for | |
| const RECIPE_BY_ID = Object.fromEntries(RECIPES.map(r => [r.id, r])); | |
| /** The output-buffer capacity of a building type, or 0 if it has no buffer. */ | |
| export function storeCapOf(type) { | |
| const def = BUILDINGS[type]; | |
| if (!def) return 0; | |
| if (def.storeCap != null) return def.storeCap; | |
| return def.recipe ? DEFAULT_FACTORY_STORE : 0; | |
| } | |
| // The REAL (haulable) input commodities a building needs hauled in — a recipe's ingredients | |
| // (every key but "energy", which is a live per-tick Power draw, engine/industry.js, never a | |
| // hauled/stored good), a fuel-burning power station's acceptable fuels (def.combust.fuels — | |
| // gas for the Combustion Generator, biomass for the Biomass Reactor; a building CAN accept more | |
| // than one — ANY ONE of them keeps it running, not all at once — see haul.js inputNeedsOf/ | |
| // neededInput, which already treats "pick whichever's neediest" the same way for both an | |
| // AND-recipe and an OR-fuel-choice), or an ammo-fed static defense's single feed commodity | |
| // (def.ammo.com — the Torpedo Battery's plasmatorp). Empty for a building with none of the | |
| // three (or an unknown recipe id — belt-and-suspenders for stale data). | |
| function realInputComs(type) { | |
| const def = BUILDINGS[type]; | |
| const recipe = RECIPE_BY_ID[def?.recipe]; | |
| if (recipe) return Object.keys(recipe.in).filter(c => c !== "energy"); | |
| if (def?.combust) return def.combust.fuels; | |
| if (def?.ammo) return [def.ammo.com]; | |
| return []; | |
| } | |
| // The input larder's total capacity is split EVENLY across however many real commodities the | |
| // recipe needs, so each gets its OWN guaranteed slice — a 2-input recipe (e.g. chipfab: crystals + | |
| // metals) gets 40 each of an 80 total, a 3-input one (e.g. plasmafab) gets ~26.7 each. Without | |
| // this a single over-supplied input (workers keep bringing whichever the treasury happens to have | |
| // plenty of) can fill the WHOLE shared pool on its own, leaving zero room for whichever OTHER | |
| // input the recipe is actually starved of — the factory then sits stalled forever on a "Starved" | |
| // input it can never actually receive, since haul.js's inputRoom check (below) always reads 0. | |
| /** The per-commodity input-buffer capacity of a building type (a factory, a fuel-burning power | |
| * station, or an ammo-fed static defense), or 0 if it has none. */ | |
| export function inputCapOf(type) { | |
| const def = BUILDINGS[type]; | |
| if (!def) return 0; | |
| const total = def.inputCap != null ? def.inputCap : ((def.recipe || def.combust || def.ammo) ? DEFAULT_FACTORY_INPUT : 0); | |
| if (total <= 0) return 0; | |
| const n = realInputComs(type).length; | |
| return n > 0 ? total / n : total; | |
| } | |
| /** Sum a commodity→qty buffer (order-independent → deterministic); 0 for a missing buffer. */ | |
| function bufTotal(buf) { | |
| let t = 0; | |
| if (buf) for (const c in buf) t += buf[c] || 0; | |
| return t; | |
| } | |
| /** How much is currently sitting in a building's output buffer (0 if none). */ | |
| export function storeTotal(building) { return bufTotal(building.store); } | |
| /** The free room left in a building's output buffer (clamped ≥ 0). */ | |
| export function storeRoom(building) { | |
| return Math.max(0, storeCapOf(building.type) - storeTotal(building)); | |
| } | |
| /** How much (of every commodity combined) is currently sitting in a factory's input buffer. */ | |
| export function inputTotal(building) { return bufTotal(building.input); } | |
| /** The free room left for ONE SPECIFIC input commodity (clamped ≥ 0) — each real input commodity | |
| * gets its own independent slice of the larder (inputCapOf), so one oversupplied input can never | |
| * crowd out room for another the recipe still needs. @param {Building} building @param {string} com */ | |
| export function inputRoom(building, com) { | |
| return Math.max(0, inputCapOf(building.type) - (building.input?.[com] || 0)); | |
| } | |
| // ---- Freighter cargo hold (Odyssey freight) ------------------------------------ | |
| // A freighter's `freight` is a multi-commodity hold (unlike a worker's single-slot `cargo`), | |
| // capped by `def.cargoHold`. Lives here (not engine/galaxy.js, where the player-manual | |
| // load/unload panel logic lives) so engine/haul.js can read a freighter's room/fill too — the | |
| // worker↔freighter physical loading path — without importing galaxy.js, which itself imports | |
| // engine/sim.js -> engine/haul.js and would otherwise be a cycle. galaxy.js re-exports both. | |
| /** How much is currently aboard a freighter's hold (0 for a non-freighter unit). */ | |
| export function freightUsed(unit) { return unit ? bufTotal(unit.freight) : 0; } | |
| /** A freighter's remaining hold room = its cargoHold minus what's aboard (0 for a non-freighter). */ | |
| export function freightRoom(unit) { | |
| const cap = unit ? (UNITS[unit.type]?.cargoHold || 0) : 0; | |
| return Math.max(0, cap - freightUsed(unit)); | |
| } | |
| // Player-wide Refinery upgrades, arranged as three MUTUALLY EXCLUSIVE doctrines, each three tiers | |
| // deep (docs/improvement-proposals.md's doctrine-depth redesign brought Assault and Bulwark up to | |
| // the depth Logistics already had). You commit to Assault (offense), Bulwark (defense), or | |
| // Logistics (economy/tempo) — researching any upgrade of one doctrine locks the others — and can | |
| // then deepen your chosen path tier by tier (each requiring the tier right below it, via the same | |
| // prereqsMet machinery the tech tree uses). So "which upgrade" is a real strategic fork with an | |
| // opportunity cost, not a buy-both no-brainer. Like the Odyssey tech tree's TECHS | |
| // (engine/techtree.js), each entry is PAID ON ENQUEUE and DEVELOPED OVER TIME — `time` is seconds | |
| // to develop at a tech-5 world, scaled by researchTimeScale — queued at a Refinery via | |
| // production.js's researchUpgrade and ticked by the SAME updateResearch loop the Datacenter uses | |
| // (it resolves TECHS or UPGRADES by building.type). Effects apply live, army-wide (and base-wide | |
| // — see reinforcedPlating/reinforcedBulwark below), the instant a queued upgrade completes; | |
| // multipliers stack multiplicatively in combat.js. Assault costs radioactives, Bulwark crystals — | |
| // so a world's deposit specialty tilts which combat doctrine comes easier. | |
| // Each doctrine's Tier-3 is a CAPSTONE, additionally gated on a completed Arsenal (not just its | |
| // own Tier-2) — Logistics' is a capability flag (recycling); Assault's and Bulwark's each change | |
| // TEXTURE, not just magnitude, so the deepening tier adds a genuine tactical verb rather than a | |
| // third copy of the same multiplier (see overdriveActuators/selfSealingPlating below). | |
| // `ico` is the doctrine's emblem (assault ⚔️, bulwark 🛡️, logistics 📦), reused on the Refinery | |
| // research buttons so the doctrine reads at a glance — same iconography as the rest of the HUD; | |
| // a Tier-3 capstone breaks from its own doctrine's emblem for a more specific one instead | |
| // (recycling ♻️, overdriveActuators ⚡, selfSealingPlating 🩹), the same way recycling already did. | |
| export const UPGRADES = { | |
| overchargedWeapons: { | |
| id: "overchargedWeapons", name: "Overcharged Weapons", doctrine: "assault", tier: 1, ico: "⚔️", | |
| cost: { radioactives: 150 }, time: 25, desc: "+15% damage dealt by all combat units", damageDealtMult: 1.15, | |
| }, | |
| // Doctrine depth (docs/improvement-proposals.md "Give the doctrine Tier-2s a verb"): a flat | |
| // damage stack alone changes no decision a player makes IN a fight, so Tier-2 also grants a | |
| // tactical verb on top of it — chaseSpeedMult moves an Assault army ~10% faster specifically | |
| // while it's chasing an already-acquired target (the out-of-weapon-range chase branch in | |
| // engine/combat.js updateCombat), never on a plain move order. Read by upgradeMult exactly like | |
| // damageDealtMult — it's a genuine multiplier, just consumed at a different call site. | |
| overchargedCore: { | |
| id: "overchargedCore", name: "Overcharged Core", doctrine: "assault", tier: 2, ico: "⚔️", | |
| cost: { radioactives: 200, ore: 120 }, time: 32, requires: ["overchargedWeapons"], | |
| desc: "+15% more damage dealt (stacks with Overcharged Weapons); +10% move speed while chasing an acquired target", | |
| damageDealtMult: 1.15, chaseSpeedMult: 1.1, | |
| }, | |
| // The Arsenal-gated capstone (docs/improvement-proposals.md "Tier-3 doctrine capstones"): | |
| // texture, not just magnitude. Tier-2's chaseSpeedMult is about CLOSING a fight; this is about | |
| // WINNING it once joined — a genuinely different tactical identity (tempo), so it needs no | |
| // reconciliation with Tier-2 the way Bulwark's regen does below. Applied at every "reset the | |
| // cooldown after a landed shot" site in engine/combat.js — the main unit attack path and | |
| // updateWorkerCombat — but deliberately NOT updateBuildingCombat: this is the ARMY's tempo | |
| // upgrade (mobile units only), not a base-defense buff. Bulwark, not Assault, is the doctrine | |
| // that already reaches structures too (see reinforcedPlating's own comment below). Mixed | |
| // building+upgrade requires — prereqsMet already resolves both token kinds. | |
| overdriveActuators: { | |
| id: "overdriveActuators", name: "Overdrive Actuators", doctrine: "assault", tier: 3, ico: "⚡", | |
| cost: { radioactives: 220, ore: 140 }, time: 38, requires: ["overchargedCore", "arsenal"], | |
| desc: "-10% attack cooldown — the army shoots faster once it's engaged", attackCooldownMult: 0.9, | |
| }, | |
| // "all units and structures", not just combat units: attackDamage (engine/combat.js) applies | |
| // damageTakenMult to EVERY target it computes damage for — units AND buildings alike, with no | |
| // kind/role filter — so Bulwark already shields turrets, the Command Center, and Habitats too. | |
| // Bulwark is the defense doctrine for the army AND the base. | |
| reinforcedPlating: { | |
| id: "reinforcedPlating", name: "Reinforced Plating", doctrine: "bulwark", tier: 1, ico: "🛡️", | |
| cost: { crystals: 150 }, time: 25, desc: "-12% damage taken by all units and structures", damageTakenMult: 0.88, | |
| }, | |
| // Doctrine depth, the Bulwark half (docs/improvement-proposals.md "Give the doctrine Tier-2s a | |
| // verb" AND "Tier-3 doctrine capstones" — RECONCILED into one mechanic here; see | |
| // selfSealingPlating below for why there's only one regen system, not two independently-tracked | |
| // ones). This is the verb itself: role:"combat" army units passively heal `regenRate` hp/s once | |
| // `regenDelay` seconds have passed since they last took a hit (engine/repair.js | |
| // updateBulwarkRegen reads these two fields directly, like recycling's capability flag below — | |
| // NOT through the generic upgradeMult product, since a rate and a delay aren't multipliers to | |
| // stack, they're the two knobs of one mechanic). "Win attrition wars by cycling out of fights" — | |
| // strictly out-of-combat: a unit under continuous fire keeps restamping unit.lastHitAt | |
| // (engine/combat.js) every hit, so it never crosses even this delay — see | |
| // test/balance.test.js's auto-battle duels, untouched by design. | |
| reinforcedBulwark: { | |
| id: "reinforcedBulwark", name: "Reinforced Bulwark", doctrine: "bulwark", tier: 2, ico: "🛡️", | |
| cost: { crystals: 200, ore: 120 }, time: 32, requires: ["reinforcedPlating"], | |
| desc: "-12% more damage taken (stacks with Reinforced Plating); army units regenerate hp once out of combat", | |
| damageTakenMult: 0.88, regenRate: 0.5, regenDelay: 8, | |
| }, | |
| // The Bulwark capstone (docs/improvement-proposals.md "Tier-3 doctrine capstones") — and the | |
| // RECONCILIATION point with "Give the doctrine Tier-2s a verb" above, which independently | |
| // proposed the exact same "out-of-combat hp regen" identity for reinforcedBulwark. Rather than | |
| // ship two separately-tracked regen fields (a silent double-heal for a player who owns both, or | |
| // a Tier-3 pick that just restates what Tier-2 already grants), this is ONE mechanic: | |
| // engine/repair.js's updateBulwarkRegen reads regenRate/regenDelay off whichever of these two | |
| // upgrades the player holds, this capstone's numbers winning whenever both are present — so a | |
| // save can never double-apply both tiers at once. And this entry genuinely DEEPENS Tier-2's | |
| // grant rather than repeating it: 3x the heal rate, well under half the unhit delay. A | |
| // Tier-2-only army must fully disengage for 8s before it heals at all; a Tier-2+3 army peels a | |
| // wounded unit out for a much shorter breather AND patches it up faster once it does — "armies | |
| // that hold ground recover" (the proposal's own framing), a sustain identity that complements | |
| // the Mender rather than replacing it. Still strictly out-of-combat at every tier: the | |
| // shortened delay is still a real delay, so a continuously-hit unit (lastHitAt restamped every | |
| // hit) never benefits at ANY tier — see test/repair.test.js's reconciliation-proving cases. | |
| selfSealingPlating: { | |
| id: "selfSealingPlating", name: "Self-Sealing Plating", doctrine: "bulwark", tier: 3, ico: "🩹", | |
| cost: { crystals: 220, ore: 140 }, time: 38, requires: ["reinforcedBulwark", "arsenal"], | |
| desc: "out-of-combat hp regen kicks in sooner and heals faster than Reinforced Bulwark alone", | |
| regenRate: 1.5, regenDelay: 3, | |
| }, | |
| // A third doctrine that isn't about the fight at all: Logistics trades combat | |
| // upgrades for economy and tempo. Committing to it locks Assault AND Bulwark | |
| // (and vice-versa) through the same committedDoctrine machinery, so "out-macro | |
| // them" is a real, mutually-exclusive plan against "out-fight them" — not a | |
| // free third buy. gatherYieldMult/produceTimeMult are read by gather.js and | |
| // production.js the same data-driven way the damage mults are read by combat.js. | |
| logisticsNetwork: { | |
| id: "logisticsNetwork", name: "Logistics Network", doctrine: "logistics", tier: 1, ico: "📦", | |
| cost: { crystals: 140 }, time: 25, desc: "+25% resource yield from every haul", gatherYieldMult: 1.25, | |
| }, | |
| rapidFabrication: { | |
| id: "rapidFabrication", name: "Rapid Fabrication", doctrine: "logistics", tier: 2, ico: "📦", | |
| cost: { crystals: 160, ore: 120 }, time: 32, requires: ["logisticsNetwork"], | |
| desc: "-20% unit & building production time", produceTimeMult: 0.8, | |
| }, | |
| // No multiplier field: unlike its two Logistics siblings above, this GATES a capability | |
| // (raises the recycling refund cap) rather than feeding the generic upgradeMult product — read | |
| // directly by id, the same way FREIGHTER_AI_TECH is (engine/recycle.js RECYCLE_TECH). Shares | |
| // that exact id with the Odyssey tech tree's own "recycling" node (engine/techtree.js) — only | |
| // one of the two trees is ever active in a given match, so the shared key is safe and lets | |
| // engine/recycle.js check a single flag regardless of mode. | |
| recycling: { | |
| id: "recycling", name: "Field Recycling", doctrine: "logistics", tier: 3, ico: "♻️", | |
| cost: { crystals: 180, ore: 140 }, time: 38, requires: ["rapidFabrication"], | |
| desc: "+30% of a recycled unit/building's cost reclaimed (up to an 80% cap)", | |
| }, | |
| // Hard difficulty's economic edge (engine/aiDifficulty.js) — seeded straight onto | |
| // state.players.ai.upgrades at creation (engine/state.js), never researched, so it needs | |
| // none of a real entry's machinery: no cost, no time, no doctrine, no tier/requires. It rides | |
| // the exact same gatherYieldMult/produceTimeMult fields logisticsNetwork/rapidFabrication use — | |
| // gather.js/production.js need no changes at all to pick it up. `aiOnly` keeps it out of the | |
| // player-facing Refinery research panel and its cost fingerprint (hudSelection.js); having no | |
| // `doctrine` keeps it invisible to committedDoctrine (which now guards on `.doctrine` | |
| // explicitly — see below) and to aiEconomy.js's per-doctrine research path. | |
| hardEdge: { | |
| id: "hardEdge", name: "Hard Edge", aiOnly: true, | |
| gatherYieldMult: 1.1, produceTimeMult: 0.9, | |
| }, | |
| }; | |
| // Product of a multiplier field across a player's RESEARCHED upgrades (1 when | |
| // none apply) — the single place combat/gather/production read upgrade effects. | |
| // A new upgrade is then pure data: give it a field, and its multiplier is picked | |
| // up wherever that field is consumed (damageDealtMult, damageTakenMult, | |
| // gatherYieldMult, produceTimeMult, ...). | |
| export function upgradeMult(upgrades, field) { | |
| let m = 1; | |
| if (!upgrades) return m; | |
| for (const id of Object.keys(upgrades)) { | |
| if (upgrades[id] && UPGRADES[id] && UPGRADES[id][field]) m *= UPGRADES[id][field]; | |
| } | |
| return m; | |
| } | |
| // The doctrine a player has committed to — the doctrine of any upgrade they've | |
| // researched, OR is still developing (queued at a Refinery, not yet complete) — or | |
| // null if neither. Researching (or queuing) an upgrade of the other doctrine is | |
| // then locked out (see production.js's researchUpgrade). The queued half matters | |
| // because doctrine research now DEVELOPS OVER TIME instead of landing instantly | |
| // (engine/techtree.js updateResearch): the cost is paid up front on enqueue, so the | |
| // commitment has to bite the instant it's queued, not only once the timer finishes | |
| // — otherwise both doctrines could sit queued side-by-side during the development | |
| // window, defeating the whole "real commitment" point above. Scoped to `type === | |
| // "refinery"` specifically (not just "any researchQueue"): a Datacenter's OWN queue | |
| // uses the SAME field name but resolves against TECHS, which shares no doctrine | |
| // tokens with UPGRADES except the deliberately-overlapping "recycling" id — cross- | |
| // checking a Datacenter job against UPGRADES here would misread that shared id as a | |
| // Logistics commitment. `state.buildings` is optional-chained so a bare test state | |
| // (no buildings map at all) reads as "nothing queued", identical to before this queued | |
| // half existed. | |
| // Guards on `.doctrine` itself, not just UPGRADES membership: a non-doctrine entry | |
| // (hardEdge, Hard difficulty's seeded economic edge) must stay invisible here, the same | |
| // way researchUpgrade's own doctrine-lock check already reads `def.doctrine` rather than | |
| // just `UPGRADES[id]` — without this, hardEdge being seeded before any real research would | |
| // make this return `undefined` forever, silently disabling the doctrine lock entirely. | |
| export function committedDoctrine(state, owner) { | |
| const ups = state.players[owner].upgrades; | |
| for (const id of Object.keys(ups)) if (ups[id] && UPGRADES[id]?.doctrine) return UPGRADES[id].doctrine; | |
| for (const b of state.buildings?.values() || []) { | |
| if (b.owner !== owner || b.type !== "refinery" || !b.researchQueue) continue; | |
| for (const job of b.researchQueue) { const def = UPGRADES[job.techId]; if (def?.doctrine) return def.doctrine; } | |
| } | |
| return null; | |
| } | |
| // A STANDING structure's bonus: the product of a multiplier field across a player's own | |
| // COMPLETED buildings whose def carries it (e.g. produceTimeMult on the Foundry/Arsenal above) — | |
| // the live-scanned counterpart to upgradeMult/techMult, which read a RESEARCHED id instead of a | |
| // building that has to keep standing. Mirrors committedDoctrine's own live scan just above: razing | |
| // the building drops the bonus on the very next read, with no separate flag to track or clear. | |
| // Multiple standing structures with the same field STACK multiplicatively (a Foundry AND an | |
| // Arsenal both apply), same rule upgradeMult/techMult already use for stacking research. 1 (no-op) | |
| // for an owner with no completed building carrying that field. | |
| export function structureMult(state, owner, field) { | |
| let m = 1; | |
| for (const b of state.buildings?.values() || []) { | |
| if (b.owner !== owner || b.constructing) continue; | |
| const def = BUILDINGS[b.type]; | |
| if (def && def[field]) m *= def[field]; | |
| } | |
| return m; | |
| } | |
| // Veterancy ranks (docs/improvement-proposals.md "Veterancy ranks: kills forge small combat | |
| // multipliers and visible chevrons"): each rank layers on the same ~+6% damage-dealt / -6% | |
| // damage-taken edge, so a whole campaign's survivors compound rather than jumping to full | |
| // strength off one lucky trade. Thresholds (3/8/18 kills) are spaced so a single engagement | |
| // rarely mints even rank 1 — combat.js's performAttack only increments `kills` on a CONFIRMED | |
| // kill by a unit-kind attacker, so racking up 3 in one fight means winning three separate | |
| // exchanges, not one. Verified against test/balance.test.js's whole auto-battle regression | |
| // harness (the duel/cracksBase-style invariants), which stays green with veterancy folded in. | |
| export const VETERANCY_RANKS = [ | |
| { kills: 3, dealtMult: 1.06, takenMult: 0.94 }, | |
| { kills: 8, dealtMult: 1.06 ** 2, takenMult: 0.94 ** 2 }, | |
| { kills: 18, dealtMult: 1.06 ** 3, takenMult: 0.94 ** 3 }, | |
| ]; | |
| // A unit's veterancy rank (0..VETERANCY_RANKS.length) and the two multipliers that go with it — | |
| // 1/1 (no-op) below the first threshold, or for anything with no `kills` field at all (a fresh | |
| // unit off the line, or a building/turret, which never accrues kills). Pure and side-effect-free | |
| // so attackDamage (combat.js) and the chevron renderer (renderUnits.js) can both call it straight | |
| // off the entity with no shared bookkeeping. | |
| /** @param {Unit} unit @returns {{ rank: number, dealtMult: number, takenMult: number }} */ | |
| export function rankMults(unit) { | |
| const kills = unit?.kills || 0; | |
| let rank = 0; | |
| for (const r of VETERANCY_RANKS) { if (kills < r.kills) break; rank++; } | |
| const tier = VETERANCY_RANKS[rank - 1]; | |
| return { rank, dealtMult: tier ? tier.dealtMult : 1, takenMult: tier ? tier.takenMult : 1 }; | |
| } | |
| // Skiff, Bastion and Lancer form a deliberate rock-paper-scissors: each | |
| // one's bonusVs targets exactly the unit that would otherwise be its | |
| // hardest matchup, and nothing beats all three at once. | |
| // Skiff -> beats Lancer (fast raiders shred a lightly-armored gun platform before it can find its range) | |
| // Bastion -> beats Skiff (heavy armor shrugs off skiff fire and tears through light hulls up close) | |
| // Lancer -> beats Bastion (armor-piercing rounds built specifically to punch through heavy plating) | |
| export const UNITS = { | |
| worker: { | |
| id: "worker", name: "Worker", hp: 40, radius: 6, speed: 60, | |
| cost: { ore: 50 }, altCost: { biomass: 50 }, buildTime: 8, supplyCost: 1, | |
| // `altCost` is an EITHER/OR price: a worker can be trained on ore (the default) or on | |
| // biomass instead (engine/production.js queueProduction's `alt` flag) — so a crystal/ore-poor, | |
| // biomass-rich claim can still grow its workforce. The queued job remembers which it paid, so a | |
| // cancel refunds the right commodity. | |
| role: "worker", gatherRate: 10, cargoCap: 10, | |
| // Saturation: the first `minerSoftCap` workers on a deposit mine at full | |
| // rate; each one past that pulls only `minerFalloff` of a full share (see | |
| // gather.js's miningEfficiency), so over-piling a node has diminishing | |
| // returns and spreading out / expanding to a fresh field is a real call. | |
| // The cap matches the ~3 home seams and the 3 starting workers, so the | |
| // opening economy is never penalised. | |
| minerSoftCap: 3, minerFalloff: 0.4, | |
| sight: 110, | |
| // Can defend itself in a pinch — a weak short-range strike — but only when | |
| // explicitly ordered to attack. Workers never auto-acquire, so they don't | |
| // abandon the economy to go pick fights; a handful ganging up can drive off | |
| // a lone raider, but they're no substitute for real military units. | |
| attack: 4, range: 15, cooldown: 1.4, | |
| // The one economy unit, and it does everything: every build category, gather, AND | |
| // logistics — no specialization, no gate. | |
| buildCategories: ["infrastructure", "military", "industrial"], canGather: true, canLogistics: true, | |
| }, | |
| ranger: { | |
| id: "ranger", name: "Ranger", hp: 50, radius: 6, speed: 115, | |
| cost: { ore: 45 }, buildTime: 10, supplyCost: 1, | |
| // A dedicated recon unit, built at the Command Center like a Worker. Cheap | |
| // and fragile — it scouts, it doesn't fight — with a token bite for | |
| // self-defence only (role "scout" ⇒ it never auto-acquires, so it won't wander | |
| // into a fight on its own; the attack fires only when explicitly ordered, like | |
| // a Worker's). Its edges are the three things a scout wants: | |
| role: "scout", attack: 6, range: 22, cooldown: 1.3, | |
| sight: 340, // sees far — vision is the whole point of the unit | |
| allTerrain: true, // ice fields and rough ground never slow it (movement.js honours this flag) | |
| // ...and a "scout mode" (issueScout / order type "scout") where it ranges the | |
| // map on its own, heading for the nearest unexplored ground — see scout.js. | |
| }, | |
| colonyship: { | |
| id: "colonyship", name: "Colony Ship", hp: 600, radius: 13, speed: 48, | |
| cost: { ore: 500 }, buildTime: 40, supplyCost: 3, | |
| // The mobile seed of a base (Odyssey only): move it to a site and DEPLOY it | |
| // (engine/colony.js) into a Command Center; its colonists — the opening workers | |
| // — disembark on deploy. Its own non-combat role: unarmed (no `attack`, so it | |
| // can never be ordered to fight), never auto-acquires, and is transparent to the | |
| // army/threat scans — but the main-acquire still lets enemies shoot it, so it's a | |
| // real escort risk on the trek, not incidentally invincible. Pricier than the CC | |
| // (400) it replaces: the mobility premium. | |
| role: "colony", sight: 200, | |
| odysseyOnly: true, | |
| }, | |
| skiff: { | |
| id: "skiff", name: "Skiff", hp: 72, radius: 7, speed: 90, | |
| cost: { ore: 100 }, buildTime: 12, supplyCost: 1, | |
| role: "combat", attack: 12, range: 40, cooldown: 1, | |
| sight: 160, aggroRange: 120, | |
| // Fast and cheap, but a touch fragile (72 hp): it wins by harassment and | |
| // numbers, not by trading blows, so its counters punish it faster now. | |
| bonusVs: { lancer: 10 }, | |
| }, | |
| bastion: { | |
| id: "bastion", name: "Bastion", hp: 160, radius: 9, speed: 68, | |
| cost: { ore: 160 }, buildTime: 18, supplyCost: 2, | |
| role: "combat", attack: 10, range: 44, cooldown: 1.2, | |
| sight: 130, aggroRange: 110, | |
| // Its job is to catch and crush Skiffs. It now OUT-RANGES the Skiff (44 vs 40) — | |
| // just barely, still under the AI's KITE_MIN_RANGE 50 so it stands and trades rather | |
| // than kiting — so a player-microed Skiff can no longer sit at 40 and orbit forever | |
| // outside the reach of the very unit built to hard-counter it. bonusVs trimmed to 10 | |
| // (from 14) so the head-on time-to-kill stays close to before despite the extra reach. | |
| bonusVs: { skiff: 10 }, | |
| }, | |
| lancer: { | |
| id: "lancer", name: "Lancer", hp: 70, radius: 8, speed: 75, | |
| cost: { ore: 150 }, buildTime: 16, supplyCost: 2, | |
| role: "combat", attack: 16, range: 55, cooldown: 1.4, | |
| sight: 170, aggroRange: 130, | |
| bonusVs: { bastion: 20 }, | |
| requires: ["foundry"], // Tier-2: the answer to a massed Bastion ball, but you must tech to it | |
| }, | |
| breacher: { | |
| id: "breacher", name: "Breacher", hp: 130, radius: 10, speed: 50, | |
| cost: { ore: 100, radioactives: 60 }, buildTime: 20, supplyCost: 2, | |
| role: "combat", attack: 10, range: 150, cooldown: 2, | |
| sight: 180, aggroRange: 150, | |
| // Deliberately OUTSIDE the Skiff/Lancer/Bastion triangle: no bonusVs | |
| // any unit type, and no unit gets bonusVs breacher. Its whole identity | |
| // is the class-wide structure bonus below plus outranging the turret. | |
| bonusVsBuildings: 30, | |
| prefersBuildings: true, | |
| // Not a bonusVs-derived hard counter (this adds no new combat math) — a | |
| // cost-parity Skiff swarm still crushes it in practice (test/balance.test.js), | |
| // "folds to massed Skiffs for a fraction of its cost" per README. Data the | |
| // AI's counter-pick (engine/aiMilitary.js COUNTER_OF) can fold in directly. | |
| counteredBy: "skiff", | |
| requires: ["foundry"], // Tier-2 siege: a tech investment, not a turn-one option | |
| }, | |
| dreadnought: { | |
| id: "dreadnought", name: "Dreadnought", hp: 340, radius: 12, speed: 42, | |
| cost: { ore: 240, radioactives: 100 }, buildTime: 30, supplyCost: 4, | |
| role: "combat", attack: 26, range: 68, cooldown: 1.6, | |
| sight: 190, aggroRange: 150, | |
| // Tier-3 capital platform: tanky, long-reaching, heavy-hitting — a real | |
| // power spike you tech to (Barracks -> Foundry -> Arsenal). Deliberately | |
| // OUTSIDE the rock-paper-scissors triangle, like the Breacher: no bonusVs | |
| // any type and nothing bonuses against it, and its steep cost + 4 supply | |
| // mean cheaper massed units still trade cost-effectively into it — so it | |
| // anchors an army rather than hard-countering it. | |
| counteredBy: "skiff", // the cost-efficiency answer above, certified by test/balance.test.js's supply-parity duel | |
| requires: ["arsenal"], | |
| }, | |
| mender: { | |
| id: "mender", name: "Mender", hp: 70, radius: 8, speed: 78, | |
| cost: { ore: 90, crystals: 60 }, buildTime: 16, supplyCost: 2, | |
| // A pure-support drone: no attack of any kind (role "support" ⇒ it never | |
| // auto-acquires and combat.js never gives it a weapon). It closes a real | |
| // gap in the roster — until now every hp lost was permanent, so attrition | |
| // always favoured whoever could out-produce. A Mender lets a bruised army | |
| // heal between fights and lets a besieged base patch its buildings, so | |
| // *keeping* an army alive becomes a strategy, not just re-buying it. | |
| role: "support", requires: ["foundry"], sight: 130, | |
| // Heals every damaged friendly unit AND building within repairRange at | |
| // repairRate hp/sec each (see repair.js) — capped at each target's maxHp, | |
| // never itself, never something still under construction. Fragile and | |
| // unarmed, so it's a priority kill: escort it or lose it. | |
| repairRate: 6, repairRange: 110, | |
| }, | |
| // The convoy freighter — a defenceless cargo hauler used only by the scenario | |
| // modes (engine/scenarios.js), never trained at a building. Slow, no weapon | |
| // (role "freighter" ⇒ it never auto-acquires and combat.js never arms it), but | |
| // a big hull so it can survive a raid long enough for its escort to answer. | |
| // supplyCost/sight satisfy the roster invariants; cost is empty (it's spawned, | |
| // not bought). | |
| freighter: { | |
| id: "freighter", name: "Freighter", hp: 220, radius: 11, speed: 46, | |
| cost: {}, buildTime: 0, supplyCost: 1, | |
| role: "freighter", sight: 130, | |
| }, | |
| /* ---- ODYSSEY FREIGHT — cargo ships in three sizes. A jump's cargo hold is the combined | |
| `cargoHold` of the cargo ships staged for it (engine/galaxy.js freightCapacity), so hauling | |
| manufactured goods between worlds means building and staging shipping: a bigger fleet, or | |
| bigger ships, moves more per trip. Role "freighter" ⇒ they carry no weapon (combat.js never | |
| arms them), so they need escorting. Gated behind the Spaceport (no point shipping without a | |
| jump pad) and Odyssey-only, so the skirmish roster + its byte-identical replay are untouched. | |
| Their supplyCost also draws on the Spaceport's per-jump capacity, so a Bulk Freighter needs a | |
| bigger pad to lift alongside an army. ---- */ | |
| hauler: { | |
| id: "hauler", name: "Hauler", hp: 180, radius: 9, speed: 58, | |
| cost: { ore: 90 }, buildTime: 12, supplyCost: 1, | |
| role: "freighter", sight: 130, cargoHold: 250, odysseyOnly: true, requires: ["spaceport"], | |
| }, | |
| heavyhauler: { | |
| id: "heavyhauler", name: "Heavy Hauler", hp: 350, radius: 12, speed: 44, | |
| cost: { ore: 220 }, buildTime: 24, supplyCost: 3, | |
| role: "freighter", sight: 140, cargoHold: 650, odysseyOnly: true, requires: ["spaceport"], | |
| }, | |
| bulkfreighter: { | |
| id: "bulkfreighter", name: "Bulk Freighter", hp: 600, radius: 15, speed: 32, | |
| cost: { ore: 480 }, buildTime: 42, supplyCost: 6, | |
| role: "freighter", sight: 150, cargoHold: 1600, odysseyOnly: true, requires: ["spaceport"], | |
| }, | |
| /* ---- Tier-3 SPECIALTY units: one per "rare" surface commodity, so a world's | |
| deposit specialty shapes which elite you can field (radioactives already | |
| give the balanced Dreadnought above). All Arsenal-gated, all deliberately | |
| OUTSIDE the Skiff/Bastion/Lancer triangle — situational power, not a hard | |
| counter — and each pays in a commodity that was otherwise never spent (gas | |
| on Vesper/Glacius/Nimbus, ice on Glacius, relics on Korrath/Oort). ---- */ | |
| wraith: { | |
| id: "wraith", name: "Wraith", hp: 84, radius: 8, speed: 104, | |
| cost: { ore: 120, gas: 60 }, buildTime: 18, supplyCost: 2, | |
| role: "combat", attack: 22, range: 58, cooldown: 0.85, | |
| sight: 175, aggroRange: 150, | |
| // Helium-3-fuelled strike craft: the roster's fastest combatant and its | |
| // hardest hitter per shot, but paper-thin — a glass cannon that shreds a | |
| // line and then melts to any focused fire. Gas turns a dead deposit into | |
| // the fuel for raids. | |
| counteredBy: "skiff", // "melts to any focused fire" above, certified by test/balance.test.js's cost-parity duel | |
| requires: ["arsenal"], | |
| }, | |
| aegis: { | |
| id: "aegis", name: "Aegis", hp: 360, radius: 11, speed: 48, | |
| cost: { ore: 160, ice: 90 }, buildTime: 26, supplyCost: 4, | |
| role: "combat", attack: 11, range: 26, cooldown: 1.3, | |
| sight: 140, aggroRange: 110, | |
| // A cryo-armoured wall: the tankiest hull in the game with an almost token gun. It | |
| // doesn't kill things — it projects a cryo-armour bubble that REDUCES the damage its | |
| // nearby allies take (guardAura, read in combat.js attackDamage), so the army fighting | |
| // around it lives longer wherever it stands — no need to pre-position it as a literal | |
| // wall, and enemy targeting doesn't have to cooperate. The anvil to the Wraith's hammer. | |
| // Faster now (48) so it can keep formation with the line it shields. Ice is its armour. | |
| guardAura: { range: 96, damageTakenMult: 0.82 }, | |
| // Out-shot, not out-tanked: armies are supply-capped lategame, not cost-capped | |
| // (cost parity actually favours the Aegis — its hp pool buys more survivability | |
| // per ore than the Lancer's), but at equal SUPPLY the Lancer's armor-piercing | |
| // rounds out-DPS the almost-token gun before the huge hp pool matters — the | |
| // Wraith's hammer needed an anvil; the Aegis needed a sharper spear. Certified | |
| // by test/balance.test.js's supply-parity duel. | |
| counteredBy: "lancer", | |
| requires: ["arsenal"], | |
| }, | |
| colossus: { | |
| id: "colossus", name: "Colossus", hp: 150, radius: 12, speed: 32, | |
| cost: { ore: 180, relics: 80 }, buildTime: 30, supplyCost: 4, | |
| role: "combat", attack: 42, range: 185, cooldown: 2.6, | |
| sight: 210, aggroRange: 185, | |
| // A reactivated ancient siege engine: out-ranges everything on the field — | |
| // the Sentinel Turret (130) and even the Breacher (150) — and hits like a | |
| // truck, but fires slowly, crawls, and is fragile for its cost, so it must | |
| // be screened or it's sniped/rushed down. A flat structure bonus makes it a | |
| // base-cracker. Relics (ancient tech) are its ammunition. | |
| bonusVsBuildings: 25, | |
| // The T3 anti-mass verb (docs/improvement-proposals.md "Colossus splash"): the primary hit | |
| // also rattles enemy units caught within `radius` of the impact point, for `frac` of this | |
| // hit's damage, falling off linearly to zero at the edge (engine/combat.js performAttack). | |
| // This is the mechanical answer to "spread out vs artillery" — a packed formation (exactly | |
| // what separation.js's own same-owner packing produces) eats real splash; a spread one barely | |
| // does. Enemy-only and units-only by construction (performAttack only ever walks | |
| // state.unitGrid/state.units, never state.buildings) — never the Colossus's own side, and | |
| // never a building, however close one stands to the impact. Tuned against | |
| // test/balance.test.js the same way SALVAGE_FRAC once was: the Skiff counter (below) must | |
| // still win head-on, cost-parity, splash included. | |
| splash: { radius: 26, frac: 0.5 }, | |
| // "must be screened or it's sniped/rushed down" above, certified by | |
| // test/balance.test.js's supply-parity duel: fragile and slow-firing, it | |
| // folds to a mass it can't kill fast enough. | |
| counteredBy: "skiff", | |
| requires: ["arsenal"], | |
| }, | |
| leviathan: { | |
| id: "leviathan", name: "Leviathan", hp: 900, radius: 14, speed: 34, | |
| cost: { ore: 300, ai: 3, plasmatorp: 4 }, buildTime: 60, supplyCost: 8, | |
| role: "combat", attack: 70, range: 200, cooldown: 2.4, | |
| sight: 220, aggroRange: 190, | |
| // The Strategic-tier capital ship: built only at a Star Dock (Odyssey-only), | |
| // costed in AI Cores + Plasma Torpedoes you must MANUFACTURE — the military | |
| // half of the endgame. Huge hull, long reach, a base-cracker's structure | |
| // bonus. Deliberately OUTSIDE the rock-paper-scissors triangle (no bonusVs, | |
| // nothing hard-counters it) — but 8 supply and a strategic-good price mean a | |
| // swarm of cheap units still trades into it, and every good spent on a | |
| // Leviathan is one not fed to the Antimatter Gate. | |
| bonusVsBuildings: 40, | |
| requires: ["stardock"], | |
| odysseyOnly: true, // the endgame capital ship deliberately exceeds the skirmish specialists (see entities.test) | |
| }, | |
| heliumbomb: { | |
| id: "heliumbomb", name: "Helium Bomb", hp: 80, radius: 10, speed: 60, | |
| cost: { gas: 150, antimatter: 3, plasmatorp: 3 }, buildTime: 45, supplyCost: 3, | |
| // A doomsday device, not a combatant: no `attack`, and role "bomb" (not | |
| // "combat") means it never auto-fights and the AI's army/threat scans | |
| // (which filter role === "combat") skip right past it, the same way they | |
| // skip the Colony Ship. It's still a perfectly legal target for an ENEMY's | |
| // own auto-acquire — combat.js's targeting picks the nearest live enemy of | |
| // any role, not just role:"combat" — so shooting an armed one is the worst | |
| // possible move (see engine/bomb.js: any hit on an armed bomb detonates it | |
| // instead of just damaging it). | |
| role: "bomb", sight: 150, | |
| requires: ["stardock"], | |
| odysseyOnly: true, | |
| }, | |
| }; | |
| // Every commodity that anything (a unit, a building, an upgrade) actually costs — computed | |
| // once. Shared by aiWorkers.js's assignIdleWorkers (so a poor-economy world's AI, e.g. Glacius' | |
| // ice/gas it can never spend, prefers nodes it can actually use) and market.js's AI barter (so | |
| // it never treats an already-dead-end commodity as a real "bottleneck" to trade toward). | |
| export const SPENDABLE = (() => { | |
| const coms = new Set(); | |
| for (const d of [...Object.values(UNITS), ...Object.values(BUILDINGS), ...Object.values(UPGRADES)]) | |
| for (const com of Object.keys(d.cost || {})) coms.add(com); | |
| return coms; | |
| })(); | |
| export function canAfford(resources, cost) { | |
| return Object.entries(cost).every(([com, qty]) => (resources[com] || 0) >= qty); | |
| } | |
| // Clamp to a range. Byte-identical private copies lived in diplomacy.js and market.js, both on | |
| // determinism-sensitive paths (stance drift and price math), so one being "fixed" without the other | |
| // is a divergence no single-module suite would see. | |
| /** @param {number} v @param {number} lo @param {number} hi @returns {number} */ | |
| export function clamp(v, lo, hi) { return v < lo ? lo : v > hi ? hi : v; } | |
| // The refund delta for a cost bag. Lives here, beside payCost, because BOTH refund paths need it: | |
| // engine/production.js (a cancelled unit) and engine/techtree.js (a cancelled research) each used to | |
| // carry a byte-identical private copy, so a rounding or negative-zero fix applied to one and not the | |
| // other would be a silent economy asymmetry no single-module suite could see. | |
| /** @param {Resources} cost @returns {Resources} */ | |
| export function negate(cost) { | |
| return Object.fromEntries(Object.entries(cost).map(([com, qty]) => [com, -qty])); | |
| } | |
| // Does `owner` have a FINISHED building of this type? The prereq question both UI surfaces ask — | |
| // overlays.js's help panel and techChart.js's ladder — which used to carry the same body under two | |
| // different names (hasBuilding / hasCompletedBuilding), which is why the duplication went unnoticed. | |
| /** @param {State} state @param {string} owner @param {string} type @returns {boolean} */ | |
| export function hasCompletedBuilding(state, owner, type) { | |
| for (const b of state.buildings.values()) if (b.owner === owner && b.type === type && !b.constructing) return true; | |
| return false; | |
| } | |
| export function payCost(resources, cost) { | |
| Object.entries(cost).forEach(([com, qty]) => { resources[com] = (resources[com] || 0) - qty; }); | |
| } | |