@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/game-definition/moves/setup/choose-first-player.test.ts

@@ -0,0 +1,450 @@
+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: Choose First Player", () => {
+  let testEngine: LorcanaTestEngine;
+
+  beforeEach(() => {
+    testEngine = new LorcanaTestEngine(
+      { hand: 7, deck: 10 },
+      { hand: 7, deck: 10 },
+      { skipPreGame: false },
+    );
+
+    expect(testEngine.getGameSegment()).toBe("startingAGame");
+    expect(testEngine.getGamePhase()).toBe("chooseFirstPlayer");
+  });
+
+  afterEach(() => {
+    testEngine.dispose();
+  });
+
+  it("Choosing player_one as first player", () => {
+    const ctx = testEngine.getCtx();
+    const choosingPlayer = ctx.choosingFirstPlayer;
+
+    // Execute the move as the designated choosing player
+    testEngine.changeActivePlayer(choosingPlayer || PLAYER_ONE);
+    testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+    const updatedCtx = testEngine.getCtx();
+
+    // Verify OTP is set
+    expect(updatedCtx.otp).toBe(PLAYER_ONE);
+
+    // Verify pending mulligan is set for both players
+    expect(updatedCtx.pendingMulligan?.length).toBe(2);
+    expect(updatedCtx.pendingMulligan?.map((p) => String(p))).toContain(
+      PLAYER_ONE,
+    );
+    expect(updatedCtx.pendingMulligan?.map((p) => String(p))).toContain(
+      PLAYER_TWO,
+    );
+
+    // Verify phase transition occurred
+    expect(testEngine.getGamePhase()).toBe("mulligan");
+  });
+
+  it("Choosing player_two as first player", () => {
+    const ctx = testEngine.getCtx();
+    const choosingPlayer = ctx.choosingFirstPlayer;
+
+    // Execute the move as the designated choosing player
+    testEngine.changeActivePlayer(choosingPlayer || PLAYER_ONE);
+    testEngine.chooseWhoGoesFirst(PLAYER_TWO);
+    const updatedCtx = testEngine.getCtx();
+
+    // Verify OTP is set
+    expect(updatedCtx.otp).toBe(PLAYER_TWO);
+
+    // Verify pending mulligan is set for both players
+    expect(updatedCtx.pendingMulligan?.length).toBe(2);
+    expect(updatedCtx.pendingMulligan?.map((p) => String(p))).toContain(
+      PLAYER_ONE,
+    );
+    expect(updatedCtx.pendingMulligan?.map((p) => String(p))).toContain(
+      PLAYER_TWO,
+    );
+
+    // Verify phase transition occurred
+    expect(testEngine.getGamePhase()).toBe("mulligan");
+  });
+
+  it("Only the designated player can choose first player", () => {
+    // Rule 3.1.2: First, use a method for randomly determining WHO CHOOSES who is the starting player
+    // One player is randomly designated to make the choice (like winning a coin flip)
+
+    const ctx = testEngine.getCtx();
+    const choosingPlayer = ctx.choosingFirstPlayer;
+
+    // Verify that a choosing player was randomly designated
+    expect(choosingPlayer).toBeDefined();
+    expect([PLAYER_ONE, PLAYER_TWO]).toContain(choosingPlayer!);
+
+    // The designated player should be able to choose
+    if (choosingPlayer === PLAYER_ONE) {
+      testEngine.changeActivePlayer(PLAYER_ONE);
+      testEngine.chooseWhoGoesFirst(PLAYER_TWO); // Can choose either player
+      expect(testEngine.getCtx().otp).toBe(PLAYER_TWO);
+    } else {
+      testEngine.changeActivePlayer(PLAYER_TWO);
+      testEngine.chooseWhoGoesFirst(PLAYER_ONE); // Can choose either player
+      expect(testEngine.getCtx().otp).toBe(PLAYER_ONE);
+    }
+
+    expect(testEngine.getGamePhase()).toBe("mulligan");
+  });
+
+  it("Non-designated player cannot choose first player", () => {
+    // Check who is the designated chooser
+    const ctx = testEngine.getCtx();
+    const choosingPlayer = ctx.choosingFirstPlayer;
+    const otherPlayer = choosingPlayer === PLAYER_ONE ? PLAYER_TWO : PLAYER_ONE;
+
+    // Try to have the OTHER player choose - should fail
+    testEngine.changeActivePlayer(otherPlayer);
+    const result = testEngine.engine.executeMove("chooseWhoGoesFirstMove", {
+      playerId: createPlayerId(otherPlayer),
+      params: { playerId: createPlayerId(PLAYER_ONE) },
+    });
+
+    // Should fail with detailed error information
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.errorCode).toBe("NOT_CHOOSING_PLAYER");
+      expect(result.error).toContain("can choose the first player");
+      expect(result.error).toContain(String(choosingPlayer));
+      expect(result.error).toContain(String(otherPlayer));
+      expect(result.errorContext?.choosingPlayer).toBe(choosingPlayer);
+      expect(result.errorContext?.executingPlayer).toBe(otherPlayer);
+    }
+
+    // Verify OTP was not set
+    expect(testEngine.getCtx().otp).toBeUndefined();
+    expect(testEngine.getGamePhase()).toBe("chooseFirstPlayer");
+  });
+
+  // ========== Turn Player and Priority Tests ==========
+
+  it("should have no turn player but priority during chooseFirstPlayer phase", () => {
+    // Before choosing, turn player should be undefined
+    expect(testEngine.getTurnPlayer()).toBeUndefined();
+
+    // But priority should be the choosingFirstPlayer
+    const ctx = testEngine.getCtx();
+    expect(testEngine.getPriorityPlayers()).toContain(ctx.choosingFirstPlayer!);
+  });
+
+  it("should set turn player after OTP is chosen", () => {
+    const ctx = testEngine.getCtx();
+    const choosingPlayer = ctx.choosingFirstPlayer;
+
+    testEngine.changeActivePlayer(choosingPlayer || PLAYER_ONE);
+    testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+
+    // After choosing, turn player should be set to OTP
+    expect(testEngine.getTurnPlayer()).toBe(PLAYER_ONE);
+
+    // And priority should also be OTP (for mulligan)
+    expect(testEngine.getPriorityPlayers()).toContain(PLAYER_ONE);
+  });
+
+  it("should switch priority after each player mulligans", () => {
+    const ctx = testEngine.getCtx();
+    const choosingPlayer = ctx.choosingFirstPlayer;
+
+    testEngine.changeActivePlayer(choosingPlayer || PLAYER_ONE);
+    testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+
+    // OTP has priority first
+    expect(testEngine.getPriorityPlayers()).toContain(PLAYER_ONE);
+
+    testEngine.changeActivePlayer(PLAYER_ONE);
+    testEngine.alterHand([]);
+
+    // After OTP mulligans, priority switches to other player
+    expect(testEngine.getPriorityPlayers()).toContain(PLAYER_TWO);
+    expect(testEngine.getPriorityPlayers()).not.toContain(PLAYER_ONE);
+  });
+
+  // ========== Invalid Move Tests ==========
+
+  it("should reject invalid player ID", () => {
+    // Get the designated chooser so we can execute as them
+    const ctx = testEngine.getCtx();
+    const choosingPlayer = ctx.choosingFirstPlayer;
+
+    // Attempt to choose an invalid player ID as the designated chooser
+    const result = testEngine.engine.executeMove("chooseWhoGoesFirstMove", {
+      playerId: createPlayerId(choosingPlayer || PLAYER_ONE),
+      params: { playerId: createPlayerId("invalid_player_id") },
+    });
+
+    // Should fail with detailed error information
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.errorCode).toBe("INVALID_PLAYER_ID");
+      expect(result.error).toContain("Invalid player ID");
+      expect(result.error).toContain("invalid_player_id");
+      expect(result.errorContext?.playerId).toBe("invalid_player_id");
+      expect(result.errorContext?.validPlayers).toEqual([
+        PLAYER_ONE,
+        PLAYER_TWO,
+      ]);
+    }
+
+    // Verify OTP was not set
+    const updatedCtx = testEngine.getCtx();
+    expect(updatedCtx.otp).toBeUndefined();
+    expect(testEngine.getGamePhase()).toBe("chooseFirstPlayer");
+  });
+
+  it("should reject choosing first player twice", () => {
+    // Get the designated chooser
+    const ctx = testEngine.getCtx();
+    const choosingPlayer = ctx.choosingFirstPlayer;
+
+    // Choose first player successfully as the designated chooser
+    testEngine.changeActivePlayer(choosingPlayer || PLAYER_ONE);
+    testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+    const ctxAfterFirst = testEngine.getCtx();
+    expect(ctxAfterFirst.otp).toBe(PLAYER_ONE);
+    expect(testEngine.getGamePhase()).toBe("mulligan");
+
+    // Try to choose again - should fail
+    // Note: We need to be in chooseFirstPlayer phase, but we already transitioned to mulligan
+    // So this test verifies that once OTP is set, it can't be changed
+    // We'll need to manually set phase back for this specific test scenario
+
+    // For now, let's test by creating a new engine and trying to choose twice before phase transition
+    const testEngine2 = new LorcanaTestEngine(
+      { hand: 7, deck: 10 },
+      { hand: 7, deck: 10 },
+      { skipPreGame: false },
+    );
+
+    // Get the designated chooser for the new engine
+    const ctx2 = testEngine2.getCtx();
+    const choosingPlayer2 = ctx2.choosingFirstPlayer;
+
+    // Execute the move as the designated chooser
+    const result = testEngine2.engine.executeMove("chooseWhoGoesFirstMove", {
+      playerId: createPlayerId(choosingPlayer2 || PLAYER_ONE),
+      params: { playerId: createPlayerId(PLAYER_ONE) },
+    });
+    expect(result.success).toBe(true);
+
+    // Now try to choose again - should fail because phase has changed to mulligan
+    // Note: The move transitions to mulligan phase after successful execution,
+    // so the wrong phase error takes precedence over OTP already being set
+    const result2 = testEngine2.engine.executeMove("chooseWhoGoesFirstMove", {
+      playerId: createPlayerId(choosingPlayer2 || PLAYER_ONE),
+      params: { playerId: createPlayerId(PLAYER_TWO) },
+    });
+
+    expect(result2.success).toBe(false);
+    if (!result2.success) {
+      expect(result2.errorCode).toBe("WRONG_PHASE");
+      expect(result2.error).toContain(
+        "Cannot choose first player during mulligan phase",
+      );
+      expect(result2.errorContext?.currentPhase).toBe("mulligan");
+    }
+
+    testEngine2.dispose();
+  });
+
+  it("should reject choosing first player during wrong phase", () => {
+    // Get the designated chooser
+    const ctx = testEngine.getCtx();
+    const choosingPlayer = ctx.choosingFirstPlayer;
+
+    // Choose first player successfully - this transitions to mulligan phase
+    testEngine.changeActivePlayer(choosingPlayer || PLAYER_ONE);
+    testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+    expect(testEngine.getGamePhase()).toBe("mulligan");
+
+    // Try to choose first player again while in mulligan phase
+    const result = testEngine.engine.executeMove("chooseWhoGoesFirstMove", {
+      playerId: createPlayerId(choosingPlayer || PLAYER_ONE),
+      params: { playerId: createPlayerId(PLAYER_TWO) },
+    });
+
+    // Should fail with detailed error about wrong phase
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.errorCode).toBe("WRONG_PHASE");
+      expect(result.error).toContain(
+        "Cannot choose first player during mulligan phase",
+      );
+      expect(result.error).toContain("Must be in chooseFirstPlayer phase");
+      expect(result.errorContext?.currentPhase).toBe("mulligan");
+      expect(result.errorContext?.requiredPhase).toBe("chooseFirstPlayer");
+    }
+
+    // Verify OTP hasn't changed
+    const updatedCtx = testEngine.getCtx();
+    expect(updatedCtx.otp).toBe(PLAYER_ONE); // Still player_one, not player_two
+  });
+
+  // ========== Move Enumeration Tests ==========
+
+  describe("Move Enumeration", () => {
+    it("should list chooseWhoGoesFirstMove as available for designated player", () => {
+      const ctx = testEngine.getCtx();
+      const choosingPlayer = ctx.choosingFirstPlayer;
+
+      // Get available moves for the designated chooser
+      const availableMoves = testEngine.getAvailableMoves(
+        choosingPlayer || PLAYER_ONE,
+      );
+
+      // Should include chooseWhoGoesFirstMove
+      expect(availableMoves).toContain("chooseWhoGoesFirstMove");
+    });
+
+    it("should NOT list chooseWhoGoesFirstMove for non-designated player", () => {
+      const ctx = testEngine.getCtx();
+      const choosingPlayer = ctx.choosingFirstPlayer;
+      const otherPlayer =
+        choosingPlayer === PLAYER_ONE ? PLAYER_TWO : PLAYER_ONE;
+
+      // Get available moves for the OTHER player
+      const availableMoves = testEngine.getAvailableMoves(otherPlayer);
+
+      // Should NOT include chooseWhoGoesFirstMove
+      expect(availableMoves).not.toContain("chooseWhoGoesFirstMove");
+
+      // Should be empty (no moves available during this phase)
+      expect(availableMoves).toEqual([]);
+    });
+
+    it("should enumerate valid parameters for chooseWhoGoesFirstMove", () => {
+      const ctx = testEngine.getCtx();
+      const choosingPlayer = ctx.choosingFirstPlayer;
+
+      // Enumerate parameters
+      const params = testEngine.enumerateMoveParameters(
+        "chooseWhoGoesFirstMove",
+        choosingPlayer || PLAYER_ONE,
+      );
+
+      // Should have valid combinations for both players
+      expect(params).not.toBeNull();
+      expect(params?.validCombinations).toHaveLength(2);
+
+      // Should include both player IDs
+      const playerIds = params?.validCombinations.map((c: any) => c.playerId);
+      expect(playerIds).toContain(PLAYER_ONE);
+      expect(playerIds).toContain(PLAYER_TWO);
+
+      // Should have parameter info
+      expect(params?.parameterInfo.playerId).toBeDefined();
+      expect(params?.parameterInfo.playerId.type).toBe("playerId");
+      expect(params?.parameterInfo.playerId.validValues).toEqual([
+        PLAYER_ONE,
+        PLAYER_TWO,
+      ]);
+    });
+
+    it("should NOT enumerate parameters for non-designated player", () => {
+      const ctx = testEngine.getCtx();
+      const choosingPlayer = ctx.choosingFirstPlayer;
+      const otherPlayer =
+        choosingPlayer === PLAYER_ONE ? PLAYER_TWO : PLAYER_ONE;
+
+      // Try to enumerate parameters as other player
+      const params = testEngine.enumerateMoveParameters(
+        "chooseWhoGoesFirstMove",
+        otherPlayer,
+      );
+
+      // Should return null (move not available)
+      expect(params).toBeNull();
+    });
+
+    it("should provide detailed move information", () => {
+      const ctx = testEngine.getCtx();
+      const choosingPlayer = ctx.choosingFirstPlayer;
+
+      // Get detailed move info
+      const moves = testEngine.getAvailableMovesDetailed(
+        choosingPlayer || PLAYER_ONE,
+      );
+
+      // Should have one move
+      expect(moves).toHaveLength(1);
+
+      const moveInfo = moves[0];
+      expect(moveInfo.moveId).toBe("chooseWhoGoesFirstMove");
+      expect(moveInfo.displayName).toBe("Choose First Player");
+      expect(moveInfo.description).toContain("first");
+      expect(moveInfo.paramSchema).toBeDefined();
+      expect(moveInfo.paramSchema?.required).toHaveLength(1);
+    });
+
+    it("should explain why non-designated player cannot choose", () => {
+      const ctx = testEngine.getCtx();
+      const choosingPlayer = ctx.choosingFirstPlayer;
+      const otherPlayer =
+        choosingPlayer === PLAYER_ONE ? PLAYER_TWO : PLAYER_ONE;
+
+      // Try to execute as other player
+      const error = testEngine.whyCannotExecuteMove("chooseWhoGoesFirstMove", {
+        playerId: createPlayerId(otherPlayer),
+        params: { playerId: createPlayerId(PLAYER_ONE) },
+      });
+
+      // Should have error
+      expect(error).not.toBeNull();
+      expect(error?.errorCode).toBe("NOT_CHOOSING_PLAYER");
+      expect(error?.reason).toContain("can choose the first player");
+      expect(error?.context?.choosingPlayer).toBe(choosingPlayer);
+    });
+
+    it("should remove chooseWhoGoesFirstMove after OTP is set", () => {
+      const ctx = testEngine.getCtx();
+      const choosingPlayer = ctx.choosingFirstPlayer;
+
+      // Choose first player
+      testEngine.changeActivePlayer(choosingPlayer || PLAYER_ONE);
+      testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+
+      // Get available moves for OTP (who has priority in mulligan phase)
+      const otpMoves = testEngine.getAvailableMoves(PLAYER_ONE);
+
+      expect(otpMoves).not.toContain("chooseWhoGoesFirstMove");
+
+      // OTP should have alterHand available (mulligan phase, has priority)
+      expect(otpMoves).toContain("alterHand");
+    });
+
+    it("should transition to mulligan moves after choosing first player", () => {
+      const ctx = testEngine.getCtx();
+      const choosingPlayer = ctx.choosingFirstPlayer;
+
+      // Before choosing, should have chooseWhoGoesFirstMove
+      let availableMoves = testEngine.getAvailableMoves(
+        choosingPlayer || PLAYER_ONE,
+      );
+      expect(availableMoves).toContain("chooseWhoGoesFirstMove");
+
+      // Choose first player
+      testEngine.changeActivePlayer(choosingPlayer || PLAYER_ONE);
+      testEngine.chooseWhoGoesFirst(PLAYER_ONE);
+
+      // After choosing, OTP should have alterHand available (has priority)
+      availableMoves = testEngine.getAvailableMoves(PLAYER_ONE);
+      expect(availableMoves).toContain("alterHand");
+
+      // Other player should NOT have alterHand yet (doesn't have priority)
+      // Priority passes to them after OTP completes their mulligan
+      availableMoves = testEngine.getAvailableMoves(PLAYER_TWO);
+      expect(availableMoves).not.toContain("alterHand");
+    });
+  });
+});

