@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/__tests__/rules/section-07-abilities.test.ts

@@ -0,0 +1,333 @@
+/**
+ * Section 7: Abilities
+ *
+ * Tests for rules 7.1-7.8 from Disney Lorcana Comprehensive Rules (Aug 22, 2025)
+ * Covers General ability rules, Action Cards, Keywords, Triggered Abilities,
+ * Activated Abilities, Static Abilities, Replacement Effects, and Ability Modifiers.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  LorcanaTestEngine,
+  PLAYER_ONE,
+  PLAYER_TWO,
+} from "../../testing/lorcana-test-engine";
+
+describe("Section 7: Abilities", () => {
+  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("7.1. General", () => {
+    /**
+     * Rule 7.1.1: Abilities can have multiple clauses separated by periods or commas.
+     */
+    test.failing("Rule 7.1.1 - Multiple clauses in abilities", () => {
+      // Arrange: Ability with multiple clauses
+      // e.g., "Draw 2 cards. Deal 2 damage to chosen character."
+
+      // Assert: Each clause should resolve in order
+      expect(true).toBe(false); // Will fail until multi-clause parsing implemented
+    });
+
+    /**
+     * Rule 7.1.2: "May" means the player can choose not to do it.
+     */
+    test.failing("Rule 7.1.2 - 'May' is optional", () => {
+      // Arrange: Ability with "may"
+      // e.g., "You may draw a card"
+
+      // Act: Choose not to do it
+
+      // Assert: Should be valid to skip
+      expect(true).toBe(false); // Will fail until optional handling implemented
+    });
+
+    /**
+     * Rule 7.1.3: "Put into hand" is different from "draw" (not affected by draw prevention).
+     */
+    test.failing("Rule 7.1.3 - Put into hand is not drawing", () => {
+      // Arrange: Effect that prevents drawing, effect that puts into hand
+
+      // Act: Use put into hand effect
+
+      // Assert: Should still work despite draw prevention
+      expect(true).toBe(false); // Will fail until put vs draw distinction implemented
+    });
+
+    /**
+     * Rule 7.1.4: "Other" or "Another" means a different card than the source.
+     */
+    test.failing("Rule 7.1.4 - 'Other' excludes the source card", () => {
+      // Arrange: Ability that affects "other characters"
+
+      // Assert: Should not affect the card with the ability
+      expect(true).toBe(false); // Will fail until other/another targeting implemented
+    });
+
+    /**
+     * Rule 7.1.5: Playing cards while resolving abilities requires explicit permission.
+     */
+    test.failing("Rule 7.1.5 - Cannot play cards during ability resolution", () => {
+      // Arrange: Resolving an ability
+
+      // Act: Try to play a card
+
+      // Assert: Should fail unless ability grants permission
+      expect(true).toBe(false); // Will fail until resolution timing implemented
+    });
+
+    /**
+     * Rule 7.1.6: Loops - If a loop would occur with no way to end, it ends immediately.
+     */
+    test.failing("Rule 7.1.6 - Infinite loops end immediately", () => {
+      // Arrange: Set up potential infinite loop
+
+      // Assert: Loop should be broken
+      expect(true).toBe(false); // Will fail until loop detection implemented
+    });
+
+    /**
+     * Rule 7.1.7: "Up to" allows choosing any number from 0 to the stated maximum.
+     */
+    test.failing("Rule 7.1.7 - 'Up to' includes 0", () => {
+      // Arrange: Effect with "up to 3"
+
+      // Act: Choose 0
+
+      // Assert: Should be valid
+      expect(true).toBe(false); // Will fail until up-to handling implemented
+    });
+
+    /**
+     * Rule 7.1.8: "That" refers back to a previously mentioned card/target.
+     */
+    test.failing("Rule 7.1.8 - 'That' references previous target", () => {
+      // Arrange: Effect that chooses target, then refers to "that character"
+
+      // Assert: "That" should reference the chosen target
+      expect(true).toBe(false); // Will fail until reference tracking implemented
+    });
+
+    /**
+     * Rule 7.1.9: Revealing cards shows them to all players.
+     */
+    test.failing("Rule 7.1.9 - Revealed cards visible to all", () => {
+      // Arrange: Effect that reveals cards
+
+      // Assert: Both players should see revealed cards
+      expect(true).toBe(false); // Will fail until reveal visibility implemented
+    });
+  });
+
+  describe("7.2. Action Cards", () => {
+    /**
+     * Action cards have effects, not abilities.
+     * Effects resolve immediately and don't use the bag.
+     */
+    test.failing("Rule 7.2 - Action effects resolve immediately", () => {
+      // Arrange: Play action card
+
+      // Assert: Effect should resolve without entering bag
+      expect(true).toBe(false); // Will fail until action resolution implemented
+    });
+  });
+
+  describe("7.3. Keywords", () => {
+    /**
+     * Rule 7.3.1: Keywords are words/phrases representing larger abilities.
+     */
+    test.failing("Rule 7.3.1 - Keywords expand to full abilities", () => {
+      // Arrange: Character with "Bodyguard"
+
+      // Assert: Should have the full Bodyguard ability effect
+      expect(true).toBe(false); // Will fail until keyword expansion implemented
+    });
+
+    /**
+     * Rule 7.3.2: Reminder text (in italics) isn't rules text - just memory aid.
+     */
+    test.failing("Rule 7.3.2 - Reminder text not used for rules", () => {
+      // Assert: Reminder text should be ignored in effect resolution
+      expect(true).toBe(false); // Will fail until reminder text stripping implemented
+    });
+  });
+
+  describe("7.4. Triggered Abilities", () => {
+    /**
+     * Rule 7.4.1: Triggered abilities look for specific conditions and fire when met.
+     */
+    test.failing("Rule 7.4.1 - Triggered abilities fire on condition", () => {
+      // Arrange: Character with "When this character quests, draw a card"
+
+      // Act: Quest with the character
+
+      // Assert: Trigger should fire, effect added to bag
+      expect(true).toBe(false); // Will fail until triggers implemented
+    });
+
+    /**
+     * Rule 7.4.2: Abilities with two trigger conditions need both to be met.
+     */
+    test.failing("Rule 7.4.2 - Multiple trigger conditions must all be met", () => {
+      // Arrange: Ability with "When X and Y"
+
+      // Act: Only satisfy one condition
+
+      // Assert: Should not trigger
+      expect(true).toBe(false); // Will fail until compound triggers implemented
+    });
+
+    /**
+     * Rule 7.4.3: Floating triggered abilities exist temporarily after source leaves.
+     */
+    test.failing("Rule 7.4.3 - Floating triggers persist after source leaves", () => {
+      // Arrange: Character with "When this character is banished" trigger
+
+      // Act: Banish the character
+
+      // Assert: Trigger should still resolve
+      expect(true).toBe(false); // Will fail until floating triggers implemented
+    });
+
+    /**
+     * Rule 7.4.4: Delayed triggered abilities are set up by effects.
+     */
+    test.failing("Rule 7.4.4 - Delayed triggers created by effects", () => {
+      // Arrange: Effect that creates "At end of turn, do X"
+
+      // Act: Reach end of turn
+
+      // Assert: Delayed trigger should fire
+      expect(true).toBe(false); // Will fail until delayed triggers implemented
+    });
+  });
+
+  describe("7.5. Activated Abilities", () => {
+    /**
+     * Rule 7.5.1: Activated abilities have a cost and effect.
+     */
+    test.failing("Rule 7.5.1 - Activated abilities require paying cost", () => {
+      // Arrange: Character with activated ability "{exert}: Draw a card"
+
+      // Act: Use the ability
+
+      // Assert: Cost (exert) should be paid, effect should occur
+      expect(true).toBe(false); // Will fail until activated abilities implemented
+    });
+
+    /**
+     * Rule 7.5.2: Costs must be paid before effect resolves.
+     */
+    test.failing("Rule 7.5.2 - Pay costs before effect", () => {
+      // Assert: If cost can't be paid, ability can't be used
+      expect(true).toBe(false); // Will fail until cost requirement verified
+    });
+
+    /**
+     * Rule 7.5.3: Steps to use activated ability:
+     * 1. Announce ability
+     * 2. Pay costs
+     * 3. Effect resolves
+     */
+    test.failing("Rule 7.5.3 - Activated ability resolution steps", () => {
+      // Assert: Steps should occur in order
+      expect(true).toBe(false); // Will fail until activation steps implemented
+    });
+  });
+
+  describe("7.6. Static Abilities", () => {
+    /**
+     * Rule 7.6.1: Static abilities are continuously active.
+     */
+    test.failing("Rule 7.6.1 - Static abilities always active", () => {
+      // Arrange: Character with "Your other characters get +1 strength"
+
+      // Assert: Effect should apply continuously while card in play
+      expect(true).toBe(false); // Will fail until static abilities implemented
+    });
+
+    /**
+     * Rule 7.6.2: Static abilities have duration (while in play or fixed time).
+     */
+    test.failing("Rule 7.6.2 - Static ability duration", () => {
+      // Arrange: Static ability
+
+      // Act: Remove card from play
+
+      // Assert: Effect should end
+      expect(true).toBe(false); // Will fail until static duration implemented
+    });
+
+    /**
+     * Rule 7.6.3: Timing - static abilities apply immediately when card enters.
+     */
+    test.failing("Rule 7.6.3 - Static abilities apply immediately", () => {
+      // Arrange: Play card with static ability
+
+      // Assert: Effect should apply right away
+      expect(true).toBe(false); // Will fail until static timing implemented
+    });
+
+    /**
+     * Rule 7.6.4: Some static abilities work outside of play (e.g., Shift).
+     */
+    test.failing("Rule 7.6.4 - Static abilities can work outside play", () => {
+      // Arrange: Card with Shift (works from hand)
+
+      // Assert: Shift should be usable from hand
+      expect(true).toBe(false); // Will fail until out-of-play statics implemented
+    });
+  });
+
+  describe("7.7. Replacement Effects", () => {
+    /**
+     * Rule 7.7.1: Replacement effects substitute one effect for another.
+     */
+    test.failing("Rule 7.7.1 - Replacement effects substitute", () => {
+      // Arrange: "If this character would be banished, return it to hand instead"
+
+      // Act: Try to banish the character
+
+      // Assert: Character should return to hand instead
+      expect(true).toBe(false); // Will fail until replacement effects implemented
+    });
+
+    /**
+     * Rule 7.7.2: "Skip" is a replacement effect that replaces with nothing.
+     */
+    test.failing("Rule 7.7.2 - Skip replaces with nothing", () => {
+      // Arrange: "Skip your draw step"
+
+      // Act: Reach draw step
+
+      // Assert: Draw should be skipped entirely
+      expect(true).toBe(false); // Will fail until skip effects implemented
+    });
+  });
+
+  describe("7.8. Ability Modifiers", () => {
+    /**
+     * Ability modifiers change how abilities work.
+     */
+    test.failing("Rule 7.8 - Ability modifiers", () => {
+      // Arrange: Effect that modifies abilities
+      // e.g., "Abilities can't be used"
+
+      // Act: Try to use ability
+
+      // Assert: Should be blocked by modifier
+      expect(true).toBe(false); // Will fail until ability modifiers implemented
+    });
+  });
+});

