Combustion Generator: cheap gas/biomass power on a tight grid

A fuel-burning alternative to the Reactor. It grants half the Power (energyGrants 10
vs 20) over a much smaller grid (powerRange 0.55 shrinks its efficiency zones), and
only while it's fed — it burns gas OR biomass (whichever the stockpile has more of) at
combust.rate/sec from the treasury, the mirror of the Reactor's free-but-pricey grid:
cheap to raise, ongoing fuel bill. Out of fuel or paused, it grants nothing.

- entities.js: `combustor` def (energyGrants 10, powerRange 0.55, combust spec); the
Reactor gains powerRange 1 as the reference reach.
- industry.js: powerEfficiency now scales each source's distance by its powerRange
(nearestReactorDist → bestGridDist), so a Generator's zones sit tight and a consumer
must huddle close; powerCap and the grid only count ACTIVE sources; updateCombustors
burns fuel each tick and sets the transient `powered`/`fuel`.
- sim.js: settle Generators before any consumer reads powerCap.
- persist.js: strip the transient powered/fuel from saves.
- render.js: the efficiency-zone rings (selected source + build-ghost cue) scale by
powerRange; 🔥 map glyph.
- hud.js: build-menu entry + a selected-Generator panel (grants/fuel/stalled + a pause
toggle to stop the fuel bill).

Deterministic (fuel-gated), Odyssey-only. Tests: test/combustor.test.js (fuelled-only
power, gas|biomass fallback, smaller grid, no false on-grid off a dead generator, save-
clean determinism). Full suite 596 green, tsc clean, browser-verified.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AEQUVetLk31Jj7niDQAsXL

engine/entities.js