package/src/game-definition/moves/setup/choose-first-player.ts

@@ -0,0 +1,105 @@
+import { type ConditionFailure, createMove, type PlayerId } from "@drmxrcy/tcg-core";
+import type {
+  LorcanaCardMeta,
+  LorcanaGameState,
+  LorcanaMoveParams,
+} from "../../../types";
+
+/**
+ * Choose Who Goes First Move
+ *
+ * Rule 3.1.1: First player determined randomly
+ *
+ * This move:
+ * - Marks the chosen player as OTP (On The Play)
+ * - Initializes pending mulligan list with all players
+ *
+ * The engine handles:
+ * - Setting activePlayer
+ * - Initializing turn counter
+ * - Transitioning to first phase
+ *
+ * Validation:
+ * - Player ID must be valid (exists in game)
+ * - OTP must not be already set (can't choose twice)
+ * - Must be in chooseFirstPlayer phase
+ */
+export const chooseWhoGoesFirstMove = createMove<
+  LorcanaGameState,
+  LorcanaMoveParams,
+  "chooseWhoGoesFirstMove",
+  LorcanaCardMeta
+>({
+  condition: (state, context): true | ConditionFailure => {
+    const { playerId } = context.params;
+
+    // 1. Check we're in the correct phase (most fundamental constraint)
+    if (context.flow?.currentPhase !== "chooseFirstPlayer") {
+      return {
+        reason: `Cannot choose first player during ${context.flow?.currentPhase || "unknown"} phase. Must be in chooseFirstPlayer phase.`,
+        errorCode: "WRONG_PHASE",
+        context: {
+          currentPhase: context.flow?.currentPhase,
+          requiredPhase: "chooseFirstPlayer",
+        },
+      };
+    }
+
+    // 2. Check that the executing player is the one designated to choose
+    // Rule 3.1.2: One player is randomly determined to choose who is the starting player
+    const choosingPlayer = context.game.getChoosingFirstPlayer();
+    if (choosingPlayer && context.playerId !== choosingPlayer) {
+      return {
+        reason: `Only ${String(choosingPlayer)} can choose the first player. You are ${String(context.playerId)}.`,
+        errorCode: "NOT_CHOOSING_PLAYER",
+        context: {
+          choosingPlayer: String(choosingPlayer),
+          executingPlayer: String(context.playerId),
+        },
+      };
+    }
+
+    // 3. Check OTP hasn't been set yet (prevent choosing twice)
+    const currentOTP = context.game.getOTP();
+    if (currentOTP) {
+      return {
+        reason: "First player has already been chosen",
+        errorCode: "FIRST_PLAYER_ALREADY_CHOSEN",
+        context: {
+          currentOTP: String(currentOTP),
+        },
+      };
+    }
+
+    // 4. Validate player exists in the game
+    const validPlayers = Object.keys(state.external.loreScores) as PlayerId[];
+    if (!validPlayers.includes(playerId)) {
+      return {
+        reason: `Invalid player ID: ${playerId}. Valid players: ${validPlayers.join(", ")}`,
+        errorCode: "INVALID_PLAYER_ID",
+        context: {
+          playerId: String(playerId),
+          validPlayers: validPlayers.map((p) => String(p)),
+        },
+      };
+    }
+
+    return true;
+  },
+
+  reducer: (draft, context) => {
+    const { playerId } = context.params;
+
+    context.game.setOTP(playerId);
+
+    // All players can mulligan after first player is chosen
+    // Get all player IDs from the game state
+    context.game.setPendingMulligan(
+      Object.keys(draft.external.loreScores) as PlayerId[],
+    );
+
+    if (context.flow) {
+      context.flow.endPhase("chooseFirstPlayer");
+    }
+  },
+});

