@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/targeting/filter-resolver.ts

@@ -0,0 +1,145 @@
+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 { filterRegistry, registerDefaultFilters } from "./filter-registry";
+import type { LorcanaContext, LorcanaFilter } from "./lorcana-target-dsl";
+
+// Initialize registry
+registerDefaultFilters();
+
+/**
+ * Check if a card matches a Lorcana-specific filter using the registry
+ */
+export function matchesLorcanaFilter(
+  card: CardInstance<LorcanaCardMeta>,
+  filter: LorcanaFilter,
+  state: LorcanaGameState,
+  registry: CardRegistry<LorcanaCardDefinition>,
+  context?: LorcanaContext,
+): boolean {
+  const handler = filterRegistry.get(filter.type);
+  if (!handler) {
+    console.warn(`No handler found for filter type: ${filter.type}`);
+    return false;
+  }
+
+  return handler.evaluate(filter, card, { state, registry, context });
+}
+
+/**
+ * Sort filters by rank using registry complexity
+ */
+export function sortFilters(filters: LorcanaFilter[]): LorcanaFilter[] {
+  return [...filters].sort((a, b) => {
+    const handlerA = filterRegistry.get(a.type);
+    const handlerB = filterRegistry.get(b.type);
+    const rankA = handlerA ? handlerA.complexity : 100;
+    const rankB = handlerB ? handlerB.complexity : 100;
+    return rankA - rankB;
+  });
+}
+
+/**
+ * Creates a predicate function that checks if a card matches all filters
+ */
+export function createTargetFiltersPredicate(
+  filters: LorcanaFilter[] | undefined,
+  state: LorcanaGameState,
+  registry: CardRegistry<LorcanaCardDefinition>,
+  context?: LorcanaContext,
+): (card: CardInstance<LorcanaCardMeta>) => boolean {
+  if (!filters || filters.length === 0) {
+    return () => true;
+  }
+
+  const sortedFilters = sortFilters(filters);
+
+  return (card: CardInstance<LorcanaCardMeta>) => {
+    return sortedFilters.every((filter) =>
+      matchesLorcanaFilter(card, filter, state, registry, context),
+    );
+  };
+}
+
+/**
+ * Debug info for filter evaluation
+ */
+export interface FilterDebugInfo {
+  filter: LorcanaFilter;
+  passed: boolean;
+  executionTime: number;
+}
+
+/**
+ * Create a predicate with debug capabilities
+ */
+export function createTargetFiltersPredicateWithDebug(
+  filters: LorcanaFilter[] | undefined,
+  state: LorcanaGameState,
+  registry: CardRegistry<LorcanaCardDefinition>,
+  context?: LorcanaContext,
+): {
+  predicate: (card: CardInstance<LorcanaCardMeta>) => boolean;
+  debug: (card: CardInstance<LorcanaCardMeta>) => {
+    result: boolean;
+    details: FilterDebugInfo[];
+  };
+} {
+  const rawPredicate = createTargetFiltersPredicate(
+    filters,
+    state,
+    registry,
+    context,
+  );
+  const sortedFilters = filters ? sortFilters(filters) : [];
+
+  const debug = (card: CardInstance<LorcanaCardMeta>) => {
+    const details: FilterDebugInfo[] = [];
+    let result = true;
+
+    for (const filter of sortedFilters) {
+      const start = performance.now();
+      const passed = matchesLorcanaFilter(
+        card,
+        filter,
+        state,
+        registry,
+        context,
+      );
+      const duration = performance.now() - start;
+
+      details.push({
+        filter,
+        passed,
+        executionTime: duration,
+      });
+
+      if (!passed) {
+        result = false;
+        break;
+      }
+    }
+
+    return { result, details };
+  };
+
+  return { predicate: rawPredicate, debug };
+}
+
+/**
+ * Validate filters configuration
+ */
+export function validateFilters(filters: LorcanaFilter[]): {
+  valid: boolean;
+  errors: string[];
+} {
+  const errors: string[] = [];
+  for (const f of filters) {
+    const handler = filterRegistry.get(f.type);
+    if (!handler) {
+      errors.push(`Unknown filter type: ${f.type}`);
+    }
+    // TODO: Add specific handler validation if needed
+  }
+  return { valid: errors.length === 0, errors };
+}

package/src/targeting/index.ts

@@ -0,0 +1,91 @@
+/**
+ * Lorcana Targeting Module
+ *
+ * Provides Lorcana-specific targeting DSL and utilities.
+ *
+ * @module targeting
+ */
+
+// Re-export core types for convenience
+export type {
+  BaseContext,
+  OwnerScope,
+  PlayerTargetDSL,
+  SelectorScope,
+  TargetCount,
+  TargetDSL,
+  TargetingUIHint,
+} from "@drmxrcy/tcg-core";
+
+// Enum expansion utilities
+export {
+  ALL_TARGET_ENUMS,
+  CHARACTER_TARGET_ENUMS,
+  expandCharacterTarget,
+  expandItemTarget,
+  expandLocationTarget,
+  expandTarget,
+  ITEM_TARGET_ENUMS,
+  isCharacterEnum,
+  isItemEnum,
+  isLocationEnum,
+  LOCATION_TARGET_ENUMS,
+} from "./enum-expansion";
+export {
+  type FilterHandler,
+  FilterRegistry,
+  filterRegistry,
+  registerDefaultFilters,
+} from "./filter-registry";
+// Filter matching logic
+export {
+  createTargetFiltersPredicate,
+  createTargetFiltersPredicateWithDebug,
+  type FilterDebugInfo,
+  matchesLorcanaFilter,
+  sortFilters,
+  validateFilters,
+} from "./filter-resolver";
+// Lorcana Target DSL types
+export {
+  type AtLocationFilter,
+  type CharacterTarget,
+  type CharacterTargetEnum,
+  type CostFilter,
+  type DamagedFilter,
+  type DryFilter,
+  type ExertedFilter,
+  type HasClassificationFilter,
+  type HasKeywordFilter,
+  type InkableFilter,
+  type ItemTarget,
+  type ItemTargetEnum,
+  isDSLTarget,
+  isNumericFilter,
+  isStateFilter,
+  type LocationTarget,
+  type LocationTargetEnum,
+  type LorcanaCardTarget,
+  type LorcanaCardType,
+  type LorcanaCharacterTarget,
+  type LorcanaContext,
+  type LorcanaFilter,
+  type LorcanaItemTarget,
+  type LorcanaLocationTarget,
+  type LorcanaPlayerTarget,
+  type LorcanaTarget,
+  type LoreValueFilter,
+  type MoveCostFilter,
+  type NameFilter,
+  type ReadyFilter,
+  type StrengthFilter,
+  type UndamagedFilter,
+  type WillpowerFilter,
+} from "./lorcana-target-dsl";
+
+// UI utilities
+export {
+  generateTargetDescription,
+  getTargetUIHints,
+  type LorcanaTargetUIHint,
+} from "./targeting-ui";