@@ -98,6 +98,19 @@ export const BUILDINGS = {
     id: "reactor", name: "Reactor", hp: 400, radius: 16,
     cost: { ore: 120 }, buildTime: 16, sight: 130,
     energyGrants: 20,   // 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)
+    odysseyOnly: true,
+  },
+  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 10 vs 20)
+    // over a SMALLER grid (powerRange 0.55 shrinks its efficiency zones — industry.js), and only while
+    // it's fed. It burns gas OR biomass from the treasury (combust.rate/sec, whichever the stockpile has)
+    // — so it's cheap to raise but carries an ongoing fuel bill, the mirror of the Reactor's free-but-
+    // pricey grid. Out of fuel (or paused) it grants nothing. See engine/industry.js updateCombustors.
+    energyGrants: 10, powerRange: 0.55,
+    combust: { fuels: ["gas", "biomass"], rate: 0.6 },
     odysseyOnly: true,
   },
   smelter: {

engine/industry.js

@@ -54,31 +54,58 @@ export const POWER_TIERS = [
   { name: "isolated", max: Infinity, mult: 2.3, label: "Isolated" },
 ];
 
-// The nearest COMPLETED own Reactor's distance from (x,y), or Infinity if the owner
-// has none. Guards non-finite coordinates (the industry unit-test stubs omit x/y) so
-// they read as co-located rather than NaN-poisoning the scan.
-function nearestReactorDist(state, owner, x, y) {
+// Whether a power SOURCE is actually feeding the grid right now: a Reactor always is; a
+// fuel-burning Generator only while it's fed (engine/industry.js updateCombustors sets `powered`).
+function sourceActive(building, def) {
+  return def.combust ? !!building.powered : true;
+}
+
+// The best (smallest) grid-distance from (x,y) to any ACTIVE own power source, each source's
+// distance divided by its `powerRange` — so a short-range Generator's efficiency zones shrink and
+// a consumer must huddle much closer to it than to a Reactor. Infinity if the owner has no active
+// source in reach. Guards non-finite coordinates (the industry unit-test stubs omit x/y) so they
+// read as co-located rather than NaN-poisoning the scan.
+function bestGridDist(state, owner, x, y) {
   let best = Infinity;
   for (const b of state.buildings.values()) {
     if (b.owner !== owner || b.constructing) continue;
-    if (!(BUILDINGS[b.type]?.energyGrants > 0)) continue;
-    const d = Math.hypot(b.x - x, b.y - y);
+    const def = BUILDINGS[b.type];
+    if (!(def?.energyGrants > 0) || !sourceActive(b, def)) continue;
+    const d = Math.hypot(b.x - x, b.y - y) / (def.powerRange || 1);
     if (Number.isFinite(d) && d < best) best = d;
   }
   return best;
 }
 
-// The grid-efficiency tier of a spot for `owner`: the band its distance to the nearest
-// Reactor falls in. No Reactor (or a non-positional stub) → the neutral 'linked' tier
-// (×1): there's no grid to lose against, and powerThrottle already zeroes an unpowered
+// The grid-efficiency tier of a spot for `owner`: the band its (range-scaled) distance to the
+// nearest active power source falls in. No source (or a non-positional stub) → the neutral 'linked'
+// tier (×1): there's no grid to lose against, and powerThrottle already zeroes an unpowered
 // consumer, so an isolated penalty would be moot there anyway.
 export function powerEfficiency(state, owner, x, y) {
-  const d = nearestReactorDist(state, owner, x, y);
+  const d = bestGridDist(state, owner, x, y);
   if (!Number.isFinite(d)) return POWER_TIERS[0];
   for (const t of POWER_TIERS) if (d <= t.max) return t;
   return POWER_TIERS[POWER_TIERS.length - 1];
 }
 
+// Burn one tick of fuel for every Combustion Generator: it draws combust.rate/sec of gas OR biomass
+// (whichever the treasury has more of) and is `powered` only while fed — paused or dry, it grants no
+// Power. Runs at tick start, before anything reads powerCap, so the grid it provides is settled for
+// the tick. Deterministic (fuel-gated); a no-op for any building without a `combust` def.
+export function updateCombustors(state, dt) {
+  for (const b of state.buildings.values()) {
+    const def = BUILDINGS[b.type];
+    if (!def?.combust || b.constructing) continue;
+    const res = state.players[b.owner]?.resources;
+    if (b.paused || !res) { b.powered = false; continue; }
+    const need = def.combust.rate * dt;
+    let fuel = null, most = 0;
+    for (const f of def.combust.fuels) { const have = res[f] || 0; if (have > most) { most = have; fuel = f; } }
+    if (fuel && (res[fuel] || 0) >= need) { res[fuel] -= need; b.powered = true; b.fuel = fuel; }
+    else b.powered = false;
+  }
+}
+
 // data.js RECIPES is an array; index it by id once for O(1) lookup.
 const RECIPE_BY_ID = Object.fromEntries(RECIPES.map(r => [r.id, r]));
 
@@ -92,8 +119,12 @@ export function recipeOf(building) {
 // by the Fusion Containment tech (techtree.js `reactors` node, +50%) if researched.
 export function powerCap(state, owner) {
   let cap = 0;
-  for (const b of state.buildings.values())
-    if (b.owner === owner && !b.constructing) cap += BUILDINGS[b.type].energyGrants || 0;
+  for (const b of state.buildings.values()) {
+    if (b.owner !== owner || b.constructing) continue;
+    const def = BUILDINGS[b.type];
+    if (!(def.energyGrants > 0) || !sourceActive(b, def)) continue;   // an unfueled Generator grants nothing
+    cap += def.energyGrants;
+  }
   return cap * techMult(state.players[owner]?.upgrades, "powerMult");
 }
 

engine/persist.js

@@ -168,10 +168,10 @@ function serPlanet(state) {
     // by buildUnitGrid, meaningless once saved. Strip it so it doesn't bloat the payload with a
     // per-unit integer that the next tick overwrites anyway. Shallow copy, only at save time.
     units: [...state.units.values()].map(({ _gi, ...u }) => u),
-    // `haulers`/`suppliers` are the transient per-tick logistics tallies (engine/haul.js),
-    // stamped fresh each tick like a unit's `_gi` grid index — strip them so they never bloat
-    // or drift a save.
-    buildings: [...state.buildings.values()].map(({ haulers, suppliers, ...b }) => b),
+    // `haulers`/`suppliers` are the transient per-tick logistics tallies (engine/haul.js), and
+    // `powered`/`fuel` are the Generator's per-tick fuel state (engine/industry.js) — all stamped
+    // fresh each tick like a unit's `_gi` grid index, so strip them (they never bloat or drift a save).
+    buildings: [...state.buildings.values()].map(({ haulers, suppliers, powered, fuel, ...b }) => b),
     nodes: state.map.nodes.map(n => ({ id: n.id, amount: n.amount })),
     fog: [...state.fog.explored],
     fogAI: [...state.fogAI.explored],

engine/sim.js

@@ -14,7 +14,7 @@ import { updateScoutMode } from "./scout.js";
 import { updateRepair } from "./repair.js";
 import { updateCombat, updateBuildingCombat, updateWorkerCombat } from "./combat.js";
 import { updateBuildingConstruction, updateProductionQueue, BUILD_REACH } from "./production.js";
-import { updateProduction } from "./industry.js";
+import { updateProduction, updateCombustors } from "./industry.js";
 import { updatePlasmaRig } from "./rig.js";
 import { updateResearch } from "./techtree.js";
 import { updateWonder } from "./wonder.js";
@@ -47,6 +47,9 @@ export function tick(state, dt) {
   // assigned a logistics job below — so the "≤2 per building" caps read the same regardless
   // of Map iteration order (determinism). A no-op in skirmish: nothing there has a buffer.
   countLogistics(state);
+  // Settle the fuel-burning Generators' Power BEFORE any consumer reads powerCap this tick,
+  // so the grid a factory/rig sees is stable. A no-op without a Combustion Generator.
+  updateCombustors(state, dt);
   // Aura projectors (Aegis) for this tick, read by combat.js attackDamage. Collected
   // once here (a tiny list — the units are Tier-3 and rare) so a landed hit costs O(anvils)
   // not O(units); positions are frozen at tick start like the grid above (deterministic).

engine/types.js

@@ -119,6 +119,8 @@
  * @property {Object.<string, number>} [input]  a factory's finite input larder, commodity → qty (engine/haul.js)
  * @property {number} [haulers]       transient per-tick count of workers hauling from this producer (engine/haul.js)
  * @property {number} [suppliers]     transient per-tick count of workers supplying this factory (engine/haul.js)
+ * @property {boolean} [powered]      transient: a Combustion Generator is fed & granting Power this tick (engine/industry.js)
+ * @property {string} [fuel]          transient: which fuel the Generator burned this tick (HUD)
  */
 
 /**

hud.js

@@ -384,6 +384,11 @@ function renderSelectionPanel() {
         const d = sel.find(e => e.kind === "building" && e.owner === "player" && !e.constructing
           && storeCapOf(e.type) > 0 && !BUILDINGS[e.type].recipe && !BUILDINGS[e.type].isCommandCenter);
         return d ? Math.round((storeTotal(d) / (storeCapOf(d.type) || 1)) * 10) : "";
+      })()
+    // Rebuild a selected Combustion Generator's status when its fuel/power state flips.
+    + "|" + (() => {
+        const gen = sel.find(e => e.kind === "building" && e.type === "combustor" && !e.constructing);
+        return gen ? `${!!gen.paused}:${!!gen.powered}:${gen.fuel || ""}` : "";
       })();
 
   if (signature !== lastPanelSignature) {
@@ -974,6 +979,27 @@ function rebuildSelectionPanel(sel) {
     panelEl.appendChild(note);
   }
 
+  // Combustion Generator (Odyssey): cheap Power that burns gas/biomass over a small grid. Say how
+  // much it grants, whether it's fuelled right now, and let the player pause it to stop the fuel bill.
+  const gen = sel.find(e => e.kind === "building" && e.type === "combustor" && !e.constructing);
+  if (gen) {
+    const def = BUILDINGS.combustor;
+    const row = document.createElement("div");
+    const lit = !gen.paused && gen.powered;
+    row.className = "sel-note " + (gen.paused ? "" : lit ? "good" : "bad");
+    row.textContent = gen.paused ? `Paused — grants no Power (⚡${def.energyGrants} when running)`
+      : lit ? `Grants ⚡${def.energyGrants} Power · burning ${COM[gen.fuel]?.name || gen.fuel}`
+            : `Stalled — out of fuel (needs ${def.combust.fuels.map(f => COM[f]?.name || f).join(" or ")})`;
+    panelEl.appendChild(row);
+    const note = document.createElement("p");
+    note.className = "hint";
+    note.textContent = `Cheap Power on a tight grid — half a Reactor's reach. Burns ${def.combust.rate}/s of gas or biomass while running; keep the stockpile fed or pause it.`;
+    panelEl.appendChild(note);
+    panelEl.appendChild(makeButton(gen.paused ? "▶ Resume generator" : "⏸ Pause generator",
+      () => { gen.paused = !gen.paused; },
+      { tip: gen.paused ? "Restart it (resumes burning fuel)" : "Stop it drawing fuel until resumed" }));
+  }
+
   // Forward drop-off (Refinery / Foundry / Arsenal): a finite INTAKE buffer gatherers bank
   // raw hauls into (engine/gather.js). When it fills, gatherers reroute elsewhere until a
   // worker clears it to the Command Center — so surface how full it is and whether it's full.
@@ -1099,14 +1125,14 @@ function rebuildSelectionPanel(sel) {
       // tier would bury the menu), mirroring how the Barracks hides units you can't yet
       // field.
       const GROUPS = [
-        ["Economy", ["reactor", "smelter", "datacenter", "assembler", "chipfab",
+        ["Economy", ["reactor", "combustor", "smelter", "datacenter", "assembler", "chipfab",
                      "machineworks", "antimatterforge", "aifoundry", "torpedoworks", "plasmarig"]],
         ["Military", ["barracks", "foundry", "arsenal", "refinery", "turret", "habitat", "stardock"]],
         ["Endgame", ["antimatter_gate"]],
         ["Travel", ["spaceport"]],
       ];
       const alwaysShow = new Set(["barracks", "foundry", "arsenal", "refinery", "turret",
-                                  "habitat", "reactor", "smelter", "datacenter", "spaceport"]);
+                                  "habitat", "reactor", "combustor", "smelter", "datacenter", "spaceport"]);
       for (const [title, types] of GROUPS) {
         const shown = types.filter(t => alwaysShow.has(t) || prereqsMet(state, "player", BUILDINGS[t]));
         if (!shown.length) continue;

render.js

@@ -524,17 +524,17 @@ function drawJumpStaging(ctx, state, view) {
 // player WHERE to drop one. Green (on-grid, no loss) → red (isolated, worst).
 const POWER_TIER_COLOR = { linked: "#4ade80", near: "#a3e635", far: "#fbbf24", isolated: "#f87171" };
 
-// Concentric efficiency zones around one Reactor at (rx, ry): a faint tinted disc per
+// Concentric efficiency zones around one power source at (rx, ry): a faint tinted disc per
 // finite band (painted largest-first so each inner band shows its own hue) with a dashed
-// boundary ring. Everything past the outermost ring is the 'isolated' tier. Shared by the
-// selected-Reactor overlay and the placement cue, so both read the same zones.
-function drawReactorBands(ctx, rx, ry) {
+// boundary ring. `scale` is the source's powerRange — a short-range Generator's zones shrink,
+// so its rings sit tighter than a Reactor's. Shared by the selected-source overlay and the cue.
+function drawReactorBands(ctx, rx, ry, scale = 1) {
   const bands = POWER_TIERS.filter(t => Number.isFinite(t.max));
   ctx.save();
   for (let i = bands.length - 1; i >= 0; i--) {        // largest radius first, so inner hues win
     const t = bands[i], col = POWER_TIER_COLOR[t.name];
     ctx.beginPath();
-    ctx.arc(rx, ry, t.max, 0, Math.PI * 2);
+    ctx.arc(rx, ry, t.max * scale, 0, Math.PI * 2);
     ctx.fillStyle = hexA(col, 0.05);
     ctx.fill();
   }
@@ -542,23 +542,26 @@ function drawReactorBands(ctx, rx, ry) {
   ctx.lineWidth = 1.5;
   for (const t of bands) {
     ctx.beginPath();
-    ctx.arc(rx, ry, t.max, 0, Math.PI * 2);
+    ctx.arc(rx, ry, t.max * scale, 0, Math.PI * 2);
     ctx.strokeStyle = hexA(POWER_TIER_COLOR[t.name], 0.55);
     ctx.stroke();
   }
   ctx.restore();
 }
 
-// The power-grid overlay around a SELECTED player Reactor: its efficiency zones, so a
-// player can see the on-grid / near / far bands before placing a factory or rig near it.
-// Drawn only for a selected Reactor (mirrors the Spaceport's jump-staging ring), so it
-// never clutters the field otherwise.
+// The power-grid overlay around a SELECTED player power source (Reactor or Combustion Generator):
+// its efficiency zones, so a player can see the on-grid / near / far bands — scaled to the source's
+// reach — before placing a factory or rig near it. Drawn only for a selected source (mirrors the
+// Spaceport's jump-staging ring), so it never clutters the field otherwise.
 function drawPowerGrid(ctx, state, view) {
   const selSet = new Set(state.selection);
+  const outer = POWER_TIERS[POWER_TIERS.length - 2].max;
   for (const b of state.buildings.values()) {
-    if (b.type !== "reactor" || b.owner !== "player" || b.constructing || !selSet.has(b.id)) continue;
-    if (view && !inView(view, b.x, b.y, POWER_TIERS[POWER_TIERS.length - 2].max + 8)) continue;
-    drawReactorBands(ctx, b.x, b.y);
+    const def = BUILDINGS[b.type];
+    if (!(def && def.energyGrants > 0) || b.owner !== "player" || b.constructing || !selSet.has(b.id)) continue;
+    const scale = def.powerRange || 1;
+    if (view && !inView(view, b.x, b.y, outer * scale + 8)) continue;
+    drawReactorBands(ctx, b.x, b.y, scale);
   }
 }
 
@@ -777,7 +780,7 @@ const RECIPE_OUT = Object.fromEntries(RECIPES.map(r => [r.id, r.out]));
 // recipe-running factory shows the commodity it OUTPUTS; a handful of non-recipe industrial
 // buildings get an explicit emoji for what they DO — the Reactor grants Power (⚡), the Datacenter
 // runs research (🔬), the Stardock is a capital-ship yard (🛰️), the Antimatter Gate is the wonder (🌀).
-const BUILDING_GLYPH = { reactor: "⚡", datacenter: "🔬", stardock: "🛰️", antimatter_gate: "🌀", plasmarig: "⛏️" };
+const BUILDING_GLYPH = { reactor: "⚡", combustor: "🔥", datacenter: "🔬", stardock: "🛰️", antimatter_gate: "🌀", plasmarig: "⛏️" };
 function factoryGlyph(type) {
   const def = BUILDINGS[type];
   if (def && def.recipe && RECIPE_OUT[def.recipe]) return COM[RECIPE_OUT[def.recipe]]?.ico || null;
@@ -1570,18 +1573,22 @@ function drawEffects(ctx) {
 // and label ("On-grid · draw ×1.0" … "Isolated · draw ×2.3"). Mirrors how the Spaceport
 // shows its jump radius — it turns "where do I put this factory?" into a visible choice.
 function drawGhostPowerCue(ctx, state, ghost, def) {
-  let nearest = null, bestD = Infinity;
+  // The source that DETERMINES the ghost's tier: the nearest by RANGE-SCALED distance, so a
+  // close short-range Generator can out-rank a far Reactor exactly as the efficiency math does.
+  let nearest = null, bestD = Infinity, nearestScale = 1;
   for (const b of state.buildings.values()) {
-    if (b.owner !== "player" || b.constructing || b.type !== "reactor") continue;
-    const d = Math.hypot(b.x - ghost.x, b.y - ghost.y);
-    if (d < bestD) { bestD = d; nearest = b; }
+    const bd = BUILDINGS[b.type];
+    if (b.owner !== "player" || b.constructing || !(bd && bd.energyGrants > 0)) continue;
+    const scale = bd.powerRange || 1;
+    const d = Math.hypot(b.x - ghost.x, b.y - ghost.y) / scale;
+    if (d < bestD) { bestD = d; nearest = b; nearestScale = scale; }
   }
 
   const tier = powerEfficiency(state, "player", ghost.x, ghost.y);
   const col = POWER_TIER_COLOR[tier.name];
 
   if (nearest) {
-    drawReactorBands(ctx, nearest.x, nearest.y);
+    drawReactorBands(ctx, nearest.x, nearest.y, nearestScale);
     ctx.save();
     ctx.setLineDash([5, 5]);
     ctx.strokeStyle = hexA(col, 0.8);

test/combustor.test.js

@@ -0,0 +1,90 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createGameState, makeBuilding } from "../engine/state.js";
+import { tick } from "../engine/sim.js";
+import { serializeGame, deserializeGame } from "../engine/persist.js";
+import { powerCap, powerEfficiency, updateCombustors } from "../engine/industry.js";
+import { BUILDINGS } from "../engine/entities.js";
+
+// A tiny stub, like industry.test.js: the power helpers read only buildings + resources.
+function stub(buildings = [], resources = {}) {
+  return {
+    buildings: new Map(buildings.map((b, i) => {
+      const id = b.id || `b${i}`;
+      return [id, { id, owner: "player", constructing: false, ...b }];
+    })),
+    players: { player: { resources } },
+  };
+}
+const combustor = (o = {}) => ({ type: "combustor", ...o });
+const reactor = (o = {}) => ({ type: "reactor", ...o });
+
+test("a Combustion Generator grants Power only while it's fuelled", () => {
+  const s = stub([combustor()], { gas: 100 });
+  assert.equal(powerCap(s, "player"), 0, "before a tick it hasn't burned fuel → grants nothing");
+  updateCombustors(s, 0.1);
+  assert.equal(powerCap(s, "player"), BUILDINGS.combustor.energyGrants, "fuelled → grants its Power");
+  const gen = [...s.buildings.values()][0];
+  assert.ok(gen.powered && s.players.player.resources.gas < 100, "…having burned some gas to do it");
+});
+
+test("out of fuel (or paused), a Generator grants no Power", () => {
+  const dry = stub([combustor()], {});                 // no gas, no biomass
+  updateCombustors(dry, 0.1);
+  assert.equal(powerCap(dry, "player"), 0, "no fuel → dead");
+
+  const paused = stub([combustor({ paused: true })], { biomass: 100 });
+  updateCombustors(paused, 0.1);
+  assert.equal(powerCap(paused, "player"), 0, "paused → dead, and no fuel burned");
+  assert.equal(paused.players.player.resources.biomass, 100, "…the stockpile is untouched");
+});
+
+test("it burns gas OR biomass — whichever the stockpile has more of", () => {
+  const s = stub([combustor()], { biomass: 50 });      // only biomass on hand
+  updateCombustors(s, 0.1);
+  const gen = [...s.buildings.values()][0];
+  assert.equal(gen.fuel, "biomass", "falls back to biomass when there's no gas");
+  assert.ok(s.players.player.resources.biomass < 50, "…and consumes it");
+});
+
+test("a Generator's grid is SMALLER than a Reactor's (its powerRange shrinks the tiers)", () => {
+  // 250px out: on a Reactor's grid that's the 'near' tier; on a Generator's tighter grid it's already 'isolated'.
+  const nearReactor = stub([reactor({ x: 0, y: 0 })]);
+  const nearGen = stub([combustor({ x: 0, y: 0, powered: true })]);   // pre-mark fuelled so it counts as a source
+  const rTier = powerEfficiency(nearReactor, "player", 250, 0).name;
+  const gTier = powerEfficiency(nearGen, "player", 250, 0).name;
+  assert.equal(rTier, "near", "a Reactor still reaches 250px at the 'near' tier");
+  assert.ok(BUILDINGS.combustor.powerRange < 1, "the Generator has a shorter reach");
+  assert.notEqual(gTier, "linked", "the same 250px spot is off the Generator's tight on-grid zone");
+  assert.ok(["far", "isolated"].includes(gTier), `…it's a worse tier on the smaller grid (${gTier})`);
+});
+
+test("an unfuelled Generator isn't a grid source at all (no false on-grid reading)", () => {
+  const s = stub([combustor({ x: 0, y: 0 })]);   // not powered
+  assert.equal(powerEfficiency(s, "player", 30, 0).name, "linked",
+    "with no active source, a spot reads the neutral tier — not 'on-grid' off a dead Generator");
+});
+
+test("the Generator is Odyssey-only and its fuel state is deterministic + save-clean", () => {
+  assert.equal(BUILDINGS.combustor.odysseyOnly, true);
+  const run = () => {
+    const s = createGameState({ planetId: "ferros", endless: true });
+    const gen = makeBuilding("combustor", "player", 600, 500);
+    s.buildings.set(gen.id, gen);
+    s.players.player.resources.gas = 100;
+    for (let i = 0; i < 50; i++) tick(s, 0.1);
+    return s.players.player.resources.gas;
+  };
+  assert.equal(run(), run(), "same seed → identical fuel burn");
+
+  // `powered`/`fuel` are transient — they must not ride along in a save.
+  const s = createGameState({ planetId: "ferros", endless: true });
+  const gen = makeBuilding("combustor", "player", 600, 500);
+  s.buildings.set(gen.id, gen);
+  s.players.player.resources.gas = 100;
+  tick(s, 0.1);
+  const saved = serializeGame(s).buildings.find(b => b.type === "combustor");
+  assert.equal(saved.powered, undefined, "the transient power flag is stripped from the save");
+  assert.equal(saved.fuel, undefined, "…and so is the transient fuel tag");
+  assert.ok(deserializeGame(serializeGame(s)), "and the save round-trips");
+});