@gamepark/zenith 1.0.4 → 1.0.8

package/dist/rules/effect/AgentEffects.spec.js

@@ -15,7 +15,7 @@ const player1 = 1;
 const player2 = 2;
 function createGameForAgent(agent) {
     const setup = new TestSetup(agent);
-    const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+    const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
     return new ZenithRules(game);
 }
 class TestSetup extends ZenithSetup {
@@ -47,14 +47,14 @@ class TestSetup extends ZenithSetup {
             id: this.testAgent,
             location: { type: LocationType.PlayerHand, player: player1 }
         });
-        const fillers = agents.filter(a => a !== this.testAgent).slice(0, 3);
+        const fillers = agents.filter((a) => a !== this.testAgent).slice(0, 3);
         for (const agent of fillers) {
             this.material(MaterialType.AgentCard).createItem({
                 id: agent,
                 location: { type: LocationType.PlayerHand, player: player1 }
             });
         }
-        const p2Fillers = agents.filter(a => a !== this.testAgent && !fillers.includes(a)).slice(0, 4);
+        const p2Fillers = agents.filter((a) => a !== this.testAgent && !fillers.includes(a)).slice(0, 4);
         for (const agent of p2Fillers) {
             this.material(MaterialType.AgentCard).createItem({
                 id: agent,
@@ -63,11 +63,8 @@ class TestSetup extends ZenithSetup {
         }
     }
     setupRemainingDeck() {
-        const usedAgents = new Set([
-            this.testAgent,
-            ...agents.filter(a => a !== this.testAgent).slice(0, 7)
-        ]);
-        const remaining = agents.filter(a => !usedAgents.has(a));
+        const usedAgents = new Set([this.testAgent, ...agents.filter((a) => a !== this.testAgent).slice(0, 7)]);
+        const remaining = agents.filter((a) => !usedAgents.has(a));
         for (const agent of remaining) {
             this.material(MaterialType.AgentCard).createItem({
                 id: agent,
@@ -141,11 +138,7 @@ function resolveAutoMoves(rules) {
     }
 }
 function playAgentAndResolveEffects(rules, agent) {
-    const cardIndex = rules.material(MaterialType.AgentCard)
-        .location(LocationType.PlayerHand)
-        .player(player1)
-        .id(agent)
-        .getIndex();
+    const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(agent).getIndex();
     if (cardIndex === undefined) {
         return { error: `Agent ${Agent[agent]} not found in player1 hand` };
     }
@@ -206,14 +199,11 @@ describe('Agent effects resolution', () => {
 describe('Gilgamesh opponentSide fallback', () => {
     it('should allow pulling a different planet when the only opponent-side planet was pulled across by effect 2', () => {
         const setup = new GilgameshTestSetup();
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const venusStart = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace)
-            .id(Influence.Venus).getItem();
+        const venusStart = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Venus).getItem();
         expect(venusStart.location.x).toBe(-1);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Gilgamesh).getIndex();
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Gilgamesh).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Terra,
@@ -241,14 +231,11 @@ describe('Gilgamesh opponentSide fallback', () => {
 describe('Planet capture', () => {
     it('White pulling a planet at x=3 should capture it at x=4 into White TeamPlanets', () => {
         const setup = new CaptureTestSetup(Agent.Mc4ffr3y, Influence.Mars, 3);
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const marsStart = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace)
-            .id(Influence.Mars).getItem();
+        const marsStart = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars).getItem();
         expect(marsStart.location.x).toBe(3);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Mc4ffr3y).getIndex();
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Mc4ffr3y).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Mars,
@@ -272,32 +259,21 @@ describe('Planet capture', () => {
             resolveAutoMoves(rules);
             iterations++;
         }
-        const marsInWhite = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets)
-            .player(TeamColor.White)
-            .id(Influence.Mars);
+        const marsInWhite = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Mars);
         expect(marsInWhite.length).toBe(1);
-        const marsInBlack = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets)
-            .player(TeamColor.Black)
-            .id(Influence.Mars);
+        const marsInBlack = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.Black).id(Influence.Mars);
         expect(marsInBlack.length).toBe(0);
-        const marsOnBoard = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace)
-            .id(Influence.Mars);
+        const marsOnBoard = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars);
         expect(marsOnBoard.length).toBe(1);
         expect(marsOnBoard.getItem().location.x).toBe(0);
     });
     it('Black pulling a planet at x=-3 should capture it at x=-4 into Black TeamPlanets', () => {
         const setup = new CaptureTestSetupBlack(Agent.Mc4ffr3y, Influence.Mars, -3);
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const marsStart = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace)
-            .id(Influence.Mars).getItem();
+        const marsStart = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars).getItem();
         expect(marsStart.location.x).toBe(-3);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player2).id(Agent.Mc4ffr3y).getIndex();
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player2).id(Agent.Mc4ffr3y).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Mars,
@@ -321,32 +297,21 @@ describe('Planet capture', () => {
             resolveAutoMoves(rules);
             iterations++;
         }
-        const marsInBlack = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets)
-            .player(TeamColor.Black)
-            .id(Influence.Mars);
+        const marsInBlack = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.Black).id(Influence.Mars);
         expect(marsInBlack.length).toBe(1);
