@gamepark/zenith 0.1.2 → 0.1.6

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

@@ -0,0 +1,703 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { describe, expect, it } from 'vitest';
+import { Agent, agents } from '../../material/Agent';
+import { Agents } from '../../material/Agents';
+import { Credit } from '../../material/Credit';
+import { Influence, influences } from '../../material/Influence';
+import { LocationType } from '../../material/LocationType';
+import { MaterialType } from '../../material/MaterialType';
+import { TeamColor } from '../../TeamColor';
+import { Memory } from '../Memory';
+import { RuleId } from '../RuleId';
+import { ZenithRules } from '../../ZenithRules';
+import { ZenithSetup } from '../../ZenithSetup';
+const player1 = 1;
+const player2 = 2;
+function createGameForAgent(agent) {
+    const setup = new TestSetup(agent);
+    const game = setup.setup({ players: 2 });
+    return new ZenithRules(game);
+}
+class TestSetup extends ZenithSetup {
+    testAgent;
+    constructor(testAgent) {
+        super();
+        this.testAgent = testAgent;
+    }
+    setupMaterial() {
+        this.setupTurnOrder();
+        this.setupTestHands();
+        this.setupRemainingDeck();
+        this.setupInfluences();
+        this.setupLeaderBadge();
+        this.setupTechnologyBoard();
+        this.setupTeams();
+        this.setupTestBonuses();
+    }
+    setupTurnOrder() {
+        this.memorize(Memory.TurnOrder, [player1, player2]);
+    }
+    setupTestHands() {
+        this.material(MaterialType.AgentCard).createItem({
+            id: this.testAgent,
+            location: { type: LocationType.PlayerHand, player: player1 }
+        });
+        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);
+        for (const agent of p2Fillers) {
+            this.material(MaterialType.AgentCard).createItem({
+                id: agent,
+                location: { type: LocationType.PlayerHand, player: player2 }
+            });
+        }
+    }
+    setupRemainingDeck() {
+        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,
+                location: { type: LocationType.AgentDeck }
+            });
+        }
+    }
+    setupPlayers() { }
+    setupInfluences() {
+        for (const planet of influences) {
+            this.material(MaterialType.InfluenceDisc).createItem({
+                id: planet,
+                location: {
+                    type: LocationType.PlanetBoardInfluenceDiscSpace,
+                    id: planet,
+                    x: planet === Influence.Venus ? 1 : 0
+                }
+            });
+        }
+    }
+    setupTestBonuses() {
+        const bonusIds = [1, 2, 3, 4, 5];
+        for (let i = 0; i < influences.length; i++) {
+            this.material(MaterialType.BonusToken).createItem({
+                id: bonusIds[i],
+                location: { type: LocationType.PlanetBoardBonusSpace, id: influences[i] }
+            });
+        }
+        const techBoards = this.material(MaterialType.TechnologyBoard).getIndexes();
+        for (const boardIndex of techBoards) {
+            this.material(MaterialType.BonusToken).createItem({
+                id: bonusIds.length + boardIndex + 1,
+                location: { type: LocationType.TechnologyBoardBonusSpace, parent: boardIndex, x: 2 }
+            });
+        }
+    }
+    setupTeams() {
+        for (const team of [TeamColor.White, TeamColor.Black]) {
+            this.material(MaterialType.CreditToken).createItem({
+                id: Credit.Credit1,
+                location: { type: LocationType.TeamCredit, player: team },
+                quantity: 10
+            });
+            this.material(MaterialType.CreditToken).createItem({
+                id: Credit.Credit5,
+                location: { type: LocationType.TeamCredit, player: team }
+            });
+            this.material(MaterialType.ZenithiumToken).createItem({
+                location: { type: LocationType.TeamZenithium, player: team },
+                quantity: 3
+            });
+        }
+    }
+    start() {
+        this.startPlayerTurn(RuleId.PlayCard, player1);
+    }
+}
+function playConsequences(rules, move) {
+    const consequences = rules.play(move);
+    while (consequences.length > 0) {
+        consequences.push(...rules.play(consequences.shift()));
+    }
+}
+function resolveAutoMoves(rules) {
+    let autoMoves = rules.getAutomaticMoves();
+    while (autoMoves.length > 0) {
+        for (const auto of autoMoves) {
+            playConsequences(rules, auto);
+        }
+        autoMoves = rules.getAutomaticMoves();
+    }
+}
+function playAgentAndResolveEffects(rules, agent) {
+    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` };
+    }
+    const agentData = Agents[agent];
+    const playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
+        type: LocationType.Influence,
+        id: agentData.influence,
+        player: TeamColor.White
+    });
+    playConsequences(rules, playMove);
+    resolveAutoMoves(rules);
+    let iterations = 0;
+    const maxIterations = 50;
+    while (iterations < maxIterations) {
+        const ruleId = rules.game.rule?.id;
+        if (ruleId === RuleId.Refill || ruleId === RuleId.PlayCard) {
+            return { finalRule: ruleId };
+        }
+        if (rules.game.rule === undefined) {
+            return { finalRule: undefined };
+        }
+        const legalMoves = rules.getLegalMoves(player1);
+        if (legalMoves.length === 0) {
+            resolveAutoMoves(rules);
+            const newRuleId = rules.game.rule?.id;
+            if (newRuleId === RuleId.Refill || newRuleId === RuleId.PlayCard || newRuleId === undefined) {
+                return { finalRule: newRuleId };
+            }
+            const p2Moves = rules.getLegalMoves(player2);
+            if (p2Moves.length > 0) {
+                return { finalRule: ruleId };
+            }
+            return { error: `No legal moves and no auto moves at rule ${RuleId[ruleId] ?? ruleId}` };
+        }
+        playConsequences(rules, legalMoves[0]);
+        resolveAutoMoves(rules);
+        iterations++;
+    }
+    return { error: `Max iterations reached at rule ${RuleId[rules.game.rule?.id] ?? rules.game.rule?.id}` };
+}
+describe('Agent effects resolution', () => {
+    for (const agent of agents) {
+        const agentName = Agent[agent];
+        const agentData = Agents[agent];
+        it(`${agentName} (cost ${agentData.cost}, ${agentData.effects.length} effects) should resolve all effects without error`, () => {
+            const rules = createGameForAgent(agent);
+            expect(rules.game.rule?.id).toBe(RuleId.PlayCard);
+            expect(rules.getActivePlayer()).toBe(player1);
+            const result = playAgentAndResolveEffects(rules, agent);
+            expect(result.error).toBeUndefined();
+            expect(result.finalRule).toBeDefined();
+            if (result.finalRule !== undefined) {
+                expect([RuleId.Refill, RuleId.PlayCard]).toContain(result.finalRule);
+            }
+        });
+    }
+});
+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: 2 });
+        const rules = new ZenithRules(game);
+        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 playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
+            type: LocationType.Influence,
+            id: Influence.Terra,
+            player: TeamColor.White
+        });
+        playConsequences(rules, playMove);
+        resolveAutoMoves(rules);
+        let iterations = 0;
+        while (iterations < 20) {
+            const ruleId = rules.game.rule?.id;
+            if (ruleId === RuleId.Refill || ruleId === RuleId.PlayCard)
+                break;
+            const moves = rules.getLegalMoves(player1);
+            if (moves.length === 0) {
+                resolveAutoMoves(rules);
+                continue;
+            }
+            playConsequences(rules, moves[0]);
+            resolveAutoMoves(rules);
+            iterations++;
+        }
+        expect([RuleId.Refill, RuleId.PlayCard]).toContain(rules.game.rule?.id);
+    });
+});
+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: 2 });
+        const rules = new ZenithRules(game);
+        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 playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
+            type: LocationType.Influence,
+            id: Influence.Mars,
+            player: TeamColor.White
+        });
+        playConsequences(rules, playMove);
+        resolveAutoMoves(rules);
+        let iterations = 0;
+        while (iterations < 20) {
+            const ruleId = rules.game.rule?.id;
+            if (ruleId === RuleId.Refill || ruleId === RuleId.PlayCard)
+                break;
+            if (rules.game.rule === undefined)
+                break;
+            const moves = rules.getLegalMoves(player1);
+            if (moves.length === 0) {
+                resolveAutoMoves(rules);
+                continue;
+            }
+            playConsequences(rules, moves[0]);
+            resolveAutoMoves(rules);
+            iterations++;
+        }
+        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);
+        expect(marsInBlack.length).toBe(0);
+        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: 2 });
+        const rules = new ZenithRules(game);
+        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 playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
+            type: LocationType.Influence,
+            id: Influence.Mars,
+            player: TeamColor.Black
+        });
+        playConsequences(rules, playMove);
+        resolveAutoMoves(rules);
+        let iterations = 0;
+        while (iterations < 20) {
+            const ruleId = rules.game.rule?.id;
+            if (ruleId === RuleId.Refill || ruleId === RuleId.PlayCard)
+                break;
+            if (rules.game.rule === undefined)
+                break;
+            const moves = rules.getLegalMoves(player2);
+            if (moves.length === 0) {
+                resolveAutoMoves(rules);
+                continue;
+            }
+            playConsequences(rules, moves[0]);
+            resolveAutoMoves(rules);
+            iterations++;
+        }
+        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);
+        expect(marsInWhite.length).toBe(0);
+        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: 2 });
+        const rules = new ZenithRules(game);
+        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 playMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
+            type: LocationType.Influence,
+            id: Agents[Agent.Titus].influence,
+            player: TeamColor.White
+        });
+        playConsequences(rules, playMove);
+        resolveAutoMoves(rules);
+        let iterations = 0;
+        while (iterations < 30) {
+            const ruleId = rules.game.rule?.id;
+            if (ruleId === RuleId.Refill || ruleId === RuleId.PlayCard)
+                break;
+            if (rules.game.rule === undefined)
+                break;
+            const moves = rules.getLegalMoves(player1);
+            if (moves.length === 0) {
+                resolveAutoMoves(rules);
+                continue;
+            }
+            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);
+        expect(terraInBlack.length).toBe(1);
+        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);
+        expect(terraOnBoard.length).toBe(1);
+        expect(terraOnBoard.getItem().location.x).toBe(0);
+    });
+});
+class CaptureTestSetup extends TestSetup {
+    captureTargetPlanet;
+    captureTargetX;
+    constructor(agent, targetPlanet, targetX) {
+        super(agent);
+        this.captureTargetPlanet = targetPlanet;
+        this.captureTargetX = targetX;
+    }
+    setupInfluences() {
+        for (const planet of influences) {
+            const x = planet === this.captureTargetPlanet ? this.captureTargetX : 0;
+            this.material(MaterialType.InfluenceDisc).createItem({
+                id: planet,
+                location: {
+                    type: LocationType.PlanetBoardInfluenceDiscSpace,
+                    id: planet,
+                    x
+                }
+            });
+        }
+    }
+}
+class CaptureTestSetupBlack extends CaptureTestSetup {
+    setupTurnOrder() {
+        this.memorize(Memory.TurnOrder, [player2, player1]);
+    }
+    setupTestHands() {
+        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);
+        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);
+        for (const agent of p1Fillers) {
+            this.material(MaterialType.AgentCard).createItem({
+                id: agent,
+                location: { type: LocationType.PlayerHand, player: player1 }
+            });
+        }
+    }
+    start() {
+        this.startPlayerTurn(RuleId.PlayCard, player2);
+    }
+}
+class GilgameshTestSetup extends TestSetup {
+    constructor() {
+        super(Agent.Gilgamesh);
+    }
+    setupInfluences() {
+        for (const planet of influences) {
+            this.material(MaterialType.InfluenceDisc).createItem({
+                id: planet,
+                location: {
+                    type: LocationType.PlanetBoardInfluenceDiscSpace,
+                    id: planet,
+                    x: planet === Influence.Venus ? -1 : 0
+                }
+            });
+        }
+    }
+}
+describe('Refill with low/empty deck', () => {
+    function createRefillSetup(deckCount) {
+        const setup = new RefillTestSetup(deckCount);
+        const game = setup.setup({ players: 2 });
+        return new ZenithRules(game);
+    }
+    function discardAndRefill(rules) {
+        const hand = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1);
+        const discardMove = hand.moveItems({ type: LocationType.AgentDiscard })[0];
+        playConsequences(rules, discardMove);
+        resolveAutoMoves(rules);
+        let iterations = 0;
+        while (iterations < 30) {
+            const ruleId = rules.game.rule?.id;
+            if (ruleId === RuleId.PlayCard && rules.getActivePlayer() === player2)
+                break;
+            if (ruleId === undefined)
+                break;
+            const moves = rules.getLegalMoves(rules.getActivePlayer());
+            if (moves.length === 0) {
+                resolveAutoMoves(rules);
+                if (rules.game.rule?.id === RuleId.PlayCard && rules.getActivePlayer() === player2)
+                    break;
+                continue;
+            }
+            playConsequences(rules, moves[0]);
+            resolveAutoMoves(rules);
+            iterations++;
+        }
+    }
+    it('deck=0: should reshuffle discard and refill hand to 4', () => {
+        const rules = createRefillSetup(0);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDeck).length).toBe(0);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDiscard).length).toBeGreaterThan(0);
+        discardAndRefill(rules);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).length).toBe(4);
+        expect(rules.game.rule?.id).toBe(RuleId.PlayCard);
+        expect(rules.getActivePlayer()).toBe(player2);
+    });
+    it('deck=1: should deal 1 from deck then reshuffle discard for remaining', () => {
+        const rules = createRefillSetup(1);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDeck).length).toBe(1);
+        discardAndRefill(rules);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).length).toBe(4);
+        expect(rules.game.rule?.id).toBe(RuleId.PlayCard);
+        expect(rules.getActivePlayer()).toBe(player2);
+    });
+    it('deck=2: should deal 2 from deck then reshuffle discard for remaining', () => {
+        const rules = createRefillSetup(2);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDeck).length).toBe(2);
+        discardAndRefill(rules);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).length).toBe(4);
+        expect(rules.game.rule?.id).toBe(RuleId.PlayCard);
+        expect(rules.getActivePlayer()).toBe(player2);
+    });
+    it('deck has exactly the needed amount: should refill without reshuffle', () => {
+        const rules = createRefillSetup(1);
+        discardAndRefill(rules);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).length).toBe(4);
+        expect(rules.game.rule?.id).toBe(RuleId.PlayCard);
+    });
+    it('deck=0 after playing to influence (not discard): should still refill', () => {
+        const rules = createRefillSetup(0);
+        const hand = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1);
+        const cardIndex = hand.getIndex();
+        const card = hand.getItem(cardIndex);
+        const agentData = Agents[card.id];
+        const influenceMove = rules.material(MaterialType.AgentCard).index(cardIndex).moveItem({
+            type: LocationType.Influence,
+            id: agentData.influence,
+            player: TeamColor.White
+        });
+        playConsequences(rules, influenceMove);
+        resolveAutoMoves(rules);
+        let iterations = 0;
+        while (iterations < 30) {
+            const ruleId = rules.game.rule?.id;
+            if (ruleId === RuleId.PlayCard && rules.getActivePlayer() === player2)
+                break;
+            if (ruleId === undefined)
+                break;
+            const moves = rules.getLegalMoves(rules.getActivePlayer());
+            if (moves.length === 0) {
+                resolveAutoMoves(rules);
+                if (rules.game.rule?.id === RuleId.PlayCard && rules.getActivePlayer() === player2)
+                    break;
+                continue;
+            }
+            playConsequences(rules, moves[0]);
+            resolveAutoMoves(rules);
+            iterations++;
+        }
+        const p1HandAfter = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).length;
+        expect(p1HandAfter).toBe(4);
+        expect(rules.game.rule?.id).toBe(RuleId.PlayCard);
+        expect(rules.getActivePlayer()).toBe(player2);
+    });
+    it('deck has more than needed: normal refill', () => {
+        const rules = createRefillSetup(10);
+        discardAndRefill(rules);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1).length).toBe(4);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDeck).length).toBe(9);
+        expect(rules.game.rule?.id).toBe(RuleId.PlayCard);
+    });
+});
+describe('Mobilize with low/empty deck', () => {
+    function createMobilizeSetup(deckCount) {
+        const setup = new MobilizeTestSetup(deckCount);
+        const game = setup.setup({ players: 2 });
+        return new ZenithRules(game);
+    }
+    it('mobilize 2 with deck=1: should reshuffle discard and mobilize second card', () => {
+        const rules = createMobilizeSetup(1);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDeck).length).toBe(1);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDiscard).length).toBeGreaterThan(0);
+        playAgentAndResolveEffects(rules, Agent.H4milt0n);
+        const mobilized = rules.material(MaterialType.AgentCard).location(LocationType.Influence).player(TeamColor.White);
+        expect(mobilized.length).toBe(3);
+    });
+    it('mobilize 2 with deck=0: should reshuffle discard and mobilize both', () => {
+        const rules = createMobilizeSetup(0);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDeck).length).toBe(0);
+        expect(rules.material(MaterialType.AgentCard).location(LocationType.AgentDiscard).length).toBeGreaterThan(0);
+        playAgentAndResolveEffects(rules, Agent.H4milt0n);
+        const mobilized = rules.material(MaterialType.AgentCard).location(LocationType.Influence).player(TeamColor.White);
+        expect(mobilized.length).toBe(3);
+    });
+    it('mobilize 2 with deck=0 and discard=0: should skip mobilization without blocking', () => {
+        const setup = new MobilizeEmptySetup();
+        const game = setup.setup({ players: 2 });
+        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);
+        const result = playAgentAndResolveEffects(rules, Agent.H4milt0n);
+        expect(result.error).toBeUndefined();
+        expect(result.finalRule).toBeDefined();
+        const mobilized = rules.material(MaterialType.AgentCard).location(LocationType.Influence).player(TeamColor.White);
+        expect(mobilized.length).toBe(1);
+    });
+    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: 2 });
+        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);
+        const result = playAgentAndResolveEffects(rules, Agent.H4milt0n);
+        expect(result.error).toBeUndefined();
+        expect(result.finalRule).toBeDefined();
+        const mobilized = rules.material(MaterialType.AgentCard).location(LocationType.Influence).player(TeamColor.White);
+        expect(mobilized.length).toBe(2);
+    });
+    it('mobilize 2 with deck=2: normal mobilize without reshuffle', () => {
+        const rules = createMobilizeSetup(2);
+        playAgentAndResolveEffects(rules, Agent.H4milt0n);
+        const mobilized = rules.material(MaterialType.AgentCard).location(LocationType.Influence).player(TeamColor.White);
+        expect(mobilized.length).toBe(3);
+    });
+});
+class MobilizeTestSetup extends TestSetup {
+    deckCount;
+    constructor(deckCount) {
+        super(Agent.H4milt0n);
+        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));
+        let idx = 0;
+        for (let i = 0; i < this.deckCount && idx < remaining.length; i++, idx++) {
+            this.material(MaterialType.AgentCard).createItem({
+                id: remaining[idx],
+                location: { type: LocationType.AgentDeck }
+            });
+        }
+        for (; idx < remaining.length; idx++) {
+            this.material(MaterialType.AgentCard).createItem({
+                id: remaining[idx],
+                location: { type: LocationType.AgentDiscard }
+            });
+        }
+    }
+}
+class MobilizeEmptySetup extends TestSetup {
+    constructor() {
+        super(Agent.H4milt0n);
+    }
+    setupRemainingDeck() {
+    }
+}
+class MobilizePartialSetup extends TestSetup {
+    deckCount;
+    constructor(deckCount) {
+        super(Agent.H4milt0n);
+        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));
+        for (let i = 0; i < this.deckCount && i < remaining.length; i++) {
+            this.material(MaterialType.AgentCard).createItem({
+                id: remaining[i],
+                location: { type: LocationType.AgentDeck }
+            });
+        }
+    }
+}
+class RefillTestSetup extends TestSetup {
+    deckCount;
+    constructor(deckCount) {
+        super(agents[0]);
+        this.deckCount = deckCount;
+    }
+    setupTestHands() {
+        for (let i = 0; i < 4; i++) {
+            this.material(MaterialType.AgentCard).createItem({
+                id: agents[i],
+                location: { type: LocationType.PlayerHand, player: player1 }
+            });
+        }
+        for (let i = 4; i < 8; i++) {
+            this.material(MaterialType.AgentCard).createItem({
+                id: agents[i],
+                location: { type: LocationType.PlayerHand, player: player2 }
+            });
+        }
+    }
+    setupRemainingDeck() {
+        let idx = 8;
+        for (let i = 0; i < this.deckCount && idx < agents.length; i++, idx++) {
+            this.material(MaterialType.AgentCard).createItem({
+                id: agents[idx],
+                location: { type: LocationType.AgentDeck }
+            });
+        }
+        for (; idx < agents.length; idx++) {
+            this.material(MaterialType.AgentCard).createItem({
+                id: agents[idx],
+                location: { type: LocationType.AgentDiscard }
+            });
+        }
+    }
+}
+//# sourceMappingURL=AgentEffects.spec.js.map