@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/__tests__/rules/section-05-cards.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Section 5: Cards
+ *
+ * Tests for rules 5.1 from Disney Lorcana Comprehensive Rules (Aug 22, 2025)
+ * Covers card conditions: Ready, Exerted, Damaged, Undamaged, Under, On Top, In a Stack.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  LorcanaTestEngine,
+  PLAYER_ONE,
+  PLAYER_TWO,
+} from "../../testing/lorcana-test-engine";
+
+describe("Section 5: Cards", () => {
+  let testEngine: LorcanaTestEngine;
+
+  beforeEach(() => {
+    testEngine = new LorcanaTestEngine(
+      { hand: 7, deck: 53, inkwell: 3 },
+      { hand: 7, deck: 53, inkwell: 3 },
+      { skipPreGame: true },
+    );
+  });
+
+  afterEach(() => {
+    testEngine.dispose();
+  });
+
+  describe("5.1. Conditions", () => {
+    /**
+     * Rule 5.1.1: Ready - Cards enter play ready. A player can't use any of an
+     * exerted card's abilities that include exert as part of the cost.
+     */
+    test.failing("Rule 5.1.1 - Cards enter play ready", () => {
+      // Arrange: Create a character
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 3,
+      });
+
+      // Assert: Should be ready (not exerted)
+      const meta = testEngine.getCardMeta(character);
+      expect(meta?.state).toBe("ready");
+      expect(true).toBe(false); // Will fail until ready state verified
+    });
+
+    /**
+     * Rule 5.1.1 (continued): Exerted card's exert abilities cannot be used.
+     */
+    test.failing("Rule 5.1.1 - Cannot use exert abilities when exerted", () => {
+      // Arrange: Create character with exert ability, then exert it
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 3,
+      });
+
+      // Exert by questing
+      testEngine.quest(character);
+
+      // Act: Try to use exert ability
+      // Assert: Should fail because character is exerted
+      expect(true).toBe(false); // Will fail until exert ability check implemented
+    });
+
+    /**
+     * Rule 5.1.2: Exerted - When a card is exerted, it's turned sideways.
+     * A player can use an exerted card's abilities that don't require exert.
+     */
+    test.failing("Rule 5.1.2 - Exerted cards can use non-exert abilities", () => {
+      // Arrange: Character with non-exert ability, exert it
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 3,
+      });
+
+      testEngine.quest(character);
+      expect(testEngine.getCardMeta(character)?.state).toBe("exerted");
+
+      // Act: Use non-exert ability
+      // Assert: Should succeed despite being exerted
+      expect(true).toBe(false); // Will fail until non-exert ability check implemented
+    });
+
+    /**
+     * Rule 5.1.3: Damaged - A card that has at least 1 damage is considered damaged.
+     */
+    test.failing("Rule 5.1.3 - Card with 1+ damage is damaged", () => {
+      // Arrange: Create character and give it damage
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 5,
+      });
+
+      // Would need a way to deal damage
+      // After damage dealt:
+      // Assert: Character should be considered "damaged"
+      expect(true).toBe(false); // Will fail until damage tracking implemented
+    });
+
+    /**
+     * Rule 5.1.4: Undamaged - A card that has no damage is considered undamaged.
+     */
+    test.failing("Rule 5.1.4 - Card with 0 damage is undamaged", () => {
+      // Arrange: Create fresh character
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 3,
+      });
+
+      // Assert: Should have 0 damage, be considered "undamaged"
+      expect(testEngine.getDamage(character)).toBe(0);
+      // Would need isDamaged() helper
+      expect(true).toBe(false); // Will fail until undamaged check implemented
+    });
+
+    /**
+     * Rule 5.1.5: Under - A card that has one or more cards on top of it is
+     * considered to be under the top card in a stack. A player can't choose
+     * any card that's under the top card.
+     */
+    test.failing("Rule 5.1.5 - Cards under others cannot be chosen", () => {
+      // Arrange: Create stack (e.g., Shift onto character)
+      // The base character is "under"
+
+      // Act: Try to target the under card
+
+      // Assert: Should not be choosable
+      expect(true).toBe(false); // Will fail until stack targeting implemented
+    });
+
+    /**
+     * Rule 5.1.6: On Top - A card on top of others doesn't gain the text
+     * of any card under it. The card on top is called the top card.
+     */
+    test.failing("Rule 5.1.6 - Top card doesn't gain text from cards under", () => {
+      // Arrange: Create stack via Shift
+      // Base card has ability X, top card has ability Y
+
+      // Assert: Top card should only have ability Y, not X
+      expect(true).toBe(false); // Will fail until stack text handling implemented
+    });
+
+    /**
+     * Rule 5.1.7: In a Stack - When a card is placed on top of one or more
+     * other cards in play, all cards are in a stack. If top card leaves play,
+     * all cards in stack move to the same zone.
+     */
+    test.failing("Rule 5.1.7 - Stack moves together when top card leaves", () => {
+      // Arrange: Create stack (Shift)
+
+      // Act: Banish the top card
+
+      // Assert: All cards in stack should go to discard together
+      expect(true).toBe(false); // Will fail until stack leaving play implemented
+    });
+  });
+});

