@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/targeting/__tests__/real-cards-targeting.test.ts

@@ -0,0 +1,303 @@
+import { describe, expect, it } from "bun:test";
+import type {
+  CardId,
+  CardInstance,
+  CardRegistry,
+  PlayerId,
+  ZoneId,
+} from "@drmxrcy/tcg-core";
+import type { LorcanaCardDefinition } from "@drmxrcy/tcg-lorcana-types";
+import type { LorcanaCardMeta, LorcanaGameState } from "../../types/game-state";
+import { createTargetFiltersPredicate } from "../filter-resolver";
+import type { LorcanaFilter } from "../lorcana-target-dsl";
+
+// --- Mock Data Setup ---
+
+const mockRegistry = {
+  getCard: (id: string) => mockDefinitions[id],
+} as unknown as CardRegistry<LorcanaCardDefinition>;
+
+const mockDefinitions: Record<string, LorcanaCardDefinition> = {
+  "char-villain": {
+    id: "char-villain",
+    name: "Maleficent",
+    cardType: "character",
+    classifications: ["Villain", "Sorcerer"],
+    cost: 3,
+    strength: 2,
+    willpower: 2,
+    lore: 1,
+    color: "amethyst",
+    inkable: true,
+  } as any,
+  "char-hero": {
+    id: "char-hero",
+    name: "Aladdin",
+    cardType: "character",
+    classifications: ["Hero", "Storyborn"],
+    cost: 2,
+    strength: 2,
+    willpower: 2,
+    lore: 1,
+    color: "ruby",
+    inkable: true,
+  } as any,
+  "char-high-str": {
+    id: "char-high-str",
+    name: "Maui",
+    cardType: "character",
+    classifications: ["Hero", "Demigod"],
+    cost: 5,
+    strength: 6,
+    willpower: 5,
+    lore: 2,
+    color: "ruby",
+    inkable: true,
+  } as any,
+  "item-basic": {
+    id: "item-basic",
+    name: "Dinglehopper",
+    cardType: "item",
+    cost: 1,
+    color: "emerald",
+    inkable: true,
+  } as any,
+  "loc-basic": {
+    id: "loc-basic",
+    name: "Forbidden Mountain",
+    cardType: "location",
+    cost: 2,
+    moveCost: 1,
+    willpower: 6,
+    lore: 1,
+    color: "amethyst",
+    inkable: true,
+  } as any,
+  "char-support": {
+    id: "char-support",
+    name: "Alice",
+    cardType: "character",
+    abilities: [{ type: "keyword", keyword: "Support" }],
+    cost: 3,
+    strength: 2,
+    willpower: 2,
+    lore: 1,
+    color: "sapphire",
+    inkable: true,
+  } as any,
+};
+
+const mockState: LorcanaGameState = {
+  playerIds: ["player1" as PlayerId, "player2" as PlayerId],
+  turnNumber: 1,
+  activePlayerId: "player1" as PlayerId,
+  cards: {}, // Populated per test
+} as any;
+
+const makeCard = (
+  id: string,
+  defId: string,
+  ownerId: string,
+  updates: Partial<LorcanaCardMeta> = {},
+): CardInstance<LorcanaCardMeta> => ({
+  id: id as CardId,
+  definitionId: defId,
+  owner: ownerId as PlayerId,
+  controller: ownerId as PlayerId,
+  zone: "play" as ZoneId,
+  tapped: false,
+  flipped: false,
+  revealed: true,
+  phased: false,
+  // Custom State Mixed In
+  state: "ready",
+  damage: 0,
+  isDrying: false,
+  ...updates,
+});
+
+// --- Tests ---
+
+describe("Real Card Targeting Scenarios", () => {
+  const p1Villain = makeCard("c1", "char-villain", "player1");
+  const p2Hero = makeCard("c2", "char-hero", "player2");
+  const p2DamagedHero = makeCard("c3", "char-hero", "player2", { damage: 2 });
+  const p1ExertedVillain = makeCard("c4", "char-villain", "player1", {
+    state: "exerted",
+  });
+  const p1HighStr = makeCard("c5", "char-high-str", "player1");
+  const p1Item = makeCard("i1", "item-basic", "player1");
+  const p2Location = makeCard("l1", "loc-basic", "player2");
+
+  const cards = [
+    p1Villain,
+    p2Hero,
+    p2DamagedHero,
+    p1ExertedVillain,
+    p1HighStr,
+    p1Item,
+    p2Location,
+  ];
+
+  // Helper to filter cards
+  const filterCards = (filters: LorcanaFilter[]) => {
+    const predicate = createTargetFiltersPredicate(
+      filters,
+      mockState,
+      mockRegistry,
+    );
+    return cards.filter(predicate);
+  };
+
+  it("should handle 'chosen Villain character'", () => {
+    // "Banish chosen Villain character"
+    const filters: LorcanaFilter[] = [
+      { type: "card-type", value: "character" },
+      { type: "has-classification", classification: "Villain" },
+    ];
+
+    const results = filterCards(filters);
+    expect(results.map((c) => c.id)).toEqual(
+      expect.arrayContaining(["c1", "c4"]),
+    );
+    expect(results).not.toContain(p2Hero); // Not a Villain
+  });
+
+  it("should handle 'chosen damaged character'", () => {
+    // "Banish chosen damaged character"
+    const filters: LorcanaFilter[] = [
+      { type: "card-type", value: "character" },
+      { type: "damaged" },
+    ];
+
+    const results = filterCards(filters);
+    expect(results.map((c) => c.id)).toContain("c3" as CardId); // p2DamagedHero
+    expect(results).not.toContain(p1Villain); // Not damaged
+  });
+
+  it("should handle 'chosen item'", () => {
+    // "Banish chosen item"
+    const filters: LorcanaFilter[] = [{ type: "card-type", value: "item" }];
+    const results = filterCards(filters);
+    expect(results.map((c) => c.id)).toEqual(["i1"] as CardId[]);
+  });
+
+  it("should handle 'chosen location or item'", () => {
+    // "Banish chosen location or item"
+    const filters: LorcanaFilter[] = [
+      {
+        type: "or",
+        filters: [
+          { type: "card-type", value: "location" },
+          { type: "card-type", value: "item" },
+        ],
+      },
+    ];
+
+    const results = filterCards(filters);
+    expect(results.map((c) => c.id)).toEqual(
+      expect.arrayContaining(["i1", "l1"]),
+    );
+    expect(results).not.toContain(p1Villain);
+  });
+
+  it("should handle 'chosen character with cost 3 or more'", () => {
+    // "characters with cost 3 or more"
+    const filters: LorcanaFilter[] = [
+      { type: "card-type", value: "character" },
+      { type: "cost", comparison: "gte", value: 3 },
+    ];
+
+    const results = filterCards(filters);
+    // p1Villain (cost 3), p1HighStr (cost 5)
+    expect(results.map((c) => c.id)).toEqual(
+      expect.arrayContaining(["c1", "c4", "c5"]),
+    );
+    expect(results).not.toContain(p2Hero); // Cost 2
+  });
+
+  it("should handle 'chosen character with Strength 3 or less'", () => {
+    // "chosen character with 3 strength or less"
+    const filters: LorcanaFilter[] = [
+      { type: "card-type", value: "character" },
+      { type: "strength", comparison: "lte", value: 3 },
+    ];
+
+    const results = filterCards(filters);
+    // p1Villain (2), p2Hero (2), p2DamagedHero (2)
+    expect(results.map((c) => c.id)).toEqual(
+      expect.arrayContaining(["c1", "c2", "c3", "c4"]),
+    );
+    expect(results).not.toContain(p1HighStr); // Str 6
+  });
+
+  it("should handle 'chosen character named X'", () => {
+    // "chosen character named Aladdin"
+    const filters: LorcanaFilter[] = [
+      { type: "card-type", value: "character" },
+      { type: "name", equals: "Aladdin" },
+    ];
+
+    const results = filterCards(filters);
+    expect(results.map((c) => c.id)).toEqual(
+      expect.arrayContaining(["c2", "c3"]),
+    );
+    expect(results).not.toContain(p1Villain);
+  });
+
+  it("should handle 'exerted chosen damaged character'", () => {
+    // "Exert chosen damaged character" - targeting implies filter
+    // Actually command exerts it, but filter selects it.
+    // But maybe "chosen exerted character"?
+    // Let's test "chosen exerted character"
+    const filters: LorcanaFilter[] = [
+      { type: "card-type", value: "character" },
+      { type: "exerted" },
+    ];
+    const results = filterCards(filters);
+    expect(results.map((c) => c.id)).toEqual(["c4"] as CardId[]);
+  });
+
+  it("should handle composite logic: 'Item OR (Character AND Villain)'", () => {
+    // Complex arbitrary test
+    const filters: LorcanaFilter[] = [
+      {
+        type: "or",
+        filters: [
+          { type: "card-type", value: "item" },
+          {
+            type: "and",
+            filters: [
+              { type: "card-type", value: "character" },
+              { type: "has-classification", classification: "Villain" },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const results = filterCards(filters);
+    // Should define p1Item, p1Villain, p1ExertedVillain
+    expect(results.map((c) => c.id)).toEqual(
+      expect.arrayContaining(["i1", "c1", "c4"]),
+    );
+    expect(results).not.toContain(p2Hero);
+    expect(results).not.toContain(p2Location);
+  });
+
+  it("should handle 'chosen character with Support'", () => {
+    // Mock a card with Support
+    const p1Support = makeCard("c6", "char-support", "player1");
+    // mockDefinitions["char-support"] is already defined in setup
+
+    cards.push(p1Support);
+
+    const filters: LorcanaFilter[] = [
+      { type: "has-keyword", keyword: "Support" },
+    ];
+
+    const results = filterCards(filters);
+    expect(results.map((c) => c.id)).toContain("c6" as CardId);
+    expect(results).not.toContain(p1Villain);
+  });
+});

package/src/targeting/__tests__/targeting-dsl.test.ts

@@ -0,0 +1,386 @@
+import { describe, expect, it } from "bun:test";
+import {
+  ALL_TARGET_ENUMS,
+  CHARACTER_TARGET_ENUMS,
+  type CharacterTarget,
+  type CharacterTargetEnum,
+  expandCharacterTarget,
+  expandItemTarget,
+  expandLocationTarget,
+  expandTarget,
+  generateTargetDescription,
+  getTargetUIHints,
+  ITEM_TARGET_ENUMS,
+  type ItemTargetEnum,
+  isCharacterEnum,
+  isDSLTarget,
+  LOCATION_TARGET_ENUMS,
+  type LocationTargetEnum,
+  type LorcanaCardTarget,
+  type LorcanaCharacterTarget,
+} from "../index";
+
+describe("Targeting DSL", () => {
+  describe("Enum Detection", () => {
+    it("should detect string enums", () => {
+      expect(isCharacterEnum("CHOSEN_CHARACTER")).toBe(true);
+      expect(isCharacterEnum("SELF")).toBe(true);
+      expect(isCharacterEnum("ALL_OPPOSING_CHARACTERS")).toBe(true);
+    });
+
+    it("should detect DSL objects", () => {
+      const dsl: LorcanaCardTarget = {
+        selector: "chosen",
+        count: 1,
+        cardType: "character",
+      };
+      expect(isDSLTarget(dsl)).toBe(true);
+      expect(isDSLTarget("CHOSEN_CHARACTER")).toBe(false);
+    });
+  });
+
+  describe("Character Target Expansion", () => {
+    it("should expand SELF enum", () => {
+      const expanded = expandCharacterTarget("SELF");
+      expect(expanded).toMatchObject({
+        selector: "self",
+        cardType: "character",
+        context: { self: true },
+      });
+    });
+
+    it("should expand CHOSEN_CHARACTER enum", () => {
+      const expanded = expandCharacterTarget("CHOSEN_CHARACTER");
+      expect(expanded).toMatchObject({
+        selector: "chosen",
+        count: 1,
+        owner: "any",
+        cardType: "character",
+        zones: ["play"],
+      });
+    });
+
+    it("should expand CHOSEN_OPPOSING_CHARACTER enum", () => {
+      const expanded = expandCharacterTarget("CHOSEN_OPPOSING_CHARACTER");
+      expect(expanded).toMatchObject({
+        selector: "chosen",
+        count: 1,
+        owner: "opponent",
+        cardType: "character",
+        zones: ["play"],
+      });
+    });
+
+    it("should expand ALL_OPPOSING_CHARACTERS enum", () => {
+      const expanded = expandCharacterTarget("ALL_OPPOSING_CHARACTERS");
+      expect(expanded).toMatchObject({
+        selector: "all",
+        count: "all",
+        owner: "opponent",
+        cardType: "character",
+        zones: ["play"],
+      });
+    });
+
+    it("should expand CHOSEN_DAMAGED_CHARACTER enum", () => {
+      const expanded = expandCharacterTarget("CHOSEN_DAMAGED_CHARACTER");
+      expect(expanded).toMatchObject({
+        selector: "chosen",
+        count: 1,
+        owner: "any",
+        cardType: "character",
+        zones: ["play"],
+        filters: [{ type: "damaged" }],
+      });
+    });
+
+    it("should expand ANOTHER_CHOSEN_CHARACTER enum", () => {
+      const expanded = expandCharacterTarget("ANOTHER_CHOSEN_CHARACTER");
+      expect(expanded).toMatchObject({
+        selector: "chosen",
+        count: 1,
+        excludeSelf: true,
+      });
+    });
+
+    it("should return DSL object unchanged", () => {
+      const dsl: CharacterTarget = {
+        selector: "chosen",
+        count: 2,
+        owner: "opponent",
+        cardType: "character",
+        filters: [{ type: "exerted" }],
+      };
+      const expanded = expandCharacterTarget(dsl);
+      expect(expanded).toBe(dsl);
+    });
+
+    it("should expand all character enum values", () => {
+      for (const enumValue of CHARACTER_TARGET_ENUMS) {
+        const expanded = expandCharacterTarget(
+          enumValue as CharacterTargetEnum,
+        );
+        expect(expanded).toBeDefined();
+        expect(expanded.cardType).toBe("character");
+      }
+    });
+  });
+
+  describe("Item Target Expansion", () => {
+    it("should expand CHOSEN_ITEM enum", () => {
+      const expanded = expandItemTarget("CHOSEN_ITEM");
+      expect(expanded).toMatchObject({
+        selector: "chosen",
+        count: 1,
+        owner: "any",
+        cardType: "item",
+        zones: ["play"],
+      });
+    });
+
+    it("should expand THIS_ITEM enum", () => {
+      const expanded = expandItemTarget("THIS_ITEM");
+      expect(expanded).toMatchObject({
+        selector: "self",
+        cardType: "item",
+        context: { self: true },
+      });
+    });
+
+    it("should expand all item enum values", () => {
+      for (const enumValue of ITEM_TARGET_ENUMS) {
+        const expanded = expandItemTarget(enumValue as ItemTargetEnum);
+        expect(expanded).toBeDefined();
+        expect(expanded.cardType).toBe("item");
+      }
+    });
+  });
+
+  describe("Location Target Expansion", () => {
+    it("should expand CHOSEN_LOCATION enum", () => {
+      const expanded = expandLocationTarget("CHOSEN_LOCATION");
+      expect(expanded).toMatchObject({
+        selector: "chosen",
+        count: 1,
+        owner: "any",
+        cardType: "location",
+        zones: ["play"],
+      });
+    });
+
+    it("should expand THIS_LOCATION enum", () => {
+      const expanded = expandLocationTarget("THIS_LOCATION");
+      expect(expanded).toMatchObject({
+        selector: "self",
+        cardType: "location",
+        context: { self: true },
+      });
+    });
+
+    it("should expand all location enum values", () => {
+      for (const enumValue of LOCATION_TARGET_ENUMS) {
+        const expanded = expandLocationTarget(enumValue as LocationTargetEnum);
+        expect(expanded).toBeDefined();
+        expect(expanded.cardType).toBe("location");
+      }
+    });
+  });
+
+  describe("Generic Target Expansion", () => {
+    it("should expand any target enum", () => {
+      expect(expandTarget("CHOSEN_CHARACTER").cardType).toBe("character");
+      expect(expandTarget("CHOSEN_ITEM").cardType).toBe("item");
+      expect(expandTarget("CHOSEN_LOCATION").cardType).toBe("location");
+    });
+
+    it("should throw for unknown enum", () => {
+      expect(() => expandTarget("UNKNOWN" as any)).toThrow();
+    });
+  });
+
+  describe("Enum Registries", () => {
+    it("should have all character enums registered", () => {
+      expect(CHARACTER_TARGET_ENUMS.has("SELF")).toBe(true);
+      expect(CHARACTER_TARGET_ENUMS.has("CHOSEN_CHARACTER")).toBe(true);
+      expect(CHARACTER_TARGET_ENUMS.has("ALL_OPPOSING_CHARACTERS")).toBe(true);
+    });
+
+    it("should have all item enums registered", () => {
+      expect(ITEM_TARGET_ENUMS.has("CHOSEN_ITEM")).toBe(true);
+      expect(ITEM_TARGET_ENUMS.has("YOUR_ITEMS")).toBe(true);
+    });
+
+    it("should have all location enums registered", () => {
+      expect(LOCATION_TARGET_ENUMS.has("CHOSEN_LOCATION")).toBe(true);
+      expect(LOCATION_TARGET_ENUMS.has("YOUR_LOCATIONS")).toBe(true);
+    });
+
+    it("should have complete ALL_TARGET_ENUMS", () => {
+      expect(ALL_TARGET_ENUMS.size).toBe(
+        CHARACTER_TARGET_ENUMS.size +
+          ITEM_TARGET_ENUMS.size +
+          LOCATION_TARGET_ENUMS.size,
+      );
+    });
+  });
+});
+
+describe("Target Description Generation", () => {
+  it("should describe CHOSEN_CHARACTER", () => {
+    const desc = generateTargetDescription("CHOSEN_CHARACTER");
+    expect(desc).toBe("a character");
+  });
+
+  it("should describe CHOSEN_OPPOSING_CHARACTER", () => {
+    const desc = generateTargetDescription("CHOSEN_OPPOSING_CHARACTER");
+    expect(desc).toBe("an opposing character");
+  });
+
+  it("should describe ALL_OPPOSING_CHARACTERS", () => {
+    const desc = generateTargetDescription("ALL_OPPOSING_CHARACTERS");
+    expect(desc).toBe("all opposing characters");
+  });
+
+  it("should describe CHOSEN_DAMAGED_CHARACTER", () => {
+    const desc = generateTargetDescription("CHOSEN_DAMAGED_CHARACTER");
+    expect(desc).toBe("a damaged character");
+  });
+
+  it("should describe YOUR_CHARACTERS", () => {
+    const desc = generateTargetDescription("YOUR_CHARACTERS");
+    expect(desc).toBe("all your characters");
+  });
+
+  it("should describe SELF", () => {
+    const desc = generateTargetDescription("SELF");
+    expect(desc).toBe("this character");
+  });
+
+  it("should describe complex DSL with filters", () => {
+    const dsl: LorcanaCharacterTarget = {
+      selector: "chosen",
+      count: 2,
+      owner: "opponent",
+      cardType: "character",
+      filters: [
+        { type: "damaged" },
+        { type: "cost", comparison: "lte", value: 3 },
+      ],
+    };
+    const desc = generateTargetDescription(dsl);
+    expect(desc).toContain("opposing");
+    expect(desc).toContain("damaged");
+    expect(desc).toContain("character");
+    expect(desc).toContain("cost");
+  });
+
+  it("should describe DSL with keyword filter", () => {
+    const dsl: LorcanaCharacterTarget = {
+      selector: "all",
+      owner: "you",
+      cardType: "character",
+      filters: [{ type: "has-keyword", keyword: "Evasive" }],
+    };
+    const desc = generateTargetDescription(dsl);
+    expect(desc).toContain("your");
+    expect(desc).toContain("Evasive");
+    expect(desc).toContain("characters");
+  });
+});
+
+describe("Target UI Hints", () => {
+  it("should generate single selection hints for CHOSEN_CHARACTER", () => {
+    const hints = getTargetUIHints("CHOSEN_CHARACTER");
+    expect(hints.selectionType).toBe("single");
+    expect(hints.minSelections).toBe(1);
+    expect(hints.maxSelections).toBe(1);
+    expect(hints.optional).toBe(false);
+  });
+
+  it("should generate automatic hints for ALL_OPPOSING_CHARACTERS", () => {
+    const hints = getTargetUIHints("ALL_OPPOSING_CHARACTERS");
+    expect(hints.selectionType).toBe("automatic");
+    expect(hints.ownerFilter).toBe("opponent");
+  });
+
+  it("should generate no selection for SELF", () => {
+    const hints = getTargetUIHints("SELF");
+    expect(hints.selectionType).toBe("none");
+  });
+
+  it("should generate multiple selection hints for up-to count", () => {
+    const dsl: LorcanaCharacterTarget = {
+      selector: "chosen",
+      count: { upTo: 3 },
+      cardType: "character",
+    };
+    const hints = getTargetUIHints(dsl);
+    expect(hints.selectionType).toBe("multiple");
+    expect(hints.minSelections).toBe(0);
+    expect(hints.maxSelections).toBe(3);
+    expect(hints.optional).toBe(true);
+  });
+
+  it("should include card type in hints", () => {
+    const hints = getTargetUIHints("CHOSEN_ITEM");
+    expect(hints.cardType).toBe("item");
+  });
+
+  it("should include owner filter in hints", () => {
+    const hints = getTargetUIHints("CHOSEN_OPPOSING_CHARACTER");
+    expect(hints.ownerFilter).toBe("opponent");
+  });
+
+  it("should include prompt text", () => {
+    const hints = getTargetUIHints("CHOSEN_CHARACTER");
+    expect(hints.prompt).toContain("Choose");
+  });
+});
+
+describe("Complex DSL Creation", () => {
+  it("should create complex character target", () => {
+    const target: LorcanaCardTarget = {
+      selector: "chosen",
+      count: { upTo: 2 },
+      owner: "opponent",
+      cardType: "character",
+      zones: ["play"],
+      filters: [
+        { type: "damaged" },
+        { type: "strength", comparison: "lte", value: 3 },
+      ],
+    };
+
+    expect(target.selector).toBe("chosen");
+    expect(target.owner).toBe("opponent");
+    expect(target.filters).toHaveLength(2);
+  });
+
+  it("should create target with context reference", () => {
+    const target: LorcanaCardTarget = {
+      selector: "self",
+      cardType: "character",
+      context: {
+        self: true,
+        triggerSource: false,
+      },
+    };
+
+    expect(target.context?.self).toBe(true);
+  });
+
+  it("should create target with composite filters", () => {
+    const target: LorcanaCardTarget = {
+      selector: "all",
+      cardType: "character",
+      filters: [
+        {
+          type: "or",
+          filters: [{ type: "damaged" }, { type: "exerted" }],
+        },
+      ],
+    };
+
+    expect(target.filters?.[0].type).toBe("or");
+  });
+});