@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/__tests__/rules/section-09-damage.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Section 9: Damage
+ *
+ * Tests for rules 9.1-9.4 from Disney Lorcana Comprehensive Rules (Aug 22, 2025)
+ * Covers damage representation, "put" vs "deal", moving damage, and leaving play.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  LorcanaTestEngine,
+  PLAYER_ONE,
+  PLAYER_TWO,
+} from "../../testing/lorcana-test-engine";
+
+describe("Section 9: Damage", () => {
+  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("9.1. Representation of Damage", () => {
+    /**
+     * Rule 9.1.1: Damage is tracked on characters and locations using damage counters.
+     * Each counter represents 1 damage.
+     */
+    test.failing("Rule 9.1.1 - Damage tracked with counters", () => {
+      // Arrange: Create character
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 5,
+      });
+
+      // Initially should have 0 damage
+      expect(testEngine.getDamage(character)).toBe(0);
+
+      // After taking damage, counter should increase
+      // (need to deal damage somehow)
+      expect(true).toBe(false); // Will fail until damage dealing implemented
+    });
+
+    /**
+     * Damage is persistent - accumulates over the game.
+     */
+    test.failing("Rule 9.1 - Damage persists across turns", () => {
+      // Arrange: Deal damage to character
+
+      // Act: Pass multiple turns
+
+      // Assert: Damage should still be there
+      expect(true).toBe(false); // Will fail until damage persistence verified
+    });
+  });
+
+  describe("9.2. 'Put' Damage", () => {
+    /**
+     * Rule 9.2.1: "Put damage" is different from "deal damage".
+     * Put bypasses effects that modify dealt damage (like Resist).
+     */
+    test.failing("Rule 9.2.1 - Put damage bypasses Resist", () => {
+      // Arrange: Character with Resist 2
+
+      // Act: Put 3 damage on it
+
+      // Assert: Should take full 3 damage (Resist doesn't apply)
+      expect(true).toBe(false); // Will fail until put vs deal distinction implemented
+    });
+
+    /**
+     * "Put" also bypasses damage prevention effects.
+     */
+    test.failing("Rule 9.2 - Put damage bypasses prevention", () => {
+      // Arrange: Damage prevention effect active
+
+      // Act: Put damage
+
+      // Assert: Damage should still be placed
+      expect(true).toBe(false); // Will fail until put damage implemented
+    });
+  });
+
+  describe("9.3. Moving Damage Counters", () => {
+    /**
+     * Rule 9.3.1: Some effects can move damage counters between cards.
+     */
+    test.failing("Rule 9.3.1 - Damage counters can be moved", () => {
+      // Arrange: Two characters, one with damage
+
+      // Act: Move damage from one to other
+
+      // Assert: Damage should transfer
+      expect(true).toBe(false); // Will fail until damage movement implemented
+    });
+
+    /**
+     * Moving damage is not dealing or putting damage (doesn't trigger those effects).
+     */
+    test.failing("Rule 9.3 - Moving damage is not dealing", () => {
+      // Arrange: "When this character takes damage" trigger
+
+      // Act: Move damage to this character
+
+      // Assert: Trigger should NOT fire (moving isn't dealing/taking)
+      expect(true).toBe(false); // Will fail until damage movement semantics implemented
+    });
+  });
+
+  describe("9.4. Leaving Play", () => {
+    /**
+     * Rule 9.4.1: When a card leaves play, all damage on it is removed.
+     */
+    test.failing("Rule 9.4.1 - Damage cleared when leaving play", () => {
+      // Arrange: Character with 2 damage (not lethal)
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 5,
+      });
+
+      // Deal 2 damage somehow
+      // Then return character to hand
+
+      // Act: Play character again
+
+      // Assert: Should have 0 damage (cleared when left play)
+      expect(true).toBe(false); // Will fail until leaving play cleanup implemented
+    });
+
+    /**
+     * If a character would leave play but is prevented, damage stays.
+     */
+    test.failing("Rule 9.4 - Prevention keeps damage", () => {
+      // Arrange: Character with damage, replacement effect preventing leaving
+
+      // Act: Try to banish character (prevented)
+
+      // Assert: Damage should remain
+      expect(true).toBe(false); // Will fail until leave prevention implemented
+    });
+  });
+});