package/src/game-definition/moves/setup/draw-cards.ts

@@ -0,0 +1,37 @@
+import { createMove, type ZoneId } from "@drmxrcy/tcg-core";
+import type {
+  LorcanaCardMeta,
+  LorcanaGameState,
+  LorcanaMoveParams,
+} from "../../../types";
+
+/**
+ * Draw Cards Move
+ *
+ * Utility move for drawing cards from deck to hand.
+ * Used by:
+ * - Beginning phase (draw for turn)
+ * - Card effects that draw cards
+ * - Testing/debugging
+ */
+export const drawCards = createMove<
+  LorcanaGameState,
+  LorcanaMoveParams,
+  "drawCards",
+  LorcanaCardMeta
+>({
+  condition: (_state, context) => {
+    // Not available during chooseFirstPlayer phase
+    return context.flow?.currentPhase !== "chooseFirstPlayer";
+  },
+  reducer: (_draft, context) => {
+    const { playerId, count } = context.params;
+
+    context.zones.drawCards({
+      from: "deck" as ZoneId,
+      to: "hand" as ZoneId,
+      count,
+      playerId,
+    });
+  },
+});

package/src/game-definition/moves/songs/sing-together.ts

@@ -0,0 +1,47 @@
+import { createMove, type ZoneId } from "@drmxrcy/tcg-core";
+import { useLorcanaOps } from "../../../operations";
+import type {
+  LorcanaCardMeta,
+  LorcanaGameState,
+  LorcanaMoveParams,
+} from "../../../types";
+import { and, cardInHand, isMainPhase } from "../../../validators";
+
+/**
+ * Sing Together Move (Legacy)
+ *
+ * Rule 10.10: Multiple characters exert to sing together
+ *
+ * Note: Prefer using playCard with "singTogether" cost parameter instead.
+ * This move is kept for backward compatibility.
+ *
+ * Requirements:
+ * - Song must be in hand
+ * - All singers must be ready (not exerted)
+ * - Combined ink values of singers must meet or exceed song cost
+ */
+export const singTogether = createMove<
+  LorcanaGameState,
+  LorcanaMoveParams,
+  "singTogether",
+  LorcanaCardMeta
+>({
+  condition: and(isMainPhase(), (state, context) =>
+    cardInHand(context.params.songId)(state, context),
+  ),
+  reducer: (draft, context) => {
+    const { singersIds, songId } = context.params;
+    const ops = useLorcanaOps(context);
+
+    // Exert all singers
+    for (const singerId of singersIds) {
+      ops.exertCard(singerId);
+    }
+
+    // Play song to discard
+    context.zones.moveCard({
+      cardId: songId,
+      targetZoneId: "discard" as ZoneId,
+    });
+  },
+});