-        const marsInWhite = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets)
-            .player(TeamColor.White)
-            .id(Influence.Mars);
+        const marsInWhite = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Mars);
         expect(marsInWhite.length).toBe(0);
-        const marsOnBoard = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace)
-            .id(Influence.Mars);
+        const marsOnBoard = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars);
         expect(marsOnBoard.length).toBe(1);
         expect(marsOnBoard.getItem().location.x).toBe(0);
     });
     it('White pushing Terra at x=-3 should capture it at x=-4 into Black TeamPlanets (opponent)', () => {
         const setup = new CaptureTestSetup(Agent.Titus, Influence.Terra, -3);
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const terraStart = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace)
-            .id(Influence.Terra).getItem();
+        const terraStart = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra).getItem();
         expect(terraStart.location.x).toBe(-3);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Titus).getIndex();
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Titus).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Agents[Agent.Titus].influence,
@@ -366,25 +331,16 @@ describe('Planet capture', () => {
                 resolveAutoMoves(rules);
                 continue;
             }
-            const terraPush = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-                rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Terra);
+            const terraPush = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) && rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Terra);
             playConsequences(rules, terraPush ?? moves[0]);
             resolveAutoMoves(rules);
             iterations++;
         }
-        const terraInBlack = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets)
-            .player(TeamColor.Black)
-            .id(Influence.Terra);
+        const terraInBlack = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.Black).id(Influence.Terra);
         expect(terraInBlack.length).toBe(1);
-        const terraInWhite = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets)
-            .player(TeamColor.White)
-            .id(Influence.Terra);
+        const terraInWhite = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Terra);
         expect(terraInWhite.length).toBe(0);
-        const terraOnBoard = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace)
-            .id(Influence.Terra);
+        const terraOnBoard = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra);
         expect(terraOnBoard.length).toBe(1);
         expect(terraOnBoard.getItem().location.x).toBe(0);
     });
@@ -392,16 +348,12 @@ describe('Planet capture', () => {
 describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
     it('should allow capturing Mercury and still apply remaining pattern moves to Venus and Terra', () => {
         const setup = new AugustusPatternSetup({ [Influence.Mercury]: 3 });
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        expect(rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mercury).getItem().location.x).toBe(3);
-        expect(rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Venus).getItem().location.x).toBe(0);
-        expect(rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra).getItem().location.x).toBe(0);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
+        expect(rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mercury).getItem().location.x).toBe(3);
+        expect(rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Venus).getItem().location.x).toBe(0);
+        expect(rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra).getItem().location.x).toBe(0);
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Terra,
@@ -421,33 +373,29 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
                 resolveAutoMoves(rules);
                 continue;
             }
-            const mercuryMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-                rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mercury);
-            const venusMove = !mercuryMove ? moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-                rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Venus &&
-                m.location.x === 2) : undefined;
+            const mercuryMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) && rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mercury);
+            const venusMove = !mercuryMove
+                ? moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
+                    rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Venus &&
+                    m.location.x === 2)
+                : undefined;
             playConsequences(rules, mercuryMove ?? venusMove ?? moves[0]);
             resolveAutoMoves(rules);
             iterations++;
         }
-        const mercuryCaptured = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Mercury);
+        const mercuryCaptured = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Mercury);
         expect(mercuryCaptured.length).toBe(1);
-        const venus = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Venus);
+        const venus = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Venus);
         expect(venus.getItem().location.x).toBe(2);