package/src/__tests__/rules/section-10-keywords.test.ts

@@ -0,0 +1,469 @@
+/**
+ * Section 10: Keywords
+ *
+ * Tests for rules 10.1-10.13 from Disney Lorcana Comprehensive Rules (Aug 22, 2025)
+ * Covers all keywords: General, Bodyguard, Challenger, Evasive, Reckless, Resist,
+ * Rush, Shift, Singer, Sing Together, Support, Vanish, and Ward.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  LorcanaTestEngine,
+  PLAYER_ONE,
+  PLAYER_TWO,
+} from "../../testing/lorcana-test-engine";
+
+describe("Section 10: Keywords", () => {
+  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("10.1. General", () => {
+    /**
+     * Rule 10.1.1: Keywords are abilities represented by specific words or phrases.
+     */
+    test.failing("Rule 10.1.1 - Keywords represent abilities", () => {
+      // Assert: Keyword should expand to full ability rules
+      expect(true).toBe(false); // Will fail until keyword system implemented
+    });
+
+    /**
+     * Rule 10.1.2: Some keywords stack (add together), some don't.
+     */
+    test.failing("Rule 10.1.2 - Keyword stacking rules", () => {
+      // Arrange: Character with Challenger +2 from two sources
+
+      // Assert: Should have Challenger +4 (stacks)
+      expect(true).toBe(false); // Will fail until keyword stacking implemented
+    });
+
+    /**
+     * Rule 10.1.3: Technical definitions define exact keyword behavior.
+     * Reminder text is not rules text.
+     */
+    test.failing("Rule 10.1.3 - Reminder text is not rules", () => {
+      // Assert: Only technical definition applies, not reminder text
+      expect(true).toBe(false); // Will fail until keyword parsing verified
+    });
+  });
+
+  describe("10.2. Bodyguard", () => {
+    /**
+     * Rule 10.2.1: Bodyguard - When this character is exerted, opposing characters
+     * must challenge this character if able.
+     */
+    test.failing("Rule 10.2.1 - Bodyguard forces challenges to this character", () => {
+      // Arrange: Bodyguard character (exerted), other character
+      // Opponent has character that could challenge either
+
+      // Assert: Opponent must challenge Bodyguard
+      expect(true).toBe(false); // Will fail until Bodyguard implemented
+    });
+
+    /**
+     * Bodyguard only applies when exerted.
+     */
+    test.failing("Rule 10.2 - Bodyguard requires exerted state", () => {
+      // Arrange: Bodyguard character (ready)
+
+      // Assert: Opponent can challenge other characters
+      expect(true).toBe(false); // Will fail until Bodyguard state check implemented
+    });
+
+    /**
+     * Multiple Bodyguards - opponent chooses which to challenge.
+     */
+    test.failing("Rule 10.2 - Multiple Bodyguards allow choice", () => {
+      // Arrange: Two exerted Bodyguard characters
+
+      // Assert: Opponent can choose either
+      expect(true).toBe(false); // Will fail until multiple Bodyguard implemented
+    });
+  });
+
+  describe("10.3. Challenger", () => {
+    /**
+     * Rule 10.3.1: Challenger +X - This character gets +X Strength while challenging.
+     */
+    test.failing("Rule 10.3.1 - Challenger adds Strength when challenging", () => {
+      // Arrange: Character with Challenger +2 (base strength 3)
+      // Defender with 4 willpower
+
+      // Act: Challenge
+
+      // Assert: Should deal 5 damage (3 + 2 from Challenger)
+      expect(true).toBe(false); // Will fail until Challenger implemented
+    });
+
+    /**
+     * Rule 10.3.2: Challenger stacks - multiple sources add together.
+     */
+    test.failing("Rule 10.3.2 - Challenger stacks", () => {
+      // Arrange: Character with Challenger +2 and Challenger +1
+
+      // Assert: Should have Challenger +3 total
+      expect(true).toBe(false); // Will fail until Challenger stacking implemented
+    });
+
+    /**
+     * Challenger only applies while challenging, not when being challenged.
+     */
+    test.failing("Rule 10.3 - Challenger only when attacking", () => {
+      // Arrange: Challenger character being challenged
+
+      // Assert: Challenger bonus should NOT apply
+      expect(true).toBe(false); // Will fail until Challenger direction implemented
+    });
+  });
+
+  describe("10.4. Evasive", () => {
+    /**
+     * Rule 10.4.1: Evasive - Only characters with Evasive can challenge this character.
+     */
+    test.failing("Rule 10.4.1 - Only Evasive can challenge Evasive", () => {
+      // Arrange: Evasive character (exerted), non-Evasive attacker
+
+      // Act: Try to challenge Evasive character
+
+      // Assert: Should fail
+      expect(true).toBe(false); // Will fail until Evasive implemented
+    });
+
+    /**
+     * Evasive character can challenge Evasive character.
+     */
+    test.failing("Rule 10.4 - Evasive can challenge Evasive", () => {
+      // Arrange: Two Evasive characters
+
+      // Act: One challenges the other
+
+      // Assert: Should succeed
+      expect(true).toBe(false); // Will fail until Evasive vs Evasive implemented
+    });
+  });
+
+  describe("10.5. Reckless", () => {
+    /**
+     * Rule 10.5.1: Reckless - This character must challenge if able.
+     */
+    test.failing("Rule 10.5.1 - Reckless must challenge when possible", () => {
+      // Arrange: Reckless character, exerted opponent character
+
+      // Assert: Reckless character cannot quest (must challenge)
+      expect(true).toBe(false); // Will fail until Reckless implemented
+    });
+
+    /**
+     * Reckless only forced when a valid challenge target exists.
+     */
+    test.failing("Rule 10.5 - Reckless can quest if no targets", () => {
+      // Arrange: Reckless character, no exerted opponent characters
+
+      // Assert: Reckless character can quest
+      expect(true).toBe(false); // Will fail until Reckless target check implemented
+    });
+
+    /**
+     * Reckless character can use abilities instead of challenging.
+     */
+    test.failing("Rule 10.5 - Reckless can use abilities", () => {
+      // Arrange: Reckless character with activated ability, valid challenge target
+
+      // Assert: Can use ability (Reckless doesn't force challenge over abilities)
+      // Note: This may depend on exact ruling interpretation
+      expect(true).toBe(false); // Will fail until Reckless ability interaction implemented
+    });
+  });
+
+  describe("10.6. Resist", () => {
+    /**
+     * Rule 10.6.1: Resist +X - When this character takes damage, reduce it by X.
+     */
+    test.failing("Rule 10.6.1 - Resist reduces damage taken", () => {
+      // Arrange: Character with Resist 2, willpower 5
+
+      // Act: Deal 4 damage
+
+      // Assert: Should take 2 damage (4 - 2 Resist)
+      expect(true).toBe(false); // Will fail until Resist implemented
+    });
+
+    /**
+     * Rule 10.6.2: Resist stacks - multiple sources add together.
+     */
+    test.failing("Rule 10.6.2 - Resist stacks", () => {
+      // Arrange: Character with Resist 2 and Resist 1
+
+      // Act: Deal 5 damage
+
+      // Assert: Should take 2 damage (5 - 3 total Resist)
+      expect(true).toBe(false); // Will fail until Resist stacking implemented
+    });
+
+    /**
+     * Rule 10.6.3: Resist can reduce damage to 0 but not below.
+     */
+    test.failing("Rule 10.6.3 - Resist cannot make damage negative", () => {
+      // Arrange: Character with Resist 5
+
+      // Act: Deal 2 damage
+
+      // Assert: Should take 0 damage (not -3)
+      expect(true).toBe(false); // Will fail until Resist floor implemented
+    });
+
+    /**
+     * Resist only applies to dealt damage, not put damage.
+     */
+    test.failing("Rule 10.6 - Resist doesn't affect put damage", () => {
+      // Arrange: Character with Resist 2
+
+      // Act: Put 3 damage
+
+      // Assert: Should take 3 damage (put bypasses Resist)
+      expect(true).toBe(false); // Will fail until Resist vs put implemented
+    });
+  });
+
+  describe("10.7. Rush", () => {
+    /**
+     * Rule 10.7.1: Rush - This character can challenge the turn it's played.
+     */
+    test.failing("Rule 10.7.1 - Rush allows immediate challenge", () => {
+      // Arrange: Play Rush character
+
+      // Act: Challenge same turn
+
+      // Assert: Should succeed (no drying restriction)
+      expect(true).toBe(false); // Will fail until Rush implemented
+    });
+
+    /**
+     * Rush only bypasses challenge restriction, not quest restriction.
+     */
+    test.failing("Rule 10.7 - Rush doesn't allow immediate quest", () => {
+      // Arrange: Play Rush character
+
+      // Act: Try to quest same turn
+
+      // Assert: Should fail (Rush doesn't bypass quest drying)
+      expect(true).toBe(false); // Will fail until Rush limitation implemented
+    });
+  });
+
+  describe("10.8. Shift", () => {
+    /**
+     * Rule 10.8.1: Shift X (cost) - Pay X ink to play this on top of a character
+     * with the specified name.
+     */
+    test.failing("Rule 10.8.1 - Shift as alternate play cost", () => {
+      // Arrange: "Elsa - Snow Queen" in play
+      // Floodborn Elsa with Shift 4 in hand
+
+      // Act: Pay 4 ink to Shift onto Elsa
+
+      // Assert: Floodborn Elsa should be on top of stack
+      expect(true).toBe(false); // Will fail until Shift implemented
+    });
+
+    /**
+     * Rule 10.8.2: Shifted character inherits the "dry" state of the base.
+     */
+    test.failing("Rule 10.8.2 - Shift inherits dry state", () => {
+      // Arrange: Dry character in play
+
+      // Act: Shift onto it
+
+      // Assert: New character should also be dry (can quest/challenge)
+      expect(true).toBe(false); // Will fail until Shift state inheritance implemented
+    });
+
+    /**
+     * Rule 10.8.3: Shifted character inherits damage from the base.
+     */
+    test.failing("Rule 10.8.3 - Shift inherits damage", () => {
+      // Arrange: Character with 2 damage
+
+      // Act: Shift onto it
+
+      // Assert: New character should have 2 damage
+      expect(true).toBe(false); // Will fail until Shift damage inheritance implemented
+    });
+
+    /**
+     * Rule 10.8.4: When shifted character leaves play, all cards in stack leave.
+     */
+    test.failing("Rule 10.8.4 - Stack leaves play together", () => {
+      // Arrange: Create shift stack
+
+      // Act: Banish the top card
+
+      // Assert: All cards in stack should go to discard
+      expect(true).toBe(false); // Will fail until stack leaving implemented
+    });
+  });
+
+  describe("10.9. Singer", () => {
+    /**
+     * Rule 10.9.1: Singer X - This character counts as cost X for singing songs.
+     */
+    test.failing("Rule 10.9.1 - Singer allows singing songs", () => {
+      // Arrange: Character with Singer 5, Song with cost 4
+
+      // Act: Exert character to sing song
+
+      // Assert: Song should be played (Singer 5 >= Song cost 4)
+      expect(true).toBe(false); // Will fail until Singer implemented
+    });
+
+    /**
+     * Character cannot sing songs with cost higher than Singer value.
+     */
+    test.failing("Rule 10.9 - Singer limits song cost", () => {
+      // Arrange: Character with Singer 3, Song with cost 5
+
+      // Act: Try to sing song
+
+      // Assert: Should fail (Singer 3 < Song cost 5)
+      expect(true).toBe(false); // Will fail until Singer cost check implemented
+    });
+  });
+
+  describe("10.10. Sing Together", () => {
+    /**
+     * Rule 10.10.1: Sing Together X - Multiple characters can exert together
+     * to sing this song if their total ink costs meet or exceed X.
+     */
+    test.failing("Rule 10.10.1 - Sing Together combines character costs", () => {
+      // Arrange: Two characters (cost 2 each), Song with Sing Together 4
+
+      // Act: Exert both to sing
+
+      // Assert: Should succeed (2 + 2 = 4 >= required 4)
+      expect(true).toBe(false); // Will fail until Sing Together implemented
+    });
+
+    /**
+     * Sing Together uses character ink cost, not Singer value.
+     */
+    test.failing("Rule 10.10 - Sing Together uses ink cost", () => {
+      // Arrange: Two characters (cost 3 each), even if they have Singer
+
+      // Assert: Contribution is 3 + 3 = 6, not Singer values
+      expect(true).toBe(false); // Will fail until Sing Together cost source implemented
+    });
+  });
+
+  describe("10.11. Support", () => {
+    /**
+     * Rule 10.11.1: Support - When this character quests, choose another character.
+     * That character gets +X Strength this turn.
+     */
+    test.failing("Rule 10.11.1 - Support grants Strength when questing", () => {
+      // Arrange: Character with Support, another character
+
+      // Act: Quest with Support character
+
+      // Assert: Chosen character should have +X Strength
+      expect(true).toBe(false); // Will fail until Support implemented
+    });
+
+    /**
+     * Support bonus lasts until end of turn.
+     */
+    test.failing("Rule 10.11 - Support ends at end of turn", () => {
+      // Arrange: Use Support
+
+      // Act: End turn
+
+      // Assert: Strength bonus should end
+      expect(true).toBe(false); // Will fail until Support duration implemented
+    });
+  });
+
+  describe("10.12. Vanish", () => {
+    /**
+     * Rule 10.12.1: Vanish - After this character quests, return it to your hand.
+     */
+    test.failing("Rule 10.12.1 - Vanish returns to hand after quest", () => {
+      // Arrange: Vanish character
+
+      // Act: Quest
+
+      // Assert: Character should be in hand (gained lore first)
+      expect(true).toBe(false); // Will fail until Vanish implemented
+    });
+
+    /**
+     * Vanish triggers after quest completes (lore is gained first).
+     */
+    test.failing("Rule 10.12 - Vanish triggers after lore gained", () => {
+      // Arrange: Vanish character, note initial lore
+
+      // Act: Quest
+
+      // Assert: Lore should be gained, then character returns to hand
+      expect(true).toBe(false); // Will fail until Vanish timing implemented
+    });
+  });
+
+  describe("10.13. Ward", () => {
+    /**
+     * Rule 10.13.1: Ward - Opponents can't choose this character except to challenge.
+     */
+    test.failing("Rule 10.13.1 - Ward prevents opponent targeting", () => {
+      // Arrange: Ward character, opponent effect that chooses character
+
+      // Act: Opponent tries to target Ward character
+
+      // Assert: Should fail (can't choose)
+      expect(true).toBe(false); // Will fail until Ward implemented
+    });
+
+    /**
+     * Ward doesn't prevent challenges.
+     */
+    test.failing("Rule 10.13 - Ward allows challenges", () => {
+      // Arrange: Exerted Ward character, opponent attacker
+
+      // Act: Opponent challenges Ward character
+
+      // Assert: Should succeed (Ward doesn't block challenges)
+      expect(true).toBe(false); // Will fail until Ward challenge exception implemented
+    });
+
+    /**
+     * Ward doesn't prevent effects that don't "choose" (e.g., "all characters").
+     */
+    test.failing("Rule 10.13 - Ward doesn't block non-choosing effects", () => {
+      // Arrange: Ward character, effect that damages "all characters"
+
+      // Act: Execute effect
+
+      // Assert: Ward character should be affected
+      expect(true).toBe(false); // Will fail until Ward choose distinction implemented
+    });
+
+    /**
+     * Ward only protects from opponents, not owner.
+     */
+    test.failing("Rule 10.13 - Ward doesn't block owner targeting", () => {
+      // Arrange: Ward character, owner effect that chooses character
+
+      // Act: Owner targets their Ward character
+
+      // Assert: Should succeed (Ward only blocks opponents)
+      expect(true).toBe(false); // Will fail until Ward owner exception implemented
+    });
+  });
+});