package/src/game-definition/moves/songs/sing.ts

@@ -0,0 +1,56 @@
+import { createMove, type ZoneId } from "@drmxrcy/tcg-core";
+import { useLorcanaOps } from "../../../operations";
+import type {
+  LorcanaCardMeta,
+  LorcanaGameState,
+  LorcanaMoveParams,
+} from "../../../types";
+import {
+  and,
+  cardInHand,
+  cardInPlay,
+  cardOwnedByPlayer,
+  isMainPhase,
+} from "../../../validators";
+
+/**
+ * Sing Move (Legacy)
+ *
+ * Rule 6.3.3: Exert character to play song for free
+ *
+ * Note: Prefer using playCard with "sing" cost parameter instead.
+ * This move is kept for backward compatibility.
+ *
+ * Requirements:
+ * - Song must be in hand
+ * - Singer must be in play
+ * - Singer must be owned by current player
+ * - Singer must be able to sing (ready, not drying, meets cost requirement)
+ */
+export const sing = createMove<
+  LorcanaGameState,
+  LorcanaMoveParams,
+  "sing",
+  LorcanaCardMeta
+>({
+  condition: and(
+    isMainPhase(),
+    (state, context) => cardInHand(context.params.songId)(state, context),
+    (state, context) => cardInPlay(context.params.singerId)(state, context),
+    (state, context) =>
+      cardOwnedByPlayer(context.params.singerId)(state, context),
+  ),
+  reducer: (draft, context) => {
+    const { singerId, songId } = context.params;
+    const ops = useLorcanaOps(context);
+
+    // Exert singer
+    ops.exertCard(singerId);
+
+    // Play song to discard (actions go to discard)
+    context.zones.moveCard({
+      cardId: songId,
+      targetZoneId: "discard" as ZoneId,
+    });
+  },
+});