@drmxrcy/tcg-lorcana 0.0.0-202602060544

package/src/resolvers/condition-resolver.ts

@@ -0,0 +1,85 @@
+import type { CardInstance, CardRegistry } from "@drmxrcy/tcg-core";
+import type { Condition, LorcanaCardDefinition } from "@drmxrcy/tcg-lorcana-types";
+import type { LorcanaContext } from "../targeting/lorcana-target-dsl";
+import type { LorcanaCardMeta, LorcanaGameState } from "../types/game-state";
+import { conditionRegistry } from "./condition-registry";
+
+const MAX_RECURSION_DEPTH = 10;
+
+/**
+ * Check if a condition is met
+ */
+export function isConditionMet(
+  condition: Condition,
+  sourceCard: CardInstance<LorcanaCardMeta>,
+  state: LorcanaGameState,
+  registry: CardRegistry<LorcanaCardDefinition>,
+  context?: LorcanaContext,
+): boolean {
+  // Initialize context if needed
+  const ctx = context ?? ({} as LorcanaContext);
+  const depth = ctx.recursionDepth ?? 0;
+
+  // 1. Recursion protection
+  if (depth > MAX_RECURSION_DEPTH) {
+    console.warn(
+      `Max recursion depth ${MAX_RECURSION_DEPTH} reached evaluating condition for ${sourceCard.id}`,
+    );
+    return false; // Fail safe
+  }
+
+  // 2. Evaluation
+  try {
+    // Increment depth in context
+    ctx.recursionDepth = depth + 1;
+
+    // Get handler
+    const handler = conditionRegistry.get(condition.type);
+    if (!handler) {
+      console.warn(`No handler found for condition type: ${condition.type}`);
+      return false;
+    }
+
+    const result = handler.evaluate(condition, sourceCard, {
+      state,
+      registry,
+      context: ctx,
+    });
+
+    return result;
+  } catch (error) {
+    console.warn("Error evaluating condition", error);
+    return false;
+  } finally {
+    // Restore depth
+    ctx.recursionDepth = depth;
+  }
+}
+
+/**
+ * Check if a list of conditions are ALL met (Implicit AND)
+ */
+export function areConditionsMet(
+  conditions: Condition[] | undefined,
+  sourceCard: CardInstance<LorcanaCardMeta>,
+  state: LorcanaGameState,
+  registry: CardRegistry<LorcanaCardDefinition>,
+  context?: LorcanaContext,
+): boolean {
+  if (!conditions || conditions.length === 0) {
+    return true;
+  }
+
+  // Sort by complexity to fail fast
+  const sorted = [...conditions].sort((a, b) => {
+    const ha = conditionRegistry.get(a.type);
+    const hb = conditionRegistry.get(b.type);
+    const ca = ha ? ha.complexity : 100;
+    const cb = hb ? hb.complexity : 100;
+    return ca - cb;
+  });
+
+  return sorted.every((cond) =>
+    isConditionMet(cond, sourceCard, state, registry, context),
+  );
+}

package/src/resolvers/conditions/basic.ts

@@ -0,0 +1,81 @@
+import type {
+  HasAnyDamageCondition,
+  IfCondition,
+  InChallengeCondition,
+  InInkwellCondition,
+  InPlayCondition,
+  IsExertedCondition,
+  IsReadyCondition,
+  NoDamageCondition,
+  TurnCondition,
+} from "@drmxrcy/tcg-lorcana-types";
+import { conditionRegistry } from "../condition-registry";
+
+conditionRegistry.register<TurnCondition>("turn", {
+  complexity: 10,
+  evaluate: (condition, sourceCard, { state }) => {
+    const isActivePlayer =
+      state.external.activePlayerId === sourceCard.controller;
+    return condition.whose === "your" ? isActivePlayer : !isActivePlayer;
+  },
+});
+
+conditionRegistry.register<IsExertedCondition>("is-exerted", {
+  complexity: 10,
+  evaluate: (_condition, sourceCard) => {
+    return sourceCard.state === "exerted";
+  },
+});
+
+conditionRegistry.register<IsReadyCondition>("is-ready", {
+  complexity: 10,
+  evaluate: (_condition, sourceCard) => {
+    return sourceCard.state === "ready";
+  },
+});
+
+conditionRegistry.register<InInkwellCondition>("in-inkwell", {
+  complexity: 10,
+  evaluate: (_condition, sourceCard) => {
+    return sourceCard.zone === "inkwell";
+  },
+});
+
+conditionRegistry.register<InPlayCondition>("in-play", {
+  complexity: 10,
+  evaluate: (_condition, sourceCard) => {
+    return sourceCard.zone === "play";
+  },
+});
+
+conditionRegistry.register<HasAnyDamageCondition>("has-any-damage", {
+  complexity: 2,
+  evaluate: (_condition, sourceCard) => {
+    return (sourceCard.damage || 0) > 0;
+  },
+});
+
+conditionRegistry.register<NoDamageCondition>("no-damage", {
+  complexity: 2,
+  evaluate: (_condition, sourceCard) => {
+    return (sourceCard.damage || 0) === 0;
+  },
+});
+
+conditionRegistry.register<InChallengeCondition>("in-challenge", {
+  complexity: 5,
+  evaluate: (_condition, _sourceCard, { context }) => {
+    return !!(context?.attacker || context?.defender);
+  },
+});
+
+// Register IfCondition handler (parser catch-all)
+conditionRegistry.register<IfCondition>("if", {
+  complexity: 99,
+  evaluate: (_condition, _sourceCard, _context) => {
+    // IfCondition is a parser catch-all for unparseable expressions
+    // It should be converted to specific conditions before evaluation
+    // For now, always return false to indicate it cannot be evaluated
+    return false;
+  },
+});