package/src/__tests__/rules/section-08-zones.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Section 8: Zones
+ *
+ * Tests for rules 8.1-8.7 from Disney Lorcana Comprehensive Rules (Aug 22, 2025)
+ * Covers General zone rules, Deck, Hand, Play, Inkwell, Discard, and Bag.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  LorcanaTestEngine,
+  PLAYER_ONE,
+  PLAYER_TWO,
+} from "../../testing/lorcana-test-engine";
+
+describe("Section 8: Zones", () => {
+  let testEngine: LorcanaTestEngine;
+
+  beforeEach(() => {
+    testEngine = new LorcanaTestEngine(
+      { hand: 7, deck: 53, inkwell: 0 },
+      { hand: 7, deck: 53, inkwell: 0 },
+      { skipPreGame: true },
+    );
+  });
+
+  afterEach(() => {
+    testEngine.dispose();
+  });
+
+  describe("8.1. General", () => {
+    /**
+     * Rule 8.1.1: Zones are places where cards exist during the game.
+     */
+    test.failing("Rule 8.1.1 - Cards exist in zones", () => {
+      // Assert: Every card should be in exactly one zone
+      expect(true).toBe(false); // Will fail until zone tracking verified
+    });
+
+    /**
+     * Rule 8.1.2: Public zones - all players can see cards.
+     * Private zones - only owner can see cards.
+     */
+    test.failing("Rule 8.1.2 - Public vs private zone visibility", () => {
+      // Assert: Play/Discard are public, Hand/Deck are private
+      expect(true).toBe(false); // Will fail until visibility system implemented
+    });
+
+    /**
+     * Rule 8.1.3: Fail to find - If an effect searches for a card that doesn't exist,
+     * the search fails but the effect continues.
+     */
+    test.failing("Rule 8.1.3 - Fail to find doesn't stop effect", () => {
+      // Arrange: Effect that searches for non-existent card
+
+      // Act: Execute effect
+
+      // Assert: Search fails gracefully, rest of effect continues
+      expect(true).toBe(false); // Will fail until fail-to-find implemented
+    });
+  });
+
+  describe("8.2. Deck", () => {
+    /**
+     * Rule 8.2.1: Deck is a private zone. Players can't look at cards in deck.
+     */
+    test.failing("Rule 8.2.1 - Deck is private", () => {
+      // Assert: Players shouldn't be able to view opponent's deck
+      expect(true).toBe(false); // Will fail until deck privacy implemented
+    });
+
+    /**
+     * Rule 8.2.2: When adding cards to top or bottom of deck, they go in order
+     * (first card mentioned goes to extreme position).
+     */
+    test.failing("Rule 8.2.2 - Deck ordering for top/bottom", () => {
+      // Arrange: Put cards A, B, C on top (in that order)
+
+      // Assert: Next draw should be C (last put on top = top)
+      expect(true).toBe(false); // Will fail until deck ordering implemented
+    });
+  });
+
+  describe("8.3. Hand", () => {
+    /**
+     * Rule 8.3.1: Hand is a private zone. Only the owner can see their hand.
+     */
+    test.failing("Rule 8.3.1 - Hand is private", () => {
+      // Assert: Opponent shouldn't see your hand
+      expect(true).toBe(false); // Will fail until hand privacy implemented
+    });
+
+    /**
+     * Hand has no size limit.
+     */
+    test.failing("Rule 8.3 - No hand size limit", () => {
+      // Assert: Player can have any number of cards in hand
+      expect(true).toBe(false); // Will fail until hand size verified
+    });
+  });
+
+  describe("8.4. Play", () => {
+    /**
+     * Rule 8.4.1: Play is a public zone where characters, items, and locations exist.
+     */
+    test.failing("Rule 8.4.1 - Play zone is public", () => {
+      // Assert: Both players can see cards in play
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 3,
+      });
+
+      // Both players should be able to see this character
+      expect(testEngine.getZone("play", PLAYER_ONE)).toContain(character);
+      expect(true).toBe(false); // Will fail until visibility verified
+    });
+
+    /**
+     * Rule 8.4.2: "In play" means the card is in the Play zone.
+     */
+    test.failing("Rule 8.4.2 - 'In play' means in Play zone", () => {
+      // Assert: Only cards in Play zone are "in play"
+      expect(true).toBe(false); // Will fail until in-play check implemented
+    });
+
+    /**
+     * Rule 8.4.3: Leaving play - when a card leaves play, all attached cards,
+     * damage, and effects on it are removed.
+     */
+    test.failing("Rule 8.4.3 - Leaving play clears damage and effects", () => {
+      // Arrange: Character with damage
+      const character = testEngine.createCharacterInPlay(PLAYER_ONE, {
+        strength: 2,
+        willpower: 5,
+      });
+
+      // Add damage somehow
+      // Then banish/return to hand
+
+      // Assert: Damage should be cleared when leaving play
+      expect(true).toBe(false); // Will fail until leaving play cleanup implemented
+    });
+  });
+
+  describe("8.5. Inkwell", () => {
+    /**
+     * Rule 8.5.1: Inkwell contains ink cards used to pay costs.
+     */
+    test.failing("Rule 8.5.1 - Inkwell holds ink for paying costs", () => {
+      // Arrange: Put cards in inkwell
+
+      // Act: Pay a cost
+
+      // Assert: Ink cards should exert to pay
+      expect(true).toBe(false); // Will fail until inkwell payment verified
+    });
+
+    /**
+     * Ink cards are placed facedown.
+     */
+    test.failing("Rule 8.5 - Ink cards are facedown", () => {
+      // Assert: Ink cards should be facedown (not visible)
+      expect(true).toBe(false); // Will fail until ink visibility implemented
+    });
+
+    /**
+     * Ink cards ready at start of turn.
+     */
+    test.failing("Rule 8.5 - Ink readies at turn start", () => {
+      // Arrange: Exert ink by paying cost
+
+      // Act: Pass turn, start new turn
+
+      // Assert: Ink should be ready again
+      expect(true).toBe(false); // Will fail until ink ready implemented
+    });
+  });
+
+  describe("8.6. Discard", () => {
+    /**
+     * Rule 8.6.1: Discard pile is a public zone.
+     */
+    test.failing("Rule 8.6.1 - Discard is public", () => {
+      // Assert: Both players can see discard pile
+      expect(true).toBe(false); // Will fail until discard visibility verified
+    });
+
+    /**
+     * Banished characters and used actions go to discard.
+     */
+    test.failing("Rule 8.6 - Banished cards go to discard", () => {
+      // Arrange: Banish a character
+
+      // Assert: Character should be in discard pile
+      expect(true).toBe(false); // Will fail until banish destination verified
+    });
+  });
+
+  describe("8.7. Bag", () => {
+    /**
+     * Rule 8.7.1: The bag holds triggered abilities waiting to resolve.
+     */
+    test.failing("Rule 8.7.1 - Bag holds triggered abilities", () => {
+      // Arrange: Trigger an ability
+
+      // Assert: Ability should be in bag waiting to resolve
+      expect(true).toBe(false); // Will fail until bag system implemented
+    });
+
+    /**
+     * Rule 8.7.2: Active player chooses which triggered ability to resolve first.
+     */
+    test.failing("Rule 8.7.2 - Active player chooses resolution order", () => {
+      // Arrange: Multiple triggers in bag
+
+      // Act: Active player selects order
+
+      // Assert: Triggers resolve in chosen order
+      expect(true).toBe(false); // Will fail until bag ordering implemented
+    });
+
+    /**
+     * Rule 8.7.3: Abilities from active player resolve before opponent's.
+     */
+    test.failing("Rule 8.7.3 - Active player's triggers first", () => {
+      // Arrange: Both players have triggered abilities
+
+      // Assert: Active player's resolve first
+      expect(true).toBe(false); // Will fail until bag priority implemented
+    });
+  });
+});