@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/targeting/enum-expansion.ts

@@ -0,0 +1,387 @@
+/**
+ * Enum Expansion - Converts enum shortcuts to full DSL objects
+ *
+ * This module provides the mapping from string enum shortcuts to
+ * their full DSL representations. This enables enums as syntactic
+ * sugar while the DSL is the canonical form.
+ *
+ * @module targeting/enum-expansion
+ */
+
+import type {
+  CharacterTarget,
+  CharacterTargetEnum,
+  ItemTarget,
+  ItemTargetEnum,
+  LocationTarget,
+  LocationTargetEnum,
+  LorcanaCardTarget,
+  LorcanaCharacterTarget,
+  LorcanaItemTarget,
+  LorcanaLocationTarget,
+} from "./lorcana-target-dsl";
+
+// ============================================================================
+// Character Target Expansions
+// ============================================================================
+
+/**
+ * Mapping from character enum shortcuts to full DSL
+ */
+const CHARACTER_ENUM_EXPANSIONS: Record<CharacterTargetEnum, CharacterTarget> =
+  {
+    // Self-referential
+    SELF: {
+      selector: "self",
+      cardType: "character",
+      context: { self: true },
+    },
+    THIS_CHARACTER: {
+      selector: "self",
+      cardType: "character",
+      context: { self: true },
+    },
+
+    // Chosen (single target, player choice)
+    CHOSEN_CHARACTER: {
+      selector: "chosen",
+      count: 1,
+      owner: "any",
+      cardType: "character",
+      zones: ["play"],
+    },
+    CHOSEN_OPPOSING_CHARACTER: {
+      selector: "chosen",
+      count: 1,
+      owner: "opponent",
+      cardType: "character",
+      zones: ["play"],
+    },
+    CHOSEN_CHARACTER_OF_YOURS: {
+      selector: "chosen",
+      count: 1,
+      owner: "you",
+      cardType: "character",
+      zones: ["play"],
+    },
+    ANOTHER_CHOSEN_CHARACTER: {
+      selector: "chosen",
+      count: 1,
+      owner: "any",
+      cardType: "character",
+      zones: ["play"],
+      excludeSelf: true,
+    },
+    ANOTHER_CHOSEN_CHARACTER_OF_YOURS: {
+      selector: "chosen",
+      count: 1,
+      owner: "you",
+      cardType: "character",
+      zones: ["play"],
+      excludeSelf: true,
+    },
+
+    // All/Each (multiple targets, automatic)
+    ALL_CHARACTERS: {
+      selector: "all",
+      count: "all",
+      owner: "any",
+      cardType: "character",
+      zones: ["play"],
+    },
+    ALL_OPPOSING_CHARACTERS: {
+      selector: "all",
+      count: "all",
+      owner: "opponent",
+      cardType: "character",
+      zones: ["play"],
+    },
+    YOUR_CHARACTERS: {
+      selector: "all",
+      count: "all",
+      owner: "you",
+      cardType: "character",
+      zones: ["play"],
+    },
+    YOUR_OTHER_CHARACTERS: {
+      selector: "all",
+      count: "all",
+      owner: "you",
+      cardType: "character",
+      zones: ["play"],
+      excludeSelf: true,
+    },
+    EACH_CHARACTER: {
+      selector: "each",
+      count: "all",
+      owner: "any",
+      cardType: "character",
+      zones: ["play"],
+    },
+    EACH_OPPOSING_CHARACTER: {
+      selector: "each",
+      count: "all",
+      owner: "opponent",
+      cardType: "character",
+      zones: ["play"],
+    },
+
+    // Damaged variants
+    CHOSEN_DAMAGED_CHARACTER: {
+      selector: "chosen",
+      count: 1,
+      owner: "any",
+      cardType: "character",
+      zones: ["play"],
+      filters: [{ type: "damaged" }],
+    },
+    CHOSEN_OPPOSING_DAMAGED_CHARACTER: {
+      selector: "chosen",
+      count: 1,
+      owner: "opponent",
+      cardType: "character",
+      zones: ["play"],
+      filters: [{ type: "damaged" }],
+    },
+    ALL_OPPOSING_DAMAGED_CHARACTERS: {
+      selector: "all",
+      count: "all",
+      owner: "opponent",
+      cardType: "character",
+      zones: ["play"],
+      filters: [{ type: "damaged" }],
+    },
+  };
+
+// ============================================================================
+// Item Target Expansions
+// ============================================================================
+
+/**
+ * Mapping from item enum shortcuts to full DSL
+ */
+const ITEM_ENUM_EXPANSIONS: Record<ItemTargetEnum, ItemTarget> = {
+  CHOSEN_ITEM: {
+    selector: "chosen",
+    count: 1,
+    owner: "any",
+    cardType: "item",
+    zones: ["play"],
+  },
+  CHOSEN_OPPOSING_ITEM: {
+    selector: "chosen",
+    count: 1,
+    owner: "opponent",
+    cardType: "item",
+    zones: ["play"],
+  },
+  YOUR_ITEMS: {
+    selector: "all",
+    count: "all",
+    owner: "you",
+    cardType: "item",
+    zones: ["play"],
+  },
+  ALL_ITEMS: {
+    selector: "all",
+    count: "all",
+    owner: "any",
+    cardType: "item",
+    zones: ["play"],
+  },
+  ALL_OPPOSING_ITEMS: {
+    selector: "all",
+    count: "all",
+    owner: "opponent",
+    cardType: "item",
+    zones: ["play"],
+  },
+  THIS_ITEM: {
+    selector: "self",
+    cardType: "item",
+    context: { self: true },
+  },
+};
+
+// ============================================================================
+// Location Target Expansions
+// ============================================================================
+
+/**
+ * Mapping from location enum shortcuts to full DSL
+ */
+const LOCATION_ENUM_EXPANSIONS: Record<LocationTargetEnum, LocationTarget> = {
+  CHOSEN_LOCATION: {
+    selector: "chosen",
+    count: 1,
+    owner: "any",
+    cardType: "location",
+    zones: ["play"],
+  },
+  CHOSEN_OPPOSING_LOCATION: {
+    selector: "chosen",
+    count: 1,
+    owner: "opponent",
+    cardType: "location",
+    zones: ["play"],
+  },
+  YOUR_LOCATIONS: {
+    selector: "all",
+    count: "all",
+    owner: "you",
+    cardType: "location",
+    zones: ["play"],
+  },
+  ALL_OPPOSING_LOCATIONS: {
+    selector: "all",
+    count: "all",
+    owner: "opponent",
+    cardType: "location",
+    zones: ["play"],
+  },
+  THIS_LOCATION: {
+    selector: "self",
+    cardType: "location",
+    context: { self: true },
+  },
+};
+
+// ============================================================================
+// Expansion Functions
+// ============================================================================
+
+/**
+ * Check if a character target is an enum (vs DSL object)
+ */
+export function isCharacterEnum(
+  target: LorcanaCharacterTarget,
+): target is CharacterTargetEnum {
+  return typeof target === "string" && target in CHARACTER_ENUM_EXPANSIONS;
+}
+
+/**
+ * Expand a character target enum to full DSL
+ *
+ * @param target - Character target (enum or DSL)
+ * @returns Full DSL representation
+ */
+export function expandCharacterTarget(
+  target: LorcanaCharacterTarget,
+): CharacterTarget {
+  if (isCharacterEnum(target)) {
+    const expansion = CHARACTER_ENUM_EXPANSIONS[target];
+    if (!expansion) {
+      throw new Error(`Unknown character target enum: ${target}`);
+    }
+    return expansion;
+  }
+  return target;
+}
+
+/**
+ * Check if an item target is an enum
+ */
+export function isItemEnum(
+  target: LorcanaItemTarget,
+): target is ItemTargetEnum {
+  return typeof target === "string" && target in ITEM_ENUM_EXPANSIONS;
+}
+
+/**
+ * Expand an item target enum to full DSL
+ */
+export function expandItemTarget(target: LorcanaItemTarget): ItemTarget {
+  if (isItemEnum(target)) {
+    const expansion = ITEM_ENUM_EXPANSIONS[target];
+    if (!expansion) {
+      throw new Error(`Unknown item target enum: ${target}`);
+    }
+    return expansion;
+  }
+  return target;
+}
+
+/**
+ * Check if a location target is an enum
+ */
+export function isLocationEnum(
+  target: LorcanaLocationTarget,
+): target is LocationTargetEnum {
+  return typeof target === "string" && target in LOCATION_ENUM_EXPANSIONS;
+}
+
+/**
+ * Expand a location target enum to full DSL
+ */
+export function expandLocationTarget(
+  target: LorcanaLocationTarget,
+): LocationTarget {
+  if (isLocationEnum(target)) {
+    const expansion = LOCATION_ENUM_EXPANSIONS[target];
+    if (!expansion) {
+      throw new Error(`Unknown location target enum: ${target}`);
+    }
+    return expansion;
+  }
+  return target;
+}
+
+/**
+ * Expand any Lorcana target to full DSL
+ *
+ * Attempts to determine the type and expand accordingly
+ */
+export function expandTarget(
+  target: LorcanaCharacterTarget | LorcanaItemTarget | LorcanaLocationTarget,
+): LorcanaCardTarget {
+  if (typeof target === "string") {
+    // Try character enum first (most common)
+    if (target in CHARACTER_ENUM_EXPANSIONS) {
+      return CHARACTER_ENUM_EXPANSIONS[target as CharacterTargetEnum];
+    }
+    // Try item enum
+    if (target in ITEM_ENUM_EXPANSIONS) {
+      return ITEM_ENUM_EXPANSIONS[target as ItemTargetEnum];
+    }
+    // Try location enum
+    if (target in LOCATION_ENUM_EXPANSIONS) {
+      return LOCATION_ENUM_EXPANSIONS[target as LocationTargetEnum];
+    }
+    throw new Error(`Unknown target enum: ${target}`);
+  }
+  return target;
+}
+
+// ============================================================================
+// All Enum Values (for validation)
+// ============================================================================
+
+/**
+ * Set of all valid character target enum values
+ */
+export const CHARACTER_TARGET_ENUMS = new Set<string>(
+  Object.keys(CHARACTER_ENUM_EXPANSIONS),
+);
+
+/**
+ * Set of all valid item target enum values
+ */
+export const ITEM_TARGET_ENUMS = new Set<string>(
+  Object.keys(ITEM_ENUM_EXPANSIONS),
+);
+
+/**
+ * Set of all valid location target enum values
+ */
+export const LOCATION_TARGET_ENUMS = new Set<string>(
+  Object.keys(LOCATION_ENUM_EXPANSIONS),
+);
+
+/**
+ * Set of all valid target enum values
+ */
+export const ALL_TARGET_ENUMS = new Set<string>([
+  ...CHARACTER_TARGET_ENUMS,
+  ...ITEM_TARGET_ENUMS,
+  ...LOCATION_TARGET_ENUMS,
+]);

