@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/__tests__/rules/section-03-gameplay.test.ts

@@ -0,0 +1,298 @@
+/**
+ * Section 3: Gameplay
+ *
+ * Tests for rules 3.1-3.2 from Disney Lorcana Comprehensive Rules (Aug 22, 2025)
+ * Covers starting and ending a game.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  LorcanaTestEngine,
+  PLAYER_ONE,
+  PLAYER_TWO,
+} from "../../testing/lorcana-test-engine";
+
+describe("Section 3: Gameplay", () => {
+  describe("3.1. Starting a Game", () => {
+    /**
+     * Rule 3.1.1: Starting a game involves several steps that all players follow.
+     * Once these steps are completed, the game is considered to be started.
+     */
+    test.failing("Rule 3.1.1 - Game start requires completing all setup steps", () => {
+      // Arrange: Create engine without skipping pre-game
+      const testEngine = new LorcanaTestEngine(
+        { hand: 0, deck: 60 },
+        { hand: 0, deck: 60 },
+        { skipPreGame: false },
+      );
+
+      try {
+        // Assert: Game should require setup steps before main game
+        const segment = testEngine.getGameSegment();
+        expect(segment).toBe("startingAGame");
+        expect(true).toBe(false); // Will fail until fully verified
+      } finally {
+        testEngine.dispose();
+      }
+    });
+
+    /**
+     * Rule 3.1.2: First, use a method for randomly determining who chooses
+     * who is the starting player. If this is next in a best-of series,
+     * the losing player of the previous game chooses.
+     */
+    test.failing("Rule 3.1.2 - Random determination of starting player chooser", () => {
+      const testEngine = new LorcanaTestEngine(
+        { hand: 0, deck: 60 },
+        { hand: 0, deck: 60 },
+        { skipPreGame: false },
+      );
+
+      try {
+        // Assert: One player should be designated to choose first player
+        const ctx = testEngine.getCtx();
+        expect(ctx.choosingFirstPlayer).toBeDefined();
+        expect(true).toBe(false); // Will fail until fully verified
+      } finally {
+        testEngine.dispose();
+      }
+    });
+
+    /**
+     * Rule 3.1.3: Second, each player randomizes (shuffles) their deck.
+     * Each player must offer an opposing player a chance to cut their deck.
+     */
+    test.failing("Rule 3.1.3 - Decks must be shuffled at game start", () => {
+      // Arrange: Create two games with same seed to verify shuffle occurs
+      const testEngine = new LorcanaTestEngine(
+        { hand: 0, deck: 60 },
+        { hand: 0, deck: 60 },
+        { skipPreGame: false, seed: "test-seed" },
+      );
+
+      try {
+        // Assert: Deck should be randomized
+        // (Hard to verify without comparing to unshuffled state)
+        expect(true).toBe(false); // Will fail until shuffle verification implemented
+      } finally {
+        testEngine.dispose();
+      }
+    });
+
+    /**
+     * Rule 3.1.4: Third, each player begins the game with 0 lore.
+     */
+    test.failing("Rule 3.1.4 - Players start with 0 lore", () => {
+      const testEngine = new LorcanaTestEngine(
+        { hand: 7, deck: 53 },
+        { hand: 7, deck: 53 },
+        { skipPreGame: true },
+      );
+
+      try {
+        // Assert: Both players should start with 0 lore
+        expect(testEngine.getLore(PLAYER_ONE)).toBe(0);
+        expect(testEngine.getLore(PLAYER_TWO)).toBe(0);
+        // This might actually pass - update assertion once verified
+        expect(true).toBe(false);
+      } finally {
+        testEngine.dispose();
+      }
+    });
+
+    /**
+     * Rule 3.1.5: Fourth, each player draws 7 cards.
+     */
+    test.failing("Rule 3.1.5 - Players draw 7 cards at start", () => {
+      const testEngine = new LorcanaTestEngine(
+        { hand: 0, deck: 60 },
+        { hand: 0, deck: 60 },
+        { skipPreGame: false },
+      );
+
+      try {
+        // After setup, each player should have 7 cards
+        // Would need to complete setup first
+        expect(true).toBe(false); // Will fail until draw step implemented
+      } finally {
+        testEngine.dispose();
+      }
+    });
+
+    /**
+     * Rule 3.1.6: Fifth, players may alter their hands (mulligan),
+     * beginning with the starting player.
+     */
+    test.failing("Rule 3.1.6 - Mulligan in starting player order", () => {
+      const testEngine = new LorcanaTestEngine(
+        { hand: 7, deck: 53 },
+        { hand: 7, deck: 53 },
+        { skipPreGame: false },
+      );
+
+      try {
+        // Complete first player selection
+        const ctx = testEngine.getCtx();
+        testEngine.changeActivePlayer(ctx.choosingFirstPlayer || PLAYER_ONE);
+        testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+
+        // Now mulligan phase - starting player should go first
+        // Assert: Mulligan order follows starting player
+        expect(true).toBe(false); // Will fail until mulligan order verified
+      } finally {
+        testEngine.dispose();
+      }
+    });
+
+    /**
+     * Rule 3.1.6.1: Step 1 - The player selects any number of cards from their hand
+     * and places them on the bottom of their deck without revealing them.
+     */
+    test.failing("Rule 3.1.6.1 - Mulligan puts cards on bottom of deck", () => {
+      const testEngine = new LorcanaTestEngine(
+        { hand: 7, deck: 53 },
+        { hand: 7, deck: 53 },
+        { skipPreGame: false },
+      );
+
+      try {
+        // Complete setup to mulligan phase
+        const ctx = testEngine.getCtx();
+        testEngine.changeActivePlayer(ctx.choosingFirstPlayer || PLAYER_ONE);
+        testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+        testEngine.changeActivePlayer(PLAYER_ONE);
+
+        // Get initial hand
+        const initialHand = testEngine.getZone("hand", PLAYER_ONE);
+        const cardsToMulligan = initialHand.slice(0, 3);
+
+        // Mulligan those cards
+        testEngine.alterHand(cardsToMulligan);
+
+        // Assert: Cards should be on bottom of deck (not revealed)
+        expect(true).toBe(false); // Will fail until mulligan bottom placement verified
+      } finally {
+        testEngine.dispose();
+      }
+    });
+
+    /**
+     * Rule 3.1.6.2: Step 2 - The player draws until they have 7 cards in hand.
+     */
+    test.failing("Rule 3.1.6.2 - Draw back up to 7 after mulligan", () => {
+      const testEngine = new LorcanaTestEngine(
+        { hand: 7, deck: 53 },
+        { hand: 7, deck: 53 },
+        { skipPreGame: false },
+      );
+
+      try {
+        // Complete setup and mulligan
+        const ctx = testEngine.getCtx();
+        testEngine.changeActivePlayer(ctx.choosingFirstPlayer || PLAYER_ONE);
+        testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+        testEngine.changeActivePlayer(PLAYER_ONE);
+
+        const initialHand = testEngine.getZone("hand", PLAYER_ONE);
+        testEngine.alterHand(initialHand.slice(0, 3)); // Mulligan 3 cards
+
+        // Assert: Hand should be back to 7 cards
+        const finalHand = testEngine.getZone("hand", PLAYER_ONE);
+        expect(finalHand).toHaveLength(7);
+        expect(true).toBe(false); // Will fail until mulligan draw verified
+      } finally {
+        testEngine.dispose();
+      }
+    });
+
+    /**
+     * Rule 3.1.6.4: Step 4 - Each player who altered their hand by 1 or more cards
+     * shuffles their deck.
+     */
+    test.failing("Rule 3.1.6.4 - Deck shuffled after mulligan", () => {
+      // Assert: Deck should be shuffled if mulligan occurred
+      expect(true).toBe(false); // Will fail until mulligan shuffle implemented
+    });
+
+    /**
+     * Rule 3.1.7: Once all players have altered or chosen not to alter their hand,
+     * the game officially starts with the starting player's Beginning Phase.
+     */
+    test.failing("Rule 3.1.7 - Game starts after all mulligans complete", () => {
+      const testEngine = new LorcanaTestEngine(
+        { hand: 7, deck: 53 },
+        { hand: 7, deck: 53 },
+        { skipPreGame: false },
+      );
+
+      try {
+        // Complete all setup
+        const ctx = testEngine.getCtx();
+        testEngine.changeActivePlayer(ctx.choosingFirstPlayer || PLAYER_ONE);
+        testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+        testEngine.changeActivePlayer(PLAYER_ONE);
+        testEngine.alterHand([]);
+        testEngine.changeActivePlayer(PLAYER_TWO);
+        testEngine.alterHand([]);
+
+        // Assert: Game should now be in mainGame segment
+        const segment = testEngine.getGameSegment();
+        expect(segment).toBe("mainGame");
+        expect(true).toBe(false); // Will fail until transition verified
+      } finally {
+        testEngine.dispose();
+      }
+    });
+  });
+
+  describe("3.2. Ending a Game", () => {
+    let testEngine: LorcanaTestEngine;
+
+    beforeEach(() => {
+      testEngine = new LorcanaTestEngine(
+        { hand: 7, deck: 53, inkwell: 0 },
+        { hand: 7, deck: 53, inkwell: 0 },
+        { skipPreGame: true },
+      );
+    });
+
+    afterEach(() => {
+      testEngine.dispose();
+    });
+
+    /**
+     * Rule 3.2.1.1: When a player reaches 20 lore, they win the game.
+     */
+    test.failing("Rule 3.2.1.1 - 20 lore wins the game", () => {
+      // Arrange: Set up scenario to reach 20 lore
+      // Create many characters and quest repeatedly
+
+      // Act: Quest until 20 lore reached
+
+      // Assert: Game should end with that player winning
+      expect(true).toBe(false); // Will fail until win condition implemented
+    });
+
+    /**
+     * Rule 3.2.1.2: If a player attempted to draw from a deck with no cards
+     * since the last game state check, that player loses the game.
+     * All cards in play and abilities from that player are removed.
+     */
+    test.failing("Rule 3.2.1.2 - Empty deck draw loses the game", () => {
+      // Arrange: Would need to set up scenario where deck is empty
+
+      // Act: Attempt to draw from empty deck
+
+      // Assert: Player should lose, their cards/effects removed
+      expect(true).toBe(false); // Will fail until deck-out loss implemented
+    });
+
+    /**
+     * Rule 3.2.1.3: If a player is the last person left in a game, they win.
+     */
+    test.failing("Rule 3.2.1.3 - Last player standing wins", () => {
+      // In 2-player, if one player loses (e.g., deck-out), other wins
+      expect(true).toBe(false); // Will fail until last player win implemented
+    });
+  });
+});