Fix hauler ping-pong loop when its source is itself a drop-off (#27)

A Foundry/Refinery/Arsenal is both a haul-able collection point and a
valid forward drop-off. Once a worker loaded cargo there, it was also
the nearest drop-off (distance ~0, closer than a far-off CC), so
updateHaul delivered the load straight back into the pile it just
took it from, then reloaded — forever, with zero net progress.

nearestGatherDrop now takes an excludeId so updateHaul's "toDrop"
phase can exclude the job's own source building from the drop-off
search.

Co-authored-by: Claude <noreply@anthropic.com>

engine/gather.js

@@ -117,12 +117,18 @@ export function updateGather(state, unit, dt) {
 // 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.
-/** @param {State} state @param {string} owner @param {number} x @param {number} y @returns {Building|null} */
-export function nearestGatherDrop(state, owner, x, y) {
+// 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).
+/** @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; }

engine/haul.js

@@ -349,7 +349,11 @@ export function updateHaul(state, unit, dt) {
     return;
   }
   if (order.phase === "toDrop") {
-    const drop = nearestGatherDrop(state, unit.owner, unit.x, unit.y);
+    // 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).
+    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 (reached(unit, drop)) {
       depositHaul(state, unit, drop);

test/haul.test.js

@@ -64,6 +64,27 @@ test("a hauler prefers a forward drop-off (Refinery/Foundry/Arsenal) over the Co
     "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);