@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/resolvers/conditions/revealed.ts

@@ -0,0 +1,42 @@
+import type { RevealedMatchesNamedCondition } from "@drmxrcy/tcg-lorcana-types";
+import { conditionRegistry } from "../condition-registry";
+
+conditionRegistry.register<RevealedMatchesNamedCondition>(
+  "revealed-matches-named",
+  {
+    complexity: 40,
+    evaluate: (_condition, _sourceCard, { state, context, registry }) => {
+      const namedCard = state.external.namedCard;
+      if (!namedCard) return false;
+
+      // Check revealed cards in context
+      if (!context?.revealedCards || context.revealedCards.length === 0) {
+        return false;
+      }
+
+      // Usually checks the "top card" or just "the revealed card"
+      // We iterate all revealed cards in context. If any matches, we return true?
+      // Or stricter: "If IT matches". Usually implies a single card was revealed.
+      // We'll check if ANY of the revealed cards matches the name.
+
+      return context.revealedCards.some((cardId) => {
+        // We need lookup definition from registry using the card ID?
+        // context.revealedCards are IDs?
+        // Wait, context.revealedCards in DSL is string[]. Assuming IDs.
+
+        // We need to look up the card in state to get definitionId?
+        // Or if it's from deck, it might not be in state.cards yet?
+        // In Lorcana engine, usually cards in deck are fully instantiated or just definitions?
+        // If they are IDs, they should be in state.cards (even if in deck).
+
+        const card = state.internal.cards[cardId];
+        if (!card) return false;
+
+        const def = registry.getCard(card.definitionId);
+        if (!def) return false;
+
+        return def.name === namedCard || def.fullName === namedCard;
+      });
+    },
+  },
+);

package/src/resolvers/conditions/zone.ts

@@ -0,0 +1,84 @@
+import type { CardInstance, PlayerId } from "@drmxrcy/tcg-core";
+import type {
+  AtLocationCondition,
+  HasCharacterHereCondition,
+  HasNamedLocationCondition,
+  ZoneCondition,
+} from "@drmxrcy/tcg-lorcana-types";
+import type { LorcanaCardMeta } from "../../types/game-state";
+import { conditionRegistry } from "../condition-registry";
+
+conditionRegistry.register<ZoneCondition>("zone", {
+  complexity: 20,
+  evaluate: (condition, sourceCard, { state, registry }) => {
+    // Determine target controller
+    const targetControllerId =
+      condition.controller === "you"
+        ? sourceCard.controller
+        : (Object.keys(state.external.loreScores).find(
+            (id) => id !== sourceCard.controller,
+          ) as PlayerId);
+
+    if (!targetControllerId) return false;
+
+    // Filter cards
+    const matchingCards = Object.values(state.internal.cards).filter((c) => {
+      if (c.controller !== targetControllerId) return false;
+      if (c.zone !== condition.zone) return false;
+
+      // Registry check
+      if (condition.cardType || condition.cardName) {
+        const def = registry.getCard(c.definitionId);
+        if (!def) return false;
+        if (condition.cardType && def.cardType !== condition.cardType)
+          return false;
+        if (condition.cardName && def.name !== condition.cardName) return false;
+      }
+
+      return true;
+    });
+
+    if (condition.hasCards !== undefined) {
+      return matchingCards.length > 0 === condition.hasCards;
+    }
+
+    return matchingCards.length > 0;
+  },
+});
+
+conditionRegistry.register<AtLocationCondition>("at-location", {
+  complexity: 20,
+  evaluate: (_condition, sourceCard) => {
+    // Check if sourceCard has attached location
+    return !!sourceCard.atLocationId;
+  },
+});
+
+conditionRegistry.register<HasCharacterHereCondition>("has-character-here", {
+  complexity: 30,
+  evaluate: (_condition, sourceCard, { state }) => {
+    // Check all cards in play to see if their 'atLocationId' matches sourceCard.id
+    return Object.values(state.internal.cards).some((c) => {
+      const card = c as CardInstance<LorcanaCardMeta>;
+      return card.zone === "play" && card.atLocationId === sourceCard.id;
+    });
+  },
+});
+
+conditionRegistry.register<HasNamedLocationCondition>("has-named-location", {
+  complexity: 40,
+  evaluate: (condition, sourceCard, { state, registry }) => {
+    return Object.values(state.internal.cards).some((c) => {
+      if (c.zone !== "play") return false;
+      const def = registry.getCard(c.definitionId);
+      if (def?.cardType !== "location") return false;
+      if (condition.name && def.name !== condition.name) return false;
+
+      if (condition.controller === "you")
+        return c.controller === sourceCard.controller;
+      if (condition.controller === "opponent")
+        return c.controller !== sourceCard.controller;
+      return true;
+    });
+  },
+});

package/src/setup.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "bun:test";
+
+describe("@drmxrcy/tcg-lorcana Package Setup", () => {
+  it("package is properly configured", () => {
+    // Basic smoke test to verify package structure
+    expect(true).toBe(true);
+  });
+
+  it(
+    "can import from @drmxrcy/tcg-core",
+    async () => {
+      const core = await import("@drmxrcy/tcg-core");
+      expect(core).toBeDefined();
+      expect(core.RuleEngine).toBeDefined();
+    },
+    { timeout: 30000 },
+  );
+});

package/src/targeting/__tests__/filter-resolver.test.ts