package/src/__tests__/rules/section-06-card-types.test.ts

@@ -0,0 +1,342 @@
+/**
+ * Section 6: Card Types
+ *
+ * Tests for rules 6.1-6.5 from Disney Lorcana Comprehensive Rules (Aug 22, 2025)
+ * Covers Characters, Parts of a Card, Actions, Items, and Locations.
+ *
+ * Note: Some tests in spec-01-foundation-types.test.ts already cover card type guards.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  LorcanaTestEngine,
+  PLAYER_ONE,
+  PLAYER_TWO,
+} from "../../testing/lorcana-test-engine";
+
+describe("Section 6: Card Types", () => {
+  let testEngine: LorcanaTestEngine;
+
+  beforeEach(() => {
+    testEngine = new LorcanaTestEngine(
+      { hand: 7, deck: 53, inkwell: 3 },
+      { hand: 7, deck: 53, inkwell: 3 },
+      { skipPreGame: true },
+    );
+  });
+
+  afterEach(() => {
+    testEngine.dispose();
+  });
+
+  describe("6.1. Characters", () => {
+    /**
+     * Rule 6.1.1: Characters are a type of card that can be in play.
+     * A character card in the Play zone is a character; in other zones it's a character card.
+     */
+    test.failing("Rule 6.1.1 - Character card becomes character when in play", () => {
+      // Arrange: Character in hand (card) vs in play (character)
+
+      // Assert: Terminology distinction should apply
+      expect(true).toBe(false); // Will fail until zone-based terminology implemented
+    });
+
+    /**
+     * Rule 6.1.2.1: A character has a Strength value and a Willpower value.
+     */
+    test.failing("Rule 6.1.2.1 - Characters have Strength and Willpower", () => {
+      // Arrange: Create character with stats
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 3,
+        willpower: 4,
+      });
+
+      // Assert: Character should have both values accessible
+      // Would need getStrength/getWillpower helpers
+      expect(true).toBe(false); // Will fail until stat access implemented
+    });
+
+    /**
+     * Rule 6.1.2.2: A character has at least one classification
+     * (Storyborn, Dreamborn, Floodborn, Hero, Villain, etc.).
+     */
+    test.failing("Rule 6.1.2.2 - Characters have classifications", () => {
+      // Assert: Character should have at least one valid classification
+      expect(true).toBe(false); // Will fail until classification system implemented
+    });
+
+    /**
+     * Rule 6.1.3: Only characters can quest or challenge.
+     */
+    test.failing("Rule 6.1.3 - Only characters can quest or challenge", () => {
+      // Assert: Items and locations should not be able to quest/challenge
+      expect(true).toBe(false); // Will fail until type restrictions enforced
+    });
+
+    /**
+     * Rule 6.1.4: A character must have been in play at the beginning of the Set step
+     * to quest, challenge, or exert as part of a cost.
+     */
+    test.failing("Rule 6.1.4 - Fresh characters cannot quest/challenge (drying)", () => {
+      // Arrange: Create fresh character
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 3,
+      });
+
+      // Act: Try to quest immediately (this test uses a backdoor that skips drying)
+      // In real gameplay, fresh characters can't quest
+
+      // Assert: Should be blocked until dry
+      expect(true).toBe(false); // Will fail until drying properly enforced in moves
+    });
+  });
+
+  describe("6.2. Parts of a Card", () => {
+    /**
+     * Rule 6.2.3: Ink Type - The ink type of the card, identified by ink type symbol.
+     */
+    test.failing("Rule 6.2.3 - Cards have ink type", () => {
+      // Assert: Card should have identifiable ink type (amber, ruby, etc.)
+      expect(true).toBe(false); // Will fail until ink type access implemented
+    });
+
+    /**
+     * Rule 6.2.3.1: Some cards have more than one ink type (dual-ink cards).
+     */
+    test.failing("Rule 6.2.3.1 - Dual-ink cards have two ink types", () => {
+      // Assert: Dual-ink card should report both types
+      expect(true).toBe(false); // Will fail until dual-ink implemented
+    });
+
+    /**
+     * Rule 6.2.4: Name - An effect looking for a card with specified name looks
+     * only at this line and ignores the version. Full name = name + version.
+     */
+    test.failing("Rule 6.2.4 - Name matching ignores version", () => {
+      // Arrange: Effect that looks for "Elsa" should find both
+      // "Elsa - Ice Queen" and "Elsa - Snow Queen"
+
+      // Assert: Both versions should match
+      expect(true).toBe(false); // Will fail until name matching implemented
+    });
+
+    /**
+     * Rule 6.2.4.1: Some characters have two names (separated by &).
+     * Effect looking for specified name only needs to match one.
+     */
+    test.failing("Rule 6.2.4.1 - Dual-name characters match either name", () => {
+      // Arrange: "Flotsam & Jetsam" should match both "Flotsam" and "Jetsam"
+
+      // Assert: Effect targeting "Flotsam" should find this character
+      expect(true).toBe(false); // Will fail until dual-name matching implemented
+    });
+
+    /**
+     * Rule 6.2.4.2: A character with multiple names is still a single character.
+     */
+    test.failing("Rule 6.2.4.2 - Dual-name is one character", () => {
+      // Assert: Should count as 1 character, not 2
+      expect(true).toBe(false); // Will fail until dual-name counting verified
+    });
+
+    /**
+     * Rule 6.2.7: Card Cost - The amount of ink needed to play the card.
+     */
+    test.failing("Rule 6.2.7 - Card cost determines ink needed", () => {
+      // Assert: Playing card should require exerting ink equal to cost
+      expect(true).toBe(false); // Will fail until cost payment verified
+    });
+
+    /**
+     * Rule 6.2.8: Inkwell Symbol - If present, card can be put into inkwell.
+     */
+    test.failing("Rule 6.2.8 - Inkable cards have inkwell symbol", () => {
+      // Assert: Only cards with inkwell symbol can be inked
+      expect(true).toBe(false); // Will fail until inkable check implemented
+    });
+
+    /**
+     * Rule 6.2.9: Strength - How much damage character deals in challenge.
+     * If 0 or less, deals no damage.
+     */
+    test.failing("Rule 6.2.9 - Strength determines challenge damage", () => {
+      // Arrange: Create characters with different strengths
+
+      // Act: Challenge
+
+      // Assert: Damage dealt should equal strength
+      expect(true).toBe(false); // Will fail until strength-based damage verified
+    });
+
+    /**
+     * Rule 6.2.10: Willpower - If damage >= willpower, character is banished.
+     */
+    test.failing("Rule 6.2.10 - Damage >= Willpower banishes", () => {
+      // Arrange: Character with willpower 3
+
+      // Act: Deal 3 damage
+
+      // Assert: Character should be banished
+      expect(true).toBe(false); // Will fail until willpower threshold implemented
+    });
+
+    /**
+     * Rule 6.2.11: Lore Value - How much lore gained when character quests.
+     */
+    test.failing("Rule 6.2.11 - Lore value determines quest reward", () => {
+      // Arrange: Character with lore 2
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 3,
+        lore: 2,
+      });
+
+      // Act: Quest
+      testEngine.quest(character);
+
+      // Assert: Should gain 2 lore
+      expect(testEngine.getLore(PLAYER_ONE)).toBe(2);
+      expect(true).toBe(false); // Will fail until lore value properly used
+    });
+  });
+
+  describe("6.3. Actions", () => {
+    /**
+     * Rule 6.3.1: Actions are a type of card that can be played but can't be in play.
+     */
+    test.failing("Rule 6.3.1 - Actions are not in play after resolution", () => {
+      // Arrange: Play an action card
+
+      // Assert: Action should not be in play zone after resolving
+      expect(true).toBe(false); // Will fail until action zone handling implemented
+    });
+
+    /**
+     * Rule 6.3.1.2: Actions are played from hand but not considered in play.
+     * Effect from action doesn't enter the bag.
+     */
+    test.failing("Rule 6.3.1.2 - Action effects don't use the bag", () => {
+      // Arrange: Play action
+
+      // Assert: Effect should resolve immediately, not via bag
+      expect(true).toBe(false); // Will fail until action resolution implemented
+    });
+
+    /**
+     * Rule 6.3.2: Actions have effects rather than abilities.
+     */
+    test.failing("Rule 6.3.2 - Actions have effects, not abilities", () => {
+      // Terminology distinction
+      expect(true).toBe(false); // Will fail until effect/ability distinction implemented
+    });
+
+    /**
+     * Rule 6.3.3.3: Songs allow exerting a character to pay instead of ink cost.
+     * "Singer" keyword specifies minimum cost of character that can sing.
+     */
+    test.failing("Rule 6.3.3.3 - Songs can be sung by characters", () => {
+      // Arrange: Song with cost 4, character with Singer 4+
+
+      // Act: Exert character to play song for free
+
+      // Assert: Song should be played without paying ink
+      expect(true).toBe(false); // Will fail until singing implemented
+    });
+
+    /**
+     * Rule 6.3.4: Effects triggered by playing action wait until action resolves.
+     */
+    test.failing("Rule 6.3.4 - Triggers from action wait for resolution", () => {
+      // Arrange: Effect that triggers when action is played
+
+      // Act: Play action
+
+      // Assert: Trigger should resolve after action effect
+      expect(true).toBe(false); // Will fail until trigger ordering implemented
+    });
+  });
+
+  describe("6.4. Items", () => {
+    /**
+     * Rule 6.4.1: Items are a type of card that can be in play.
+     */
+    test.failing("Rule 6.4.1 - Items stay in play", () => {
+      // Arrange: Play an item
+
+      // Assert: Item should be in play zone
+      expect(true).toBe(false); // Will fail until item zone handling implemented
+    });
+
+    /**
+     * Rule 6.4.3: If an item has an ability, it can be used the turn played.
+     */
+    test.failing("Rule 6.4.3 - Item abilities usable same turn", () => {
+      // Arrange: Play item with activated ability
+
+      // Act: Use ability same turn
+
+      // Assert: Should work (no drying for items)
+      expect(true).toBe(false); // Will fail until item ability timing implemented
+    });
+  });
+
+  describe("6.5. Locations", () => {
+    /**
+     * Rule 6.5.1: Locations are a type of card that can be in play.
+     */
+    test.failing("Rule 6.5.1 - Locations stay in play", () => {
+      // Arrange: Play a location
+
+      // Assert: Location should be in play zone
+      expect(true).toBe(false); // Will fail until location zone handling implemented
+    });
+
+    /**
+     * Rule 6.5.4: Move Cost - Amount of ink needed to move a character to location.
+     */
+    test.failing("Rule 6.5.4 - Moving to location costs ink", () => {
+      // Arrange: Location with move cost 2
+
+      // Act: Move character to location
+
+      // Assert: Should spend 2 ink
+      expect(true).toBe(false); // Will fail until move cost implemented
+    });
+
+    /**
+     * Rule 6.5.5: Locations have Willpower but no Strength.
+     * They don't deal damage when challenged.
+     */
+    test.failing("Rule 6.5.5 - Locations have willpower, no strength", () => {
+      // Arrange: Challenge a location
+
+      // Assert: Attacker should take no damage from location
+      expect(true).toBe(false); // Will fail until location combat implemented
+    });
+
+    /**
+     * Rule 6.5.6: Location may have Lore value, gained at Set step.
+     */
+    test.failing("Rule 6.5.6 - Location lore gained at Set step", () => {
+      // Arrange: Location with lore 1 in play
+
+      // Act: Start turn (Set step)
+
+      // Assert: Should gain 1 lore from location
+      expect(true).toBe(false); // Will fail until location lore implemented
+    });
+
+    /**
+     * Rule 6.5.7: Location abilities can be used the turn played.
+     */
+    test.failing("Rule 6.5.7 - Location abilities usable same turn", () => {
+      // Arrange: Play location with activated ability
+
+      // Act: Use ability same turn
+
+      // Assert: Should work (no drying for locations)
+      expect(true).toBe(false); // Will fail until location ability timing implemented
+    });
+  });
+});