@drmxrcy/tcg-core 0.0.0-202602060542

package/src/cards/conditional-modifiers.test.ts

@@ -0,0 +1,390 @@
+import { describe, expect, it } from "bun:test";
+import { createCardRegistry } from "../operations/card-registry-impl";
+import { createCardId, createPlayerId, createZoneId } from "../types";
+import type { CardDefinition } from "./card-definition";
+import type { CardInstance } from "./card-instance";
+import { getCardPower } from "./computed-properties";
+import type { Modifier } from "./modifiers";
+
+type GameStateWithCards = {
+  // biome-ignore lint/suspicious/noExplicitAny: any required for test covariance
+  cards: Record<
+    string,
+    CardInstance<{ tapped: boolean; modifiers: Modifier<any>[] }>
+  >;
+};
+
+describe("Conditional Modifiers", () => {
+  describe("while-condition duration", () => {
+    it("should apply modifier when condition is true", () => {
+      const cardId = createCardId("card-1");
+
+      const definition: CardDefinition = {
+        id: "creature",
+        name: "Creature",
+        type: "creature",
+        basePower: 2,
+        abilities: [],
+      };
+
+      const registry = createCardRegistry([definition]);
+
+      const card: CardInstance<{
+        tapped: boolean;
+        modifiers: Modifier<GameStateWithCards>[];
+      }> = {
+        id: cardId,
+        definitionId: "creature",
+        owner: createPlayerId("player-1"),
+        controller: createPlayerId("player-1"),
+        zone: createZoneId("play"),
+        tapped: true, // Card is tapped
+        flipped: false,
+        revealed: false,
+        phased: false,
+        modifiers: [
+          {
+            id: "mod-1",
+            type: "stat",
+            property: "power",
+            value: 2,
+            duration: "while-condition",
+            condition: (state: GameStateWithCards) => {
+              const c = state.cards[String(cardId)];
+              return c?.tapped === true; // Only apply if tapped
+            },
+            source: createCardId("source-1"),
+          },
+        ],
+      };
+
+      const state: GameStateWithCards = {
+        cards: {
+          [String(cardId)]: card,
+        },
+      };
+
+      const power = getCardPower(card, state, registry);
+
+      expect(power).toBe(4); // 2 base + 2 from conditional modifier
+    });
+
+    it("should not apply modifier when condition is false", () => {
+      const cardId = createCardId("card-1");
+
+      const definition: CardDefinition = {
+        id: "creature",
+        name: "Creature",
+        type: "creature",
+        basePower: 2,
+        abilities: [],
+      };
+
+      const registry = createCardRegistry([definition]);
+
+      const card: CardInstance<{
+        tapped: boolean;
+        modifiers: Modifier<GameStateWithCards>[];
+      }> = {
+        id: cardId,
+        definitionId: "creature",
+        owner: createPlayerId("player-1"),
+        controller: createPlayerId("player-1"),
+        zone: createZoneId("play"),
+        tapped: false, // Card is NOT tapped
+        flipped: false,
+        revealed: false,
+        phased: false,
+        modifiers: [
+          {
+            id: "mod-1",
+            type: "stat",
+            property: "power",
+            value: 2,
+            duration: "while-condition",
+            condition: (state: GameStateWithCards) => {
+              const c = state.cards[String(cardId)];
+              return c?.tapped === true; // Only apply if tapped
+            },
+            source: createCardId("source-1"),
+          },
+        ],
+      };
+
+      const state: GameStateWithCards = {
+        cards: {
+          [String(cardId)]: card,
+        },
+      };
+
+      const power = getCardPower(card, state, registry);
+
+      expect(power).toBe(2); // 2 base only, modifier not applied
+    });
+
+    it("should dynamically re-evaluate condition when state changes", () => {
+      const cardId = createCardId("card-1");
+
+      const definition: CardDefinition = {
+        id: "creature",
+        name: "Creature",
+        type: "creature",
+        basePower: 3,
+        abilities: [],
+      };
+
+      const registry = createCardRegistry([definition]);
+
+      const card: CardInstance<{
+        tapped: boolean;
+        modifiers: Modifier<GameStateWithCards>[];
+      }> = {
+        id: cardId,
+        definitionId: "creature",
+        owner: createPlayerId("player-1"),
+        controller: createPlayerId("player-1"),
+        zone: createZoneId("play"),
+        tapped: false,
+        flipped: false,
+        revealed: false,
+        phased: false,
+        modifiers: [
+          {
+            id: "mod-1",
+            type: "stat",
+            property: "power",
+            value: 2,
+            duration: "while-condition",
+            condition: (state: GameStateWithCards) => {
+              const c = state.cards[String(cardId)];
+              return c?.tapped === true;
+            },
+            source: createCardId("source-1"),
+          },
+        ],
+      };
+
+      // Initial state: card is untapped
+      const state1: GameStateWithCards = {
+        cards: {
+          [String(cardId)]: card,
+        },
+      };
+
+      const power1 = getCardPower(card, state1, registry);
+      expect(power1).toBe(3); // Base power only
+
+      // State changes: card becomes tapped
+      const tappedCard = { ...card, tapped: true };
+      const state2: GameStateWithCards = {
+        cards: {
+          [String(cardId)]: tappedCard,
+        },
+      };
+
+      const power2 = getCardPower(tappedCard, state2, registry);
+      expect(power2).toBe(5); // Base + conditional modifier
+    });
+
+    it("should handle multiple conditional modifiers independently", () => {
+      const cardId = createCardId("card-1");
+
+      const definition: CardDefinition = {
+        id: "creature",
+        name: "Creature",
+        type: "creature",
+        basePower: 1,
+        abilities: [],
+      };
+
+      const registry = createCardRegistry([definition]);
+
+      const card: CardInstance<{
+        tapped: boolean;
+        modifiers: Modifier<GameStateWithCards>[];
+      }> = {
+        id: cardId,
+        definitionId: "creature",
+        owner: createPlayerId("player-1"),
+        controller: createPlayerId("player-1"),
+        zone: createZoneId("play"),
+        tapped: true,
+        flipped: false,
+        revealed: false,
+        phased: false,
+        modifiers: [
+          {
+            id: "mod-1",
+            type: "stat",
+            property: "power",
+            value: 2,
+            duration: "while-condition",
+            condition: (state: GameStateWithCards) => {
+              const c = state.cards[String(cardId)];
+              return c?.tapped === true; // Applies when tapped
+            },
+            source: createCardId("source-1"),
+          },
+          {
+            id: "mod-2",
+            type: "stat",
+            property: "power",
+            value: 3,
+            duration: "while-condition",
+            condition: (state: GameStateWithCards) => {
+              const c = state.cards[String(cardId)];
+              return c?.tapped === false; // Applies when NOT tapped
+            },
+            source: createCardId("source-2"),
+          },
+        ],
+      };
+
+      const state: GameStateWithCards = {
+        cards: {
+          [String(cardId)]: card,
+        },
+      };
+
+      const power = getCardPower(card, state, registry);
+
+      // Card is tapped, so first modifier applies (+2), second doesn't
+      expect(power).toBe(3); // 1 base + 2 from first modifier
+    });
+
+    it("should handle complex condition logic", () => {
+      const cardId = createCardId("card-1");
+      const otherCardId = createCardId("card-2");
+
+      const definition: CardDefinition = {
+        id: "creature",
+        name: "Creature",
+        type: "creature",
+        basePower: 2,
+        abilities: [],
+      };
+
+      const registry = createCardRegistry([definition]);
+
+      const card: CardInstance<{
+        tapped: boolean;
+        modifiers: Modifier<GameStateWithCards>[];
+      }> = {
+        id: cardId,
+        definitionId: "creature",
+        owner: createPlayerId("player-1"),
+        controller: createPlayerId("player-1"),
+        zone: createZoneId("play"),
+        tapped: false,
+        flipped: false,
+        revealed: false,
+        phased: false,
+        modifiers: [
+          {
+            id: "mod-1",
+            type: "stat",
+            property: "power",
+            value: 3,
+            duration: "while-condition",
+            condition: (state: GameStateWithCards) => {
+              // Complex condition: +3 power if there's another tapped card
+              const otherCard = state.cards[String(otherCardId)];
+              return otherCard?.tapped === true;
+            },
+            source: createCardId("source-1"),
+          },
+        ],
+      };
+
+      const otherCard: CardInstance<{
+        tapped: boolean;
+        modifiers: Modifier[];
+      }> = {
+        id: otherCardId,
+        definitionId: "creature",
+        owner: createPlayerId("player-1"),
+        controller: createPlayerId("player-1"),
+        zone: createZoneId("play"),
+        tapped: true, // This card is tapped
+        flipped: false,
+        revealed: false,
+        phased: false,
+        modifiers: [],
+      };
+
+      const state: GameStateWithCards = {
+        cards: {
+          [String(cardId)]: card,
+          [String(otherCardId)]: otherCard,
+        },
+      };
+
+      const power = getCardPower(card, state, registry);
+
+      expect(power).toBe(5); // 2 base + 3 from conditional (other card is tapped)
+    });
+
+    it("should mix conditional and unconditional modifiers correctly", () => {
+      const cardId = createCardId("card-1");
+
+      const definition: CardDefinition = {
+        id: "creature",
+        name: "Creature",
+        type: "creature",
+        basePower: 1,
+        abilities: [],
+      };
+
+      const registry = createCardRegistry([definition]);
+
+      const card: CardInstance<{
+        tapped: boolean;
+        modifiers: Modifier<GameStateWithCards>[];
+      }> = {
+        id: cardId,
+        definitionId: "creature",
+        owner: createPlayerId("player-1"),
+        controller: createPlayerId("player-1"),
+        zone: createZoneId("play"),
+        tapped: false,
+        flipped: false,
+        revealed: false,
+        phased: false,
+        modifiers: [
+          {
+            id: "mod-1",
+            type: "stat",
+            property: "power",
+            value: 2,
+            duration: "permanent",
+            source: createCardId("source-1"),
+            // No condition - always applies
+          },
+          {
+            id: "mod-2",
+            type: "stat",
+            property: "power",
+            value: 3,
+            duration: "while-condition",
+            condition: (state: GameStateWithCards) => {
+              const c = state.cards[String(cardId)];
+              return c?.tapped === true; // Only applies if tapped
+            },
+            source: createCardId("source-2"),
+          },
+        ],
+      };
+
+      const state: GameStateWithCards = {
+        cards: {
+          [String(cardId)]: card,
+        },
+      };
+
+      const power = getCardPower(card, state, registry);
+
+      // Card is NOT tapped: 1 base + 2 permanent modifier (conditional doesn't apply)
+      expect(power).toBe(3);
+    });
+  });
+});