-        const terra = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra);
+        const terra = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra);
         expect(terra.getItem().location.x).toBe(2);
     });
     it('should allow truncated pattern at left edge — Mercury+2 capture with Venus+1', () => {
         const setup = new AugustusPatternSetup({ [Influence.Mercury]: 2 });
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        expect(rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mercury).getItem().location.x).toBe(2);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
+        expect(rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mercury).getItem().location.x).toBe(2);
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Terra,
@@ -467,28 +415,24 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
                 resolveAutoMoves(rules);
                 continue;
             }
-            const mercuryMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
+            const mercuryMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
                 rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mercury &&
                 m.location.x === 4);
             playConsequences(rules, mercuryMove ?? moves[0]);
             resolveAutoMoves(rules);
             iterations++;
         }
-        const mercuryCaptured = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Mercury);
+        const mercuryCaptured = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Mercury);
         expect(mercuryCaptured.length).toBe(1);
-        const venus = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Venus);
+        const venus = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Venus);
         expect(venus.getItem().location.x).toBe(1);
     });
     it('should allow truncated pattern at right edge — Jupiter+2 capture with Mars+1', () => {
         const setup = new AugustusPatternSetup({ [Influence.Jupiter]: 2 });
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        expect(rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Jupiter).getItem().location.x).toBe(2);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
+        expect(rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Jupiter).getItem().location.x).toBe(2);
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Terra,
@@ -508,26 +452,23 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
                 resolveAutoMoves(rules);
                 continue;
             }
-            const jupiterMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
+            const jupiterMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
                 rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Jupiter &&
                 m.location.x === 4);
             playConsequences(rules, jupiterMove ?? moves[0]);
             resolveAutoMoves(rules);
             iterations++;
         }
-        const jupiterCaptured = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Jupiter);
+        const jupiterCaptured = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Jupiter);
         expect(jupiterCaptured.length).toBe(1);
-        const mars = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars);
+        const mars = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars);
         expect(mars.getItem().location.x).toBe(1);
     });
     it('should not allow moving Mercury+2 when it is not at the edge (no truncated pattern needed)', () => {
         const setup = new AugustusPatternSetup({});
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Terra,
@@ -539,8 +480,7 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
         let iterations = 0;
         while (iterations < 20) {
             const moves = rules.getLegalMoves(player1);
-            const mercuryMoves = moves.filter(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-                rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mercury);
+            const mercuryMoves = moves.filter((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) && rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mercury);
             if (mercuryMoves.length > 0) {
                 patternMoves = moves;
                 break;
@@ -554,18 +494,16 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
             }
             iterations++;
         }
-        const mercuryMoves = patternMoves.filter(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-            rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mercury);
-        const mercuryTargetXs = mercuryMoves.map(m => m.location.x).sort();
+        const mercuryMoves = patternMoves.filter((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) && rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mercury);
+        const mercuryTargetXs = mercuryMoves.map((m) => m.location.x).sort();
         expect(mercuryTargetXs).toContain(1);
         expect(mercuryTargetXs).toContain(2);
     });
     it('should not allow moving a non-adjacent planet with pattern', () => {
         const setup = new AugustusPatternSetup({});
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Terra,
@@ -576,7 +514,7 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
         let iterations = 0;
         while (iterations < 20) {
             const moves = rules.getLegalMoves(player1);
-            const mercuryMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
+            const mercuryMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
                 rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mercury &&
                 m.location.x === 1);
             if (mercuryMove) {
@@ -595,8 +533,8 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
         }
         const nextMoves = rules.getLegalMoves(player1);
         const movablePlanets = new Set(nextMoves
-            .filter(m => isMoveItemType(MaterialType.InfluenceDisc)(m))
-            .map(m => rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id));
+            .filter((m) => isMoveItemType(MaterialType.InfluenceDisc)(m))
+            .map((m) => rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id));
         expect(movablePlanets.has(Influence.Venus)).toBe(true);
         expect(movablePlanets.has(Influence.Terra)).toBe(true);
         expect(movablePlanets.has(Influence.Mars)).toBe(false);
@@ -604,10 +542,9 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
     });
     it('should not allow moving only Jupiter+2 without Mars (pattern requires adjacency)', () => {
         const setup = new AugustusPatternSetup({ [Influence.Jupiter]: 2 });
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Terra,
@@ -618,13 +555,12 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
         let iterations = 0;
         while (iterations < 20) {
             const moves = rules.getLegalMoves(player1);
-            const jupiterMoves = moves.filter(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-                rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Jupiter);
+            const jupiterMoves = moves.filter((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) && rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Jupiter);
             if (jupiterMoves.length > 0) {
-                const jupiterTargetXs = jupiterMoves.map(m => m.location.x).sort();
+                const jupiterTargetXs = jupiterMoves.map((m) => m.location.x).sort();
                 expect(jupiterTargetXs).toContain(3);
                 expect(jupiterTargetXs).toContain(4);
-                const captureMove = jupiterMoves.find(m => m.location.x === 4);
+                const captureMove = jupiterMoves.find((m) => m.location.x === 4);
                 playConsequences(rules, captureMove);
                 resolveAutoMoves(rules);
                 break;
@@ -654,16 +590,14 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
             resolveAutoMoves(rules);
             iterations++;
         }
-        const mars = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars);
+        const mars = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars);
         expect(mars.getItem().location.x).toBe(1);
     });
     it('should continue pattern when Venus is clamped at limit — Mercury+1, Venus captured, Terra+1', () => {
         const setup = new AugustusPatternSetup({ [Influence.Venus]: 3 });
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Terra,
@@ -683,35 +617,28 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
                 resolveAutoMoves(rules);
                 continue;
             }
-            const mercuryMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
+            const mercuryMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
                 rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mercury &&
                 m.location.x === 1);