package/src/resolvers/conditions/card-state.ts

@@ -0,0 +1,12 @@
+import type { HasCardUnderCondition } from "@drmxrcy/tcg-lorcana-types";
+import { conditionRegistry } from "../condition-registry";
+
+conditionRegistry.register<HasCardUnderCondition>("has-card-under", {
+  complexity: 20,
+  evaluate: (_condition, sourceCard) => {
+    const stack = sourceCard.stackPosition;
+    if (!stack) return false;
+    // Check if there are cards underneath
+    return !!(stack.cardsUnderneath && stack.cardsUnderneath.length > 0);
+  },
+});

package/src/resolvers/conditions/comparison.ts

@@ -0,0 +1,102 @@
+import type { CardInstance } from "@drmxrcy/tcg-core";
+import type { ComparisonCondition, ComparisonValue } from "@drmxrcy/tcg-lorcana-types";
+import type { LorcanaCardMeta, LorcanaGameState } from "../../types/game-state";
+import { conditionRegistry } from "../condition-registry";
+
+// Rewriting register to include registry in helper
+conditionRegistry.register<ComparisonCondition>("comparison", {
+  complexity: 40,
+  evaluate: (condition, sourceCard, { state, registry }) => {
+    const resolve = (v: ComparisonValue): number => {
+      if ("value" in v) return v.value;
+
+      // Types that have controller
+      let targetController: string | undefined;
+      if ("controller" in v) {
+        if (v.controller === "you") {
+          targetController = sourceCard.controller;
+        } else if (v.controller === "opponent") {
+          const playerIds = Object.keys(state.external.loreScores);
+          targetController = playerIds.find(
+            (id) => id !== sourceCard.controller,
+          );
+        }
+      }
+
+      if (v.type === "damage-on-self") return sourceCard.damage || 0;
+
+      if (!targetController && v.type !== "strength-of-self") return 0;
+
+      // Needs definitions for Strength/Willpower/Type checks
+      if (v.type === "strength-of-self") {
+        const def = registry.getCard(sourceCard.definitionId);
+        // TODO: Add modifiers? Conditions usually check CURRENT strength.
+        // This requires the whole Engine/Modifier system which we might not have access to here.
+        // For now, return base strength.
+        return def?.strength || 0;
+      }
+
+      return resolveValueWithState(v, state, targetController || "", registry);
+    };
+
+    const left = resolve(condition.left);
+    const right = resolve(condition.right);
+
+    // console.log("Comparison:", { left, right, op: condition.comparison, sourceCtrl: sourceCard.controller, keys: Object.keys(sourceCard) });
+
+    switch (condition.comparison) {
+      // @ts-expect-error - comparison operators mismatch
+      case "eq":
+        return left === right;
+      // @ts-expect-error - comparison operators mismatch
+      case "ne":
+        return left !== right;
+      // @ts-expect-error - comparison operators mismatch
+      case "gt":
+        return left > right;
+      // @ts-expect-error - comparison operators mismatch
+      case "gte":
+        return left >= right;
+      // @ts-expect-error - comparison operators mismatch
+      case "lt":
+        return left < right;
+      // @ts-expect-error - comparison operators mismatch
+      case "lte":
+        return left <= right;
+      default:
+        return false;
+    }
+  },
+});
+
+function resolveValueWithState(
+  v: ComparisonValue,
+  state: LorcanaGameState,
+  targetOwnerId: string,
+  registry: any, // Typing as any to avoid circular deps or complex type logic for now
+): number {
+  if ("value" in v) return v.value;
+  if (v.type === "lore") {
+    return state.external.loreScores[targetOwnerId as any] || 0;
+  }
+
+  // Zone counts
+  if (v.type === "cards-in-hand") {
+    return Object.values(state.internal.cards).filter(
+      (c) => c.zone === "hand" && c.controller === targetOwnerId,
+    ).length;
+  }
+  if (v.type === "cards-in-inkwell") {
+    return Object.values(state.internal.cards).filter(
+      (c) => c.zone === "inkwell" && c.controller === targetOwnerId,
+    ).length;
+  }
+  if (v.type === "character-count") {
+    return Object.values(state.internal.cards).filter((c) => {
+      if (c.zone !== "play" || c.controller !== targetOwnerId) return false;
+      const def = registry.getCard(c.definitionId);
+      return def?.cardType === "character";
+    }).length;
+  }
+  return 0;
+}

