Workers trainable on biomass as an alternative to ore

A worker now carries an `altCost` ({biomass: 50}) alongside its ore price — an
either/or, so a biomass-rich but ore-poor claim can still grow its workforce.

- entities.js: worker.altCost.
- production.js: queueProduction(state, id, type, alt) charges the alternative price when
asked and tags the queued job (job.alt); cancelProduction refunds whichever commodity
was actually charged.
- hud.js: the Command Center shows a second "Produce Worker (50 biomass)" button beside
the ore one; the affordability signature tracks altCosts so it greys live.

Tests: production.test.js (biomass charged not ore, job tagged, cancel refunds biomass).
Full suite 597 green, tsc clean. AI path unchanged (it queues via the ore cost only).

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

engine/entities.js

@@ -400,7 +400,11 @@ export function committedDoctrine(state, owner) {
 export const UNITS = {
   worker: {
     id: "worker", name: "Worker", hp: 40, radius: 6, speed: 60,
-    cost: { ore: 50 }, buildTime: 8, supplyCost: 1,
+    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

engine/production.js

@@ -94,12 +94,17 @@ export function updateProductionQueue(state, building, dt) {
   }
 }
 
-export function queueProduction(state, buildingId, unitType) {
+export function queueProduction(state, buildingId, unitType, alt = false) {
   const building = state.buildings.get(buildingId);
   if (!building || building.constructing) return false;
   const def = UNITS[unitType];
   const producable = def && BUILDINGS[building.type].produces?.includes(unitType);
   if (!producable) return false;
+  // A unit with an `altCost` (the Worker) can be trained on its alternative price — the queued job
+  // remembers which it paid so a cancel refunds the right commodity. Falls back to the base cost if
+  // this unit has no alternative.
+  const useAlt = alt && !!def.altCost;
+  const cost = useAlt ? def.altCost : def.cost;
   // An Odyssey-only unit (e.g. the Colony Ship) can never be built in a skirmish,
   // regardless of menu wiring — hard-guarantees it stays out of the byte-identical
   // skirmish path. A no-op for existing skirmish (no odysseyOnly unit is reachable).
@@ -112,7 +117,7 @@ export function queueProduction(state, buildingId, unitType) {
     return false;
   }
   const player = state.players[building.owner];
-  if (!canAfford(player.resources, def.cost)) return false;
+  if (!canAfford(player.resources, cost)) return false;
   // Supply check sits AFTER canAfford (so being broke stays the silent
   // today-UX, and the supply beep only fires when supply is the real
   // blocker) and BEFORE payCost (reject before charging — nothing to
@@ -123,8 +128,8 @@ export function queueProduction(state, buildingId, unitType) {
                         x: building.x, y: building.y, owner: building.owner });
     return false;
   }
-  payCost(player.resources, def.cost);
-  building.queue.push({ unitType, progress: 0 });
+  payCost(player.resources, cost);
+  building.queue.push({ unitType, progress: 0, ...(useAlt ? { alt: true } : {}) });
   return true;
 }
 
@@ -141,7 +146,9 @@ export function cancelProduction(state, buildingId, queueIndex) {
   if (!job) return false;
   building.queue.splice(queueIndex, 1);
   const player = state.players[building.owner];
-  payCost(player.resources, negate(UNITS[job.unitType].cost));
+  const def = UNITS[job.unitType];
+  const refund = (job.alt && def.altCost) ? def.altCost : def.cost;   // refund the commodity actually charged
+  payCost(player.resources, negate(refund));
   return true;
 }
 

hud.js

@@ -281,6 +281,7 @@ function availabilitySignature() {
   const res = state.players.player.resources;
   const costs = [
     ...Object.values(UNITS).map(u => u.cost),
+    ...Object.values(UNITS).filter(u => u.altCost).map(u => u.altCost),   // e.g. the Worker's biomass price
     ...Object.values(BUILDINGS).map(b => b.cost),
     ...Object.values(UPGRADES).map(u => u.cost),
   ];
@@ -764,6 +765,14 @@ function rebuildSelectionPanel(sel) {
       panelEl.appendChild(prodButton(`Produce ${def.name} (${costText(def.cost)})`,
         () => queueProduction(state, cc.id, t),
         { cost: def.cost, tip: unitTip(def), locked, lockTip: locked ? lockTipFor(def) : null, icon: { kind: "unit", type: t } }));
+      // A unit with an alternative price (the Worker, buildable on biomass instead of ore) gets a
+      // second button paying that cost — so a biomass-rich, ore-poor claim can still grow its labour.
+      if (def.altCost) {
+        panelEl.appendChild(prodButton(`Produce ${def.name} (${costText(def.altCost)})`,
+          () => queueProduction(state, cc.id, t, true),
+          { cost: def.altCost, tip: `${def.name} paid in ${costText(def.altCost)} instead of ore`, locked,
+            lockTip: locked ? lockTipFor(def) : null, icon: { kind: "unit", type: t } }));
+      }
     }
     if (cc.queue.length) renderQueueRows(cc);
     if (game.galaxy) renderCapital(state, cc);              // Odyssey: fortify this CC into the anchored Capital

test/production.test.js

@@ -17,6 +17,24 @@ function withFoundry(state, owner = "player") {
   return f;
 }
 
+test("a Worker can be trained on biomass instead of ore, and a cancel refunds the right commodity", () => {
+  const state = createGameState({ planetId: "ferros" });
+  const cc = commandCenterOf(state, "player");
+  const res = state.players.player.resources;
+  res.ore = 0; res.biomass = 200;                    // ore-poor, biomass-rich claim
+  assert.equal(queueProduction(state, cc.id, "worker"), false, "no ore → the ore-priced Worker is unaffordable");
+
+  const biomassBefore = res.biomass;
+  assert.equal(queueProduction(state, cc.id, "worker", true), true, "…but the biomass-priced Worker queues");
+  assert.equal(res.biomass, biomassBefore - UNITS.worker.altCost.biomass, "biomass was charged, not ore");
+  assert.equal(res.ore, 0, "ore untouched");
+  assert.equal(cc.queue[0].alt, true, "the job remembers it paid the alternative price");
+
+  cancelProduction(state, cc.id, 0);
+  assert.equal(res.biomass, biomassBefore, "cancelling refunds biomass (the commodity actually charged)");
+  assert.equal(res.ore, 0, "…and not ore");
+});
+
 test("queueProduction pays the cost and enqueues the job", () => {
   const state = createGameState({ planetId: "ferros" });
   const cc = commandCenterOf(state, "player");