package/src/targeting/filter-registry.ts

@@ -0,0 +1,322 @@
+import type { CardInstance, CardRegistry } from "@drmxrcy/tcg-core";
+import type { LorcanaCardDefinition } from "@drmxrcy/tcg-lorcana-types";
+import type { LorcanaCardMeta, LorcanaGameState } from "../types/game-state";
+import type { LorcanaContext, LorcanaFilter } from "./lorcana-target-dsl";
+
+/**
+ * Filter evaluation context
+ */
+export interface FilterContext {
+  state: LorcanaGameState;
+  registry: CardRegistry<LorcanaCardDefinition>;
+  context?: LorcanaContext;
+}
+
+/**
+ * Handler for a specific filter type
+ */
+export interface FilterHandler<T extends LorcanaFilter = LorcanaFilter> {
+  name: T["type"];
+  complexity: number;
+  evaluate: (
+    filter: T,
+    card: CardInstance<LorcanaCardMeta>,
+    context: FilterContext,
+  ) => boolean;
+}
+
+export class FilterRegistry {
+  private handlers = new Map<string, FilterHandler>();
+
+  /**
+   * Register a filter handler
+   */
+  register<T extends LorcanaFilter>(handler: FilterHandler<T>): void {
+    this.handlers.set(handler.name, handler as unknown as FilterHandler);
+  }
+
+  /**
+   * Get a handler for a filter type
+   */
+  get(type: string): FilterHandler | undefined {
+    return this.handlers.get(type);
+  }
+
+  /**
+   * Get all registered handlers
+   */
+  getAll(): FilterHandler[] {
+    return Array.from(this.handlers.values());
+  }
+}
+
+// Global registry instance
+export const filterRegistry = new FilterRegistry();
+
+export function registerDefaultFilters() {
+  // --- State Filters ---
+  filterRegistry.register<LorcanaFilter & { type: "damaged" }>({
+    name: "damaged",
+    complexity: 0,
+    evaluate: (_, card) => (card.damage ?? 0) > 0,
+  });
+
+  filterRegistry.register<LorcanaFilter & { type: "undamaged" }>({
+    name: "undamaged",
+    complexity: 0,
+    evaluate: (_, card) => (card.damage ?? 0) === 0,
+  });
+
+  filterRegistry.register<LorcanaFilter & { type: "exerted" }>({
+    name: "exerted",
+    complexity: 0,
+    evaluate: (_, card) => card.state === "exerted",
+  });
+
+  filterRegistry.register<LorcanaFilter & { type: "ready" }>({
+    name: "ready",
+    complexity: 0,
+    evaluate: (_, card) => card.state === "ready",
+  });
+
+  filterRegistry.register<LorcanaFilter & { type: "dry" }>({
+    name: "dry",
+    complexity: 0,
+    evaluate: (_, card) => !(card.isDrying ?? false),
+  });
+
+  filterRegistry.register<LorcanaFilter & { type: "inkable"; value: boolean }>({
+    name: "inkable",
+    complexity: 0,
+    evaluate: (filter, card, { registry }) => {
+      const def = registry.getCard(card.definitionId);
+      return def ? def.inkable === filter.value : false;
+    },
+  });
+
+  // --- Property Filters ---
+  filterRegistry.register<
+    LorcanaFilter & { type: "has-keyword"; keyword: any }
+  >({
+    name: "has-keyword",
+    complexity: 10,
+    evaluate: (filter, card, { registry }) => {
+      const def = registry.getCard(card.definitionId);
+      return (
+        def?.abilities?.some(
+          (a: any) => a.type === "keyword" && a.keyword === filter.keyword,
+        ) ?? false
+      );
+    },
+  });
+
+  filterRegistry.register<
+    LorcanaFilter & { type: "has-classification"; classification: string }
+  >({
+    name: "has-classification",
+    complexity: 10,
+    evaluate: (filter, card, { registry }) => {
+      const def = registry.getCard(card.definitionId);
+      if (!def || def.cardType !== "character") return false;
+      return (
+        def.classifications?.some(
+          (c: string) =>
+            c.toLowerCase() === filter.classification.toLowerCase(),
+        ) ?? false
+      );
+    },
+  });
+
+  filterRegistry.register<
+    LorcanaFilter & { type: "name" } & (
+        | { equals: string }
+        | { contains: string }
+      )
+  >({
+    name: "name",
+    complexity: 10,
+    evaluate: (filter, card, { registry }) => {
+      const def = registry.getCard(card.definitionId);
+      if (!def) return false;
+      if ("equals" in filter) {
+        return def.name === filter.equals;
+      }
+      if ("contains" in filter) {
+        return def.name.includes(filter.contains);
+      }
+      return false;
+    },
+  });
+
+  filterRegistry.register<LorcanaFilter & { type: "card-type"; value: any }>({
+    name: "card-type",
+    complexity: 5,
+    evaluate: (filter, card, { registry }) => {
+      const def = registry.getCard(card.definitionId);
+      return def ? def.cardType === filter.value : false;
+    },
+  });
+
+  // --- Numeric Filters ---
+  const checkComparison = (
+    actual: number,
+    operator: string,
+    target: number,
+  ) => {
+    switch (operator) {
+      case "eq":
+        return actual === target;
+      case "ne":
+        return actual !== target;
+      case "gt":
+        return actual > target;
+      case "gte":
+        return actual >= target;
+      case "lt":
+        return actual < target;
+      case "lte":
+        return actual <= target;
+      default:
+        return false;
+    }
+  };
+
+  const getComparisonValue = (
+    value: number | "target",
+    // context: FilterContext - unused for now
+    // TODO: Implement getTargetValue when context is fully fleshed out
+  ): number => {
+    if (value === "target") return 0; // Placeholder
+    return value;
+  };
+
+  filterRegistry.register<
+    LorcanaFilter & { type: "strength"; comparison: any; value: any }
+  >({
+    name: "strength",
+    complexity: 20,
+    evaluate: (filter, card, ctx) => {
+      const def = ctx.registry.getCard(card.definitionId);
+      if (!def || def.cardType !== "character") return false;
+      const targetVal = getComparisonValue(filter.value);
+      return checkComparison(
+        (def as any).strength ?? 0,
+        filter.comparison,
+        targetVal,
+      );
+    },
+  });
+
+  filterRegistry.register<
+    LorcanaFilter & { type: "willpower"; comparison: any; value: any }
+  >({
+    name: "willpower",
+    complexity: 20,
+    evaluate: (filter, card, ctx) => {
+      const def = ctx.registry.getCard(card.definitionId);
+      if (!def || def.cardType !== "character") return false;
+      const targetVal = getComparisonValue(filter.value);
+      return checkComparison(
+        (def as any).willpower ?? 0,
+        filter.comparison,
+        targetVal,
+      );
+    },
+  });
+
+  filterRegistry.register<
+    LorcanaFilter & { type: "cost"; comparison: any; value: any }
+  >({
+    name: "cost",
+    complexity: 20,
+    evaluate: (filter, card, ctx) => {
+      const def = ctx.registry.getCard(card.definitionId);
+      if (!def) return false;
+      const targetVal = getComparisonValue(filter.value);
+      return checkComparison(def.cost, filter.comparison, targetVal);
+    },
+  });
+
+  filterRegistry.register<
+    LorcanaFilter & { type: "lore-value"; comparison: any; value: any }
+  >({
+    name: "lore-value",
+    complexity: 20,
+    evaluate: (filter, card, ctx) => {
+      const def = ctx.registry.getCard(card.definitionId);
+      if (!def || (def.cardType !== "character" && def.cardType !== "location"))
+        return false;
+      const targetVal = getComparisonValue(filter.value);
+      return checkComparison(
+        (def as any).lore ?? 0,
+        filter.comparison,
+        targetVal,
+      );
+    },
+  });
+
+  filterRegistry.register<
+    LorcanaFilter & { type: "move-cost"; comparison: any; value: number }
+  >({
+    name: "move-cost",
+    complexity: 20,
+    evaluate: (filter, card, { registry }) => {
+      const def = registry.getCard(card.definitionId);
+      if (!def || def.cardType !== "location") return false;
+      return checkComparison(
+        def.moveCost ?? 0,
+        filter.comparison,
+        filter.value,
+      );
+    },
+  });
+
+  filterRegistry.register<LorcanaFilter & { type: "at-location" }>({
+    name: "at-location",
+    complexity: 30,
+    evaluate: (_, card) => {
+      return !!card.atLocationId;
+    },
+  });
+
+  // --- Composite Filters ---
+  filterRegistry.register<
+    LorcanaFilter & { type: "and"; filters: LorcanaFilter[] }
+  >({
+    name: "and",
+    complexity: 50,
+    evaluate: (filter, card, context) => {
+      return filter.filters.every((f) => {
+        const handler = filterRegistry.get(f.type);
+        return handler ? handler.evaluate(f, card, context) : false;
+      });
+    },
+  });
+
+  filterRegistry.register<
+    LorcanaFilter & { type: "or"; filters: LorcanaFilter[] }
+  >({
+    name: "or",
+    complexity: 50,
+    evaluate: (filter, card, context) => {
+      return filter.filters.some((f) => {
+        const handler = filterRegistry.get(f.type);
+        return handler ? handler.evaluate(f, card, context) : false;
+      });
+    },
+  });
+
+  filterRegistry.register<
+    LorcanaFilter & { type: "not"; filter: LorcanaFilter }
+  >({
+    name: "not",
+    complexity: 50,
+    evaluate: (filter, card, context) => {
+      // Safe cast because we validated the type string
+      const handler = filterRegistry.get(
+        filter.filter.type,
+      ) as unknown as FilterHandler<LorcanaFilter>;
+      return handler ? !handler.evaluate(filter.filter, card, context) : false;
+    },
+  });
+}