@@ -0,0 +1,294 @@
+import { describe, expect, it } from "bun:test";
+import type { CardRegistry } from "@drmxrcy/tcg-core";
+import type { LorcanaCardDefinition } from "@drmxrcy/tcg-lorcana-types";
+import { createDefaultCardMeta } from "../../types/game-state";
+import {
+  createTargetFiltersPredicate,
+  matchesLorcanaFilter,
+  sortFilters,
+} from "../filter-resolver";
+import type { LorcanaFilter } from "../lorcana-target-dsl";
+
+// Mock Registry
+const mockRegistry: CardRegistry<LorcanaCardDefinition> = {
+  getCard: (id: string) => {
+    return MOCK_DEFINITIONS[id];
+  },
+  getAllCards: () => Object.values(MOCK_DEFINITIONS),
+  hasCard: (id: string) => !!MOCK_DEFINITIONS[id],
+  queryCards: () => [],
+  getCardCount: () => 0,
+};
+
+const MOCK_DEFINITIONS: Record<string, LorcanaCardDefinition> = {
+  "char-1": {
+    id: "char-1",
+    name: "Mickey Mouse",
+    set: "set1",
+    cardType: "character",
+    cost: 3,
+    inkable: true,
+    inkType: ["ruby"],
+    strength: 3,
+    willpower: 3,
+    lore: 1,
+    abilities: [
+      { type: "keyword", keyword: "Evasive", id: "k1", text: "Evasive" },
+    ],
+  },
+  "char-2": {
+    id: "char-2",
+    name: "Donald Duck",
+    set: "set1",
+    cardType: "character",
+    cost: 5,
+    inkable: false,
+    inkType: ["sapphire"],
+    strength: 5,
+    willpower: 6,
+    lore: 2,
+    classifications: ["Hero"],
+  },
+  "loc-1": {
+    id: "loc-1",
+    name: "The Library",
+    set: "set1",
+    cardType: "location",
+    cost: 2,
+    inkable: true,
+    inkType: ["amethyst"],
+    moveCost: 1,
+    lore: 1,
+  },
+};
+
+const mockState: any = {}; // Simple mock state
+
+describe("Filter Resolver", () => {
+  describe("Ranking", () => {
+    it("should sort filters by rank", () => {
+      const filters: LorcanaFilter[] = [
+        { type: "cost", comparison: "eq", value: 3 },
+        { type: "ready" },
+        { type: "has-keyword", keyword: "Evasive" },
+      ];
+
+      const sorted = sortFilters(filters);
+      expect(sorted[0].type).toBe("ready"); // Cheap
+      expect(sorted[1].type).toBe("has-keyword"); // Property
+      expect(sorted[2].type).toBe("cost"); // Numeric
+    });
+  });
+
+  describe("Matching", () => {
+    const char1Instance = {
+      definitionId: "char-1",
+      ...createDefaultCardMeta(),
+      state: "ready",
+      damage: 0,
+    } as any;
+
+    const char1Exerted = {
+      definitionId: "char-1",
+      ...createDefaultCardMeta(),
+      state: "exerted",
+      damage: 2,
+    } as any;
+
+    it("should match state filters", () => {
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "ready" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+      expect(
+        matchesLorcanaFilter(
+          char1Exerted,
+          { type: "ready" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(false);
+
+      expect(
+        matchesLorcanaFilter(
+          char1Exerted,
+          { type: "exerted" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+
+      expect(
+        matchesLorcanaFilter(
+          char1Exerted,
+          { type: "damaged" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "damaged" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(false);
+
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "undamaged" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+    });
+
+    it("should match property filters", () => {
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "has-keyword", keyword: "Evasive" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "has-keyword", keyword: "Rush" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(false);
+
+      const char2Instance = {
+        definitionId: "char-2",
+        ...createDefaultCardMeta(),
+      } as any;
+      expect(
+        matchesLorcanaFilter(
+          char2Instance,
+          { type: "has-classification", classification: "Hero" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "has-classification", classification: "Hero" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(false);
+
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "name", equals: "Mickey Mouse" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "name", contains: "Mickey" },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+    });
+
+    it("should match numeric filters", () => {
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "strength", comparison: "eq", value: 3 },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "strength", comparison: "gt", value: 2 },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "strength", comparison: "lt", value: 4 },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+
+      expect(
+        matchesLorcanaFilter(
+          char1Instance,
+          { type: "cost", comparison: "lte", value: 3 },
+          mockState,
+          mockRegistry,
+        ),
+      ).toBe(true);
+    });
+
+    it("should match composite filters", () => {
+      const filter: LorcanaFilter = {
+        type: "and",
+        filters: [
+          { type: "ready" },
+          { type: "strength", comparison: "eq", value: 3 },
+        ],
+      };
+      expect(
+        matchesLorcanaFilter(char1Instance, filter, mockState, mockRegistry),
+      ).toBe(true);
+
+      const orFilter: LorcanaFilter = {
+        type: "or",
+        filters: [
+          { type: "exerted" }, // false
+          { type: "strength", comparison: "eq", value: 3 }, // true
+        ],
+      };
+      expect(
+        matchesLorcanaFilter(char1Instance, orFilter, mockState, mockRegistry),
+      ).toBe(true);
+    });
+  });
+
+  describe("Predicate Creation", () => {
+    it("should create working predicate", () => {
+      const predicate = createTargetFiltersPredicate(
+        [{ type: "ready" }, { type: "cost", comparison: "eq", value: 3 }],
+        mockState,
+        mockRegistry,
+      );
+
+      const char1Instance = {
+        definitionId: "char-1",
+        ...createDefaultCardMeta(),
+        state: "ready",
+      } as any;
+
+      const char1Exerted = {
+        definitionId: "char-1",
+        ...createDefaultCardMeta(),
+        state: "exerted",
+      } as any;
+
+      expect(predicate(char1Instance)).toBe(true);
+      expect(predicate(char1Exerted)).toBe(false);
+    });
+  });
+});