-            const venusMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-                rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Venus);
-            const terraMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-                rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Terra);
+            const venusMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) && rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Venus);
+            const terraMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) && rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Terra);
             playConsequences(rules, mercuryMove ?? venusMove ?? terraMove ?? moves[0]);
             resolveAutoMoves(rules);
             iterations++;
         }
-        const mercury = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mercury);
+        const mercury = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mercury);
         expect(mercury.getItem().location.x).toBe(1);
-        const venusCaptured = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Venus);
-        const venusOnBoard = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Venus);
+        const venusCaptured = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Venus);
+        const venusOnBoard = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Venus);
         expect(venusCaptured.length + (venusOnBoard.length > 0 && venusOnBoard.getItem().location.x === 4 ? 1 : 0)).toBeGreaterThanOrEqual(1);
-        const terra = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra);
+        const terra = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra);
         expect(terra.getItem().location.x).toBe(2);
     });
     it('should work with pattern on right side — Terra+1, Mars+2 clamped/captured, Jupiter+1', () => {
         const setup = new AugustusPatternSetup({ [Influence.Mars]: 3 });
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const cardIndex = rules.material(MaterialType.AgentCard)
-            .location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
+        const cardIndex = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).id(Agent.Augustus).getIndex();
         const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
             type: LocationType.Influence,
             id: Influence.Terra,
@@ -731,27 +658,21 @@ describe('Augustus pattern [1,2,1] at extreme — Mercury capture', () => {
                 resolveAutoMoves(rules);
                 continue;
             }
-            const marsMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-                rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mars);
-            const jupiterMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
+            const marsMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) && rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Mars);
+            const jupiterMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
                 rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Jupiter &&
                 m.location.x === 1);
-            const terraMove = moves.find(m => isMoveItemType(MaterialType.InfluenceDisc)(m) &&
-                rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Terra);
+            const terraMove = moves.find((m) => isMoveItemType(MaterialType.InfluenceDisc)(m) && rules.material(MaterialType.InfluenceDisc).getItem(m.itemIndex).id === Influence.Terra);
             playConsequences(rules, marsMove ?? jupiterMove ?? terraMove ?? moves[0]);
             resolveAutoMoves(rules);
             iterations++;
         }
-        const marsCaptured = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Mars);
-        const marsOnBoard = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars);
+        const marsCaptured = rules.material(MaterialType.InfluenceDisc).location(LocationType.TeamPlanets).player(TeamColor.White).id(Influence.Mars);
+        const marsOnBoard = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Mars);
         expect(marsCaptured.length + (marsOnBoard.length > 0 && marsOnBoard.getItem().location.x === 4 ? 1 : 0)).toBeGreaterThanOrEqual(1);
-        const jupiter = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Jupiter);
+        const jupiter = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Jupiter);
         expect(jupiter.getItem().location.x).toBe(1);