package/src/resolvers/conditions/existence.ts

@@ -0,0 +1,219 @@
+import type { CardInstance } from "@drmxrcy/tcg-core";
+import type {
+  HasCharacterCountCondition,
+  HasCharacterWithClassificationCondition,
+  HasNamedCharacterCondition,
+  ResourceCountCondition,
+} from "@drmxrcy/tcg-lorcana-types";
+import type { LorcanaFilter } from "../../targeting/lorcana-target-dsl";
+import type { LorcanaCardMeta, LorcanaGameState } from "../../types/game-state";
+import { conditionRegistry } from "../condition-registry";
+
+/**
+ * Helper to count cards matching a predicate
+ */
+function countCards(
+  state: LorcanaGameState,
+  predicate: (card: CardInstance<LorcanaCardMeta>) => boolean,
+): number {
+  let count = 0;
+  for (const card of Object.values(state.internal.cards)) {
+    if (predicate(card as CardInstance<LorcanaCardMeta>)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+/**
+ * Helper to compare numbers
+ */
+function compare(val: number, op: string, target: number): boolean {
+  switch (op) {
+    case "eq":
+      return val === target;
+    case "ne":
+      return val !== target;
+    case "gt":
+      return val > target;
+    case "gte":
+      return val >= target;
+    case "lt":
+      return val < target;
+    case "lte":
+      return val <= target;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Helper to get zone filter for "in play" (default for "have a character")
+ */
+function getPlayZoneFilter(
+  controller: "you" | "opponent" | "any",
+  sourceCard: CardInstance<LorcanaCardMeta>,
+): (card: CardInstance<LorcanaCardMeta>) => boolean {
+  return (card) => {
+    // Check Zone (must be in play)
+    if (card.zone !== "play") return false;
+
+    // Check Controller
+    if (controller === "you") {
+      return card.controller === sourceCard.controller;
+    }
+    if (controller === "opponent") {
+      return card.controller !== sourceCard.controller;
+    }
+    return true; // any
+  };
+}
+
+// Register HasNamedCharacterCondition
+conditionRegistry.register<HasNamedCharacterCondition>("has-named-character", {
+  complexity: 40,
+  evaluate: (condition, sourceCard, { state, registry }) => {
+    const zoneFilter = getPlayZoneFilter(
+      condition.controller ?? "you",
+      sourceCard,
+    );
+
+    // Check if ANY card matches
+    return Object.values(state.internal.cards).some((c) => {
+      const card = c as CardInstance<LorcanaCardMeta>;
+      if (!zoneFilter(card)) return false;
+      if (card.definitionId === undefined) return false;
+
+      const def = registry.getCard(card.definitionId);
+      // Usually "named X" implies the name property.
+      return (
+        def && (def.name === condition.name || def.fullName === condition.name)
+      );
+    });
+  },
+});
+
+// Register HasCharacterWithClassificationCondition
+conditionRegistry.register<HasCharacterWithClassificationCondition>(
+  "has-character-with-classification",
+  {
+    complexity: 45,
+    evaluate: (condition, sourceCard, { state, registry }) => {
+      const zoneFilter = getPlayZoneFilter(condition.controller, sourceCard);
+
+      return Object.values(state.internal.cards).some((c) => {
+        const card = c as CardInstance<LorcanaCardMeta>;
+        if (!zoneFilter(card)) return false;
+
+        // This condition doesn't seem to have a dedicated filterResolver helper in DSL?
+        // But we can construct one or manually check.
+        const def = registry.getCard(card.definitionId);
+        if (def?.cardType !== "character") return false;
+
+        return def.classifications?.includes(condition.classification as any);
+      });
+    },
+  },
+);
+
+// Register HasCharacterCountCondition
+conditionRegistry.register<HasCharacterCountCondition>("has-character-count", {
+  complexity: 50,
+  evaluate: (condition, sourceCard, { state, registry }) => {
+    const zoneFilter = getPlayZoneFilter(
+      condition.controller ?? "you",
+      sourceCard,
+    );
+
+    let count = 0;
+
+    // Check if there are generic filters?
+    // The condition usually implies "Has X characters"
+    // Usually no extra filters unless specified.
+
+    count = countCards(state, (c) => {
+      if (!zoneFilter(c)) return false;
+      const def = registry.getCard(c.definitionId);
+      return def?.cardType === "character";
+    });
+
+    return compare(count, condition.comparison ?? "gte", condition.count ?? 1);
+  },
+});
+
+// Register ResourceCountCondition (Ink, Cards in Hand, etc.)
+conditionRegistry.register<ResourceCountCondition>("resource-count", {
+  complexity: 40,
+  evaluate: (condition, sourceCard, { state, registry }) => {
+    // Check controller
+    const targetOwnerId =
+      condition.controller === "you"
+        ? sourceCard.controller
+        : Object.keys(state.external.loreScores).find(
+            (id) => id !== sourceCard.controller,
+          );
+
+    if (!targetOwnerId) return false;
+
+    // Helper for specific resource type
+    const isTargetController = (cId: string) => cId === targetOwnerId;
+
+    let count = 0;
+    switch (condition.what) {
+      case "cards-in-hand":
+        count = countCards(state, (c) => {
+          return c.zone === "hand" && isTargetController(c.controller);
+        });
+        break;
+
+      case "cards-in-inkwell":
+        count = countCards(state, (c) => {
+          return c.zone === "inkwell" && isTargetController(c.controller);
+        });
+        break;
+
+      case "characters":
+        // This duplicates has-character-count but under resource-count umbrella
+        count = countCards(state, (c) => {
+          if (c.zone !== "play" || !isTargetController(c.controller))
+            return false;
+          const def = registry.getCard(c.definitionId);
+          return def?.cardType === "character";
+        });
+        break;
+
+      case "items":
+        count = countCards(state, (c) => {
+          if (c.zone !== "play" || !isTargetController(c.controller))
+            return false;
+          const def = registry.getCard(c.definitionId);
+          return def?.cardType === "item";
+        });
+        break;
+
+      case "locations":
+        count = countCards(state, (c) => {
+          if (c.zone !== "play" || !isTargetController(c.controller))
+            return false;
+          const def = registry.getCard(c.definitionId);
+          return def?.cardType === "location";
+        });
+        break;
+
+      case "damage-on-characters" as any:
+        // Special case: Total damage on ALL characters?
+        // Condition usually is "damage-on-self".
+        // If "resource-count" type "damage-on-characters" exists?
+        // I don't think it's robustly defined yet.
+        break;
+
+      default:
+        console.warn(
+          `Resource counting for ${condition.what} not fully implemented in existence.ts`,
+        );
+        return false;
+    }
+
+    return compare(count, condition.comparison, condition.value);
+  },
+});

package/src/resolvers/conditions/history.ts

@@ -0,0 +1,68 @@
+import type {
+  ThisTurnCountCondition,
+  ThisTurnHappenedCondition,
+} from "@drmxrcy/tcg-lorcana-types";
+import { conditionRegistry } from "../condition-registry";
+
+conditionRegistry.register<ThisTurnHappenedCondition>("this-turn-happened", {
+  complexity: 60,
+  evaluate: (condition, sourceCard, { state }) => {
+    const events = state.external.turnHistory || [];
+    // We need to filter by controller
+    const matchedEvents = events.filter((e) => {
+      if (e.type !== condition.event) return false;
+
+      if (condition.who === "you") {
+        return e.controllerId === sourceCard.controller;
+      }
+
+      return e.controllerId !== sourceCard.controller;
+    });
+
+    return matchedEvents.length > 0;
+  },
+});
+
+conditionRegistry.register<ThisTurnCountCondition>("this-turn-count", {
+  complexity: 70,
+  evaluate: (condition, sourceCard, { state }) => {
+    const events = state.external.turnHistory || [];
+
+    const count = events.reduce((acc, e) => {
+      if (e.type !== condition.event) return acc;
+
+      let matchesWho = false;
+      if (condition.who === "you") {
+        matchesWho = e.controllerId === sourceCard.controller;
+      } else {
+        matchesWho = e.controllerId !== sourceCard.controller;
+      }
+
+      if (matchesWho) return acc + e.count;
+      return acc;
+    }, 0);
+
+    switch (condition.comparison) {
+      // @ts-expect-error - comparison operators mismatch
+      case "eq":
+        return count === condition.count;
+      // @ts-expect-error - comparison operators mismatch
+      case "ne":
+        return count !== condition.count;
+      // @ts-expect-error - comparison operators mismatch
+      case "gt":
+        return count > condition.count;
+      // @ts-expect-error - comparison operators mismatch
+      case "gte":
+        return count >= condition.count;
+      // @ts-expect-error - comparison operators mismatch in shared types
+      case "lt":
+        return count < condition.count;
+      // @ts-expect-error - comparison operators mismatch in shared types
+      case "lte":
+        return count <= condition.count;
+      default:
+        return false;
+    }
+  },
+});

package/src/resolvers/conditions/index.ts

@@ -0,0 +1,15 @@
+import "./basic";
+import "./logical";
+import "./resolution";
+import "./existence";
+import "./comparison";
+import "./history";
+import "./zone";
+import "./card-state";
+import "./revealed";
+
+// Ensure all conditions are registered by side effect
+export * from "./basic";
+export * from "./existence";
+export * from "./logical";
+export * from "./resolution";

package/src/resolvers/conditions/logical.ts

@@ -0,0 +1,55 @@
+import type {
+  AndCondition,
+  NotCondition,
+  OrCondition,
+} from "@drmxrcy/tcg-lorcana-types";
+import { conditionRegistry } from "../condition-registry";
+import { isConditionMet } from "../condition-resolver";
+
+// Register AND Condition
+conditionRegistry.register<AndCondition>("and", {
+  complexity: 25, // Higher than simple, depends on children
+  evaluate: (condition, sourceCard, context) => {
+    // Short-circuit: if any is false, return false
+    return condition.conditions.every((subCondition) =>
+      isConditionMet(
+        subCondition,
+        sourceCard,
+        context.state,
+        context.registry,
+        context.context,
+      ),
+    );
+  },
+});
+
+// Register OR Condition
+conditionRegistry.register<OrCondition>("or", {
+  complexity: 25,
+  evaluate: (condition, sourceCard, context) => {
+    // Short-circuit: if any is true, return true
+    return condition.conditions.some((subCondition) =>
+      isConditionMet(
+        subCondition,
+        sourceCard,
+        context.state,
+        context.registry,
+        context.context,
+      ),
+    );
+  },
+});
+
+// Register NOT Condition
+conditionRegistry.register<NotCondition>("not", {
+  complexity: 15,
+  evaluate: (condition, sourceCard, context) => {
+    return !isConditionMet(
+      condition.condition,
+      sourceCard,
+      context.state,
+      context.registry,
+      context.context,
+    );
+  },
+});

package/src/resolvers/conditions/resolution.ts

@@ -0,0 +1,41 @@
+import type {
+  ResolutionCondition,
+  UsedShiftCondition,
+} from "@drmxrcy/tcg-lorcana-types";
+import { conditionRegistry } from "../condition-registry";
+
+// Register Used-Shift Condition
+conditionRegistry.register<UsedShiftCondition>("used-shift", {
+  complexity: 5,
+  evaluate: (_condition, sourceCard) => {
+    // A card is shifted if it has cards underneath it in the stack
+    return !!(
+      sourceCard.stackPosition?.cardsUnderneath &&
+      sourceCard.stackPosition.cardsUnderneath.length > 0
+    );
+  },
+});
+
+// Register Resolution Condition (Legacy/Context)
+conditionRegistry.register<ResolutionCondition>("resolution", {
+  complexity: 10,
+  evaluate: (condition, sourceCard, { context }) => {
+    if (condition.value === "bodyguard") {
+      // Check if we are currently resolving a Bodyguard trigger/check
+      return context?.resolutionContext === "bodyguard";
+    }
+
+    if (condition.value === "shift") {
+      // Check if the card is shifted (similar to used-shift)
+      // Or if we are in "shift" resolution?
+      // The old docs said "Checks sourceCard.hasShift && sourceCard.meta.shifted"
+      // We'll treat it as "is currently a shifted character"
+      return !!(
+        sourceCard.stackPosition?.cardsUnderneath &&
+        sourceCard.stackPosition.cardsUnderneath.length > 0
+      );
+    }
+
+    return false;
+  },
+});