package/src/cards/modifiers.test.ts

@@ -0,0 +1,286 @@
+import { describe, expect, it } from "bun:test";
+import { createCardId } from "../types";
+import type { Modifier } from "./modifiers";
+
+describe("Modifier System", () => {
+  describe("Modifier Type", () => {
+    it("should define stat modifier with all required fields", () => {
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 2,
+        duration: "permanent",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.id).toBe("mod-1");
+      expect(modifier.type).toBe("stat");
+      expect(modifier.property).toBe("power");
+      expect(modifier.value).toBe(2);
+      expect(modifier.duration).toBe("permanent");
+      expect(modifier.source).toBeDefined();
+    });
+
+    it("should support stat modifier type", () => {
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 3,
+        duration: "permanent",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.type).toBe("stat");
+      expect(typeof modifier.value).toBe("number");
+    });
+
+    it("should support ability modifier type", () => {
+      const modifier: Modifier = {
+        id: "mod-2",
+        type: "ability",
+        property: "flying",
+        value: true,
+        duration: "until-end-of-turn",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.type).toBe("ability");
+      expect(typeof modifier.value).toBe("boolean");
+    });
+
+    it("should support type modifier type", () => {
+      const modifier: Modifier = {
+        id: "mod-3",
+        type: "type",
+        property: "creature-type",
+        value: "zombie",
+        duration: "permanent",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.type).toBe("type");
+      expect(typeof modifier.value).toBe("string");
+    });
+
+    it("should support keyword modifier type", () => {
+      const modifier: Modifier = {
+        id: "mod-4",
+        type: "keyword",
+        property: "haste",
+        value: true,
+        duration: "until-end-of-turn",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.type).toBe("keyword");
+    });
+
+    it("should support permanent duration", () => {
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 1,
+        duration: "permanent",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.duration).toBe("permanent");
+    });
+
+    it("should support until-end-of-turn duration", () => {
+      const modifier: Modifier = {
+        id: "mod-2",
+        type: "stat",
+        property: "power",
+        value: 2,
+        duration: "until-end-of-turn",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.duration).toBe("until-end-of-turn");
+    });
+
+    it("should support while-condition duration", () => {
+      const modifier: Modifier = {
+        id: "mod-3",
+        type: "stat",
+        property: "power",
+        value: 3,
+        duration: "while-condition",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.duration).toBe("while-condition");
+    });
+
+    it("should support optional condition function", () => {
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 2,
+        duration: "while-condition",
+        condition: () => true,
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.condition).toBeDefined();
+      expect(typeof modifier.condition).toBe("function");
+      expect(modifier.condition?.({} as never)).toBe(true);
+    });
+
+    it("should support optional layer for complex interactions", () => {
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 2,
+        duration: "permanent",
+        source: createCardId("card-1"),
+        layer: 7,
+      };
+
+      expect(modifier.layer).toBe(7);
+    });
+
+    it("should work without optional fields", () => {
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 2,
+        duration: "permanent",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.condition).toBeUndefined();
+      expect(modifier.layer).toBeUndefined();
+    });
+  });
+
+  describe("Modifier Values", () => {
+    it("should support number values", () => {
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 5,
+        duration: "permanent",
+        source: createCardId("card-1"),
+      };
+
+      expect(typeof modifier.value).toBe("number");
+      expect(modifier.value).toBe(5);
+    });
+
+    it("should support negative number values", () => {
+      const modifier: Modifier = {
+        id: "mod-2",
+        type: "stat",
+        property: "power",
+        value: -2,
+        duration: "permanent",
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.value).toBe(-2);
+    });
+
+    it("should support string values", () => {
+      const modifier: Modifier = {
+        id: "mod-3",
+        type: "type",
+        property: "creature-type",
+        value: "dragon",
+        duration: "permanent",
+        source: createCardId("card-1"),
+      };
+
+      expect(typeof modifier.value).toBe("string");
+      expect(modifier.value).toBe("dragon");
+    });
+
+    it("should support boolean values", () => {
+      const modifier: Modifier = {
+        id: "mod-4",
+        type: "ability",
+        property: "flying",
+        value: true,
+        duration: "permanent",
+        source: createCardId("card-1"),
+      };
+
+      expect(typeof modifier.value).toBe("boolean");
+      expect(modifier.value).toBe(true);
+    });
+  });
+
+  describe("Modifier Source Tracking", () => {
+    it("should track source card", () => {
+      const sourceCard = createCardId("source-1");
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 2,
+        duration: "permanent",
+        source: sourceCard,
+      };
+
+      expect(modifier.source).toBe(sourceCard);
+    });
+
+    it("should enforce CardId type for source", () => {
+      const sourceCard = createCardId("source-1");
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 2,
+        duration: "permanent",
+        source: sourceCard,
+      };
+
+      const _typeCheck: typeof sourceCard = modifier.source;
+      expect(modifier.source).toBe(sourceCard);
+    });
+  });
+
+  describe("Modifier Condition", () => {
+    it("should accept condition function that returns boolean", () => {
+      const modifier: Modifier = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 2,
+        duration: "while-condition",
+        condition: (state) => {
+          return state !== null;
+        },
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.condition).toBeDefined();
+      expect(modifier.condition?.({} as never)).toBe(true);
+    });
+
+    it("should support complex condition logic", () => {
+      type GameState = { cardTapped: boolean };
+      const modifier: Modifier<GameState> = {
+        id: "mod-1",
+        type: "stat",
+        property: "power",
+        value: 2,
+        duration: "while-condition",
+        condition: (state) => state.cardTapped === true,
+        source: createCardId("card-1"),
+      };
+
+      expect(modifier.condition?.({ cardTapped: true })).toBe(true);
+      expect(modifier.condition?.({ cardTapped: false })).toBe(false);
+    });
+  });
+});