The automatons awaken (branch only — not for the public droplet yet)

Phase 4 begins. The automaton is a pure function in the engine — automatonCommand(view) — playing from its own redacted GameView, the same information a human seat receives: hidden hands stay hidden from the clockwork. It ranks simple damage spells, counters what hurts (full shield at 3+, reflection at 4+, blunt at 2+), discards its worst cards by a value order, BFS-pathfinds to enemy treasures and home again, refuses to path through hazards, brawls when there is nothing to steal, and always has a safe fallback; the server's drive loop steps any bot-held seat through the same runCommand path as humans, so bot commands log, persist, replay, and broadcast like anyone's. Hosts seat them pre-start with "⚙ seat an automaton" (Automaton, Automaton II, ... V); bot seats persist as tokenless join lines and restore on boot. Proven three ways: bot-vs-bot engine games conclude across seeds in 8-14 rounds (~100 commands — human-scale), a full four-automaton table finishes, and a live websocket game of human vs. automaton ended with the clockwork carrying two treasures home through a do-nothing opponent. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-16 16:11:54 -04:00
parent 5802e1df05
commit ab52628d2f
9 changed files with 559 additions and 5 deletions
@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import {
+  applyCommand,
+  createGame,
+  type GameState,
+  type PlayerId,
+} from "../src/game";
+import { viewFor } from "../src/view";
+import { automatonCommand, automatonFallback } from "../src/automaton";
+
+/** Whose input does the maze want right now? */
+function actingSeat(state: GameState): PlayerId {
+  return (
+    state.stack?.waitingOn ??
+    state.pendingDiscard ??
+    state.chaosPending?.queue[0] ??
+    state.outOfTurnWindow?.playerId ??
+    state.players[state.turn.activeIndex]!.id
+  );
+}
+
+/** Drive a full bot-vs-bot game; returns the final state and command count. */
+function playOut(seed: number, players: number, expansion = true) {
+  const ids = Array.from({ length: players }, (_, i) => `bot${i + 1}`);
+  let { state } = createGame({
+    playerIds: ids,
+    seed,
+    sets: expansion ? ["basic", "expansion1"] : ["basic"],
+    deckRev: 8,
+  });
+  let commands = 0;
+  let stuck = 0;
+  const CAP = 4000;
+  while (state.phase === "playing" && commands < CAP) {
+    const seat = actingSeat(state);
+    const view = viewFor(state, seat);
+    const cmd = automatonCommand(view) ?? automatonFallback(view);
+    let r = applyCommand(state, seat, cmd);
+    if (!r.ok) {
+      const fb = automatonFallback(view);
+      r = applyCommand(state, seat, fb);
+      if (!r.ok) {
+        stuck++;
+        if (stuck > 3) {
+          throw new Error(
+            `automaton stuck at seat ${seat} after ${commands} commands: ` +
+            `${JSON.stringify(cmd)} -> ${JSON.stringify(fb)} both refused (${r.error})`,
+          );
+        }
+        // Last-ditch: burn the turn structure forward.
+        r = applyCommand(state, seat, { type: "endTurn", draw: 0 });
+        if (!r.ok) r = applyCommand(state, seat, { type: "pass" });
+        if (!r.ok) throw new Error(`unrecoverable at ${seat}: ${r.error}`);
+      }
+    } else {
+      stuck = 0;
+    }
+    state = r.state;
+    commands++;
+  }
+  return { state, commands };
+}
+
+describe("automaton vs automaton", () => {
+  it("two clockwork wizards fight a game to its end", () => {
+    const { state, commands } = playOut(11, 2);
+    expect(state.phase).toBe("finished");
+    expect(state.winner).not.toBeNull();
+    expect(commands).toBeLessThan(4000);
+  });
+
+  it("holds up across many seeds without wedging", () => {
+    let finished = 0;
+    for (const seed of [1, 2, 3, 5, 8, 13, 21, 34]) {
+      const { state } = playOut(seed, 2);
+      if (state.phase === "finished") finished++;
+    }
+    // Cautious clockwork can stall a maze; most games must still conclude.
+    expect(finished).toBeGreaterThanOrEqual(6);
+  });
+
+  it("a full table of four automatons concludes", () => {
+    const { state } = playOut(7, 4);
+    expect(state.phase).toBe("finished");
+  });
+});