@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/game-definition/moves/standard/concede.test.ts

@@ -0,0 +1,189 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { createPlayerId } from "@drmxrcy/tcg-core";
+import {
+  LorcanaTestEngine,
+  PLAYER_ONE,
+  PLAYER_TWO,
+} from "../../../testing/lorcana-test-engine";
+
+describe("Move: Concede", () => {
+  let testEngine: LorcanaTestEngine;
+
+  beforeEach(() => {
+    testEngine = new LorcanaTestEngine(
+      { hand: 7, deck: 10 },
+      { hand: 7, deck: 10 },
+      { skipPreGame: true },
+    );
+  });
+
+  afterEach(() => {
+    testEngine.dispose();
+  });
+
+  // ========== Basic Behavior Tests ==========
+
+  describe("Basic Concede Behavior", () => {
+    it("should end game when player concedes", () => {
+      // Player one concedes
+      testEngine.changeActivePlayer(PLAYER_ONE);
+      const result = testEngine.engine.executeMove("concede", {
+        playerId: createPlayerId(PLAYER_ONE),
+        params: {},
+      });
+
+      expect(result.success).toBe(true);
+
+      // Game should be ended
+      expect(testEngine.engine.hasGameEnded()).toBe(true);
+
+      // Verify game end result
+      const gameEndResult = testEngine.engine.getGameEndResult();
+      expect(gameEndResult).toBeDefined();
+      expect(gameEndResult?.reason).toBe("concede");
+    });
+
+    it("should include concede metadata with concedeBy field", () => {
+      // Player two concedes
+      testEngine.changeActivePlayer(PLAYER_TWO);
+      const result = testEngine.engine.executeMove("concede", {
+        playerId: createPlayerId(PLAYER_TWO),
+        params: {},
+      });
+
+      expect(result.success).toBe(true);
+
+      // Verify metadata includes concedeBy
+      const gameEndResult = testEngine.engine.getGameEndResult();
+      expect(gameEndResult).toBeDefined();
+      expect(gameEndResult?.metadata?.concedeBy).toBe(PLAYER_TWO);
+    });
+
+    it("should set opponent as winner when player concedes", () => {
+      // Player one concedes
+      testEngine.changeActivePlayer(PLAYER_ONE);
+      const result = testEngine.engine.executeMove("concede", {
+        playerId: createPlayerId(PLAYER_ONE),
+        params: {},
+      });
+
+      expect(result.success).toBe(true);
+
+      // Winner should be player two (the opponent)
+      const gameEndResult = testEngine.engine.getGameEndResult();
+      expect(gameEndResult).toBeDefined();
+      expect(gameEndResult?.winner).toBe(PLAYER_TWO);
+    });
+
+    it("should set correct winner when different player concedes", () => {
+      // Player two concedes
+      testEngine.changeActivePlayer(PLAYER_TWO);
+      const result = testEngine.engine.executeMove("concede", {
+        playerId: createPlayerId(PLAYER_TWO),
+        params: {},
+      });
+
+      expect(result.success).toBe(true);
+
+      // Winner should be player one (the opponent)
+      const gameEndResult = testEngine.engine.getGameEndResult();
+      expect(gameEndResult).toBeDefined();
+      expect(gameEndResult?.winner).toBe(PLAYER_ONE);
+    });
+  });
+
+  // ========== Game End Verification ==========
+
+  describe("Game End State", () => {
+    it("should prevent further moves after concede", () => {
+      // Player one concedes
+      testEngine.changeActivePlayer(PLAYER_ONE);
+      const concedeResult = testEngine.engine.executeMove("concede", {
+        playerId: createPlayerId(PLAYER_ONE),
+        params: {},
+      });
+
+      // Verify concede succeeded
+      expect(concedeResult.success).toBe(true);
+      expect(testEngine.engine.hasGameEnded()).toBe(true);
+
+      // Try to execute another move
+      testEngine.changeActivePlayer(PLAYER_TWO);
+      const result = testEngine.engine.executeMove("passTurn", {
+        playerId: createPlayerId(PLAYER_TWO),
+        params: {},
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.errorCode).toBe("GAME_ENDED");
+        expect(result.error).toContain("already ended");
+      }
+    });
+
+    it("should allow concede at any time (during any phase)", () => {
+      // Concede during main phase (default)
+      testEngine.changeActivePlayer(PLAYER_ONE);
+      const result = testEngine.engine.executeMove("concede", {
+        playerId: createPlayerId(PLAYER_ONE),
+        params: {},
+      });
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  // ========== Edge Cases ==========
+
+  describe("Edge Cases", () => {
+    it("should not allow concede when game already ended", () => {
+      // First player concedes
+      testEngine.changeActivePlayer(PLAYER_ONE);
+      testEngine.engine.executeMove("concede", {
+        playerId: createPlayerId(PLAYER_ONE),
+        params: {},
+      });
+
+      // Try to concede again
+      testEngine.changeActivePlayer(PLAYER_TWO);
+      const result = testEngine.engine.executeMove("concede", {
+        playerId: createPlayerId(PLAYER_TWO),
+        params: {},
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.errorCode).toBe("GAME_ENDED");
+      }
+    });
+
+    it("should handle concede when player has no cards", () => {
+      // Setup: Create a game where player one has no cards in any zone
+      const emptyTestEngine = new LorcanaTestEngine(
+        { hand: 0, deck: 0 }, // Player one has no cards
+        { hand: 7, deck: 10 }, // Player two has cards
+        { skipPreGame: true },
+      );
+
+      // Player one (with no cards) concedes
+      emptyTestEngine.changeActivePlayer(PLAYER_ONE);
+      const result = emptyTestEngine.engine.executeMove("concede", {
+        playerId: createPlayerId(PLAYER_ONE),
+        params: {},
+      });
+
+      expect(result.success).toBe(true);
+
+      // Game should be ended
+      expect(emptyTestEngine.engine.hasGameEnded()).toBe(true);
+
+      // Winner should be player two (even though player one had no cards)
+      const gameEndResult = emptyTestEngine.engine.getGameEndResult();
+      expect(gameEndResult).toBeDefined();
+      expect(gameEndResult?.winner).toBe(PLAYER_TWO);
+      expect(gameEndResult?.reason).toBe("concede");
+
+      emptyTestEngine.dispose();
+    });
+  });
+});

package/src/game-definition/moves/standard/concede.ts

@@ -0,0 +1,72 @@
+import { createMove, type PlayerId, type ZoneId } from "@drmxrcy/tcg-core";
+import type {
+  LorcanaCardMeta,
+  LorcanaGameState,
+  LorcanaMoveParams,
+} from "../../../types";
+import { lorcanaZones } from "../../zones/zone-configs";
+
+/**
+ * Concede
+ *
+ * Rule 1.9.1.2: Player can concede at any time
+ *
+ * Effects:
+ * - Current player loses immediately
+ * - Game ends
+ * - Other player(s) win
+ *
+ * The engine handles game end logic automatically.
+ */
+export const concede = createMove<
+  LorcanaGameState,
+  LorcanaMoveParams,
+  "concede",
+  LorcanaCardMeta
+>({
+  condition: (_state, context) => {
+    // Cannot concede during setup phases
+    const phase = context.flow?.currentPhase;
+    if (phase === "chooseFirstPlayer" || phase === "mulligan") {
+      return false;
+    }
+    return true;
+  },
+  reducer: (draft, context) => {
+    // Get all players from the game state
+    const allPlayers = Object.keys(draft.external.loreScores) as PlayerId[];
+
+    // Determine winner: the opponent who is NOT conceding
+    // Try to find active players by checking zones
+    const uniquePlayerIds = new Set<PlayerId>();
+
+    // Get all zone IDs dynamically from zone configuration
+    const zoneIds = Object.keys(lorcanaZones) as ZoneId[];
+
+    for (const zoneId of zoneIds) {
+      for (const playerId of allPlayers) {
+        try {
+          const cards = context.zones.getCardsInZone(zoneId, playerId);
+          if (cards.length > 0) {
+            uniquePlayerIds.add(playerId);
+          }
+        } catch {
+          // Zone might not exist for this player or other errors
+          // Continue processing other zones/players
+        }
+      }
+    }
+
+    // Find the opponent (player who is not conceding)
+    const playerIds = Array.from(uniquePlayerIds);
+    const winner = playerIds.find((id) => id !== context.playerId);
+
+    // Signal game end via context
+    // Note: winner may be undefined if no other players have cards (edge case)
+    context.endGame?.({
+      winner,
+      reason: "concede",
+      metadata: { concedeBy: context.playerId },
+    });
+  },
+});

package/src/game-definition/moves/standard/pass-turn.ts

@@ -0,0 +1,49 @@
+import { createMove } from "@drmxrcy/tcg-core";
+import type {
+  LorcanaCardMeta,
+  LorcanaGameState,
+  LorcanaMoveParams,
+} from "../../../types";
+
+/**
+ * Pass Turn
+ *
+ * Rule 4.1.2: Player completes their turn
+ *
+ * Effects:
+ * - End current phase
+ * - Pass turn to next player
+ * - Reset turn-based trackers
+ * - Ready all cards (in beginning phase)
+ *
+ * The engine handles all turn transition logic automatically.
+ */
+export const passTurn = createMove<
+  LorcanaGameState,
+  LorcanaMoveParams,
+  "passTurn",
+  LorcanaCardMeta
+>({
+  condition: (state, context) => {
+    // Cannot pass turn during setup phases
+    const phase = context.flow?.currentPhase;
+    if (phase === "chooseFirstPlayer" || phase === "mulligan") {
+      return false;
+    }
+
+    // Can only pass turn if it's your turn
+    if (
+      context.flow?.currentPlayer &&
+      context.flow.currentPlayer !== context.playerId
+    ) {
+      return false;
+    }
+
+    return true;
+  },
+  reducer: (_draft, context) => {
+    // End the current phase
+    // Flow will automatically transition: main → end → next turn's beginning
+    context.flow?.endPhase();
+  },
+});

package/src/game-definition/setup/game-setup.ts

@@ -0,0 +1,19 @@
+import type { PlayerId } from "@drmxrcy/tcg-core";
+import { createInitialLorcanaState, type LorcanaGameState } from "../../types";
+
+/**
+ * Game Setup Function
+ *
+ * Initializes the Lorcana game state.
+ *
+ * @param players - List of players in the game
+ * @returns Initial Lorcana game state
+ */
+export function setupLorcanaGame(
+  players: Array<{ id: string }>,
+): LorcanaGameState {
+  const playerIds = players.map((p) => p.id as PlayerId);
+  // Default to first player starting if not specified
+  // In a real game, this would be determined by coin flip or similar
+  return createInitialLorcanaState(playerIds[0], playerIds[1], playerIds[0]);
+}

package/src/game-definition/trackers/tracker-config.ts

@@ -0,0 +1,23 @@
+/**
+ * Tracker Configuration
+ *
+ * Defines boolean flags that track actions taken during gameplay.
+ * These trackers are automatically reset based on their configuration:
+ *
+ * - hasInked: Player can only put one card into inkwell per turn
+ * - quested:{cardId}: Each character can only quest once per turn
+ *
+ * The engine automatically resets perTurn trackers at the end of each turn.
+ */
+export const trackerConfig = {
+  /**
+   * Actions that reset at the end of each turn
+   * Supports wildcards - "quested:*" matches all "quested:cardId" trackers
+   */
+  perTurn: ["hasInked", "quested:*"],
+
+  /**
+   * Track actions separately for each player
+   */
+  perPlayer: true,
+};

package/src/game-definition/win-conditions/lore-victory.ts

@@ -0,0 +1,26 @@
+import type { LorcanaGameState } from "../../types";
+
+/**
+ * Lore Victory Win Condition
+ *
+ * Rule 1.9.1.1: First player to reach 20 lore wins the game
+ *
+ * @param state - Current game state
+ * @returns Win condition result or undefined if game continues
+ */
+export function checkLoreVictory(
+  state: LorcanaGameState,
+):
+  | { winner: string; reason: string; metadata: { finalLore: number } }
+  | undefined {
+  for (const [playerId, lore] of Object.entries(state.external.loreScores)) {
+    if (lore >= 20) {
+      return {
+        winner: playerId,
+        reason: "lore_victory",
+        metadata: { finalLore: lore },
+      };
+    }
+  }
+  return undefined;
+}