@drmxrcy/tcg-lorcana-types 0.0.0-202602060544

package/src/abilities/condition-types.ts

@@ -0,0 +1,1202 @@
+/**
+ * Condition Types for Lorcana Abilities
+ *
+ * Defines conditions that must be met for abilities to activate or apply.
+ * Used in:
+ * - Triggered abilities: "Whenever this character quests, IF you have..."
+ * - Static abilities: "WHILE you have a character named..."
+ * - Conditional effects: "If an opponent has more lore than you..."
+ * - Optional effects: "you MAY draw a card"
+ *
+ * @example "If you have a character named Elsa in play"
+ * @example "While this character has no damage"
+ * @example "If you used Shift to play this character"
+ */
+
+import type { CardType } from "../cards/card-types";
+import type {
+  CharacterTarget,
+  ComparisonOperator,
+  TargetZone,
+} from "./target-types";
+
+// ============================================================================
+// Character/Card Existence Conditions - Strict Variants
+// ============================================================================
+
+/**
+ * Check if a character with a specific name exists
+ *
+ * @example "If you have a character named Elsa in play"
+ */
+export interface HasNamedCharacterCondition {
+  type: "has-named-character";
+  /** Character must have this name - REQUIRED */
+  name?: string;
+  /** Who controls the character - REQUIRED */
+  controller?: "you" | "opponent" | "any";
+}
+
+/**
+ * Check if a character with a specific classification exists
+ *
+ * @example "If you have a Floodborn character in play"
+ */
+export interface HasCharacterWithClassificationCondition {
+  type: "has-character-with-classification";
+  /** Classification - REQUIRED */
+  classification: string;
+  /** Who controls the character - REQUIRED */
+  controller: "you" | "opponent" | "any";
+}
+
+/**
+ * Check if a character with a specific keyword exists
+ *
+ * @example "If you have a character with Bodyguard in play"
+ */
+export interface HasCharacterWithKeywordCondition {
+  type: "has-character-with-keyword";
+  /** Keyword - REQUIRED */
+  keyword?: string;
+  /** Who controls the character - REQUIRED */
+  controller?: "you" | "opponent" | "any";
+}
+
+/**
+ * Check if a specific count of characters exists
+ *
+ * @example "If you have 3 or more characters in play"
+ */
+export interface HasCharacterCountCondition {
+  type: "has-character-count";
+  /** Who controls the characters - REQUIRED */
+  controller?: "you" | "opponent" | "any";
+  /** Comparison operator - REQUIRED */
+  comparison?: ComparisonOperator;
+  /** Count to compare against - REQUIRED */
+  count?: number;
+  /** Optional classification filter */
+  classification?: string;
+  /** Optional keyword filter */
+  keyword?: string;
+}
+
+/**
+ * Combined type for all character existence conditions
+ */
+export type HasCharacterCondition =
+  | HasNamedCharacterCondition
+  | HasCharacterWithClassificationCondition
+  | HasCharacterWithKeywordCondition
+  | HasCharacterCountCondition;
+
+/**
+ * Check if an item with a specific name exists
+ */
+export interface HasNamedItemCondition {
+  type: "has-named-item";
+  name: string;
+  controller: "you" | "opponent" | "any";
+}
+
+/**
+ * Check if a specific count of items exists
+ */
+export interface HasItemCountCondition {
+  type: "has-item-count";
+  controller: "you" | "opponent" | "any";
+  comparison: ComparisonOperator;
+  count: number;
+}
+
+/**
+ * Check if you have a location in play
+ */
+export interface HasLocationInPlayCondition {
+  type: "has-location-in-play";
+  controller?: "you" | "opponent" | "any";
+}
+
+/**
+ * Check if you have fewer characters than opponent
+ */
+export interface HasFewerCharactersCondition {
+  type: "has-fewer-characters";
+  than: "opponent";
+}
+
+/**
+ * Check if opponent has more cards in hand
+ */
+export interface OpponentHasMoreCardsCondition {
+  type: "opponent-has-more-cards";
+  what?: "cards-in-hand" | "lore";
+}
+
+/**
+ * Check if opponent has a damaged character
+ */
+export interface OpponentHasDamagedCharacterCondition {
+  type: "opponent-has-damaged-character";
+}
+
+/**
+ * Check if target is a villain
+ */
+export interface TargetIsVillainCondition {
+  type: "target-is-villain";
+}
+
+/**
+ * Check if target has no damage
+ */
+export interface HasNoDamageCondition {
+  type: "has-no-damage";
+  target?: CharacterTarget | "SELF";
+}
+
+/**
+ * Check if character has strength comparison
+ */
+export interface HasCharacterWithStrengthCondition {
+  type: "has-character-with-strength";
+  comparison: ComparisonOperator;
+  value: number;
+  controller?: "you" | "opponent" | "any";
+}
+
+/**
+ * Check if returned card is a princess
+ */
+export interface ReturnedCardIsPrincessCondition {
+  type: "returned-card-is-princess";
+}
+
+/**
+ * Check if revealed card has same name
+ */
+export interface RevealedHasSameNameCondition {
+  type: "revealed-has-same-name";
+}
+
+/**
+ * Check if there are characters here (at location)
+ */
+export interface HasCharactersHereCondition {
+  type: "has-characters-here";
+  count?: number | { min: number };
+}
+
+/**
+ * Check if character is at a location
+ */
+export interface HasCharacterAtLocationCondition {
+  type: "has-character-at-location";
+}
+
+/**
+ * Check if character is being challenged
+ */
+export interface BeingChallengedCondition {
+  type: "being-challenged";
+}
+
+/**
+ * Check if self has damage
+ */
+export interface SelfHasDamageCondition {
+  type: "self-has-damage";
+}
+
+/**
+ * Check if revealed card is a character with specific name
+ */
+export interface RevealedIsCharacterNamedCondition {
+  type: "revealed-is-character-named";
+  name?: string;
+}
+
+/**
+ * Check if this is the second inkwell this turn
+ */
+export interface SecondInkwellThisTurnCondition {
+  type: "second-inkwell-this-turn";
+}
+
+/**
+ * Check while in play
+ */
+export interface WhileInPlayCondition {
+  type: "while-in-play";
+}
+
+/**
+ * Check if played a card this turn
+ */
+export interface PlayedCardThisTurnCondition {
+  type: "played-card-this-turn";
+  cardType?: string;
+}
+
+/**
+ * Check if opponent has more than X cards
+ */
+export interface OpponentHasMoreThanCardsCondition {
+  type: "opponent-has-more-than-cards";
+  count?: number;
+}
+
+/**
+ * Check if opponent has lore
+ */
+export interface OpponentHasLoreCondition {
+  type: "opponent-has-lore";
+  comparison?: ComparisonOperator;
+  value?: number;
+}
+
+/**
+ * Check if you have the strongest character
+ */
+export interface HasStrongestCharacterCondition {
+  type: "has-strongest-character";
+}
+
+/**
+ * Check if there's a damaged character here
+ */
+export interface HasDamagedCharacterHereCondition {
+  type: "has-damaged-character-here";
+}
+
+/**
+ * Check if you have an item in play
+ */
+export interface HasItemInPlayCondition {
+  type: "has-item-in-play";
+  controller?: "you" | "opponent" | "any";
+}
+
+/**
+ * Combined type for item existence conditions
+ */
+export type HasItemCondition = HasNamedItemCondition | HasItemCountCondition;
+
+/**
+ * Check if a location with a specific name exists
+ */
+export interface HasNamedLocationCondition {
+  type: "has-named-location";
+  name: string;
+  controller: "you" | "opponent" | "any";
+}
+
+export interface HasCharacterHereCondition {
+  type: "has-character-here";
+}
+
+export interface RevealedMatchesNamedCondition {
+  type: "revealed-matches-named";
+}
+
+/**
+ * Check if revealed card matches a chosen name
+ */
+export interface RevealedMatchesChosenNameCondition {
+  type: "revealed-matches-chosen-name";
+}
+
+/**
+ * "If you do" condition - effect was successfully resolved
+ */
+export interface IfYouDoCondition {
+  type: "if-you-do";
+}
+
+/**
+ * Check if a specific count of locations exists
+ */
+export interface HasLocationCountCondition {
+  type: "has-location-count";
+  controller: "you" | "opponent" | "any";
+  comparison: ComparisonOperator;
+  count: number;
+}
+
+/**
+ * Combined type for location existence conditions
+ */
+export type HasLocationCondition =
+  | HasNamedLocationCondition
+  | HasLocationCountCondition;
+
+/**
+ * Check if this character is at a location
+ */
+export interface AtLocationCondition {
+  type: "at-location";
+  /** Specific location name (optional) */
+  locationName?: string;
+}
+
+// ============================================================================
+// State Conditions - Strict Variants
+// ============================================================================
+
+/**
+ * Check if this character has any damage (simple check)
+ */
+export interface HasAnyDamageCondition {
+  type: "has-any-damage";
+}
+
+/**
+ * Check if this character has a specific amount of damage
+ */
+export interface DamageComparisonCondition {
+  type: "damage-comparison";
+  /** Comparison operator - REQUIRED */
+  comparison: ComparisonOperator;
+  /** Value to compare against - REQUIRED */
+  value: number;
+}
+
+/**
+ * Combined type for damage conditions
+ */
+export type HasDamageCondition =
+  | HasAnyDamageCondition
+  | DamageComparisonCondition;
+
+/**
+ * Check if this character has no damage
+ */
+export interface NoDamageCondition {
+  type: "no-damage";
+  target?: "SELF" | CharacterTarget;
+}
+
+/**
+ * Check if this character is exerted
+ */
+export interface IsExertedCondition {
+  type: "is-exerted";
+}
+
+/**
+ * Check if this character is ready
+ */
+export interface IsReadyCondition {
+  type: "is-ready";
+}
+
+/**
+ * Check if this card has a card under it (Boost mechanic)
+ */
+export interface HasCardUnderCondition {
+  type: "has-card-under";
+}
+
+// ============================================================================
+// Zone Presence Conditions (Self)
+// ============================================================================
+
+/**
+ * Check if this card is in inkwell
+ * Used for abilities that only work while card is in inkwell
+ */
+export interface InInkwellCondition {
+  type: "in-inkwell";
+}
+
+/**
+ * Check if this card is in play
+ * Used for abilities that only work while card is in play
+ */
+export interface InPlayCondition {
+  type: "in-play";
+}
+
+// ============================================================================
+// Legacy Resolution Conditions
+// ============================================================================
+
+/**
+ * Check resolution context (Legacy support)
+ * @deprecated Will be removed after Bodyguard/Shift refactoring
+ * Used for "If this was shifted" (legacy) or Bodyguard context
+ */
+export interface ResolutionCondition {
+  type: "resolution";
+  value: "bodyguard" | "shift";
+}
+
+// ============================================================================
+// Count/Comparison Conditions - Strict Variants
+// ============================================================================
+
+/**
+ * Base countable resources
+ */
+export type CountableResource =
+  | "characters"
+  | "items"
+  | "locations"
+  | "cards-in-hand"
+  | "cards-in-inkwell"
+  | "cards-in-discard"
+  | "damage-on-self"
+  | "damaged-characters"
+  | "exerted-characters";
+
+/**
+ * Count-based condition for generic resources
+ *
+ * @example "If you have 3 or more characters in play"
+ * @example "If you have no cards in your hand"
+ */
+export interface ResourceCountCondition {
+  type: "resource-count";
+  /** What to count - REQUIRED */
+  what: CountableResource;
+  /** Whose resources to count - REQUIRED */
+  controller: "you" | "opponent" | "any";
+  /** Comparison operator - REQUIRED */
+  comparison: ComparisonOperator;
+  /** Value to compare against - REQUIRED */
+  value: number;
+}
+
+/**
+ * Count characters with a specific keyword
+ *
+ * @example "If you have 2 or more characters with Rush"
+ */
+export interface KeywordCharacterCountCondition {
+  type: "keyword-character-count";
+  /** Which keyword - REQUIRED */
+  keyword: string;
+  /** Whose characters - REQUIRED */
+  controller: "you" | "opponent" | "any";
+  /** Comparison operator - REQUIRED */
+  comparison: ComparisonOperator;
+  /** Value to compare against - REQUIRED */
+  value: number;
+}
+
+/**
+ * Count characters with a specific classification
+ *
+ * @example "If you have 2 or more Floodborn characters"
+ */
+export interface ClassificationCharacterCountCondition {
+  type: "classification-character-count";
+  /** Which classification - REQUIRED */
+  classification?: string;
+  /** Whose characters - REQUIRED */
+  controller?: "you" | "opponent" | "any";
+  /** Comparison operator - REQUIRED */
+  comparison?: ComparisonOperator;
+  /** Value to compare against - REQUIRED */
+  value?: number;
+}
+
+/**
+ * Combined type for all count conditions
+ */
+export type CountCondition =
+  | ResourceCountCondition
+  | KeywordCharacterCountCondition
+  | ClassificationCharacterCountCondition;
+
+/**
+ * Compare two values
+ *
+ * @example "If an opponent has more cards in their hand than you"
+ * @example "If you have more lore than each opponent"
+ */
+export interface ComparisonCondition {
+  type: "comparison";
+  /** Left side of comparison */
+  left: ComparisonValue;
+  /** Comparison operator */
+  comparison: ComparisonOperator;
+  /** Right side of comparison */
+  right: ComparisonValue;
+}
+
+export type ComparisonValue =
+  | { type: "lore"; controller: "you" | "opponent" }
+  | { type: "cards-in-hand"; controller: "you" | "opponent" }
+  | { type: "cards-in-inkwell"; controller: "you" | "opponent" }
+  | { type: "character-count"; controller: "you" | "opponent" }
+  | { type: "damage-on-self" }
+  | { type: "strength-of-self" }
+  | { type: "constant"; value: number };
+
+// ============================================================================
+// Game State Conditions
+// ============================================================================
+
+/**
+ * Check if Shift was used to play this character
+ */
+export interface UsedShiftCondition {
+  type: "used-shift";
+}
+
+// ============================================================================
+// This-Turn Conditions - Strict Variants
+// ============================================================================
+
+/**
+ * Events that can be checked "this turn"
+ */
+export type ThisTurnEvent =
+  | "played-song"
+  | "played-character"
+  | "played-action"
+  | "played-floodborn"
+  | "challenged"
+  | "quested"
+  | "banished-character"
+  | "damaged-character"
+  | "was-damaged"
+  | "inked";
+
+/**
+ * Check if something happened this turn (simple boolean check)
+ *
+ * @example "If you played a song this turn"
+ */
+export interface ThisTurnHappenedCondition {
+  type: "this-turn-happened";
+  /** What event to check - REQUIRED */
+  event: ThisTurnEvent;
+  /** Who did it - REQUIRED */
+  who: "you" | "opponent";
+}
+
+/**
+ * Check if something happened a specific number of times this turn
+ *
+ * @example "If you played 2 or more characters this turn"
+ */
+export interface ThisTurnCountCondition {
+  type: "this-turn-count";
+  /** What event to check - REQUIRED */
+  event: ThisTurnEvent;
+  /** Who did it - REQUIRED */
+  who: "you" | "opponent";
+  /** Comparison operator - REQUIRED */
+  comparison: ComparisonOperator;
+  /** Count to compare against - REQUIRED */
+  count: number;
+}
+
+/**
+ * Combined type for this-turn conditions
+ */
+export type ThisTurnCondition =
+  | ThisTurnHappenedCondition
+  | ThisTurnCountCondition;
+
+/**
+ * Check whose turn it is
+ */
+export interface TurnCondition {
+  type: "turn";
+  whose: "your" | "opponent";
+}
+
+/**
+ * Check if it's your turn (simplified version)
+ */
+export interface YourTurnCondition {
+  type: "your-turn";
+}
+
+/**
+ * Check if a character is exerted
+ */
+export interface ExertedCondition {
+  type: "exerted";
+  target?: "SELF" | CharacterTarget;
+}
+
+/**
+ * Check hand count
+ */
+export interface HandCountCondition {
+  type: "hand-count";
+  controller: "you" | "opponent";
+  count: number;
+  comparison?: ComparisonOperator;
+}
+
+/**
+ * Check if a stat meets a threshold
+ */
+export interface StatThresholdCondition {
+  type: "stat-threshold";
+  stat: "strength" | "willpower" | "lore";
+  value: number;
+  comparison: ComparisonOperator;
+  target?: "SELF" | CharacterTarget;
+}
+
+/**
+ * Check if something was played this turn
+ */
+export interface PlayedThisTurnCondition {
+  type: "played-this-turn";
+  cardType?: "character" | "action" | "item" | "song";
+}
+
+/**
+ * Check if you have a character (simplified)
+ */
+export interface HaveCharacterCondition {
+  type: "have-character";
+  name?: string;
+  classification?: string;
+}
+
+/**
+ * Check if you have a card
+ */
+export interface HaveCardCondition {
+  type: "have-card";
+  cardType?: "character" | "action" | "item" | "song";
+  name?: string;
+  zone?: "hand" | "play" | "discard";
+  controller?: "you" | "opponent";
+}
+
+/**
+ * Check a name condition
+ */
+export interface NameCondition {
+  type: "name";
+  name: string;
+  target?: CharacterTarget;
+}
+
+/**
+ * Character count condition (simplified)
+ */
+export interface CharacterCountCondition {
+  type: "character-count";
+  count: number;
+  comparison?: ComparisonOperator;
+  controller?: "you" | "opponent";
+}
+
+/**
+ * Generic target condition (for parser flexibility)
+ */
+export interface TargetCondition {
+  type: "target";
+  target: CharacterTarget | string;
+}
+
+/**
+ * Check if this is the first occurrence of something this turn
+ */
+export interface FirstThisTurnCondition {
+  type: "first-this-turn";
+  event: "challenge" | "quest" | "action" | "character-play";
+}
+
+// ============================================================================
+// Zone Conditions
+// ============================================================================
+
+/**
+ * Check for cards in a specific zone
+ */
+export interface ZoneCondition {
+  type: "zone";
+  zone: TargetZone;
+  controller: "you" | "opponent";
+  /** Card type filter */
+  cardType?: CardType | "song";
+  /** Has cards / is empty */
+  hasCards?: boolean;
+  /** Card name filter */
+  cardName?: string;
+}
+
+// ============================================================================
+// Combat Context Conditions
+// ============================================================================
+
+/**
+ * Check if the character is currently in a challenge
+ *
+ * Used for conditional keywords like "Resist +2 while challenging"
+ */
+export interface InChallengeCondition {
+  type: "in-challenge";
+}
+
+// ============================================================================
+// Player Choice Conditions
+// ============================================================================
+
+/**
+ * Player may choose to do something ("you may")
+ */
+export interface PlayerChoiceCondition {
+  type: "player-choice";
+  /** Who makes the choice (defaults to controller) */
+  chooser?: "controller" | "opponent";
+}
+
+// ============================================================================
+// Logical Operators
+// ============================================================================
+
+/**
+ * AND condition - all sub-conditions must be true
+ */
+export interface AndCondition {
+  type: "and";
+  conditions: Condition[];
+}
+
+/**
+ * OR condition - at least one sub-condition must be true
+ */
+export interface OrCondition {
+  type: "or";
+  conditions: Condition[];
+}
+
+/**
+ * NOT condition - sub-condition must be false
+ */
+export interface NotCondition {
+  type: "not";
+  condition: Condition;
+}
+
+/**
+ * IF condition - catch-all for parser conditions
+ *
+ * Used when the parser cannot determine a more specific condition type.
+ * This allows for flexible "if" expressions that will be refined later.
+ *
+ * @example "If a Villain character is chosen..."
+ * @deprecated Prefer using specific condition types when possible
+ */
+export interface IfCondition {
+  type: "if";
+  /** Natural language expression of the condition */
+  expression: string;
+}
+
+// ============================================================================
+// Extended Condition Types for Parser Support
+// ============================================================================
+
+/**
+ * Check if you have another character (besides self)
+ */
+export interface HasAnotherCharacterCondition {
+  type: "has-another-character";
+  classification?: string;
+  name?: string;
+}
+
+/**
+ * Check if you have a Captain character
+ */
+export interface HasCaptainCharacterCondition {
+  type: "has-captain-character";
+}
+
+/**
+ * Check if self is exerted (alias for is-exerted)
+ */
+export interface SelfExertedCondition {
+  type: "self-exerted";
+}
+
+/**
+ * Check if target is a Villain
+ */
+export interface IsVillainCondition {
+  type: "is-villain";
+  target?: string;
+}
+
+/**
+ * Check if target is a Princess
+ */
+export interface IsPrincessCondition {
+  type: "is-princess";
+  target?: string;
+}
+
+/**
+ * Check if target has a specific name
+ */
+export interface IsNamedCondition {
+  type: "is-named";
+  name: string;
+  target?: string;
+}
+
+/**
+ * Check inkwell count
+ */
+export interface InkwellCountCondition {
+  type: "inkwell-count";
+  controller: "you" | "opponent";
+  comparison?: ComparisonOperator;
+  count?: number;
+  /** Minimum inkwell count required */
+  minimum?: number;
+}
+
+/**
+ * Alias for has-named-character (parser compatibility)
+ */
+export interface HasCharacterNamedCondition {
+  type: "has-character-named";
+  name: string;
+  controller?: "you" | "opponent" | "any";
+}
+
+/**
+ * Unless condition - negated condition wrapper
+ *
+ * @example "This character can't quest unless you have a Seven Dwarfs character"
+ */
+export interface UnlessCondition {
+  type: "unless";
+  condition: Condition;
+}
+
+/**
+ * Lore comparison condition
+ *
+ * @example "If an opponent has more lore than you"
+ */
+export interface LoreComparisonCondition {
+  type: "lore-comparison";
+  comparison: ComparisonOperator;
+  value?: number;
+  versus?: "you" | "opponent";
+  compareTo?: "you" | "opponent";
+}
+
+/**
+ * Second action in turn condition
+ *
+ * @example "The second time you play a card this turn"
+ */
+export interface SecondInTurnCondition {
+  type: "second-in-turn";
+  action?: "play" | "quest" | "challenge" | "any";
+}
+
+/**
+ * Target is damaged condition
+ *
+ * @example "If the chosen character is damaged"
+ */
+export interface TargetIsDamagedCondition {
+  type: "target-is-damaged";
+}
+
+// ============================================================================
+// Combined Condition Type
+// ============================================================================
+
+/**
+ * All possible conditions
+ *
+ * Uses strict discriminated unions - each condition type has exactly
+ * the fields it needs with no ambiguous optional fields.
+ */
+export type Condition =
+  // Character Existence (strict variants)
+  | HasNamedCharacterCondition
+  | HasCharacterWithClassificationCondition
+  | HasCharacterWithKeywordCondition
+  | HasCharacterCountCondition
+  // Item Existence (strict variants)
+  | HasNamedItemCondition
+  | HasItemCountCondition
+  // Location Existence (strict variants)
+  | HasNamedLocationCondition
+  | HasLocationCountCondition
+  // Location State
+  | AtLocationCondition
+  // Damage State (strict variants)
+  | HasAnyDamageCondition
+  | DamageComparisonCondition
+  | NoDamageCondition
+  // Card State
+  | IsExertedCondition
+  | IsReadyCondition
+  | HasCardUnderCondition
+  | InInkwellCondition
+  | InPlayCondition
+  // Count Conditions (strict variants)
+  | ResourceCountCondition
+  | KeywordCharacterCountCondition
+  | ClassificationCharacterCountCondition
+  // Comparison
+  | ComparisonCondition
+  // Game state
+  | UsedShiftCondition
+  // This-Turn Conditions (strict variants)
+  | ThisTurnHappenedCondition
+  | ThisTurnCountCondition
+  // Turn
+  | TurnCondition
+  | YourTurnCondition
+  | FirstThisTurnCondition
+  // Zone
+  | ZoneCondition
+  | HasCharacterHereCondition
+  | RevealedMatchesNamedCondition
+  | RevealedMatchesChosenNameCondition
+  // Effect resolution
+  | IfYouDoCondition
+  // Combat Context
+  | InChallengeCondition
+  // Choice
+  | PlayerChoiceCondition
+  // Logical
+  | AndCondition
+  | OrCondition
+  | NotCondition
+  // Parser catch-all
+  | IfCondition
+  // Legacy Resolution (deprecated)
+  | ResolutionCondition
+  // Additional conditions for parser support
+  | ExertedCondition
+  | HandCountCondition
+  | StatThresholdCondition
+  | PlayedThisTurnCondition
+  | HaveCharacterCondition
+  | HaveCardCondition
+  | NameCondition
+  | CharacterCountCondition
+  | TargetCondition
+  // Extended conditions for card text coverage
+  | HasAnotherCharacterCondition
+  | HasCaptainCharacterCondition
+  | SelfExertedCondition
+  | IsVillainCondition
+  | IsPrincessCondition
+  | IsNamedCondition
+  | InkwellCountCondition
+  | HasCharacterNamedCondition
+  // Additional extended conditions
+  | HasLocationInPlayCondition
+  | HasFewerCharactersCondition
+  | OpponentHasMoreCardsCondition
+  | OpponentHasDamagedCharacterCondition
+  | TargetIsVillainCondition
+  | HasNoDamageCondition
+  | HasCharacterWithStrengthCondition
+  | ReturnedCardIsPrincessCondition
+  | RevealedHasSameNameCondition
+  | HasCharactersHereCondition
+  | HasCharacterAtLocationCondition
+  // More extended conditions
+  | BeingChallengedCondition
+  | SelfHasDamageCondition
+  | RevealedIsCharacterNamedCondition
+  | SecondInkwellThisTurnCondition
+  | WhileInPlayCondition
+  | PlayedCardThisTurnCondition
+  | OpponentHasMoreThanCardsCondition
+  | OpponentHasLoreCondition
+  | HasStrongestCharacterCondition
+  | HasDamagedCharacterHereCondition
+  | HasItemInPlayCondition
+  // Additional parser-compatible conditions
+  | UnlessCondition
+  | LoreComparisonCondition
+  | SecondInTurnCondition
+  | TargetIsDamagedCondition;
+
+// ============================================================================
+// Condition Builders (convenience)
+// ============================================================================
+
+/**
+ * Create a "has character named X" condition
+ */
+export function hasCharacterNamed(
+  name: string,
+  controller: "you" | "opponent" | "any" = "you",
+): HasNamedCharacterCondition {
+  return { type: "has-named-character", name, controller };
+}
+
+/**
+ * Create a "has character with classification" condition
+ */
+export function hasCharacterWithClassification(
+  classification: string,
+  controller: "you" | "opponent" | "any" = "you",
+): HasCharacterWithClassificationCondition {
+  return {
+    type: "has-character-with-classification",
+    classification,
+    controller,
+  };
+}
+
+/**
+ * Create a "has character with keyword" condition
+ */
+export function hasCharacterWithKeyword(
+  keyword: string,
+  controller: "you" | "opponent" | "any" = "you",
+): HasCharacterWithKeywordCondition {
+  return { type: "has-character-with-keyword", keyword, controller };
+}
+
+/**
+ * Create a "has X or more characters" condition
+ */
+export function hasCharacterCount(
+  count: number,
+  controller: "you" | "opponent" | "any" = "you",
+  comparison: ComparisonOperator = "greater-or-equal",
+): HasCharacterCountCondition {
+  return {
+    type: "has-character-count",
+    controller,
+    comparison,
+    count,
+  };
+}
+
+/**
+ * Create a count-based resource condition
+ */
+export function resourceCount(
+  what: CountableResource,
+  value: number,
+  controller: "you" | "opponent" | "any" = "you",
+  comparison: ComparisonOperator = "greater-or-equal",
+): ResourceCountCondition {
+  return {
+    type: "resource-count",
+    what,
+    controller,
+    comparison,
+    value,
+  };
+}
+
+/**
+ * Create a "while this character has no damage" condition
+ */
+export function whileNoDamage(): NoDamageCondition {
+  return { type: "no-damage" };
+}
+
+/**
+ * Create a "while this character has damage" condition
+ */
+export function whileHasDamage(): HasAnyDamageCondition {
+  return { type: "has-any-damage" };
+}
+
+/**
+ * Create a "if you used Shift" condition
+ */
+export function ifUsedShift(): UsedShiftCondition {
+  return { type: "used-shift" };
+}
+
+/**
+ * Create a "this turn happened" condition
+ */
+export function thisTurnHappened(
+  event: ThisTurnEvent,
+  who: "you" | "opponent" = "you",
+): ThisTurnHappenedCondition {
+  return { type: "this-turn-happened", event, who };
+}
+
+/**
+ * Create an "in challenge" condition
+ *
+ * Used for conditional keywords like "Resist +2 while challenging"
+ */
+export function inChallenge(): InChallengeCondition {
+  return { type: "in-challenge" };
+}
+
+/**
+ * Create a "you may" condition
+ */
+export function youMay(): PlayerChoiceCondition {
+  return { type: "player-choice" };
+}
+
+/**
+ * Create an "and" condition
+ */
+export function and(...conditions: Condition[]): AndCondition {
+  return { type: "and", conditions };
+}
+
+/**
+ * Create an "or" condition
+ */
+export function or(...conditions: Condition[]): OrCondition {
+  return { type: "or", conditions };
+}
+
+// ============================================================================
+// Type Guards
+// ============================================================================
+
+/**
+ * Check if condition is a logical operator
+ */
+export function isLogicalCondition(
+  condition: Condition,
+): condition is AndCondition | OrCondition | NotCondition {
+  return (
+    condition.type === "and" ||
+    condition.type === "or" ||
+    condition.type === "not"
+  );
+}
+
+/**
+ * Check if condition is a player choice ("you may")
+ */
+export function isPlayerChoice(
+  condition: Condition,
+): condition is PlayerChoiceCondition {
+  return condition.type === "player-choice";
+}
+
+/**
+ * Check if condition requires a count comparison
+ */
+export function isCountCondition(
+  condition: Condition,
+): condition is CountCondition {
+  return (
+    condition.type === "resource-count" ||
+    condition.type === "keyword-character-count" ||
+    condition.type === "classification-character-count"
+  );
+}