Merge pull request #61 from alma92350/claude/refinery-arsenal-research-gfzxyb

CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/), and the project uses
 [semantic versioning](https://semver.org/).
 
+## [Unreleased]
+
+### Changed
+
+- The Refinery, Foundry, and Arsenal no longer double as forward resource drop-offs — they're
+  ore-tech buildings only now (Refinery for doctrine research, Foundry/Arsenal as Tier-2/Tier-3
+  gates). All gather and haul traffic runs straight to a Command Center; the AI no longer plants
+  additional Refineries out at far ore seams as decentralized collection points.
+
 ## [1.0.0] — 2026-07-22
 
 First tagged release. A complete, self-contained real-time strategy game plus an open-world

docs/logistics-design.md

@@ -153,7 +153,12 @@ storage cascades to AI worker logic — the riskier half.
 **Balance note (both phases):** default caps are generous (80 / rig 120). Tune later —
 smaller = more logistics pressure, larger = less micro.
 
-**Phase C — Finite COLLECTION storage. ✅ DONE (player-only).**
+**Phase C — Finite COLLECTION storage. ⤺ REVERTED — Refinery/Foundry/Arsenal are no longer
+drop-offs.** The forward-collection capability described below shipped, then was later
+removed: the Refinery/Foundry/Arsenal no longer carry `dropOff`/`storeCap`, `isGatherDropOff`
+now resolves to the Command Center alone, and the AI's forward-Refinery placement logic
+(`aiEconomy.js`) was deleted along with it. Every gather/haul trip is a straight run to a
+Command Center again. Left below for the historical record of what Phase C built and why.
 - The forward drop-offs (Refinery/Foundry/Arsenal — the pure `dropOff` buildings, via
   the new `isGatherDropOff`) get a finite `storeCap` intake buffer. A PLAYER gatherer
   banks its haul into that buffer (capped); a full one is skipped by `nearestGatherDrop`
@@ -319,9 +324,10 @@ Closes the two items Phase E deliberately left for later.
 
 ## Outcome
 
-All six phases shipped. Storage is finite end-to-end — collection (forward drop-offs),
-production output (rig + factories), and factory inputs — and workers move every good
-between them (gather → drop-off → haul → CC → supply → factory → haul → CC). A landed
+All six phases shipped (Phase C was later reverted — see above: the Refinery/Foundry/Arsenal
+are no longer drop-offs, and all collection now runs straight to the Command Center). Storage
+is finite end-to-end — production output (rig + factories) and factory inputs — and workers
+move every good between them (gather → CC → supply → factory → haul → CC). A landed
 freighter now sits IN that chain too — a physical collection point workers can ferry to
 directly, or (once teched) a large-capacity autonomous hauler in its own right, paid for
 in AI Cores while it runs. Logistics is a standing demand on labour (and, for an automated

docs/player-handbook.html

@@ -337,7 +337,7 @@
       <ol class="tight">
         <li>Exactly one production building selected → set its rally point.</li>
         <li>Target is your own building under construction → assist-build it.</li>
-        <li>Target is your own completed factory/Refinery/Foundry/Arsenal/Rig → assign a standing haul job.</li>
+        <li>Target is your own completed factory/Rig → assign a standing haul job.</li>
         <li>Target is your own damaged building (not caught above) → repair it.</li>
         <li>Target is your own undamaged Command Center → pin the selection's home base to it.</li>
         <li>Target is an enemy unit or building → attack it.</li>

engine/ai.js

@@ -7,11 +7,9 @@
    repeated waves, once each wave is big enough (or the game's dragged on
    long enough that it should commit anyway). Along the way it fortifies
    with Sentinel Turrets on the approach vector, expands to a second
-   Command Center when its home ore runs thin, puts up a Refinery (and, on a
-   big map, plants extra Refineries forward as resource drop-offs to shorten a
-   long ore haul without a whole second CC), and researches both upgrades — so
-   the player isn't the only side that gets to use crystals/radioactives,
-   expansions, decentralized collection, or defenses.
+   Command Center when its home ore runs thin, puts up a Refinery, and
+   researches both upgrades — so the player isn't the only side that gets to
+   use crystals/radioactives, expansions, or defenses.
 
    The AI plays under its own fog of war (state.fogAI) — it is NOT omniscient.
    It keeps one unit out scouting (updateScout), and its intel-dependent moves

engine/aiEconomy.js

@@ -1,7 +1,7 @@
 /* ============================================================
    AI — the economic build order: (re)seat a base from a colony ship, expand to
    fresh ore, raise workers/supply/Barracks and the Foundry+Arsenal tech gates,
-   run the shared unit-production cycle with Turrets and forward Refineries, and
+   run the shared unit-production cycle with Turrets and the Refinery, and
    research the doctrine. Depends on aiCommon (budget + affordability), aiWorkers
    (affordableOnSurface / aiDoctrine) and aiMilitary (pickNextUnitType); nothing
    depends back on this module, so the import graph stays acyclic.
@@ -12,7 +12,7 @@
 import { queueProduction, researchUpgrade } from "./production.js";
 import { issueBuild, issueMove } from "./commands.js";
 import { findPlacement } from "./colliders.js";
-import { BUILDINGS, UNITS, UPGRADES, canAfford, isDropOff } from "./entities.js";
+import { BUILDINGS, UNITS, UPGRADES, canAfford } from "./entities.js";
 import { recipeOf } from "./industry.js";
 import { supplyUsed, supplyCap } from "./supply.js";
 import { isNodeDiscovered } from "./fog.js";
@@ -29,8 +29,6 @@ const CLAIM_RADIUS = 260;         // a cluster with any CC this close is already
 const CLUSTER_RADIUS = 160;       // nodes within this of an anchor sum into its cluster score
 const EXPANSION_STANDOFF = 70;    // CC-to-anchor-node placement distance (26 CC radius + 16 node radius + clearance)
 const BARRACKS_BUFFER = 150;      // bank kept when adding a barracks so the mix doesn't starve
-const FORWARD_DROP_MIN = 360;     // ore worked this far from every drop-off is worth a forward Refinery drop-off
-const MAX_AI_REFINERIES = 3;      // hard cap so forward drop-offs never run away with the AI's ore
 const COLONY_ARRIVE = 40;         // Odyssey: an in-flight colony ship this close to its target deploys (ai.js expansion)
 
 // Odyssey found/survive: no Command Center but a colony ship in hand -> deploy in place. Budget-exempt so even a 1-APM neighbour always seats a base (else it mis-reads as pacified). Skirmish: colonyShip is null -> no-op.
@@ -263,7 +261,7 @@ function standingArmyCap(state, ctx) {
   return Infinity;
 }
 
-// The shared unit-production cycle across every idle Barracks (Foundry/Refinery reserves held back), Sentinel Turrets along the approach lane, a second Barracks, and the research Refinery plus forward drop-off Refineries out at far seams.
+// The shared unit-production cycle across every idle Barracks (Foundry/Refinery reserves held back), Sentinel Turrets along the approach lane, a second Barracks, and the research Refinery.
 /** @param {State} state @param {AiContext} ctx */
 export function aiProduceAndFortify(state, ctx) {
   const { allBarracks, ai, archetype, strategy, cc, barracks, workers, buildings, army } = ctx;
@@ -324,39 +322,15 @@ export function aiProduceAndFortify(state, ctx) {
     if (spot && canAct(state) && issueBuild(state, pickBuilder(workers, spot.x, spot.y).id, "barracks", spot.x, spot.y)) spend(state);
   }
 
-  // REFINERY & FORWARD DROP-OFFS. A Refinery both researches the AI's doctrine
-  // and doubles as a resource drop-off (entities.js isDropOff). So the AI builds
-  // its FIRST near home for the research (reserve-aware, kept safe behind the
-  // base) — then, once a macro AI is hauling ore a long way from every drop-off,
-  // it plants ADDITIONAL Refineries out at those far seams: cheap, decentralized
-  // collection points that shorten the haul without the cost of a whole second
-  // Command Center. Forward drop-offs spend genuine surplus only (the expansion
-  // reserve and a mix buffer stay untouched) and are capped, and no seam on a
-  // small map is ever far enough to trigger one — so it fires exactly on the big
-  // maps where the fixed home cluster can't reach the deposits. cc-guarded: cc is
-  // the completed-only find, so a home CC lost mid-expansion leaves it undefined.
+  // REFINERY. Hosts the AI's doctrine research, so it builds exactly one, near
+  // home (reserve-aware, kept safe behind the base). cc-guarded: cc is the
+  // completed-only find, so a home CC lost mid-expansion leaves it undefined.
   const refineries = buildings.filter(b => b.type === "refinery");
-  const dropoffs = buildings.filter(b => !b.constructing && isDropOff(b.type));
-  const fwdAnchor = forwardDropoffAnchor(state, workers, dropoffs);
   const buildResearchRefinery = refineries.length === 0;   // ungated by archetype, as before
-  const buildForwardDropoff = archetype.wantsRefinery && refineries.length > 0
-    && refineries.length < MAX_AI_REFINERIES && !refineries.some(r => r.constructing) && !!fwdAnchor;
-  if ((buildResearchRefinery || buildForwardDropoff) && barracks && !barracks.constructing && cc && workers.length > 0) {
-    // The research build banks behind an expansion; a forward drop-off spends
-    // only genuine surplus (keeps the expansion reserve AND a mix buffer back).
-    const keep = buildForwardDropoff ? ctx.oreReserve + BARRACKS_BUFFER : ctx.oreReserve;
-    if (canAffordKeeping(ai.resources, BUILDINGS.refinery.cost, keep)) {
-      let spot;
-      if (buildForwardDropoff) {
-        const toward = Math.atan2(cc.y - fwdAnchor.y, cc.x - fwdAnchor.x);   // home side of the far cluster
-        spot = findPlacement(state, "refinery",
-          fwdAnchor.x + Math.cos(toward) * EXPANSION_STANDOFF,
-          fwdAnchor.y + Math.sin(toward) * EXPANSION_STANDOFF);
-      } else {
-        spot = findPlacement(state, "refinery", cc.x - 90, cc.y - 90);
-      }
-      if (spot && canAct(state) && issueBuild(state, pickBuilder(workers, spot.x, spot.y).id, "refinery", spot.x, spot.y)) spend(state);
-    }
+  if (buildResearchRefinery && barracks && !barracks.constructing && cc && workers.length > 0
+      && canAffordKeeping(ai.resources, BUILDINGS.refinery.cost, ctx.oreReserve)) {
+    const spot = findPlacement(state, "refinery", cc.x - 90, cc.y - 90);
+    if (spot && canAct(state) && issueBuild(state, pickBuilder(workers, spot.x, spot.y).id, "refinery", spot.x, spot.y)) spend(state);
   }
 }
 
@@ -430,31 +404,3 @@ function bestExpansionCluster(state, myCCs) {
   }
   return best;
 }
-
-// The ore seam worth a forward Refinery drop-off: the richest cluster the AI is
-// ACTIVELY hauling from that sits beyond FORWARD_DROP_MIN of every existing
-// drop-off. Keying it off ore workers are really mining (not just any charted
-// seam) keeps the drop-off on the AI's own side — workers pick the nearest ore,
-// so a "far" worked seam is far from home, never across the map at the enemy —
-// and only fires it when the round trip is genuinely long. Returns null when
-// every worked seam is already inside a drop-off's reach, which is always the
-// case on a small map, so the forward drop-off is a big-map behaviour only.
-function forwardDropoffAnchor(state, workers, dropoffs) {
-  if (!dropoffs.length) return null;
-  const nodeById = state.map.nodesById || new Map(state.map.nodes.map(n => [n.id, n]));
-  const seen = new Set();
-  let best = null, bestCluster = -Infinity;
-  for (const w of workers) {
-    if (!w.order || w.order.type !== "gather") continue;
-    const n = nodeById.get(w.order.nodeId);
-    if (!n || n.com !== "ore" || n.amount <= 0 || seen.has(n.id)) continue;
-    seen.add(n.id);
-    const dDrop = Math.min(...dropoffs.map(d => Math.hypot(d.x - n.x, d.y - n.y)));
-    if (dDrop < FORWARD_DROP_MIN) continue;   // already inside an existing drop-off's haul
-    let cluster = 0;
-    for (const m of state.map.nodes)
-      if (m.com === "ore" && m.amount > 0 && Math.hypot(m.x - n.x, m.y - n.y) <= CLUSTER_RADIUS) cluster += m.amount;
-    if (cluster > bestCluster) { bestCluster = cluster; best = n; }
-  }
-  return best;
-}

engine/entities.js

@@ -33,8 +33,6 @@ export const BUILDINGS = {
     id: "refinery", name: "Refinery", hp: 400, radius: 18,
     cost: { ore: 200 }, buildTime: 16,
     sight: 140,
-    dropOff: true,   // doubles as a resource drop-off — see the dropOff note below
-    storeCap: 100,   // a PLAYER forward drop-off's finite intake buffer (engine/haul.js) — a full one reroutes gatherers
     // 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).
@@ -63,28 +61,24 @@ export const BUILDINGS = {
   foundry: {
     id: "foundry", name: "Foundry", hp: 450, radius: 18,
     cost: { ore: 175 }, buildTime: 22, sight: 140,
-    dropOff: true,   // an industrial building doubles as a resource drop-off
-    storeCap: 100,   // a PLAYER forward drop-off's finite intake buffer (engine/haul.js)
     // 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's also a
-    // forward drop-off (dropOff+storeCap above), same as the Refinery/Arsenal.
+    // 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",
   },
   arsenal: {
     id: "arsenal", name: "Arsenal", hp: 550, radius: 18,
     cost: { ore: 220 }, buildTime: 26, sight: 140,
-    dropOff: true,   // an industrial building doubles as a resource drop-off
-    storeCap: 100,   // a PLAYER forward drop-off's finite intake buffer (engine/haul.js)
     // 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 — dropOff+storeCap, not just a tech gate
+    category: "industrial",   // same reasoning as the Foundry above
   },
   spaceport: {
     id: "spaceport", name: "Spaceport", hp: 600, radius: 22,
@@ -304,22 +298,21 @@ export function prereqsMet(state, owner, def) {
   });
 }
 
-// A building is a resource drop-off if it's the Command Center or an industrial
-// building flagged `dropOff` (Refinery, Foundry, Arsenal). Workers deposit their
-// haul at the NEAREST drop-off (see gather.js), so planting one of these cheaper,
-// faster industrial buildings forward shortens a distant mining run without the
-// cost of a whole second Command Center — a decentralized economy where the CC
-// still keeps its unique roles (training workers, granting supply). Single source
-// of truth for the routing, tests, and any future UI.
+// 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 pure forward drop-off
-// (Refinery/Foundry/Arsenal) — NOT a factory, which drops its raws-as-inputs elsewhere and
-// whose `store` is its refined OUTPUT buffer, not a raw-intake bin. So the gather loop and
-// the finite-intake logic (engine/gather.js) share one definition of a "collection point".
+// 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)));
@@ -359,8 +352,8 @@ export function canLogisticsType(unitType) {
 // 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
-// pure drop-offs are all excluded. Pure def predicate — deterministic, shared by the draw math,
-// the boost application, and the HUD toggle.
+// 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;

engine/gather.js

@@ -2,15 +2,15 @@
 /* ============================================================
    Worker gather/deposit loop: walk to node -> mine into cargo -> walk to
    the nearest completed drop-off -> deposit -> repeat until the node runs
-   dry. A drop-off is the Command Center OR any industrial building that
-   proxies it (Refinery, Foundry, Arsenal — see entities.js isDropOff), so
-   a forward industrial building shortens a distant haul without a full CC.
+   dry. A drop-off is the Command Center (see entities.js isGatherDropOff) —
+   there is no forward/decentralized collection point, so every haul goes
+   all the way back to a CC.
    ============================================================ */
 
 "use strict";
 
 import { stepToward } from "./movement.js";
-import { UNITS, BUILDINGS, isGatherDropOff, storeRoom, upgradeMult } from "./entities.js";
+import { UNITS, BUILDINGS, isGatherDropOff, upgradeMult } from "./entities.js";
 import { sideMod } from "./map.js";
 import { hashStr } from "./rng.js";
 
@@ -77,7 +77,7 @@ export function updateGather(state, unit, dt) {
 
   if (order.phase === "toDrop") {
     const drop = nearestGatherDrop(state, unit.owner, unit.x, unit.y);
-    if (!drop) { unit.order = null; return; }   // no collection point with room (and no CC) → hold the load, idle
+    if (!drop) { unit.order = null; return; }   // no Command Center → hold the load, idle
     const dist = Math.hypot(drop.x - unit.x, drop.y - unit.y);
     if (dist <= DROP_REACH) {
       const player = state.players[unit.owner];
@@ -87,49 +87,28 @@ export function updateGather(state, unit, dt) {
       const banked = unit.cargo.qty
         * sideMod(state, unit.owner, "gatherMult", 1)
         * upgradeMult(player.upgrades, "gatherYieldMult");
-      // A PLAYER forward drop-off (Refinery/Foundry/Arsenal) has a FINITE intake buffer that
-      // workers must haul to the Command Center (engine/haul.js). Bank what fits into it; the
-      // Command Center (and every AI drop-off) is the bottomless treasury as before. Any
-      // overflow rides on in the cargo — the gatherer reroutes to another drop-off next tick.
-      if (unit.owner === "player" && !BUILDINGS[drop.type].isCommandCenter) {
-        const put = Math.min(banked, storeRoom(drop));
-        drop.store = drop.store || {};
-        drop.store[unit.cargo.com] = (drop.store[unit.cargo.com] || 0) + put;
-        unit.cargo.qty -= banked > 0 ? unit.cargo.qty * (put / banked) : unit.cargo.qty;
-        if (unit.cargo.qty <= 1e-6) unit.cargo.qty = 0;
-      } else {
-        player.resources[unit.cargo.com] = (player.resources[unit.cargo.com] || 0) + banked;
-        unit.cargo.qty = 0;
-      }
-      if (unit.cargo.qty <= 1e-6) {
-        order.phase = node.amount > 0 ? "toNode" : null;
-        if (!order.phase) unit.order = null;
-      }
-      // else: a partial deposit left cargo on board → stay in toDrop and reroute next tick.
+      player.resources[unit.cargo.com] = (player.resources[unit.cargo.com] || 0) + banked;
+      unit.cargo.qty = 0;
+      order.phase = node.amount > 0 ? "toNode" : null;
+      if (!order.phase) unit.order = null;
     } else {
       stepToward(state, unit, drop.x, drop.y, def.speed, dt);
     }
   }
 }
 
-// The nearest COMPLETED collection point a gatherer may bank a raw haul at: its own Command
-// Center or a pure forward drop-off (Refinery/Foundry/Arsenal — engine/entities.js
-// isGatherDropOff). A PLAYER's forward drop-off has a finite intake buffer, so a FULL one is
-// skipped and the gatherer reroutes to the next-nearest with room (the Command Center never
-// fills). AI drop-offs are the bottomless treasury as before — so AI gather routing is
-// byte-identical. Closest wins, deterministic Map order breaks ties. `excludeId`, when given,
-// skips that one building — a HAUL job's own source is ALSO a valid drop-off (a Foundry/Refinery/
-// Arsenal is both a haul-able collection point AND a forward drop-off), so without this a worker
-// standing right on it after loading would just find itself the nearest "drop", unload straight
-// back into the pile it just took the load from, and reload — never actually leaving (engine/
-// haul.js updateHaul passes its own source id here).
+// The nearest COMPLETED collection point a gatherer may bank a raw haul at (engine/entities.js
+// isGatherDropOff — today, always the Command Center; there is no forward/decentralized
+// collection point). Closest wins, deterministic Map order breaks ties. `excludeId`, when given,
+// skips that one building — a defensive guard against a worker finding its own HAUL source as its
+// drop target and looping (engine/haul.js updateHaul passes its own source id here); harmless
+// no-op while a Command Center can never itself be a HAUL source.
 /** @param {State} state @param {string} owner @param {number} x @param {number} y @param {string} [excludeId] @returns {Building|null} */
 export function nearestGatherDrop(state, owner, x, y, excludeId) {
   let best = null, bestD = Infinity;
   for (const b of state.buildings.values()) {
     if (b.owner !== owner || b.constructing || !isGatherDropOff(b.type)) continue;
     if (excludeId && b.id === excludeId) continue;
-    if (owner === "player" && !BUILDINGS[b.type].isCommandCenter && storeRoom(b) <= 0) continue;   // full forward buffer → skip
     const d = Math.hypot(b.x - x, b.y - y);
     if (d < bestD) { bestD = d; best = b; }
   }
@@ -137,8 +116,7 @@ export function nearestGatherDrop(state, owner, x, y, excludeId) {
 }
 
 // The nearest COMPLETED Command Center — the treasury/warehouse. Haulage delivers to it and
-// supply runs pick up from it (engine/haul.js), so goods flow through the CC, not sideways
-// between forward drop-offs. Null if the owner has no standing Command Center.
+// supply runs pick up from it (engine/haul.js). Null if the owner has no standing Command Center.
 /** @param {State} state @param {string} owner @param {number} x @param {number} y @returns {Building|null} */
 export function nearestCommandCenter(state, owner, x, y) {
   let best = null, bestD = Infinity;

engine/haul.js

@@ -5,12 +5,11 @@
    Buildings buffer goods locally (engine/entities.js store/input) and workers move
    them. Three jobs:
 
-   - HAUL: a one-way run for a PURE producer (the Plasma Rig; the forward drop-offs) —
-     buildings that only OUTPUT. The worker walks there, loads a cargo, and carries it to
-     whichever is nearer RIGHT NOW — its own Command Center, or a closer forward drop-off
-     (Refinery/Foundry/Arsenal) — the same "closest drop point at the moment" pick a raw
-     gatherer already makes (gather.js nearestGatherDrop), re-checked every tick of the
-     walk so a nearer option that appears or frees up room mid-trip is taken immediately.
+   - HAUL: a one-way run for a PURE producer (the Plasma Rig) — a building that only
+     OUTPUTs. The worker walks there, loads a cargo, and carries it to its own Command
+     Center — the same pick a raw gatherer already makes (gather.js nearestGatherDrop),
+     re-checked every tick of the walk. There is no forward/decentralized collection
+     point, so this is always a straight run home.
 
    - SERVICE: a ROUND TRIP for a FACTORY, or a one-way INPUT-ONLY run for a fuel-burning
      power station (the Combustion Generator, the Biomass Reactor — def.combust). A factory
@@ -78,7 +77,7 @@
 "use strict";
 
 import { stepToward } from "./movement.js";
-import { UNITS, BUILDINGS, storeTotal, storeCapOf, storeRoom, inputRoom, freightUsed, freightRoom } from "./entities.js";
+import { UNITS, BUILDINGS, storeTotal, storeCapOf, inputRoom, freightUsed, freightRoom } from "./entities.js";
 import { nearestCommandCenter, nearestGatherDrop, zoneFirst } from "./gather.js";
 import { recipeOf } from "./industry.js";
 
@@ -237,8 +236,8 @@ function neededInput(building, needs, res) {
   return want;
 }
 
-// The nearest own PURE producer (an output buffer, no recipe: the Plasma Rig, the forward
-// drop-offs) whose buffer is at least `minFraction` full and isn't already served by MAX_HAULERS —
+// The nearest own PURE producer (an output buffer, no recipe: the Plasma Rig) whose buffer
+// is at least `minFraction` full and isn't already served by MAX_HAULERS —
 // shared by assignHaul's auto-assignment (minFraction defaults to ASSIGN_FRACTION: don't pull a
 // fresh worker off other work for a trivial backlog) and a FERRY worker's "plan" phase (which
 // passes 0: a worker already dedicated to a freighter, with nothing else to do, should pick up
@@ -350,14 +349,11 @@ export function assignFerry(state, unit) {
 }
 
 /**
- * Advance a HAUL job: walk to the producer → load a cargo → carry it to the NEAREST place that'll
- * take it right now — its own Command Center, or a closer forward drop-off (Refinery/Foundry/
- * Arsenal) planted specifically to shorten a distant run, exactly like a raw gatherer already
- * picks (gather.js nearestGatherDrop) — and bank it there (1:1 — the goods were already
- * extracted). Re-picked fresh every tick of the walk, so a nearer option that appears (or frees up
- * room) mid-trip is taken immediately, not just at the moment the load first filled. Repeats while
- * the producer has a backlog, else idle. Salvages gracefully if the producer is razed or there's
- * nowhere to deliver to.
+ * Advance a HAUL job: walk to the producer → load a cargo → carry it to its own Command Center,
+ * exactly like a raw gatherer already picks (gather.js nearestGatherDrop) — and bank it there (1:1
+ * — the goods were already extracted). Re-picked fresh every tick of the walk. Repeats while the
+ * producer has a backlog, else idle. Salvages gracefully if the producer is razed or there's no
+ * Command Center to deliver to.
  * @param {State} state @param {Unit} unit @param {number} dt
  */
 export function updateHaul(state, unit, dt) {
@@ -380,35 +376,19 @@ export function updateHaul(state, unit, dt) {
     return;
   }
   if (order.phase === "toDrop") {
-    // Exclude the producer this load just came FROM: a Foundry/Refinery/Arsenal is both a valid
-    // haul source AND a valid forward drop-off, so without this a worker standing right on it
-    // after loading would find itself the nearest "drop", unload straight back into the same
-    // pile, then reload — an infinite loop that never actually leaves (see nearestGatherDrop).
+    // excludeId guards against a worker finding its own HAUL source as its drop target and
+    // looping (see nearestGatherDrop) — a harmless no-op today, since a Command Center (the only
+    // drop target) can never itself be a HAUL source.
     const drop = nearestGatherDrop(state, unit.owner, unit.x, unit.y, order.buildingId);
-    if (!drop) { unit.order = null; return; }   // nowhere with room to deliver (and no CC) → hold the load, idle
+    if (!drop) { unit.order = null; return; }   // no Command Center → hold the load, idle
     if (reached(unit, drop)) {
-      depositHaul(state, unit, drop);
-      if (unit.cargo && unit.cargo.qty > 0) return;   // a full forward drop-off took only part of it — reroute next tick
+      bankCargo(state, unit);
       order.phase = (src && !src.constructing && storeTotal(src) > 0) ? "toSource" : null;
       if (!order.phase) unit.order = null;
     } else stepToward(state, unit, drop.x, drop.y, def.speed, dt);
   }
 }
 
-// Deposit a hauler's cargo at `drop`: the bottomless treasury if it's a Command Center (bankCargo,
-// 1:1, always takes the whole load), or — a forward drop-off (Refinery/Foundry/Arsenal) planted
-// closer to the producer specifically to shorten the run — into ITS OWN finite `store` buffer,
-// clamped to whatever room is left (same finite-intake handling gather.js's raw gatherers already
-// get; a partial deposit just rides home on the cargo, and updateHaul above reroutes it next tick).
-function depositHaul(state, unit, drop) {
-  if (BUILDINGS[drop.type].isCommandCenter) { bankCargo(state, unit); return; }
-  const put = Math.min(unit.cargo.qty, storeRoom(drop));
-  drop.store = drop.store || {};
-  drop.store[unit.cargo.com] = (drop.store[unit.cargo.com] || 0) + put;
-  unit.cargo.qty -= put;
-  if (unit.cargo.qty <= 1e-6) { unit.cargo.qty = 0; unit.cargo.com = null; }
-}
-
 // Bank a worker's whole cargo into the owner's treasury (1:1) and empty it.
 function bankCargo(state, unit) {
   if (!unit.cargo || unit.cargo.qty <= 0) return;

hudSelection.js

@@ -250,7 +250,7 @@ export function renderSelectionPanel() {
         const info = rigInfo(state, rig);
         return `${!!rig.paused}:${info.nuclearOk}:${Math.round(info.throttle * 10)}:${rig.digCount || 0}:${Math.round(info.progress * 4)}:${powerEfficiency(state, rig.owner, rig.x, rig.y).name}:${info.storeFull}:${Math.round((info.stored / (info.storeCap || 1)) * 10)}:${iceCoolantMult(state, rig.owner) < 1}`;
       })()
-    // Rebuild a selected forward drop-off's intake line as gatherers fill it and workers clear it.
+    // Rebuild a selected non-recipe output buffer's (the Plasma Rig) intake line as workers clear it.
     + "|" + (() => {
         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);
@@ -1147,9 +1147,9 @@ function rebuildSelectionPanel(sel) {
       { tip: gen.paused ? "Bring it back online, feeding the grid again" : "Take it off the grid until resumed, without demolishing it" }));
   }
 
-  // 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.
+  // Any non-recipe building with a finite output buffer (storeCap, engine/entities.js) that
+  // isn't the Command Center: surface how full it is and whether it's full, same finite-storage
+  // idiom as the factory/Rig panels above.
   const drop = sel.find(e => e.kind === "building" && e.owner === "player" && !e.constructing
     && storeCapOf(e.type) > 0 && !BUILDINGS[e.type].recipe && !BUILDINGS[e.type].isCommandCenter);
   if (drop) {
@@ -1158,8 +1158,8 @@ function rebuildSelectionPanel(sel) {
     const full = storeRoom(drop) <= 1e-6;
     const row = document.createElement("div");
     row.className = "sel-note " + (full ? "bad" : pct >= 66 ? "warn" : "");
-    row.textContent = `Intake buffer ${Math.round(have)}/${cap} (${pct}%)`
-      + (full ? " — FULL: gatherers reroute until it's hauled off" : " — workers haul it to a Command Center");
+    row.textContent = `Output buffer ${Math.round(have)}/${cap} (${pct}%)`
+      + (full ? " — FULL: production stalls until it's hauled off" : " — workers haul it to a Command Center");
     panelEl.appendChild(row);
   }
 

input.js

@@ -239,9 +239,9 @@ export function attachInput(canvas, state, onChange) {
       if (workers.length) { issueAssistBuild(workers, target.id, target.type, queue); sound.playOrder(); onChange(); }
       return;
     }
-    // A completed friendly building with logistics buffers (a factory, the Rig, a forward drop-off):
-    // selected workers are ASSIGNED to service it — a standing round trip carrying its inputs in and
-    // its output out (engine/haul.js), until re-ordered elsewhere.
+    // A completed friendly building with logistics buffers (a factory, the Rig): selected workers
+    // are ASSIGNED to service it — a standing round trip carrying its inputs in and its output out
+    // (engine/haul.js), until re-ordered elsewhere.
     if (target && target.owner === "player" && target.kind === "building" && !target.constructing
         && (recipeOf(target) || storeCapOf(target.type) > 0)) {
       const workers = selected.filter(u => canLogisticsType(u.type));

test/ai.test.js

@@ -717,19 +717,19 @@ test("a macro AI whose archetype prefers Assault researches Bulwark instead, onc
     "…not Assault's, despite that being the archetype's own stated preference");
 });
 
-test("on a big map the macro AI plants a forward Refinery as a drop-off to shorten a long ore haul", () => {
-  // On a Gigantic map the deposit seams sit far from the base, so a long haul is
-  // exactly what the drop-off mechanic is for: the AI should plant a Refinery out
-  // by the far ore it's working, not tuck another one behind the CC.
+test("even on a big map with ore worked far from home, the AI never plants a second Refinery", () => {
+  // Forward-Refinery placement (decentralized collection) was removed along with the
+  // Refinery's drop-off capability — the AI now only ever builds its one home research
+  // Refinery, regardless of map size or how far its workers are mining from it. This
+  // used to be exactly the scenario (a Gigantic map, ore worked far from the base) that
+  // triggered a second, forward-planted Refinery.
   const state = createGameState({ planetId: "ferros", rng: () => 0.5, sizeMult: 3 });
   fundAll(state);
-  const barracks = stockedBarracks(state);          // completed Barracks at the AI base
+  stockedBarracks(state);          // completed Barracks at the AI base
   const cc = aiBuildings(state, "command")[0];
-  // Its home research Refinery already stands, so the new path under test is the
-  // FORWARD drop-off (the block only adds forward ones past the first).
   const home = makeBuilding("refinery", "ai", cc.x - 90, cc.y - 90);
   state.buildings.set(home.id, home);
-  // A far AI-side ore seam — well beyond any drop-off's haul — that workers mine.
+  // A far AI-side ore seam — well beyond the old FORWARD_DROP_MIN threshold — that workers mine.
   const farOre = state.map.nodes
     .filter(n => n.com === "ore" && n.amount > 0 && n.x >= state.map.width / 2)
     .filter(n => Math.hypot(n.x - cc.x, n.y - cc.y) > 500)
@@ -744,20 +744,11 @@ test("on a big map the macro AI plants a forward Refinery as a drop-off to short
   for (let i = 0; i < 4; i++) runAI(state, THINK_INTERVAL);
 
   const refineries = aiBuildings(state, "refinery");
-  assert.ok(refineries.length >= 2, "the AI added a forward Refinery on top of its home research one");
-  const forward = refineries.find(r => r.id !== home.id);
-  assert.ok(forward, "a forward Refinery exists");
-  const dNode = Math.hypot(forward.x - farOre.x, forward.y - farOre.y);
-  const dCC = Math.hypot(forward.x - cc.x, forward.y - cc.y);
-  assert.ok(dNode < dCC, "the forward Refinery sits out by the far ore, not back at the base");
-  assert.ok(dNode <= 120, "and close enough to the seam to actually serve as its drop-off");
-  // The cap holds: no runaway third Refinery while the forward one is still going up.
-  assert.ok(refineries.length <= 3, "forward drop-offs stay capped");
+  assert.equal(refineries.length, 1, "no forward Refinery — the AI only ever builds its one home Refinery");
+  assert.equal(refineries[0].id, home.id);
 });
 
-test("the forward drop-off never fires on a small map — every home seam is already in reach", () => {
-  // The same setup on a 1x map: no seam is far enough from a drop-off, so the AI
-  // keeps its single home Refinery and doesn't scatter forward ones.
+test("on a small map the AI likewise keeps just its single home Refinery", () => {
   const state = createGameState({ planetId: "ferros", rng: () => 0.5 });
   fundAll(state);
   stockedBarracks(state);
@@ -767,7 +758,7 @@ test("the forward drop-off never fires on a small map — every home seam is alr
   // Put workers on the AI's own home ore (as they would be) — all within reach.
   const oreSeams = state.map.nodes.filter(n => n.com === "ore" && n.amount > 0 &&
     Math.hypot(n.x - cc.x, n.y - cc.y) < 360);
-  assert.ok(oreSeams.length > 0, "fixture: home ore is within a drop-off's reach on a small map");
+  assert.ok(oreSeams.length > 0, "fixture: home ore is within reach on a small map");
   for (const seam of oreSeams) {
     const w = makeUnit("worker", "ai", seam.x, seam.y);
     w.order = { type: "gather", nodeId: seam.id, phase: "mining" };
@@ -776,7 +767,7 @@ test("the forward drop-off never fires on a small map — every home seam is alr
 
   for (let i = 0; i < 4; i++) runAI(state, THINK_INTERVAL);
 
-  assert.equal(aiBuildings(state, "refinery").length, 1, "no forward Refinery — the home one already reaches every worked seam");
+  assert.equal(aiBuildings(state, "refinery").length, 1, "still just the one home Refinery");
 });
 
 test("the AI spreads workers across ore nodes instead of over-piling one under saturation", () => {

test/entities.test.js

@@ -157,21 +157,19 @@ test("the Command Center is buildable but steep: the priciest, slowest structure
   assert.ok(BUILDINGS.command.cost.ore > BUILDINGS.refinery.cost.ore, "an expansion should out-price every other building");
 });
 
-test("resource drop-offs are the Command Center and the industrial buildings that proxy it", () => {
-  // The CC and the industrial line (Refinery, Foundry, Arsenal) all bank hauls,
-  // so a forward industrial building shortens a distant mining run without a
-  // whole second Command Center.
+test("the Command Center is the only resource drop-off in the skirmish roster", () => {
+  // No forward/decentralized collection point: every haul goes all the way back to a CC.
   assert.equal(isDropOff("command"), true, "the CC is always a drop-off");
-  assert.equal(isDropOff("refinery"), true);
-  assert.equal(isDropOff("foundry"), true);
-  assert.equal(isDropOff("arsenal"), true);
-  // Troop, defense, and housing buildings are not collection points.
+  assert.equal(isDropOff("refinery"), false, "the Refinery is a research building only, not a collection point");
+  assert.equal(isDropOff("foundry"), false, "the Foundry is a tech gate only, not a collection point");
+  assert.equal(isDropOff("arsenal"), false, "the Arsenal is a tech gate only, not a collection point");
+  // Troop, defense, and housing buildings are not collection points either.
   assert.equal(isDropOff("barracks"), false, "the Barracks trains troops, it doesn't collect");
   assert.equal(isDropOff("turret"), false);
   assert.equal(isDropOff("habitat"), false);
   assert.equal(isDropOff("not-a-building"), false, "an unknown type is never a drop-off");
   // The flag is what the routing reads — keep def and predicate in sync.
-  for (const t of ["refinery", "foundry", "arsenal"]) assert.equal(BUILDINGS[t].dropOff, true, `${t} carries the dropOff flag`);
+  for (const t of ["refinery", "foundry", "arsenal"]) assert.equal(BUILDINGS[t].dropOff, undefined, `${t} no longer carries the dropOff flag`);
 });
 
 test("the Ranger is a Command-Center recon unit: cheap, fragile, all-terrain, far-sighted", () => {
@@ -308,12 +306,11 @@ test("canBuildCategory/canBuildType: Worker builds everything, a non-worker buil
 });
 
 test("Foundry and Arsenal are Industrial, not Military, despite gating combat tech", () => {
-  // Both double as forward drop-offs (dropOff+storeCap, same as Refinery) — they already
-  // participate in the haul/service logistics system, same as Refinery.
+  // They group with the Refinery in the build menu as production-tech buildings —
+  // neither trains nor fights, unlike the Barracks/Turret/Star Dock roster below.
   assert.equal(BUILDINGS.foundry.category, "industrial");
   assert.equal(BUILDINGS.arsenal.category, "industrial");
   assert.equal(BUILDINGS.refinery.category, "industrial");
-  assert.ok(BUILDINGS.foundry.dropOff && BUILDINGS.arsenal.dropOff);
   assert.equal(BUILDINGS.barracks.category, "military");
   assert.equal(BUILDINGS.turret.category, "military");
   assert.equal(BUILDINGS.stardock.category, "military");

test/gather.test.js

@@ -129,62 +129,29 @@ test("a constructing expansion Command Center only becomes a dropoff once it com
   assert.ok(state.players.player.resources.ore > before, "the finished expansion is the nearest dropoff");
 });
 
-test("a forward Refinery is a drop-off with a FINITE intake buffer — the haul lands there, not the treasury", () => {
+test("a Refinery planted right on a node is NOT a drop-off — the gatherer walks past it to the Command Center", () => {
   const state = createGameState({ planetId: "ferros", rng: () => 0.5 });
   const worker = [...state.units.values()].find(u => u.owner === "player" && u.type === "worker");
   const node = firstNode(state, "ore");
   // A completed Refinery planted right on the node, far from the seeded base CC.
   const refinery = makeBuilding("refinery", "player", node.x + 12, node.y, { constructing: false });
   state.buildings.set(refinery.id, refinery);
-  // The worker is full and standing at the node — well beyond DROP_REACH of the
-  // base CC, so a deposit this tick can ONLY be the nearby Refinery.
-  worker.x = node.x; worker.y = node.y;
-  worker.cargo = { com: "ore", qty: 10 };
-  worker.order = { type: "gather", nodeId: node.id, phase: "toDrop" };
-  const before = state.players.player.resources.ore;
   const cc = [...state.buildings.values()].find(b => b.type === "command");
-  assert.ok(Math.hypot(cc.x - worker.x, cc.y - worker.y) > 30, "the base CC is out of drop reach — only the Refinery is close");
-
-  updateGather(state, worker, 0.05);
-  assert.ok(storeTotal(refinery) > 0, "the Refinery's finite intake buffer accepted the haul");
-  assert.equal(state.players.player.resources.ore, before, "…and it does NOT reach the treasury until a worker hauls it to the CC");
-  assert.equal(worker.cargo.qty, 0, "cargo emptied at the forward Refinery");
-});
-
-test("a FULL forward drop-off reroutes the gatherer instead of accepting more", () => {
-  const state = createGameState({ planetId: "ferros", rng: () => 0.5 });
-  const worker = [...state.units.values()].find(u => u.owner === "player" && u.type === "worker");
-  const node = firstNode(state, "ore");
-  const cc = [...state.buildings.values()].find(b => b.type === "command" && b.owner === "player");
-  const refinery = makeBuilding("refinery", "player", node.x + 12, node.y, { constructing: false });
-  refinery.store = { ore: 100 };   // brimming (storeCap 100) → can't take more
-  state.buildings.set(refinery.id, refinery);
-  worker.x = node.x; worker.y = node.y;
-  worker.cargo = { com: "ore", qty: 10 };
-  worker.order = { type: "gather", nodeId: node.id, phase: "toDrop" };
-
-  updateGather(state, worker, 0.05);
-  assert.equal(worker.cargo.qty, 10, "the full Refinery took nothing — the load stays aboard");
-  assert.ok(storeTotal(refinery) <= 100, "…and its buffer didn't exceed capacity");
-  // With the Refinery full, the gatherer is now routing to the CC (the bottomless warehouse).
-  const toCC = Math.hypot(cc.x - worker.x, cc.y - worker.y);
-  for (let i = 0; i < 4000 && state.players.player.resources.ore === 0; i++) updateGather(state, worker, 0.05);
-  assert.ok(state.players.player.resources.ore > 0, "it rerouted to the Command Center and banked there");
-});
-
-test("a still-constructing Refinery is not yet a drop-off", () => {
-  const state = createGameState({ planetId: "ferros", rng: () => 0.5 });
-  const worker = [...state.units.values()].find(u => u.owner === "player" && u.type === "worker");
-  const node = firstNode(state, "ore");
-  const refinery = makeBuilding("refinery", "player", node.x + 12, node.y, { constructing: true });
-  state.buildings.set(refinery.id, refinery);
   worker.x = node.x; worker.y = node.y;
   worker.cargo = { com: "ore", qty: 10 };
   worker.order = { type: "gather", nodeId: node.id, phase: "toDrop" };
   const before = state.players.player.resources.ore;
+  assert.ok(Math.hypot(cc.x - worker.x, cc.y - worker.y) > 30, "the base CC is out of drop reach — the Refinery sits right next to the worker");
 
   updateGather(state, worker, 0.05);
-  assert.equal(state.players.player.resources.ore, before, "an unfinished Refinery banks nothing — the worker heads for the distant CC");
+  assert.equal(storeTotal(refinery), 0, "the Refinery has no intake buffer — it never banks a raw haul");
+  assert.equal(state.players.player.resources.ore, before, "nothing reaches the treasury yet — the worker is still walking to the CC");
+  assert.equal(worker.cargo.qty, 10, "cargo stays aboard, unaffected by standing next to the Refinery");
+
+  // Walk it all the way home and confirm it banks at the CC, never at the Refinery.
+  for (let i = 0; i < 4000 && state.players.player.resources.ore === before; i++) updateGather(state, worker, 0.05);
+  assert.ok(state.players.player.resources.ore > before, "it reached the Command Center and banked there");
+  assert.equal(storeTotal(refinery), 0, "the Refinery still received nothing");
 });
 
 test("Logistics Network (+25% yield) banks more per haul", () => {

test/haul.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { createGameState, makeBuilding, makeUnit } from "../engine/state.js";
 import { tick } from "../engine/sim.js";
 import { updateHaul, assignHaul, updateService, assignService, countLogistics } from "../engine/haul.js";
-import { storeTotal, storeCapOf, inputTotal, inputRoom, inputCapOf } from "../engine/entities.js";
+import { storeTotal, inputTotal, inputRoom, inputCapOf } from "../engine/entities.js";
 import { mulberry32 } from "./_helpers.js";
 
 const near = (a, b, eps = 1e-6) => Math.abs(a - b) < eps;
@@ -41,70 +41,27 @@ test("a hauler carries a producer's buffered output to the Command Center and ba
     "the treasury gains exactly what the buffer held — no gather multiplier double-dips a rig's yield");
 });
 
-test("a hauler prefers a forward drop-off (Refinery/Foundry/Arsenal) over the Command Center when it's the closer place to deposit right now", () => {
+test("a hauler ignores a nearby Refinery/Foundry/Arsenal — the load always goes to the Command Center", () => {
   const { s, cc, workers } = base(1);
-  // The rig sits far from the CC, with a Refinery planted right next to it — the documented
-  // "forward drop-off shortens a distant mining run" pattern, now extended to a HAUL job.
-  const rig = makeBuilding("plasmarig", "player", cc.x + 900, cc.y);
-  rig.store = { ore: 60 };
+  const rig = plantRig(s, cc, { ore: 55 });
   rig.paused = true;
-  s.buildings.set(rig.id, rig);
+  // A Refinery planted right next to the rig — this used to be the "forward drop-off
+  // shortens a distant mining run" pattern; it no longer collects anything, for any owner.
   const refinery = makeBuilding("refinery", "player", rig.x + 20, rig.y);
   s.buildings.set(refinery.id, refinery);
   const w = workers[0];
   w.x = rig.x; w.y = rig.y;
   w.order = { type: "haul", buildingId: rig.id };
-  const ccOreBefore = s.players.player.resources.ore || 0;
-
-  for (let i = 0; i < 2000 && (storeTotal(rig) > 0 || (w.cargo && w.cargo.qty > 0)); i++) updateHaul(s, w, 0.05);
-
-  assert.equal(storeTotal(rig), 0, "the rig's whole buffer was hauled away");
-  assert.ok(storeTotal(refinery) > 0, "it landed in the much-closer Refinery's own buffer");
-  assert.equal(s.players.player.resources.ore || 0, ccOreBefore,
-    "not one trip detoured all the way to the distant Command Center while the Refinery had room");
-});
-
-test("a hauler whose SOURCE is itself a forward drop-off (Foundry/Refinery/Arsenal) doesn't loop delivering back to itself", () => {
-  // Regression: a Foundry/Refinery/Arsenal is both a haul-able collection point (workers dump raw
-  // gathers there) AND a valid drop-off in its own right. Once a worker loads a cargo right there,
-  // it used to be the NEAREST drop-off too (distance ~0, closer than the far-off CC) — so it
-  // "delivered" straight back into the very pile it just took from, then reloaded, forever, never
-  // making any progress toward the Command Center.
-  const { s, cc, workers } = base(1);
-  const foundry = makeBuilding("foundry", "player", cc.x + 900, cc.y);
-  foundry.store = { ore: 60 };
-  s.buildings.set(foundry.id, foundry);
-  const w = workers[0];
-  w.x = foundry.x; w.y = foundry.y;
-  w.order = { type: "haul", buildingId: foundry.id };
   const before = s.players.player.resources.ore || 0;
 
-  for (let i = 0; i < 6000 && (storeTotal(foundry) > 0 || (w.cargo && w.cargo.qty > 0)); i++) updateHaul(s, w, 0.05);
-
-  assert.equal(storeTotal(foundry), 0, "the foundry's whole buffer was hauled away instead of endlessly recycling");
-  assert.ok(near((s.players.player.resources.ore || 0) - before, 60, 1e-3), "and it actually reached the treasury");
-});
-
-test("a hauler falls back to the Command Center once the closer forward drop-off's buffer is full", () => {
-  const { s, cc, workers } = base(1);
-  const rig = makeBuilding("plasmarig", "player", cc.x + 900, cc.y);
-  rig.store = { ore: storeCapOf("refinery") + 40 };   // more than the Refinery can ever hold
-  rig.paused = true;
-  s.buildings.set(rig.id, rig);
-  const refinery = makeBuilding("refinery", "player", rig.x + 20, rig.y);
-  s.buildings.set(refinery.id, refinery);
-  const w = workers[0];
-  w.x = rig.x; w.y = rig.y;
-  w.order = { type: "haul", buildingId: rig.id };
-
   for (let i = 0; i < 6000 && (storeTotal(rig) > 0 || (w.cargo && w.cargo.qty > 0)); i++) updateHaul(s, w, 0.05);
 
-  assert.equal(storeTotal(rig), 0, "the whole (oversized) buffer eventually clears");
-  assert.equal(storeTotal(refinery), storeCapOf("refinery"), "the Refinery filled all the way up");
-  assert.ok((s.players.player.resources.ore || 0) > 0, "and the overflow still reached the treasury via the Command Center");
+  assert.equal(storeTotal(rig), 0, "the rig's whole buffer was hauled away");
+  assert.equal(storeTotal(refinery), 0, "the Refinery has no intake buffer — nothing landed there");
+  assert.ok(near((s.players.player.resources.ore || 0) - before, 55, 1e-3), "the full load reached the Command Center instead");
 });
 
-test("mid-trip re-route: a hauler already walking toward the Command Center switches to a nearer drop-off that completes along the way", () => {
+test("mid-trip: a hauler already walking toward the Command Center is unaffected by a Refinery completing nearby", () => {
   const { s, cc, workers } = base(1);
   const rig = makeBuilding("plasmarig", "player", cc.x + 900, cc.y);
   rig.store = { ore: 30 };
@@ -119,14 +76,14 @@ test("mid-trip re-route: a hauler already walking toward the Command Center swit
   assert.equal(w.order.phase, "toDrop");
   const midX = w.x;
 
-  // ...then a Refinery completes right where the worker already is, much closer than the CC.
+  // ...then a Refinery completes right where the worker already is.
   const refinery = makeBuilding("refinery", "player", w.x + 5, w.y);
   s.buildings.set(refinery.id, refinery);
 
-  for (let i = 0; i < 40 && w.order; i++) updateHaul(s, w, 0.05);
+  for (let i = 0; i < 40; i++) updateHaul(s, w, 0.05);
 
-  assert.ok(storeTotal(refinery) > 0, "it re-routed to the newly-completed, much closer Refinery instead of continuing on to the CC");
-  assert.ok(Math.abs(w.x - midX) < 50, "it didn't keep marching toward the distant CC first");
+  assert.equal(storeTotal(refinery), 0, "the newly-completed Refinery still isn't a valid drop — nothing lands there");
+  assert.ok(w.x < midX, "the worker kept walking toward the distant Command Center (lower x), unaffected");
 });
 
 test("auto haul/service offers go to Worker, never to a non-logistics unit", () => {
@@ -396,15 +353,15 @@ test("a manually-assigned worker keeps servicing its one building", () => {
   assert.ok((s.players.player.resources.metals || 0) > 0, "…and keeps the metals flowing back");
 });
 
-test("an AI-owned forward drop-off banks straight to the treasury — no buffer, no logistics (determinism)", () => {
+test("a Refinery near the AI's Command Center accumulates no buffer, and the AI never hauls or services (determinism)", () => {
   const { s, cc } = base(7);
   const aiCC = [...s.buildings.values()].find(b => b.owner === "ai" && b.type === "command");
   const ref = makeBuilding("refinery", "ai", aiCC.x + 30, aiCC.y);
   s.buildings.set(ref.id, ref);
   for (let i = 0; i < 300; i++) tick(s, 0.1);
-  assert.equal(storeTotal(ref), 0, "the AI's Refinery buffer stays empty — AI banks to the treasury as before");
+  assert.equal(storeTotal(ref), 0, "a Refinery has no intake buffer for any owner — it's a pure tech/research building now");
   const aiLogi = [...s.units.values()].some(u => u.owner === "ai" && u.order && (u.order.type === "haul" || u.order.type === "service"));
-  assert.equal(aiLogi, false, "and no AI worker ever hauls or services");
+  assert.equal(aiLogi, false, "the AI builds no producers, so its workers never haul or service — determinism holds");
 });
 
 test("assignService is owner-scoped and skips a well-stocked, cleared factory", () => {