-        const terra = rules.material(MaterialType.InfluenceDisc)
-            .location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra);
+        const terra = rules.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).id(Influence.Terra);
         expect(terra.getItem().location.x).toBe(2);
     });
 });
@@ -801,19 +722,19 @@ class CaptureTestSetupBlack extends CaptureTestSetup {
         this.memorize(Memory.TurnOrder, [player2, player1]);
     }
     setupTestHands() {
-        const testAgent = agents.find(a => a === Agent.Mc4ffr3y);
+        const testAgent = agents.find((a) => a === Agent.Mc4ffr3y);
         this.material(MaterialType.AgentCard).createItem({
             id: testAgent,
             location: { type: LocationType.PlayerHand, player: player2 }
         });
-        const fillers = agents.filter(a => a !== testAgent).slice(0, 3);
+        const fillers = agents.filter((a) => a !== testAgent).slice(0, 3);
         for (const agent of fillers) {
             this.material(MaterialType.AgentCard).createItem({
                 id: agent,
                 location: { type: LocationType.PlayerHand, player: player2 }
             });
         }
-        const p1Fillers = agents.filter(a => a !== testAgent && !fillers.includes(a)).slice(0, 4);
+        const p1Fillers = agents.filter((a) => a !== testAgent && !fillers.includes(a)).slice(0, 4);
         for (const agent of p1Fillers) {
             this.material(MaterialType.AgentCard).createItem({
                 id: agent,
@@ -845,7 +766,7 @@ class GilgameshTestSetup extends TestSetup {
 describe('Refill with low/empty deck', () => {
     function createRefillSetup(deckCount) {
         const setup = new RefillTestSetup(deckCount);
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         return new ZenithRules(game);
     }
     function discardAndRefill(rules) {
@@ -950,7 +871,7 @@ describe('Refill with low/empty deck', () => {
 describe('Mobilize with low/empty deck', () => {
     function createMobilizeSetup(deckCount) {
         const setup = new MobilizeTestSetup(deckCount);
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         return new ZenithRules(game);
     }
     it('mobilize 2 with deck=1: should reshuffle discard and mobilize second card', () => {
@@ -971,7 +892,7 @@ describe('Mobilize with low/empty deck', () => {
     });
     it('mobilize 2 with deck=0 and discard=0: should skip mobilization without blocking', () => {
         const setup = new MobilizeEmptySetup();
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
         expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDeck).length).toBe(0);
         expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDiscard).length).toBe(0);
@@ -983,7 +904,7 @@ describe('Mobilize with low/empty deck', () => {
     });
     it('mobilize 2 with deck=1 and discard=0: should mobilize 1 then skip remaining', () => {
         const setup = new MobilizePartialSetup(1);
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
         expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDeck).length).toBe(1);
         expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDiscard).length).toBe(0);
@@ -1007,11 +928,8 @@ class MobilizeTestSetup extends TestSetup {
         this.deckCount = deckCount;
     }
     setupRemainingDeck() {
-        const usedAgents = new Set([
-            Agent.H4milt0n,
-            ...agents.filter(a => a !== Agent.H4milt0n).slice(0, 7)
-        ]);
-        const remaining = agents.filter(a => !usedAgents.has(a));
+        const usedAgents = new Set([Agent.H4milt0n, ...agents.filter((a) => a !== Agent.H4milt0n).slice(0, 7)]);
+        const remaining = agents.filter((a) => !usedAgents.has(a));
         let idx = 0;
         for (let i = 0; i < this.deckCount && idx < remaining.length; i++, idx++) {
             this.material(MaterialType.AgentCard).createItem({
@@ -1041,11 +959,8 @@ class MobilizePartialSetup extends TestSetup {
         this.deckCount = deckCount;
     }
     setupRemainingDeck() {
-        const usedAgents = new Set([
-            Agent.H4milt0n,
-            ...agents.filter(a => a !== Agent.H4milt0n).slice(0, 7)
-        ]);
-        const remaining = agents.filter(a => !usedAgents.has(a));
+        const usedAgents = new Set([Agent.H4milt0n, ...agents.filter((a) => a !== Agent.H4milt0n).slice(0, 7)]);
+        const remaining = agents.filter((a) => !usedAgents.has(a));
         for (let i = 0; i < this.deckCount && i < remaining.length; i++) {
             this.material(MaterialType.AgentCard).createItem({
                 id: remaining[i],