diff --git a/backend/src/effects/compile-primitives.ts b/backend/src/effects/compile-primitives.ts new file mode 100644 index 0000000..4f6a184 --- /dev/null +++ b/backend/src/effects/compile-primitives.ts @@ -0,0 +1,558 @@ +import type { Card, CardFace } from '../cards.js' +import { + parseCondition, + parseCost, + parseDuration, + parseNumber, + parseSelector, + parseTarget, + parseValue, + ROLE_NAMES, +} from './parse.js' +import type { + Ability, + CompiledCard, + CompiledFace, + Condition, + Cost, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, +} from './types.js' + +type Status = 'supported' | 'partial' | 'unsupported' + +export const SIMPLE_KEYWORDS = new Map([ + ['flying', 'Flying'], + ['trample', 'Trample'], + ['vigilance', 'Vigilance'], + ['haste', 'Haste'], + ['flash', 'Flash'], + ['reach', 'Reach'], + ['menace', 'Menace'], + ['lifelink', 'Lifelink'], + ['deathtouch', 'Deathtouch'], + ['first strike', 'First strike'], + ['double strike', 'Double strike'], + ['defender', 'Defender'], + ['indestructible', 'Indestructible'], + ['hexproof', 'Hexproof'], + ['prowess', 'Prowess'], + ['convoke', 'Convoke'], + ['delve', 'Delve'], + ['shroud', 'Shroud'], + ['shadow', 'Shadow'], + ['horsemanship', 'Horsemanship'], + ['fear', 'Fear'], + ['intimidate', 'Intimidate'], + ['skulk', 'Skulk'], + ['wither', 'Wither'], + ['infect', 'Infect'], + ['persist', 'Persist'], + ['undying', 'Undying'], + ['exalted', 'Exalted'], + ['evolve', 'Evolve'], + ['exploit', 'Exploit'], + ['riot', 'Riot'], + ['cascade', 'Cascade'], + ['banding', 'Banding'], + ['flanking', 'Flanking'], + ['storm', 'Storm'], + ['sunburst', 'Sunburst'], + ['haunt', 'Haunt'], + ['living weapon', 'Living weapon'], + ['battle cry', 'Battle cry'], + ['dethrone', 'Dethrone'], + ['melee', 'Melee'], + ['mentor', 'Mentor'], + ['aftermath', 'Aftermath'], + ['ascend', 'Ascend'], + ['fuse', 'Fuse'], + ['jump-start', 'Jump-start'], + ['improvise', 'Improvise'], + ['undaunted', 'Undaunted'], + ['spectacle', 'Spectacle'], + ['escape', 'Escape'], + ['companion', 'Companion'], + ['daybound', 'Daybound'], + ['nightbound', 'Nightbound'], + ['training', 'Training'], + ['read ahead', 'Read ahead'], + ['casualty', 'Casualty'], + ['enlist', 'Enlist'], + ['bargain', 'Bargain'], + ['gift', 'Gift'], + ['disguise', 'Disguise'], + ['cloak', 'Cloak'], + ['saddle', 'Saddle'], + ['impending', 'Impending'], + ['harmonize', 'Harmonize'], + ['start your engines!', 'Start your engines!'], + ['devoid', 'Devoid'], + ['changeling', 'Changeling'], + ['phasing', 'Phasing'], + ['dredge', 'Dredge'], + ['bloodthirst', 'Bloodthirst'], + ['devour', 'Devour'], + ['graft', 'Graft'], + ['modular', 'Modular'], + ['bushido', 'Bushido'], + ['rampage', 'Rampage'], + ['absorb', 'Absorb'], + ['frenzy', 'Frenzy'], + ['tribute', 'Tribute'], + ['soulshift', 'Soulshift'], +]) + +const PARAMETERIZED_KEYWORDS: Array<[RegExp, string]> = [ + [/^ward\s+(.+)$/, 'Ward'], + [/^ward—(.+)$/, 'Ward'], + [/^equip\s+(.+)$/, 'Equip'], + [/^crew\s+(\d+)$/, 'Crew'], + [/^saddle\s+(\d+)$/, 'Saddle'], + [/^cycling\s+(.+)$/, 'Cycling'], + [/^typecycling\s+(.+)$/, 'Typecycling'], + [/^landcycling\s+(.+)$/, 'Landcycling'], + [/^basic landcycling\s+(.+)$/, 'Basic landcycling'], + [/^flashback(?:\s*[—-]\s*|\s+)(.+)$/, 'Flashback'], + [/^kicker(?:\s*[—-]\s*|\s+)(.+)$/, 'Kicker'], + [/^entwine\s+(.+)$/, 'Entwine'], + [/^fabricate\s+(\d+)$/, 'Fabricate'], + [/^madness\s+(.+)$/, 'Madness'], + [/^suspend\s+(\d+)\s*[—-]\s*(.+)$/, 'Suspend'], + [/^protection from (.+)$/, 'Protection'], + [/^enchant (.+)$/, 'Enchant'], + [/^annihilator\s+(\d+)$/, 'Annihilator'], + [/^afterlife\s+(\d+)$/, 'Afterlife'], + [/^afflict\s+(\d+)$/, 'Afflict'], + [/^amass\s+(.+)$/, 'Amass'], + [/^affinity for (.+)$/, 'Affinity'], + [/^bestow\s+(.+)$/, 'Bestow'], + [/^emerge\s+(.+)$/, 'Emerge'], + [/^mutate\s+(.+)$/, 'Mutate'], + [/^morph\s+(.+)$/, 'Morph'], + [/^megamorph\s+(.+)$/, 'Megamorph'], + [/^manifest\s+(.+)$/, 'Manifest'], + [/^disguise\s+(.+)$/, 'Disguise'], + [/^cloak\s+(.+)$/, 'Cloak'], + [/^escape(?:\s*[—-]\s*|\s+)(.+)$/, 'Escape'], + [/^evoke\s+(.+)$/, 'Evoke'], + [/^echo\s+(.+)$/, 'Echo'], + [/^cumulative upkeep(?:\s*[—-]\s*|\s+)(.+)$/, 'Cumulative upkeep'], + [/^fading\s+(\d+)$/, 'Fading'], + [/^vanishing\s+(\d+)$/, 'Vanishing'], + [/^modular\s+(\d+)$/, 'Modular'], + [/^bushido\s+(\d+)$/, 'Bushido'], + [/^rampage\s+(\d+)$/, 'Rampage'], + [/^absorb\s+(\d+)$/, 'Absorb'], + [/^frenzy\s+(\d+)$/, 'Frenzy'], + [/^tribute\s+(\d+)$/, 'Tribute'], + [/^bloodthirst\s+(\d+)$/, 'Bloodthirst'], + [/^devour\s+(\d+)$/, 'Devour'], + [/^graft\s+(\d+)$/, 'Graft'], + [/^soulshift\s+(\d+)$/, 'Soulshift'], + [/^dredge\s+(\d+)$/, 'Dredge'], + [/^toxic\s+(\d+)$/, 'Toxic'], + [/^backup\s+(\d+)$/, 'Backup'], + [/^firebending\s+(\d+)$/, 'Firebending'], + [/^renown\s+(\d+)$/, 'Renown'], + [/^teamwork\s+(\d+)$/, 'Teamwork'], + [/^squad\s+(\d+)$/, 'Squad'], + [/^mobilize\s+(\d+)$/, 'Mobilize'], + [/^casualty\s+(\d+)$/, 'Casualty'], + [/^level up\s+(.+)$/, 'Level up'], + [/^plot\s+(.+)$/, 'Plot'], + [/^unearth\s+(.+)$/, 'Unearth'], + [/^buyback\s+(.+)$/, 'Buyback'], + [/^foretell\s+(.+)$/, 'Foretell'], + [/^forecast(?:\s*[—-]\s*|\s+)(.+)$/, 'Forecast'], + [/^ninjutsu\s+(.+)$/, 'Ninjutsu'], + [/^dash\s+(.+)$/, 'Dash'], + [/^disturb\s+(.+)$/, 'Disturb'], + [/^warp\s+(.+)$/, 'Warp'], + [/^blitz\s+(.+)$/, 'Blitz'], + [/^encore\s+(.+)$/, 'Encore'], + [/^grandeur(?:\s*[—-]\s*|\s+)(.+)$/, 'Grandeur'], + [/^scavenge\s+(.+)$/, 'Scavenge'], + [/^fortify\s+(.+)$/, 'Fortify'], + [/^outlast\s+(.+)$/, 'Outlast'], + [/^embalm\s+(.+)$/, 'Embalm'], + [/^eternalize\s+(.+)$/, 'Eternalize'], + [/^transfigure\s+(.+)$/, 'Transfigure'], + [/^transmute\s+(.+)$/, 'Transmute'], + [/^reconfigure\s+(.+)$/, 'Reconfigure'], + [/^partner with (.+)$/, 'Partner'], + [/^partner[—-](.+)$/, 'Partner'], + [/^companion\s*[—-]\s*(.+)$/, 'Companion'], + [/^(.+?)walk$/, 'Landwalk'], +] + +export const STANDALONE_ACTIONS = new Set([ + 'investigate', + 'proliferate', + 'populate', + 'learn', + 'take the initiative', + 'venture into the dungeon', + 'time travel', + 'open an attraction', + 'manifest dread', + 'the ring tempts you', + 'connive', + 'explore', +]) + +/** Removes reminder text. Oracle text only uses parentheses for reminders. */ +export function stripReminders(text: string): string { + let result = text + let previous: string + do { + previous = result + result = result.replace(/\s*\([^()]*\)/g, '') + } while (result !== previous) + return result.replace(/\s+/g, ' ').trim() +} + +export function normalize(text: string, cardName: string): string { + let result = stripReminders(text) + .replace(/\u2019/g, "'") + .replace(/\u2212/g, '-') + .replace(/\s+/g, ' ') + .trim() + + const names = [cardName] + const shortName = cardName.split(',')[0]?.trim() + if (shortName && shortName !== cardName) names.push(shortName) + + for (const name of names) { + if (!name) continue + const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + result = result.replace(new RegExp(`\\b${escaped}\\b`, 'gi'), 'this') + } + + result = result + .replace(/\bthis\s+[a-z]+'s\b/gi, 'its') + .replace(/\bthis's\b/gi, 'its') + .replace(/\bthis (?:creature|permanent|artifact|enchantment|land|card|spell|token|vehicle|aura|planeswalker|battle|saga|equipment|class|treasure|food|clue|blood|map|gold|powerstone)\b/gi, 'this') + .replace(/\b~'s\b/g, 'its') + .replace(/~/g, 'this') + .replace(/\bit's\b/gi, 'it is') + .replace(/\bdoesn't\b/gi, 'does not') + .replace(/\bcan't\b/gi, 'cannot') + .replace(/\bwon't\b/gi, 'will not') + + return result.replace(/\s+/g, ' ').trim() +} + +export function splitSentences(text: string): string[] { + return text + .split(/(?<=[.!?])\s+(?=\S)/) + .map(part => part.trim()) + .filter(Boolean) +} + +export const LEADING_DURATION = /^(until end of turn|until your next turn|until the end of your next turn|until end of combat), /i + +/** "Until end of turn, X" is the same effect as "X until end of turn". */ +export function takeLeadingDuration(text: string): { rest: string; duration?: string } { + const match = text.match(LEADING_DURATION) + if (!match) return { rest: text } + return { rest: text.slice(match[0].length), duration: match[1].toLowerCase() } +} + +/** Lowercase oracle text without destroying mana symbol casing ({W} -> {w}). */ +export function lowerText(text: string): string { + return text + .toLowerCase() + .replace(/\{([^}]+)\}/g, (_, symbols: string) => `{${symbols.toUpperCase()}}`) +} + +export function parseKeywordToken(part: string, known: Set): KeywordAbility | undefined { + const lower = part.trim().toLowerCase() + if (!lower) return undefined + + const knownKeyword = [...known].find(keyword => keyword.toLowerCase() === lower) + if (knownKeyword) return { kind: 'keyword', keyword: knownKeyword } + + const simple = SIMPLE_KEYWORDS.get(lower) + if (simple) return { kind: 'keyword', keyword: simple } + + for (const [pattern, keyword] of PARAMETERIZED_KEYWORDS) { + const match = lower.match(pattern) + if (match) return { kind: 'keyword', keyword, value: match[1] } + } + + return undefined +} + +export function parseKeywordLine(text: string, known: Set): KeywordAbility[] | undefined { + const whole = parseKeywordToken(text, known) + if (whole) return [whole] + + const parts = text + .split(/,| and /) + .map(part => part.trim()) + .filter(Boolean) + if (!parts.length) return undefined + + const keywords: KeywordAbility[] = [] + for (const part of parts) { + const keyword = parseKeywordToken(part, known) + if (!keyword) return undefined + keywords.push(keyword) + } + return keywords +} + +export function parseGroupTarget(text: string): Target | undefined { + const direct = parseTarget(text) + if (direct) { + if (direct.kind === 'object' && direct.mode === 'choose') return { ...direct, mode: 'each' } + return direct + } + + const selector = parseSelector(text) + if (selector) return { kind: 'object', selector, mode: 'each' } + return undefined +} + +export function parseSubject(text: string): Target | undefined { + let subject = text.trim() + subject = subject.replace(/^one or more /, '') + if (subject === 'this') return { kind: 'self' } + + const orAnother = subject.match(/^this or another (.+)$/) + if (orAnother) { + const selector = parseSelector(`another ${orAnother[1]}`) + if (selector) return { kind: 'object', selector, mode: 'each', includeSelf: true } + } + + return parseGroupTarget(subject) +} + +export function valueWithSign(text: string): Value | undefined { + const sign = text.startsWith('-') ? -1 : 1 + const raw = text.replace(/^[+-]/, '') + const value = parseValue(raw) + if (!value) return undefined + if (value.kind === 'number') return { kind: 'number', value: sign * value.value } + return value +} + +export function forEachSelector(text: string): ObjectSelector | undefined { + return parseSelector(text.replace(/^each /, '')) +} + +export function scaleEffect(effect: Effect, selector: ObjectSelector): Effect | undefined { + const count: Value = { kind: 'count', selector } + switch (effect.op) { + case 'damage': + if (effect.amount.kind !== 'number' || effect.amount.value !== 1) return undefined + return { ...effect, amount: count } + case 'draw': + case 'mill': + case 'life': + if (effect.amount.kind !== 'number' || effect.amount.value !== 1) return undefined + return { ...effect, amount: count } + case 'put_counters': + if (effect.amount.kind !== 'number' || effect.amount.value !== 1) return undefined + return { ...effect, amount: count } + case 'create_token': + if (effect.amount.kind !== 'number' || effect.amount.value !== 1) return undefined + return { ...effect, amount: count } + case 'pump': + if (effect.power.kind !== 'number' || effect.toughness.kind !== 'number') return undefined + if (![0, 1].includes(effect.power.value) || ![0, 1].includes(effect.toughness.value)) return undefined + if (effect.power.value === 0 && effect.toughness.value === 0) return undefined + return { + ...effect, + power: effect.power.value === 1 ? count : effect.power, + toughness: effect.toughness.value === 1 ? count : effect.toughness, + } + default: + return undefined + } +} + +export function parseToken(text: string): TokenSpec | undefined { + let rest = text.trim().toLowerCase().replace(/\s+tokens?$/, '') + if (rest.startsWith('a ') || rest.startsWith('an ')) rest = rest.replace(/^an? /, '') + const tapped = rest.startsWith('tapped ') + if (tapped) rest = rest.slice(7) + return parseTokenBody(rest, tapped) +} + +export function parseTokenBody(text: string, tapped: boolean): TokenSpec | undefined { + let rest = text.trim() + if (!rest) return undefined + if (/\b(copy|named|equal|number of|that's|thats)\b/.test(rest)) return undefined + + const colors: string[] = [] + for (const [word, code] of Object.entries({ white: 'W', blue: 'U', black: 'B', red: 'R', green: 'G' })) { + if (new RegExp(`\\b${word}\\b`).test(rest)) colors.push(code) + } + if (/\bcolorless\b/.test(rest)) colors.push('C') + + const role = Object.entries(ROLE_NAMES).find(([name]) => rest.endsWith(`${name} role`)) + if (role) { + return { name: role[1], types: ['enchantment'], subtypes: ['aura', 'role'], colors, tapped: tapped || undefined } + } + + let power: Value | undefined + let toughness: Value | undefined + const pt = rest.match(/^(\d+|x)\/(\d+|x)\b/) + if (pt) { + power = parseValue(pt[1]) + toughness = parseValue(pt[2]) + rest = rest.slice(pt[0].length).trim() + } + + const keywords: string[] = [] + const withMatch = rest.match(/\bwith (.+)$/) + if (withMatch) { + const parsed = parseKeywordLine(withMatch[1], new Set()) + if (!parsed) return undefined + for (const keyword of parsed) { + keywords.push(keyword.value ? `${keyword.keyword} ${keyword.value}` : keyword.keyword) + } + rest = rest.slice(0, withMatch.index).trim() + } + + const typeWords = new Set(['artifact', 'creature', 'enchantment', 'instant', 'land', 'planeswalker', 'sorcery', 'battle']) + const types: string[] = [] + const subtypes: string[] = [] + for (const word of rest.split(/[\s,]+/).filter(Boolean)) { + if (word === 'and' || word === 'or') continue + if (['white', 'blue', 'black', 'red', 'green', 'colorless', 'tapped'].includes(word)) continue + if (typeWords.has(word)) { + types.push(word) + continue + } + if (/^[a-z][a-z'-]*$/.test(word)) { + subtypes.push(word.length > 3 && word.endsWith('s') && !word.endsWith('ss') ? word.slice(0, -1) : word) + continue + } + return undefined + } + + if (!types.length) types.push('artifact') + if (!subtypes.length && !power) return undefined + + return { types, subtypes, colors, power, toughness, keywords: keywords.length ? keywords : undefined, tapped: tapped || undefined } +} + +export function parseDigDestination(text: string): 'hand' | 'graveyard' | 'battlefield' | 'top' | 'bottom' { + if (text === 'into your hand') return 'hand' + if (text === 'into your graveyard') return 'graveyard' + if (text === 'onto the battlefield') return 'battlefield' + if (text === 'on top of your library') return 'top' + return 'bottom' +} + +export function parseSearchDestination( + text: string, +): { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean } | undefined { + switch (text) { + case 'into your hand': + return { destination: 'hand', tapped: false } + case 'onto the battlefield': + return { destination: 'battlefield', tapped: false } + case 'onto the battlefield tapped': + return { destination: 'battlefield', tapped: true } + case 'into your graveyard': + return { destination: 'graveyard', tapped: false } + case 'on top of your library': + return { destination: 'top', tapped: false } + case 'on the bottom of your library': + return { destination: 'bottom', tapped: false } + default: + return undefined + } +} + +export function parseSearch(text: string): Effect | undefined { + const match = text.match(/^search your (library|library and\/or graveyard) for (.+)$/) + if (!match) return undefined + const zones: ('library' | 'graveyard')[] | undefined = + match[1] === 'library' ? undefined : ['library', 'graveyard'] + const body = match[2].trim() + + // Card names can contain commas, so try every comma as the selector/destination boundary. + for (let index = body.indexOf(', '); index !== -1; index = body.indexOf(', ', index + 1)) { + const selectorText = body.slice(0, index).trim() + const rest = body.slice(index + 2).trim() + + let amount: Value = { kind: 'number', value: 1 } + let nameText = selectorText + const upTo = nameText.match(/^up to (one|two|three|four|five|\d+) (.+)$/) + if (upTo) { + amount = parseValue(upTo[1]) ?? amount + nameText = upTo[2] + } else { + nameText = nameText.replace(/^an? /, '') + } + + const selector = parseSelector(nameText) + if (!selector) continue + + const revealPrefix = /^reveal (?:it|them|that card|those cards),? (?:and )?/ + let destinationText = rest.replace(revealPrefix, '') + let shuffle = false + if (/^then shuffle and put (?:it|them|that card|those cards|the card|the chosen card) on top(?: of your library)?$/.test(destinationText)) { + return { op: 'search', player: 'you', selector, amount, destination: 'top', tapped: false, shuffle: true, ...(zones ? { zones } : {}) } + } + if (/^shuffle and put (?:it|them|that card|those cards|the card|the chosen card) on top(?: of your library)?$/.test(destinationText)) { + return { op: 'search', player: 'you', selector, amount, destination: 'top', tapped: false, shuffle: true, ...(zones ? { zones } : {}) } + } + if (/^put (?:it|them|that card|those cards|the card|the chosen card) on top of your library, then shuffle$/.test(destinationText)) { + return { op: 'search', player: 'you', selector, amount, destination: 'top', tapped: false, shuffle: true, ...(zones ? { zones } : {}) } + } + + const split = destinationText.match(/^put one (.+?) and the other (.+?)(, then shuffle)?$/) + if (split && amount.kind === 'number' && amount.value >= 2) { + const first = parseSearchDestination(split[1].trim()) + const second = parseSearchDestination(split[2].trim()) + if (first && second) { + return { + op: 'search', + player: 'you', + selector, + amount, + destination: first.destination, + tapped: first.tapped, + shuffle: Boolean(split[3]), + split: second, + ...(zones ? { zones } : {}), + } + } + } + + const put = destinationText.match( + /^put (?:it|them|that card|those cards|the chosen card) (into your hand|onto the battlefield(?: tapped)?|into your graveyard|on top of your library|on the bottom of your library)(?: under your control)?(?:, then shuffle)?$/, + ) + if (!put) continue + + const parsedDestination = parseSearchDestination(put[1]) + if (!parsedDestination) continue + shuffle = /then shuffle$/.test(destinationText) + return { + op: 'search', + player: 'you', + selector, + amount, + destination: parsedDestination.destination, + tapped: parsedDestination.tapped, + shuffle, + ...(zones ? { zones } : {}), + } + } + + return undefined +} + diff --git a/backend/src/effects/compile-sentences.ts b/backend/src/effects/compile-sentences.ts new file mode 100644 index 0000000..a25f923 --- /dev/null +++ b/backend/src/effects/compile-sentences.ts @@ -0,0 +1,507 @@ +import type { Card, CardFace } from '../cards.js' +import { + parseCondition, + parseCost, + parseDuration, + parseNumber, + parseSelector, + parseTarget, + parseValue, + ROLE_NAMES, +} from './parse.js' +import type { + Ability, + CompiledCard, + CompiledFace, + Condition, + Cost, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, +} from './types.js' + +type Status = 'supported' | 'partial' | 'unsupported' +import { parseEffect } from './compile.js' +import { forEachSelector, lowerText, scaleEffect, splitSentences, takeLeadingDuration, valueWithSign } from './compile-primitives.js' + +export function resolvePreviousTarget(text: string, target: Target): string { + return text + .replace(/\bthat creature\b/gi, 'the chosen target') + .replace(/\bthat token\b/gi, 'the chosen target') + .replace(/\bit\b(?!['’]s)/gi, 'the chosen target') +} + +export function parseEffectSentence(text: string): Effect[] | undefined { + const emblem = text.trim().match(/^you get an emblem with "(.+)"$/i) + if (emblem) return [{ op: 'emblem', text: emblem[1] }] + + let sentence = lowerText(text).trim().replace(/\.$/, '') + sentence = sentence.replace(/^then /, '') + + const exileInstead = sentence.match( + /^if (a creature dealt damage this way|that creature(?: or planeswalker)?|it|that permanent) would die this turn, exile it instead$/, + ) + if (exileInstead) { + const target: Target = exileInstead[1] === 'a creature dealt damage this way' + ? { kind: 'damaged' } + : { kind: 'previous_target' } + return [{ op: 'exile_instead_of_dying', target }] + } + + const scaled = sentence.match(/^(.+?) for each (.+)$/) + if (scaled) { + const selector = forEachSelector(scaled[2]) + const base = parseEffect(scaled[1]) + if (selector && base && !Array.isArray(base)) { + const effect = scaleEffect(base, selector) + if (effect) return [effect] + } + return undefined + } + + const whereX = sentence.match(/^(.+?), where x is the number of (.+)$/) + if (whereX) { + const selector = parseSelector(whereX[2]) + const base = parseEffect(whereX[1]) + if (selector && base && !Array.isArray(base)) { + return [replaceX(base, { kind: 'count', selector })] + } + return undefined + } + + const direct = parseEffect(sentence) + if (direct) return Array.isArray(direct) ? direct : [direct] + + if (sentence.includes(' and ')) { + const parts = sentence.split(' and ') + if (parts.length === 2) { + const first = parseEffectSentence(parts[0]) + if (first) { + const target = first.some(effect => effect.op === 'create_token') + ? ({ kind: 'previous_target' } as Target) + : primaryTargetOf(first) + const subject = parts[0].match(/^(target player|target opponent|that player|each player|each opponent|you)\b/)?.[1] + let second = parseEffectSentence(parts[1]) + if (!second && target) second = parseEffectSentence(resolvePreviousTarget(parts[1], target)) + if (!second && subject) { + const verb = parts[1].match(/^(\w+)/)?.[1] + const text = `${subject} ${subject === 'you' && verb?.endsWith('s') ? verb.slice(0, -1) : verb}${parts[1].slice(verb?.length ?? 0)}` + second = parseEffectSentence(text) + } + if (second) return [...first, ...second] + } + } + } + + if (sentence.includes(', then ')) { + const parts = sentence.split(', then ') + const effects: Effect[] = [] + let target: Target | undefined + for (const part of parts) { + const parsed = parseEffectSentence(target ? resolvePreviousTarget(part, target) : part) + ?? parseEffectSentence(part) + if (!parsed) return undefined + effects.push(...parsed) + target = parsed.some(effect => effect.op === 'create_token') + ? { kind: 'previous_target' } + : primaryTargetOf(parsed) + } + return effects + } + + return undefined +} + +export function replaceX(effect: Effect, value: Value): Effect { + const replace = (current: Value): Value => (current.kind === 'x' ? value : current) + switch (effect.op) { + case 'damage': + return { ...effect, amount: replace(effect.amount) } + case 'draw': + case 'mill': + case 'life': + return { ...effect, amount: replace(effect.amount) } + case 'put_counters': + case 'remove_counters': + return { ...effect, amount: replace(effect.amount) } + case 'create_token': + return { ...effect, amount: replace(effect.amount) } + case 'pump': + return { ...effect, power: replace(effect.power), toughness: replace(effect.toughness) } + case 'search': + return { ...effect, amount: replace(effect.amount) } + default: + return effect + } +} + +export const PRIMARY_TARGET_OPS = new Set([ + 'pump', + 'grant', + 'set_pt', + 'gain_control', + 'tap', + 'untap', + 'destroy', + 'exile', + 'return_to_hand', + 'return_to_battlefield', + 'sacrifice', + 'put_counters', + 'attach', + 'regenerate', +]) + +export function primaryTargetOf(effects: Effect[]): Target | undefined { + for (const effect of effects) { + if (!('target' in effect) || !PRIMARY_TARGET_OPS.has(effect.op)) continue + const target = (effect as { target: Target }).target + if ( + target.kind === 'object' || + target.kind === 'self' || + target.kind === 'trigger_subject' || + target.kind === 'previous_target' + ) { + return target + } + } + return undefined +} + +export function parsePick(text: string): Value | undefined { + if (text === 'any number') return { kind: 'any_number' } + return parseValue(text) +} + +export function parseDig(text: string): Effect | undefined { + const reorder = text.match( + /^look at the top (\w+) cards? of (your|target player's) library, then put them back in any order(?:\. you may (?:have that player )?shuffle)?$/, + ) + if (reorder) { + const amount = parseValue(reorder[1]) + if (!amount) return undefined + return { + op: 'look_top', + player: reorder[2] === 'your' ? 'you' : 'target_player', + amount, + reorder: true, + } + } + + const prefix = text.match(/^look at the top (\w+) cards? of your library\. (.+)$/) + if (!prefix) return undefined + const amount = parseValue(prefix[1]) + if (!amount) return undefined + const body = prefix[2].trim().replace(/\.$/, '') + + let match = body.match( + /^put (up to )?(one|two|three|four|five|six|seven|eight|nine|ten|\d+|any number) (?:of them|of those cards) into your hand and the (?:other|rest)(?: of those cards)? (on the bottom of your library(?: in (any|a random) order)?|into your graveyard|on top of your library(?: in any order)?)$/, + ) + if (match) { + const pick = parsePick(match[2]) + if (pick) { + const destination = match[3] + const rest = destination.startsWith('on the bottom') + ? 'bottom' + : destination.startsWith('into your graveyard') + ? 'graveyard' + : 'top' + const order = /in a random order$/.test(destination) ? 'random' : 'any' + return { + op: 'dig', + player: 'you', + amount, + pick, + upTo: Boolean(match[1]) || undefined, + to: 'hand', + rest, + order, + } + } + } + + match = body.match( + /^(you may )?reveal (?:up to )?(one|two|three|four|five|\d+)? ?(.+?) from among them and put (?:it|them) into your hand\. put the rest (on the bottom of your library(?: in (any|a random) order)?|into your graveyard)$/, + ) + if (match) { + const selector = parseSelector(match[3]) + const pick = match[2] ? parsePick(match[2]) : ({ kind: 'number', value: 1 } as Value) + if (selector && pick) { + const destination = match[4] + const rest = destination.startsWith('on the bottom') ? 'bottom' : 'graveyard' + const order = /in a random order$/.test(destination) ? 'random' : 'any' + return { + op: 'dig', + player: 'you', + amount, + pick, + upTo: /^(?:you may )?reveal up to /.test(body) || undefined, + pickSelector: selector, + to: 'hand', + rest, + order, + optional: Boolean(match[1]) || undefined, + } + } + } + + match = body.match( + /^put up to (one|two|three|four|five|\d+) (.+?) from among them onto the battlefield( tapped)?(?: and the rest on the bottom of your library(?: in (any|a random) order)?|\. put the rest on the bottom of your library(?: in (any|a random) order)?)$/, + ) + if (match) { + const selector = parseSelector(match[2]) + const pick = parsePick(match[1]) + if (selector && pick) { + return { + op: 'dig', + player: 'you', + amount, + pick, + upTo: true, + pickSelector: selector, + to: 'battlefield', + tapped: Boolean(match[3]) || undefined, + rest: 'bottom', + order: /in a random order$/.test(body) ? 'random' : 'any', + } + } + } + + match = body.match( + /^(you may )?put (any number|one|two|three|four|five|\d+) of them into your hand and the rest into your graveyard$/, + ) + if (match) { + const pick = parsePick(match[2]) + if (pick) { + return { + op: 'dig', + player: 'you', + amount, + pick, + to: 'hand', + rest: 'graveyard', + optional: Boolean(match[1]) || undefined, + } + } + } + + return undefined +} + +export function parseEffects(text: string, defaultPronoun?: string): { effects: Effect[]; optional: boolean } | undefined { + let rest = text.trim().replace(/\.$/, '') + let optional = false + if (/^you may /i.test(rest)) { + optional = true + rest = rest.slice(8) + } + + const leading = takeLeadingDuration(rest) + rest = leading.rest + + const dig = parseDig(rest) + if (dig) return { effects: [dig], optional: optional || (dig.op === 'dig' && Boolean(dig.optional)) } + + const sentences = splitSentences(rest) + if (!sentences.length) return undefined + if (leading.duration) sentences[0] = `${sentences[0].replace(/\.$/, '')} ${leading.duration}` + + const effects: Effect[] = [] + let previousTarget: Target | undefined + for (let sentenceIndex = 0; sentenceIndex < sentences.length; sentenceIndex++) { + const rawSentence = sentences[sentenceIndex] + let sentence = rawSentence + .replace(/^when you do, /i, 'if you do, ') + .replace(/^when you don't, /i, "if you don't, ") + const leadingIt = /^it\b/i.test(sentence) + if (previousTarget && leadingIt) { + sentence = `the chosen target${sentence.slice(2)}` + } + if (previousTarget) { + sentence = resolvePreviousTarget(sentence, previousTarget) + } else if (defaultPronoun) { + sentence = resolveIt(sentence, defaultPronoun) + } + + // "Exile the top N ... You may play that card this turn" is one impulse effect. + const topCards = sentence.match(/^exile the top (?:(\w+) )?cards? of your library( face down)?\.?$/) + if (topCards) { + const permission = sentences[sentenceIndex + 1]?.match( + /^(?:until end of turn, )?you may (?:play|cast) (?:that card|those cards|it|them)(?: this turn)?\.?$/, + ) + const amount = topCards[1] ? parseValue(topCards[1]) : { kind: 'number' as const, value: 1 } + if (permission && amount) { + effects.push({ op: 'impulse', player: 'you', amount, faceDown: Boolean(topCards[2]) }) + sentenceIndex++ + previousTarget = { kind: 'previous_target' } + continue + } + } + + const spend = sentence.match(/^spend this mana only to (.+)$/i) + if (spend) { + const last = effects[effects.length - 1] + if (last?.op === 'add_mana') { + last.mana.restriction = spend[1] + continue + } + return undefined + } + + // The search already shuffles; the sentence only spells out when. + if (/^if you search your library this way, shuffle\.?$/i.test(sentence)) { + const last = effects[effects.length - 1] + if (last?.op !== 'search') return undefined + last.shuffle = true + continue + } + + // "If damage is prevented this way, ..." is a follow-up to the shield. + const prevented = sentence.match(/^if damage (?:is|was) prevented this way, (.+)$/i) + if (prevented) { + const last = effects[effects.length - 1] + if (last?.op !== 'prevent_damage') return undefined + const inner = parseEffectSentence(prevented[1]) + if (!inner) return undefined + last.then = [...(last.then ?? []), ...inner] + continue + } + + const perPrevented = sentence.match(/^for each 1 damage prevented this way, (.+)$/i) + if (perPrevented) { + const last = effects[effects.length - 1] + if (last?.op !== 'prevent_damage') return undefined + const inner = parseEffectSentence(perPrevented[1]) + if (!inner) return undefined + const scaled = inner.map(effect => { + if (!('amount' in effect) || !effect.amount || effect.amount === 'all') return effect + if (effect.amount.kind !== 'number' || effect.amount.value !== 1) return effect + return { ...effect, amount: { kind: 'event_amount' as const } } as Effect + }) + last.then = [...(last.then ?? []), ...scaled] + continue + } + + if (/^you gain life equal to the damage prevented this way\.?$/i.test(sentence)) { + const last = effects[effects.length - 1] + if (last?.op !== 'prevent_damage') return undefined + last.then = [...(last.then ?? []), { + op: 'life', + player: 'you', + amount: { kind: 'event_amount' }, + mode: 'gain', + }] + continue + } + + const exileInstead = sentence.match( + /^if (a creature dealt damage this way|that creature(?: or planeswalker)?|it|that permanent) would die this turn, exile it instead\.?$/i, + ) + if (exileInstead) { + effects.push({ + op: 'exile_instead_of_dying', + target: exileInstead[1].toLowerCase() === 'a creature dealt damage this way' + ? { kind: 'damaged' } + : { kind: 'previous_target' }, + }) + continue + } + + const conditional = sentence.match(/^if (.+?), (.+)$/i) + if (conditional) { + const raw = conditional[1].trim().toLowerCase() + const condition: Condition | undefined = + raw === 'you do' + ? { kind: 'if_you_do' } + : raw === "you don't" || raw === 'you do not' + ? { kind: 'if_you_dont' } + : parseCondition(conditional[1]) + if (condition) { + let inner = parseEffectSentence(conditional[2]) + if (!inner && /^you may /i.test(conditional[2])) { + inner = parseEffectSentence(conditional[2].slice(8)) + } + if (inner) { + effects.push({ op: 'conditional', condition, effects: inner }) + continue + } + } + return undefined + } + + const otherwise = sentence.match(/^otherwise, (.+)$/i) + if (otherwise) { + let inner = parseEffectSentence(otherwise[1]) + if (!inner && /^you may /i.test(otherwise[1])) { + inner = parseEffectSentence(otherwise[1].slice(8)) + } + if (inner) { + effects.push({ op: 'conditional', condition: { kind: 'otherwise' }, effects: inner }) + continue + } + return undefined + } + + const trailingIf = sentence.match(/^(.+?) if (.+)$/i) + if (trailingIf) { + const condition = parseCondition(trailingIf[2]) + const inner = condition ? parseEffectSentence(trailingIf[1]) : undefined + if (condition && inner) { + effects.push({ op: 'conditional', condition, effects: inner }) + continue + } + } + + let parsed: Effect[] | undefined + if (/, then /i.test(sentence)) { + const parts = sentence.split(/,\s+then\s+/i) + const combined: Effect[] = [] + let thenTarget: Target | undefined + for (const part of parts) { + const inner = parseEffectSentence(thenTarget ? resolvePreviousTarget(part, thenTarget) : part) + ?? parseEffectSentence(part) + if (!inner) { + combined.length = 0 + break + } + combined.push(...inner) + thenTarget = inner.some(effect => effect.op === 'create_token') + ? { kind: 'previous_target' } + : primaryTargetOf(inner) + } + if (combined.length) parsed = combined + } + if (!parsed) parsed = parseEffectSentence(sentence) + if (!parsed && /^you may /i.test(sentence)) { + parsed = parseEffectSentence(sentence.slice(8)) + if (parsed) optional = true + } + if (!parsed) return undefined + if (!leadingIt) { + const prevention = parsed.find(effect => effect.op === 'prevent_damage') + const newTarget = prevention?.op === 'prevent_damage' ? prevention.target : primaryTargetOf(parsed) + if (newTarget) previousTarget = newTarget + } + if (parsed.some(effect => effect.op === 'create_token')) previousTarget = { kind: 'previous_target' } + effects.push(...parsed) + } + + return { effects, optional } +} + + + +export function resolveIt(text: string, pronoun: string): string { + if (/^it\b/i.test(text)) return `${pronoun}${text.slice(2)}` + if (/\b(?:target|that|those)\b/.test(text)) return text + // A card/token/permanent mentioned in the effect introduces a new referent; + // replacing "it" there would guess. Leave it unsupported instead. + if (/\b(?:card|cards|token|tokens|permanent|permanents|creature|creatures|spell|spells)\b/.test(text)) return text + return text.replace(/\bit\b/g, pronoun) +} \ No newline at end of file diff --git a/backend/src/effects/compile-static.ts b/backend/src/effects/compile-static.ts new file mode 100644 index 0000000..f411eee --- /dev/null +++ b/backend/src/effects/compile-static.ts @@ -0,0 +1,688 @@ +import type { Card, CardFace } from '../cards.js' +import { + parseCondition, + parseCost, + parseDuration, + parseNumber, + parseSelector, + parseTarget, + parseValue, + ROLE_NAMES, +} from './parse.js' +import type { + Ability, + CompiledCard, + CompiledFace, + Condition, + Cost, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, +} from './types.js' + +type Status = 'supported' | 'partial' | 'unsupported' +import { compileLine } from './compile.js' +import { forEachSelector, parseKeywordLine, parseToken, takeLeadingDuration, valueWithSign } from './compile-primitives.js' + +export function parseStaticTarget(text: string): Target | undefined { + if (text.trim() === 'this' || text.trim() === 'it') return { kind: 'self' } + const direct = parseTarget(text) + if (direct && direct.kind === 'object') return { ...direct, mode: 'each' } + const selector = parseSelector(text) + if (selector) return { kind: 'object', selector, mode: 'each' } + return undefined +} + +/** "Each spell you cast that's X" and "X spells and Y spells" reduce on a union. */ +export function parseCostReductionTarget(text: string): Target | undefined { + const eachSpell = text.match(/^each spell you cast that(?:'s| is) (.+)$/) + const normalized = eachSpell + ? `${eachSpell[1].replace(/^an? /, '')} spells you cast` + : text + const target = parseStaticTarget(normalized) + if (!target || target.kind !== 'object') return target + if (!/\band\b|,/.test(normalized)) return target + + target.selector.match = 'any' + // parseSelector infers one type from the first subtype; a mixed list has none. + if ((target.selector.subtypes?.length ?? 0) > 1) target.selector.types = [] + return target +} + +function tokenSpecByName(name: string): TokenSpec { + const clean = name.trim().replace(/^an? /i, '').replace(/ tokens?$/i, '') + return { + name: clean.charAt(0).toUpperCase() + clean.slice(1), + types: ['artifact'], + subtypes: [clean.toLowerCase()], + colors: [], + } +} + +function parseReplacementTokens(text: string, from: string[]): TokenSpec[] | undefined { + if (/^one of each$/i.test(text.trim())) return from.map(tokenSpecByName) + const parts = text.split(/, and |, or | and |, /i).map(part => part.trim()).filter(Boolean) + const tokens: TokenSpec[] = [] + for (const part of parts) { + const spec = parseToken(part) + if (!spec) return undefined + tokens.push(spec) + } + return tokens.length ? tokens : undefined +} + +export function parseStaticEffects(text: string): StaticEffect[] | undefined { + const sentence = text + .trim() + .replace(/\.$/, '') + // Clarifies how a colored cost reduction works; our symbols do exactly this. + .replace(/\. this effect reduces only the amount of colored mana you pay$/, '') + + let match = sentence.match(/^prevent all (combat )?damage that would be dealt to (.+?)(?: by (.+?))?$/) + if (match) { + const target = parseStaticTarget(match[2]) + const selector = match[3] ? parseSelector(match[3]) : undefined + if (target && (selector || !match[3])) { + return [{ + op: 'prevent_damage', + target, + amount: 'all', + combatOnly: Boolean(match[1]) || undefined, + duration: 'permanent', + ...(selector ? { sourceSelector: selector } : {}), + }] + } + } + + match = sentence.match(/^prevent all (combat )?damage that would be dealt by (.+?)$/) + if (match) { + const selector = parseSelector(match[2]) + if (selector) { + return [{ + op: 'prevent_damage', + target: { kind: 'any' }, + amount: 'all', + combatOnly: Boolean(match[1]) || undefined, + duration: 'permanent', + global: true, + sourceSelector: selector, + }] + } + } + + match = sentence.match(/^(?:its|this's) (base )?power and toughness are each equal to (.+)$/) + if (match) { + const value = parseValue(match[2]) + if (value) { + return [{ + op: 'set_pt', + target: { kind: 'self' }, + power: value, + toughness: value, + base: Boolean(match[1]) || undefined, + }] + } + } + + match = sentence.match(/^(?:its|this's) (base )?power is equal to (.+)$/) + if (match) { + const value = parseValue(match[2]) + if (value) { + return [{ op: 'set_pt', target: { kind: 'self' }, power: value, base: Boolean(match[1]) || undefined }] + } + } + + match = sentence.match(/^(?:its|this's) (base )?toughness is equal to (.+)$/) + if (match) { + const value = parseValue(match[2]) + if (value) { + return [{ op: 'set_pt', target: { kind: 'self' }, toughness: value, base: Boolean(match[1]) || undefined }] + } + } + + match = sentence.match(/^(.+?) (?:gets|get) ([+-]\w+)\/([+-]\w+) for each (.+)$/) + if (match) { + const target = parseStaticTarget(match[1]) + const power = valueWithSign(match[2]) + const toughness = valueWithSign(match[3]) + const selector = forEachSelector(match[4]) + if (target && power && toughness && selector) { + const count: Value = { kind: 'count', selector } + const scaled = (value: Value): Value | undefined => { + if (value.kind !== 'number' || (value.value !== 0 && value.value !== 1)) return undefined + return value.value === 1 ? count : value + } + const scaledPower = scaled(power) + const scaledToughness = scaled(toughness) + if (scaledPower && scaledToughness) { + return [{ op: 'pump', target, power: scaledPower, toughness: scaledToughness }] + } + } + } + + match = sentence.match(/^(.+?) (?:gets|get) ([+-]\w+)\/([+-]\w+) and (?:has|have) "(.+)"$/) + if (match) { + const target = parseStaticTarget(match[1]) + const power = valueWithSign(match[2]) + const toughness = valueWithSign(match[3]) + if (target && power && toughness) { + const ability = compileLine(match[4], 'Quoted', new Set(), false) + if (ability.kind !== 'unsupported') { + return [ + { op: 'pump', target, power, toughness }, + { op: 'grant_ability', target, ability }, + ] + } + } + } + + match = sentence.match(/^(.+?) (?:gets|get) ([+-]\w+)\/([+-]\w+) and (?:has|have) (.+)$/) + if (match) { + const target = parseStaticTarget(match[1]) + const power = valueWithSign(match[2]) + const toughness = valueWithSign(match[3]) + const keywords = parseKeywordLine(match[4], new Set()) + if (target && power && toughness && keywords) { + return [ + { op: 'pump', target, power, toughness }, + ...keywords.map(keyword => ({ + op: 'grant' as const, + target, + keyword: keyword.keyword, + value: keyword.value, + })), + ] + } + } + + match = sentence.match(/^(.+?) (?:gets|get) ([+-]\w+)\/([+-]\w+)$/) + if (match) { + const target = parseStaticTarget(match[1]) + const power = valueWithSign(match[2]) + const toughness = valueWithSign(match[3]) + if (target && power && toughness) return [{ op: 'pump', target, power, toughness }] + } + + match = sentence.match(/^(.+?) (?:has|have) "(.+)"$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) { + const ability = compileLine(match[2], 'Quoted', new Set(), false) + if (ability.kind !== 'unsupported') return [{ op: 'grant_ability', target, ability }] + } + } + + match = sentence.match(/^(.+?) (?:has|have) (.+)$/) + if (match) { + const target = parseStaticTarget(match[1]) + const keywords = parseKeywordLine(match[2], new Set()) + if (target && keywords) { + return keywords.map(keyword => ({ + op: 'grant', + target, + keyword: keyword.keyword, + value: keyword.value, + })) + } + } + + if (sentence === 'you have no maximum hand size') { + return [{ + op: 'restriction', + target: { kind: 'player', who: 'you', mode: 'target' }, + rule: 'no_max_hand_size', + }] + } + + if (sentence === 'you may look at the top card of your library any time') { + return [{ + op: 'restriction', + target: { kind: 'player', who: 'you', mode: 'target' }, + rule: 'may_look_at_top', + }] + } + + if (sentence === 'this can be your commander') { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'can_be_commander' }] + } + + if (sentence === 'you may choose not to untap this during your untap step') { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'may_choose_not_to_untap' }] + } + + if (sentence === 'this enters prepared') { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'enters_prepared' }] + } + + if (sentence === 'if this is in your opening hand, you may begin the game with it on the battlefield') { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'begin_on_battlefield' }] + } + + if (sentence === 'this can block only creatures with flying') { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'can_block_only_flying' }] + } + + if (sentence === "this cannot be blocked by more than one creature") { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_be_blocked_by_more_than_one' }] + } + + if (sentence === "this can't be blocked by more than one creature") { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_be_blocked_by_more_than_one' }] + } + + if (sentence === 'this cannot attack alone') { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_attack_alone' }] + } + + if (sentence === 'this cannot block alone') { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_block_alone' }] + } + + if (sentence === 'this must be blocked if able' || sentence === 'all creatures able to block this do so') { + return [{ op: 'restriction', target: { kind: 'self' }, rule: 'must_be_blocked' }] + } + + if (sentence === 'you may play an additional land on each of your turns') { + return [{ + op: 'restriction', + target: { kind: 'player', who: 'you', mode: 'target' }, + rule: 'additional_land_drop', + value: { kind: 'number', value: 1 }, + }] + } + + match = sentence.match(/^this cannot be blocked by creatures with power (\w+) or (greater|more|less)$/) + if (match) { + const value = parseValue(match[1]) + if (value) { + return [{ + op: 'restriction', + target: { kind: 'self' }, + rule: 'cant_be_blocked_by_power', + value, + comparison: match[2] === 'less' ? 'or_less' : 'or_greater', + }] + } + } + + match = sentence.match(/^this cannot attack unless defending player controls (.+)$/) + if (match) { + const selector = parseSelector(match[1]) + if (selector) { + return [{ + op: 'restriction', + target: { kind: 'self' }, + rule: 'cant_attack_unless', + condition: { kind: 'defending_player_controls', selector }, + }] + } + } + + if (sentence === 'you control enchanted creature') { + const target = parseStaticTarget('enchanted creature') + if (target) return [{ op: 'control', target }] + } + + match = sentence.match(/^as this enters, choose (?:a|an) (.+)$/) + if (match) { + const what = + match[1] === 'creature type' + ? 'creature_type' + : match[1] === 'color' + ? 'color' + : match[1] === 'card name' + ? 'card_name' + : match[1] === 'player' + ? 'player' + : match[1] === 'opponent' + ? 'opponent' + : match[1] === 'number' + ? 'number' + : undefined + if (what) return [{ op: 'choose', what }] + } + + match = sentence.match(/^if an effect would create one or more (tokens?|creature tokens?) under your control, it creates (twice|three times) that many of those tokens instead$/) + if (match) { + return [{ + op: 'token_multiplier', + multiplier: match[2] === 'twice' ? 2 : 3, + who: 'you', + ...(match[1] === 'creature tokens' ? { creatureOnly: true } : {}), + }] + } + + match = sentence.match(/^if one or more (tokens?|creature tokens?) would be created( under your control)?, (twice|three times) that many of those tokens are created instead$/) + if (match) { + return [{ + op: 'token_multiplier', + multiplier: match[3] === 'twice' ? 2 : 3, + who: match[2] ? 'you' : 'each_player', + ...(match[1] === 'creature tokens' ? { creatureOnly: true } : {}), + }] + } + + match = sentence.match(/^if you would create (.+?), instead create one of each$/) + if (match) { + const from = match[1] + .replace(/ tokens?$/i, '') + .split(/, and |, or | and |, /i) + .map(part => part.trim().replace(/^an? /i, '')) + .filter(Boolean) + if (from.length) { + return [{ op: 'token_replacement', from, tokens: from.map(tokenSpecByName), who: 'you' }] + } + } + + match = sentence.match(/^if you would create (?:a|an) (.+?) token, instead create (.+)$/) + if (match) { + const from = [match[1]] + const tokens = parseReplacementTokens(match[2], from) + if (tokens) return [{ op: 'token_replacement', from, tokens, who: 'you' }] + } + + match = sentence.match(/^if you would create (?:a|an) (.+?) token, create (.+) instead$/) + if (match) { + const from = [match[1]] + const tokens = parseReplacementTokens(match[2], from) + if (tokens) return [{ op: 'token_replacement', from, tokens, who: 'you' }] + } + + match = sentence.match(/^if (?:you|a player) would gain life, (?:you|they) gain (twice|three times|double) that much life(?: plus (\w+))? instead$/) + if (match) { + return [{ + op: 'replacement_amount', + what: 'life_gain', + multiplier: match[1] === 'three times' ? 3 : 2, + ...(match[2] ? { add: parseNumber(match[2]) ?? 0 } : {}), + }] + } + + match = sentence.match(/^if you would gain life, you gain that much life plus (\w+) instead$/) + if (match) { + return [{ op: 'replacement_amount', what: 'life_gain', multiplier: 1, add: parseNumber(match[1]) ?? 0 }] + } + + match = sentence.match(/^if you would draw a card(?: except the first one you draw in each of your draw steps)?, draw (\w+) cards? instead$/) + if (match) { + const amount = parseNumber(match[1]) + if (amount) return [{ op: 'replacement_amount', what: 'draw', multiplier: amount }] + } + + match = sentence.match(/^if a source you control would deal (noncombat )?damage(?: to a permanent or player)?, it deals (?:double|twice) that damage(?: to that permanent or player)? instead$/) + if (match) { + return [{ + op: 'replacement_amount', + what: 'damage', + multiplier: 2, + controller: 'you', + ...(match[1] ? { noncombatOnly: true } : {}), + }] + } + + match = sentence.match(/^double all damage that (?:sources|creature sources) you control would deal$/) + if (match) return [{ op: 'replacement_amount', what: 'damage', multiplier: 2, controller: 'you' }] + + match = sentence.match(/^if (?:a|another) (white|blue|black|red|green) source( you control)? would deal (noncombat )?damage(?: to a (?:player|permanent or player))?, it deals (?:that much damage plus (\w+)|(?:double|twice) that damage)(?: to that (?:player|permanent or player))? instead$/) + if (match) { + const color = match[1][0].toUpperCase() + const add = match[4] ? parseNumber(match[4]) : undefined + return [{ + op: 'replacement_amount', + what: 'damage', + multiplier: match[4] ? 1 : 2, + ...(add !== undefined ? { add } : {}), + ...(match[2] ? { controller: 'you' as const } : {}), + ...(match[3] ? { noncombatOnly: true } : {}), + sourceColor: color, + }] + } + + match = sentence.match(/^if one or more (.+?) counters? would be put on (.+?), (?:twice|three times|that many plus \w+) that many (?:.+? )?counters? (?:are|is) put on (?:it|that creature|that permanent) instead$/) + if (match) { + const target = parseStaticTarget(match[2]) + const plus = sentence.match(/that many plus (\w+)/) + if (target) { + return [{ + op: 'counter_multiplier', + target, + counter: match[1], + multiplier: /twice/.test(sentence) ? 2 : /three times/.test(sentence) ? 3 : 1, + ...(plus ? { add: parseNumber(plus[1]) ?? 0 } : {}), + }] + } + } + + match = sentence.match(/^if you would get one or more \{e\}, you get (twice|three times) that many \{e\} instead$/) + if (match) { + return [{ op: 'replacement_amount', what: 'energy', multiplier: match[1] === 'three times' ? 3 : 2 }] + } + + match = sentence.match(/^if you would get one or more \{e\}, you get that many plus (\w+) \{e\} instead$/) + if (match) { + return [{ op: 'replacement_amount', what: 'energy', multiplier: 1, add: parseNumber(match[1]) ?? 0 }] + } + + match = sentence.match(/^if this would be put into (?:a|your) graveyard from anywhere, exile it instead$/) + if (match) { + return [{ op: 'replacement', what: 'dies', instead: 'exile', target: { kind: 'self' } }] + } + + match = sentence.match(/^if this would leave the battlefield, exile it instead$/) + if (match) { + return [{ op: 'replacement', what: 'leaves_battlefield', instead: 'exile', target: { kind: 'self' } }] + } + + if (sentence === 'if a card or token would be put into a graveyard from anywhere, exile it instead') { + return [{ op: 'exile_instead_of_graveyard' }] + } + + match = sentence.match(/^if a card would be put into (an opponent's|your) graveyard from anywhere, exile it instead$/) + if (match) { + return [{ op: 'exile_instead_of_graveyard', owner: match[1] === 'your' ? 'you' : 'opponent' }] + } + + match = sentence.match(/^if (an opponent|you) would search (?:a|their) library, that player searches the top (\w+) cards? of that library instead$/) + if (match) { + const amount = parseValue(match[2]) + if (amount) return [{ op: 'search_restriction', who: match[1] === 'you' ? 'you' : 'opponent', amount }] + } + + match = sentence.match(/^activated abilities of (.+?) cannot be activated$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) return [{ op: 'restriction', target, rule: 'cant_activate' }] + } + + match = sentence.match(/^(noncreature|creature) spells cost (\{[^}]+\}) more to cast$/) + if (match) { + const amount = parseValue(match[2].slice(1, -1)) + if (amount) return [{ op: 'cost_increase', amount, spellType: match[1] === 'creature' ? 'creature' : 'noncreature' }] + } + + let costText = sentence + let costCondition: Condition | undefined + let costAmount: Value | undefined + const costWhereX = costText.match(/^(.+?), where x is (.+)$/) + if (costWhereX) { + const value = parseValue(costWhereX[2]) + if (value) { + costText = costWhereX[1] + costAmount = value + } + } + const costIf = costText.match(/^(.+?) if (.+)$/) + if (costIf) { + const parsed = parseCondition(costIf[2]) + if (parsed) { + costText = costIf[1] + costCondition = parsed + } + } + match = costText.match(/^(.+?) costs? ((?:\{[^}]+\})+) less to cast(?: for each (.+))?$/) + if (match) { + const target = parseCostReductionTarget(match[1]) + let amount: Value | undefined = costAmount + let symbols: string | undefined + if (!amount && match[3]) { + const selector = parseSelector(match[3]) + if (selector) amount = { kind: 'count', selector } + } else if (!amount) { + const parts = [...match[2].matchAll(/\{([^}]+)\}/g)].map(symbol => symbol[1]) + if (parts.some(part => /[WUBRGC]/i.test(part))) symbols = match[2].toUpperCase() + else if (parts[0]) amount = parseValue(parts[0].toLowerCase()) + } + if (target && (amount || symbols)) { + return [{ + op: 'cost_reduction', + target, + ...(amount ? { amount } : {}), + ...(symbols ? { symbols } : {}), + ...(costCondition ? { condition: costCondition } : {}), + }] + } + } + + match = sentence.match(/^(.+?) cannot attack or block$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) { + return [ + { op: 'restriction', target, rule: 'cant_attack' }, + { op: 'restriction', target, rule: 'cant_block' }, + ] + } + } + + match = sentence.match(/^(.+?) cannot attack or block, and its activated abilities cannot be activated$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) { + return [ + { op: 'restriction', target, rule: 'cant_attack' }, + { op: 'restriction', target, rule: 'cant_block' }, + { op: 'restriction', target, rule: 'cant_activate' }, + ] + } + } + + if (sentence === 'skip your draw step') { + return [{ + op: 'restriction', + target: { kind: 'player', who: 'you', mode: 'target' }, + rule: 'skip_draw_step', + }] + } + + match = sentence.match(/^(.+?) cannot attack$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) return [{ op: 'restriction', target, rule: 'cant_attack' }] + } + + match = sentence.match(/^(.+?) cannot block$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) return [{ op: 'restriction', target, rule: 'cant_block' }] + } + + match = sentence.match(/^(.+?) cannot be blocked$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) return [{ op: 'restriction', target, rule: 'cant_be_blocked' }] + } + + match = sentence.match(/^(.+?) cannot be countered$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) return [{ op: 'restriction', target, rule: 'cant_be_countered' }] + } + + match = sentence.match(/^(.+?) does not untap during (?:its controller's|your) untap step$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) return [{ op: 'restriction', target, rule: 'doesnt_untap' }] + } + + match = sentence.match(/^(.+?) attacks each combat if able$/) + if (match) { + const target = parseStaticTarget(match[1]) + if (target) return [{ op: 'restriction', target, rule: 'must_attack' }] + } + + if (sentence === 'this enters tapped') { + return [{ op: 'enters_tapped', target: { kind: 'self' } }] + } + match = sentence.match(/^as this enters, you may pay (\w+) life\. if you don't, it enters tapped$/) + if (match) { + const amount = parseValue(match[1]) + if (amount) return [{ op: 'enters_tapped', target: { kind: 'self' }, unlessCost: { kind: 'pay_life', amount } }] + } + const entersTappedUnless = sentence.match(/^this enters tapped unless (.+)$/) + if (entersTappedUnless) { + const unless = parseCondition(entersTappedUnless[1]) + if (unless) return [{ op: 'enters_tapped', target: { kind: 'self' }, unless }] + } + + match = sentence.match(/^(.+?) enters with (?:(\w+) )?(?:additional )?(.+?) counters? on it(?: for each (.+))?$/) + if (match) { + const target = parseStaticTarget(match[1]) + let amount = match[2] ? parseValue(match[2]) : ({ kind: 'number', value: 1 } as Value) + if (match[4]) { + const selector = parseSelector(match[4]) + if (selector) amount = { kind: 'count', selector } + } + if (target && amount) { + return [{ op: 'enters_with_counters', target, counter: match[3], amount }] + } + } + + return undefined +} + +export function parseStaticAbility(text: string): { effects: StaticEffect[]; condition?: Condition } | undefined { + let rest = text.trim().replace(/\.$/, '') + + // A leading duration makes this a one-shot effect, not a continuous one. + if (takeLeadingDuration(rest).duration) return undefined + + let condition: Condition | undefined + const conditionPrefix = rest.match(/^(?:during your turn|as long as it is your turn), (.+)$/) + if (conditionPrefix) { + condition = { kind: 'your_turn' } + rest = conditionPrefix[1] + } else { + const longAsPrefix = rest.match(/^as long as (.+?), (.+)$/) + if (longAsPrefix) { + condition = parseCondition(longAsPrefix[1]) + if (!condition) return undefined + rest = longAsPrefix[2] + } else { + const conditionSuffix = rest.match(/^(.+?) as long as (.+)$/) + if (conditionSuffix) { + condition = parseCondition(conditionSuffix[2]) + if (!condition) return undefined + rest = conditionSuffix[1] + } else { + const ifSuffix = rest.match(/^(.+?) if (.+)$/) + if (ifSuffix) { + const parsed = parseCondition(ifSuffix[2]) + if (parsed) { + condition = parsed + rest = ifSuffix[1] + } + } + } + } + } + + const effects = parseStaticEffects(rest) + return effects ? { effects, condition } : undefined +} + diff --git a/backend/src/effects/compile-triggers.ts b/backend/src/effects/compile-triggers.ts new file mode 100644 index 0000000..2e7701a --- /dev/null +++ b/backend/src/effects/compile-triggers.ts @@ -0,0 +1,247 @@ +import type { Card, CardFace } from '../cards.js' +import { + parseCondition, + parseCost, + parseDuration, + parseNumber, + parseSelector, + parseTarget, + parseValue, + ROLE_NAMES, +} from './parse.js' +import type { + Ability, + CompiledCard, + CompiledFace, + Condition, + Cost, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, +} from './types.js' + +type Status = 'supported' | 'partial' | 'unsupported' +import { parseSubject } from './compile-primitives.js' +import { parseEffectSentence, parseEffects } from './compile-sentences.js' + + +export function stripTriggerFrequency(text: string): { text: string; oncePerTurn: boolean } { + const trimmed = text.trim() + const match = trimmed.match(/^(.*?)\s*this ability triggers only once( each turn)?\.?$/i) + if (!match) return { text: trimmed, oncePerTurn: false } + return { text: match[1].replace(/\.$/, '').trim(), oncePerTurn: true } +} + +export function parseTriggerPrefix(text: string): { event: TriggerEvent; rest: string } | undefined { + let rest = text.trim() + + let match = rest.match(/^when(?:ever)? this (enters|dies|attacks|blocks|leaves the battlefield)(?: the battlefield)?, (.+)$/) + if (match) { + const kind = match[1] as 'enters' | 'dies' | 'attacks' | 'blocks' | 'leaves the battlefield' + const eventKind = kind === 'leaves the battlefield' ? 'leaves_battlefield' : kind + return { event: { kind: eventKind, subject: { kind: 'self' } } as TriggerEvent, rest: match[2] } + } + + match = rest.match(/^when(?:ever)? this becomes level (\d+), (.+)$/) + if (match) { + return { event: { kind: 'becomes_level', level: Number(match[1]) }, rest: match[2] } + } + + match = rest.match(/^when(?:ever)? this enters or attacks, (.+)$/) + if (match) return { event: { kind: 'enters_or_attacks', subject: { kind: 'self' } }, rest: match[1] } + + match = rest.match(/^when(?:ever)? this enters? or attacks?, (.+)$/) + if (match) return { event: { kind: 'enters_or_attacks', subject: { kind: 'self' } }, rest: match[1] } + + match = rest.match(/^when(?:ever)? this enter or attack, (.+)$/) + if (match) return { event: { kind: 'enters_or_attacks', subject: { kind: 'self' } }, rest: match[1] } + + match = rest.match(/^when(?:ever)? this enters or dies, (.+)$/) + if (match) return { event: { kind: 'enters_or_dies', subject: { kind: 'self' } }, rest: match[1] } + + match = rest.match(/^when(?:ever)? this enters? or dies?, (.+)$/) + if (match) return { event: { kind: 'enters_or_dies', subject: { kind: 'self' } }, rest: match[1] } + + match = rest.match(/^when(?:ever)? this attacks or blocks, (.+)$/) + if (match) return { event: { kind: 'attacks_or_blocks', subject: { kind: 'self' } }, rest: match[1] } + + match = rest.match(/^when(?:ever)? this attacks? or blocks?, (.+)$/) + if (match) return { event: { kind: 'attacks_or_blocks', subject: { kind: 'self' } }, rest: match[1] } + + match = rest.match(/^when(?:ever)? this blocks or becomes blocked(?: by a creature)?, (.+)$/) + if (match) return { event: { kind: 'blocks', subject: { kind: 'self' } }, rest: match[1] } + + match = rest.match(/^when(?:ever)? this becomes blocked(?: by a creature)?, (.+)$/) + if (match) return { event: { kind: 'blocks', subject: { kind: 'self' } }, rest: match[1] } + + match = rest.match(/^when(?:ever)? this deals (combat )?damage to (a player|an opponent|a creature|a planeswalker|one or more players|you), (.+)$/) + if (match) { + const recipient = + match[2] === 'a creature' || match[2] === 'a planeswalker' + ? 'permanent' + : 'player' + return { + event: { + kind: 'deals_damage', + subject: { kind: 'self' }, + recipient, + combat: Boolean(match[1]), + }, + rest: match[3], + } + } + + match = rest.match(/^when(?:ever)? this deals (combat )?damage, (.+)$/) + if (match) { + return { + event: { + kind: 'deals_damage', + subject: { kind: 'self' }, + recipient: 'any', + combat: Boolean(match[1]), + }, + rest: match[2], + } + } + + match = rest.match(/^when(?:ever)? this becomes the target of (?:a spell or ability|a spell|an ability)(?: an opponent controls)?, (.+)$/) + if (match) { + return { event: { kind: 'becomes_target', subject: { kind: 'self' } }, rest: match[1] } + } + + match = rest.match(/^when(?:ever)? this is put into a graveyard from (?:the battlefield|anywhere), (.+)$/) + if (match) { + return { event: { kind: 'dies', subject: { kind: 'self' } }, rest: match[1] } + } + + match = rest.match(/^whenever (you|an opponent|a player) (gains?|loses?) life, (.+)$/) + if (match) { + const who = match[1] === 'you' ? 'you' : match[1] === 'an opponent' ? 'opponent' : 'each_player' + const mode = match[2].startsWith('gain') ? 'gain' : 'lose' + return { event: { kind: 'life', who, mode }, rest: match[3] } + } + + match = rest.match(/^whenever (you|an opponent|a player) draws? (.+?), (.+)$/) + if (match) { + const who = match[1] === 'you' ? 'you' : match[1] === 'an opponent' ? 'opponent' : 'each_player' + const clause = match[2].trim() + let ordinal: number | undefined + const ordinalMatch = clause.match(/^(?:your|their) (\w+) card each turn$/) + if (ordinalMatch) { + ordinal = parseNumber(ordinalMatch[1]) + if (ordinal === undefined) return undefined + } else if (!/^(?:a card|their card|one or more cards|a card this turn)$/.test(clause)) { + return undefined + } + return { event: { kind: 'draw', who, ordinal }, rest: match[3] } + } + + match = rest.match(/^at the beginning of (your|each player's|each opponent's|each|the) upkeep, (.+)$/) + if (match) { + const who = match[1] === 'your' ? 'you' : 'each_player' + return { event: { kind: 'upkeep', who }, rest: match[2] } + } + + match = rest.match(/^at the beginning of (your|each player's|each opponent's|each|the) end step, (.+)$/) + if (match) { + const who = match[1] === 'your' ? 'you' : 'each_player' + return { event: { kind: 'end_step', who }, rest: match[2] } + } + + match = rest.match(/^at the beginning of combat on (your|each player's|each opponent's) turn, (.+)$/) + if (match) { + const who = match[1] === 'your' ? 'you' : 'each_player' + return { event: { kind: 'begin_combat', who }, rest: match[2] } + } + + match = rest.match(/^at the beginning of (your|each player's|each opponent's) (first|second|postcombat) main phase, (.+)$/) + if (match) { + const who = match[1] === 'your' ? 'you' : 'each_player' + return { + event: { + kind: 'main_phase', + who, + phase: match[2] === 'first' ? 'first' : 'postcombat', + }, + rest: match[3], + } + } + + match = rest.match(/^whenever (you|an opponent|a player) casts?(?: or cop(y|ies))? (.+?), (.+)$/) + if (match) { + let spellText = match[3].trim() + const who = match[1] === 'you' ? 'you' : match[1] === 'an opponent' ? 'opponent' : 'each_player' + const orCopy = Boolean(match[2]) + let ordinal: number | undefined + const nth = spellText.match(/^(?:your|their) (\w+) spell each turn$/) + if (nth) { + ordinal = parseNumber(nth[1]) + if (ordinal === undefined) return undefined + spellText = 'a spell' + } + let targetsSelf = false + if (/ that targets this$/.test(spellText)) { + targetsSelf = true + spellText = spellText.replace(/ that targets this$/, '') + } + const spell = spellText === 'a spell' || spellText === 'spell' + ? { types: [] } + : parseSelector(spellText.replace(/ spells?$/, '')) + if (spell) { + return { + event: { kind: 'cast', who, spell, targetsSelf: targetsSelf || undefined, ordinal, orCopy: orCopy || undefined }, + rest: match[4], + } + } + } + + match = rest.match(/^whenever (?:one or more )?(.+?) counters? are put on (.+?), (.+)$/) + if (match) { + const subject = parseSubject(match[2]) + if (subject) { + return { event: { kind: 'counter_placed', subject, counter: match[1] }, rest: match[3] } + } + } + + match = rest.match(/^whenever (?:one or more )?(.+?) deals? (combat )?damage to (a player|a player or battle|an opponent|a creature|a planeswalker|you), (.+)$/) + if (match) { + const subject = parseSubject(match[1]) + const recipient = + match[3] === 'a creature' || match[3] === 'a planeswalker' + ? 'permanent' + : 'player' + if (subject) { + return { + event: { kind: 'deals_damage', subject, recipient, combat: Boolean(match[2]) }, + rest: match[4], + } + } + } + + match = rest.match(/^when(?:ever)? (?:one or more )?(.+?) (enters?|dies?|attacks?|blocks?|leaves? the battlefield), (.+)$/) + if (match) { + const subject = parseSubject(match[1]) + if (subject) { + const raw = match[2] + const kind = raw.startsWith('enter') + ? 'enters' + : raw.startsWith('die') + ? 'dies' + : raw.startsWith('attack') + ? 'attacks' + : raw.startsWith('block') + ? 'blocks' + : 'leaves_battlefield' + return { event: { kind, subject } as TriggerEvent, rest: match[3] } + } + } + + return undefined +} + diff --git a/backend/src/effects/compile.ts b/backend/src/effects/compile.ts index ef4d3a5..5f4dca3 100644 --- a/backend/src/effects/compile.ts +++ b/backend/src/effects/compile.ts @@ -27,535 +27,15 @@ import type { } from './types.js' type Status = 'supported' | 'partial' | 'unsupported' +import { parseDigDestination, parseGroupTarget, parseKeywordLine, parseSearch, parseSearchDestination, parseToken, stripReminders, normalize, splitSentences, takeLeadingDuration, lowerText, valueWithSign, forEachSelector, scaleEffect, parseSubject, STANDALONE_ACTIONS } from './compile-primitives.js' +import { parseDig, parseEffectSentence, parseEffects, parsePick, primaryTargetOf, replaceX, resolvePreviousTarget } from './compile-sentences.js' +import { parseTriggerPrefix, stripTriggerFrequency } from './compile-triggers.js' +export { SIMPLE_KEYWORDS } from './compile-primitives.js' +import { parseStaticAbility } from './compile-static.js' -export const SIMPLE_KEYWORDS = new Map([ - ['flying', 'Flying'], - ['trample', 'Trample'], - ['vigilance', 'Vigilance'], - ['haste', 'Haste'], - ['flash', 'Flash'], - ['reach', 'Reach'], - ['menace', 'Menace'], - ['lifelink', 'Lifelink'], - ['deathtouch', 'Deathtouch'], - ['first strike', 'First strike'], - ['double strike', 'Double strike'], - ['defender', 'Defender'], - ['indestructible', 'Indestructible'], - ['hexproof', 'Hexproof'], - ['prowess', 'Prowess'], - ['convoke', 'Convoke'], - ['delve', 'Delve'], - ['shroud', 'Shroud'], - ['shadow', 'Shadow'], - ['horsemanship', 'Horsemanship'], - ['fear', 'Fear'], - ['intimidate', 'Intimidate'], - ['skulk', 'Skulk'], - ['wither', 'Wither'], - ['infect', 'Infect'], - ['persist', 'Persist'], - ['undying', 'Undying'], - ['exalted', 'Exalted'], - ['evolve', 'Evolve'], - ['exploit', 'Exploit'], - ['riot', 'Riot'], - ['cascade', 'Cascade'], - ['banding', 'Banding'], - ['flanking', 'Flanking'], - ['storm', 'Storm'], - ['sunburst', 'Sunburst'], - ['haunt', 'Haunt'], - ['living weapon', 'Living weapon'], - ['battle cry', 'Battle cry'], - ['dethrone', 'Dethrone'], - ['melee', 'Melee'], - ['mentor', 'Mentor'], - ['aftermath', 'Aftermath'], - ['ascend', 'Ascend'], - ['fuse', 'Fuse'], - ['jump-start', 'Jump-start'], - ['improvise', 'Improvise'], - ['undaunted', 'Undaunted'], - ['spectacle', 'Spectacle'], - ['escape', 'Escape'], - ['companion', 'Companion'], - ['daybound', 'Daybound'], - ['nightbound', 'Nightbound'], - ['training', 'Training'], - ['read ahead', 'Read ahead'], - ['casualty', 'Casualty'], - ['enlist', 'Enlist'], - ['bargain', 'Bargain'], - ['gift', 'Gift'], - ['disguise', 'Disguise'], - ['cloak', 'Cloak'], - ['saddle', 'Saddle'], - ['impending', 'Impending'], - ['harmonize', 'Harmonize'], - ['start your engines!', 'Start your engines!'], - ['devoid', 'Devoid'], - ['changeling', 'Changeling'], - ['phasing', 'Phasing'], - ['dredge', 'Dredge'], - ['bloodthirst', 'Bloodthirst'], - ['devour', 'Devour'], - ['graft', 'Graft'], - ['modular', 'Modular'], - ['bushido', 'Bushido'], - ['rampage', 'Rampage'], - ['absorb', 'Absorb'], - ['frenzy', 'Frenzy'], - ['tribute', 'Tribute'], - ['soulshift', 'Soulshift'], -]) -const PARAMETERIZED_KEYWORDS: Array<[RegExp, string]> = [ - [/^ward\s+(.+)$/, 'Ward'], - [/^ward—(.+)$/, 'Ward'], - [/^equip\s+(.+)$/, 'Equip'], - [/^crew\s+(\d+)$/, 'Crew'], - [/^saddle\s+(\d+)$/, 'Saddle'], - [/^cycling\s+(.+)$/, 'Cycling'], - [/^typecycling\s+(.+)$/, 'Typecycling'], - [/^landcycling\s+(.+)$/, 'Landcycling'], - [/^basic landcycling\s+(.+)$/, 'Basic landcycling'], - [/^flashback(?:\s*[—-]\s*|\s+)(.+)$/, 'Flashback'], - [/^kicker(?:\s*[—-]\s*|\s+)(.+)$/, 'Kicker'], - [/^entwine\s+(.+)$/, 'Entwine'], - [/^fabricate\s+(\d+)$/, 'Fabricate'], - [/^madness\s+(.+)$/, 'Madness'], - [/^suspend\s+(\d+)\s*[—-]\s*(.+)$/, 'Suspend'], - [/^protection from (.+)$/, 'Protection'], - [/^enchant (.+)$/, 'Enchant'], - [/^annihilator\s+(\d+)$/, 'Annihilator'], - [/^afterlife\s+(\d+)$/, 'Afterlife'], - [/^afflict\s+(\d+)$/, 'Afflict'], - [/^amass\s+(.+)$/, 'Amass'], - [/^affinity for (.+)$/, 'Affinity'], - [/^bestow\s+(.+)$/, 'Bestow'], - [/^emerge\s+(.+)$/, 'Emerge'], - [/^mutate\s+(.+)$/, 'Mutate'], - [/^morph\s+(.+)$/, 'Morph'], - [/^megamorph\s+(.+)$/, 'Megamorph'], - [/^manifest\s+(.+)$/, 'Manifest'], - [/^disguise\s+(.+)$/, 'Disguise'], - [/^cloak\s+(.+)$/, 'Cloak'], - [/^escape(?:\s*[—-]\s*|\s+)(.+)$/, 'Escape'], - [/^evoke\s+(.+)$/, 'Evoke'], - [/^echo\s+(.+)$/, 'Echo'], - [/^cumulative upkeep(?:\s*[—-]\s*|\s+)(.+)$/, 'Cumulative upkeep'], - [/^fading\s+(\d+)$/, 'Fading'], - [/^vanishing\s+(\d+)$/, 'Vanishing'], - [/^modular\s+(\d+)$/, 'Modular'], - [/^bushido\s+(\d+)$/, 'Bushido'], - [/^rampage\s+(\d+)$/, 'Rampage'], - [/^absorb\s+(\d+)$/, 'Absorb'], - [/^frenzy\s+(\d+)$/, 'Frenzy'], - [/^tribute\s+(\d+)$/, 'Tribute'], - [/^bloodthirst\s+(\d+)$/, 'Bloodthirst'], - [/^devour\s+(\d+)$/, 'Devour'], - [/^graft\s+(\d+)$/, 'Graft'], - [/^soulshift\s+(\d+)$/, 'Soulshift'], - [/^dredge\s+(\d+)$/, 'Dredge'], - [/^toxic\s+(\d+)$/, 'Toxic'], - [/^backup\s+(\d+)$/, 'Backup'], - [/^firebending\s+(\d+)$/, 'Firebending'], - [/^renown\s+(\d+)$/, 'Renown'], - [/^teamwork\s+(\d+)$/, 'Teamwork'], - [/^squad\s+(\d+)$/, 'Squad'], - [/^mobilize\s+(\d+)$/, 'Mobilize'], - [/^casualty\s+(\d+)$/, 'Casualty'], - [/^level up\s+(.+)$/, 'Level up'], - [/^plot\s+(.+)$/, 'Plot'], - [/^unearth\s+(.+)$/, 'Unearth'], - [/^buyback\s+(.+)$/, 'Buyback'], - [/^foretell\s+(.+)$/, 'Foretell'], - [/^forecast(?:\s*[—-]\s*|\s+)(.+)$/, 'Forecast'], - [/^ninjutsu\s+(.+)$/, 'Ninjutsu'], - [/^dash\s+(.+)$/, 'Dash'], - [/^disturb\s+(.+)$/, 'Disturb'], - [/^warp\s+(.+)$/, 'Warp'], - [/^blitz\s+(.+)$/, 'Blitz'], - [/^encore\s+(.+)$/, 'Encore'], - [/^grandeur(?:\s*[—-]\s*|\s+)(.+)$/, 'Grandeur'], - [/^scavenge\s+(.+)$/, 'Scavenge'], - [/^fortify\s+(.+)$/, 'Fortify'], - [/^outlast\s+(.+)$/, 'Outlast'], - [/^embalm\s+(.+)$/, 'Embalm'], - [/^eternalize\s+(.+)$/, 'Eternalize'], - [/^transfigure\s+(.+)$/, 'Transfigure'], - [/^transmute\s+(.+)$/, 'Transmute'], - [/^reconfigure\s+(.+)$/, 'Reconfigure'], - [/^partner with (.+)$/, 'Partner'], - [/^partner[—-](.+)$/, 'Partner'], - [/^companion\s*[—-]\s*(.+)$/, 'Companion'], - [/^(.+?)walk$/, 'Landwalk'], -] -const STANDALONE_ACTIONS = new Set([ - 'investigate', - 'proliferate', - 'populate', - 'learn', - 'take the initiative', - 'venture into the dungeon', - 'time travel', - 'open an attraction', - 'manifest dread', - 'the ring tempts you', - 'connive', - 'explore', -]) - -/** Removes reminder text. Oracle text only uses parentheses for reminders. */ -function stripReminders(text: string): string { - let result = text - let previous: string - do { - previous = result - result = result.replace(/\s*\([^()]*\)/g, '') - } while (result !== previous) - return result.replace(/\s+/g, ' ').trim() -} - -function normalize(text: string, cardName: string): string { - let result = stripReminders(text) - .replace(/\u2019/g, "'") - .replace(/\u2212/g, '-') - .replace(/\s+/g, ' ') - .trim() - - const names = [cardName] - const shortName = cardName.split(',')[0]?.trim() - if (shortName && shortName !== cardName) names.push(shortName) - - for (const name of names) { - if (!name) continue - const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') - result = result.replace(new RegExp(`\\b${escaped}\\b`, 'gi'), 'this') - } - - result = result - .replace(/\bthis\s+[a-z]+'s\b/gi, 'its') - .replace(/\bthis (?:creature|permanent|artifact|enchantment|land|card|spell|token|vehicle|aura|planeswalker|battle|saga|equipment|class|treasure|food|clue|blood|map|gold|powerstone)\b/gi, 'this') - .replace(/\b~'s\b/g, 'its') - .replace(/~/g, 'this') - .replace(/\bit's\b/gi, 'it is') - .replace(/\bdoesn't\b/gi, 'does not') - .replace(/\bcan't\b/gi, 'cannot') - .replace(/\bwon't\b/gi, 'will not') - - return result.replace(/\s+/g, ' ').trim() -} - -function splitSentences(text: string): string[] { - return text - .split(/(?<=[.!?])\s+(?=\S)/) - .map(part => part.trim()) - .filter(Boolean) -} - -const LEADING_DURATION = /^(until end of turn|until your next turn|until the end of your next turn|until end of combat), /i - -/** "Until end of turn, X" is the same effect as "X until end of turn". */ -function takeLeadingDuration(text: string): { rest: string; duration?: string } { - const match = text.match(LEADING_DURATION) - if (!match) return { rest: text } - return { rest: text.slice(match[0].length), duration: match[1].toLowerCase() } -} - -/** Lowercase oracle text without destroying mana symbol casing ({W} -> {w}). */ -function lowerText(text: string): string { - return text - .toLowerCase() - .replace(/\{([^}]+)\}/g, (_, symbols: string) => `{${symbols.toUpperCase()}}`) -} - -function parseKeywordToken(part: string, known: Set): KeywordAbility | undefined { - const lower = part.trim().toLowerCase() - if (!lower) return undefined - - const knownKeyword = [...known].find(keyword => keyword.toLowerCase() === lower) - if (knownKeyword) return { kind: 'keyword', keyword: knownKeyword } - - const simple = SIMPLE_KEYWORDS.get(lower) - if (simple) return { kind: 'keyword', keyword: simple } - - for (const [pattern, keyword] of PARAMETERIZED_KEYWORDS) { - const match = lower.match(pattern) - if (match) return { kind: 'keyword', keyword, value: match[1] } - } - - return undefined -} - -function parseKeywordLine(text: string, known: Set): KeywordAbility[] | undefined { - const whole = parseKeywordToken(text, known) - if (whole) return [whole] - - const parts = text - .split(/,| and /) - .map(part => part.trim()) - .filter(Boolean) - if (!parts.length) return undefined - - const keywords: KeywordAbility[] = [] - for (const part of parts) { - const keyword = parseKeywordToken(part, known) - if (!keyword) return undefined - keywords.push(keyword) - } - return keywords -} - -function parseGroupTarget(text: string): Target | undefined { - const direct = parseTarget(text) - if (direct) { - if (direct.kind === 'object' && direct.mode === 'choose') return { ...direct, mode: 'each' } - return direct - } - - const selector = parseSelector(text) - if (selector) return { kind: 'object', selector, mode: 'each' } - return undefined -} - -function parseSubject(text: string): Target | undefined { - let subject = text.trim() - subject = subject.replace(/^one or more /, '') - if (subject === 'this') return { kind: 'self' } - - const orAnother = subject.match(/^this or another (.+)$/) - if (orAnother) { - const selector = parseSelector(`another ${orAnother[1]}`) - if (selector) return { kind: 'object', selector, mode: 'each', includeSelf: true } - } - - return parseGroupTarget(subject) -} - -function valueWithSign(text: string): Value | undefined { - const sign = text.startsWith('-') ? -1 : 1 - const raw = text.replace(/^[+-]/, '') - const value = parseValue(raw) - if (!value) return undefined - if (value.kind === 'number') return { kind: 'number', value: sign * value.value } - return value -} - -function forEachSelector(text: string): ObjectSelector | undefined { - return parseSelector(text.replace(/^each /, '')) -} - -function scaleEffect(effect: Effect, selector: ObjectSelector): Effect | undefined { - const count: Value = { kind: 'count', selector } - switch (effect.op) { - case 'damage': - if (effect.amount.kind !== 'number' || effect.amount.value !== 1) return undefined - return { ...effect, amount: count } - case 'draw': - case 'mill': - case 'life': - if (effect.amount.kind !== 'number' || effect.amount.value !== 1) return undefined - return { ...effect, amount: count } - case 'put_counters': - if (effect.amount.kind !== 'number' || effect.amount.value !== 1) return undefined - return { ...effect, amount: count } - case 'create_token': - if (effect.amount.kind !== 'number' || effect.amount.value !== 1) return undefined - return { ...effect, amount: count } - case 'pump': - if (effect.power.kind !== 'number' || effect.toughness.kind !== 'number') return undefined - if (![0, 1].includes(effect.power.value) || ![0, 1].includes(effect.toughness.value)) return undefined - if (effect.power.value === 0 && effect.toughness.value === 0) return undefined - return { - ...effect, - power: effect.power.value === 1 ? count : effect.power, - toughness: effect.toughness.value === 1 ? count : effect.toughness, - } - default: - return undefined - } -} - -function parseToken(text: string): TokenSpec | undefined { - let rest = text.trim().toLowerCase().replace(/\s+tokens?$/, '') - if (rest.startsWith('a ') || rest.startsWith('an ')) rest = rest.replace(/^an? /, '') - const tapped = rest.startsWith('tapped ') - if (tapped) rest = rest.slice(7) - return parseTokenBody(rest, tapped) -} - -function parseTokenBody(text: string, tapped: boolean): TokenSpec | undefined { - let rest = text.trim() - if (!rest) return undefined - if (/\b(copy|named|equal|number of|that's|thats)\b/.test(rest)) return undefined - - const colors: string[] = [] - for (const [word, code] of Object.entries({ white: 'W', blue: 'U', black: 'B', red: 'R', green: 'G' })) { - if (new RegExp(`\\b${word}\\b`).test(rest)) colors.push(code) - } - if (/\bcolorless\b/.test(rest)) colors.push('C') - - const role = Object.entries(ROLE_NAMES).find(([name]) => rest.endsWith(`${name} role`)) - if (role) { - return { name: role[1], types: ['enchantment'], subtypes: ['aura', 'role'], colors, tapped: tapped || undefined } - } - - let power: Value | undefined - let toughness: Value | undefined - const pt = rest.match(/^(\d+|x)\/(\d+|x)\b/) - if (pt) { - power = parseValue(pt[1]) - toughness = parseValue(pt[2]) - rest = rest.slice(pt[0].length).trim() - } - - const keywords: string[] = [] - const withMatch = rest.match(/\bwith (.+)$/) - if (withMatch) { - const parsed = parseKeywordLine(withMatch[1], new Set()) - if (!parsed) return undefined - for (const keyword of parsed) { - keywords.push(keyword.value ? `${keyword.keyword} ${keyword.value}` : keyword.keyword) - } - rest = rest.slice(0, withMatch.index).trim() - } - - const typeWords = new Set(['artifact', 'creature', 'enchantment', 'instant', 'land', 'planeswalker', 'sorcery', 'battle']) - const types: string[] = [] - const subtypes: string[] = [] - for (const word of rest.split(/[\s,]+/).filter(Boolean)) { - if (word === 'and' || word === 'or') continue - if (['white', 'blue', 'black', 'red', 'green', 'colorless', 'tapped'].includes(word)) continue - if (typeWords.has(word)) { - types.push(word) - continue - } - if (/^[a-z][a-z'-]*$/.test(word)) { - subtypes.push(word.length > 3 && word.endsWith('s') && !word.endsWith('ss') ? word.slice(0, -1) : word) - continue - } - return undefined - } - - if (!types.length) types.push('artifact') - if (!subtypes.length && !power) return undefined - - return { types, subtypes, colors, power, toughness, keywords: keywords.length ? keywords : undefined, tapped: tapped || undefined } -} - -function parseDigDestination(text: string): 'hand' | 'graveyard' | 'battlefield' | 'top' | 'bottom' { - if (text === 'into your hand') return 'hand' - if (text === 'into your graveyard') return 'graveyard' - if (text === 'onto the battlefield') return 'battlefield' - if (text === 'on top of your library') return 'top' - return 'bottom' -} - -function parseSearchDestination( - text: string, -): { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean } | undefined { - switch (text) { - case 'into your hand': - return { destination: 'hand', tapped: false } - case 'onto the battlefield': - return { destination: 'battlefield', tapped: false } - case 'onto the battlefield tapped': - return { destination: 'battlefield', tapped: true } - case 'into your graveyard': - return { destination: 'graveyard', tapped: false } - case 'on top of your library': - return { destination: 'top', tapped: false } - case 'on the bottom of your library': - return { destination: 'bottom', tapped: false } - default: - return undefined - } -} - -function parseSearch(text: string): Effect | undefined { - const match = text.match(/^search your (library|library and\/or graveyard) for (.+)$/) - if (!match) return undefined - const zones: ('library' | 'graveyard')[] | undefined = - match[1] === 'library' ? undefined : ['library', 'graveyard'] - const body = match[2].trim() - - // Card names can contain commas, so try every comma as the selector/destination boundary. - for (let index = body.indexOf(', '); index !== -1; index = body.indexOf(', ', index + 1)) { - const selectorText = body.slice(0, index).trim() - const rest = body.slice(index + 2).trim() - - let amount: Value = { kind: 'number', value: 1 } - let nameText = selectorText - const upTo = nameText.match(/^up to (one|two|three|four|five|\d+) (.+)$/) - if (upTo) { - amount = parseValue(upTo[1]) ?? amount - nameText = upTo[2] - } else { - nameText = nameText.replace(/^an? /, '') - } - - const selector = parseSelector(nameText) - if (!selector) continue - - const revealPrefix = /^reveal (?:it|them|that card|those cards),? (?:and )?/ - let destinationText = rest.replace(revealPrefix, '') - let shuffle = false - if (/^then shuffle and put (?:it|them|that card|those cards|the card|the chosen card) on top(?: of your library)?$/.test(destinationText)) { - return { op: 'search', player: 'you', selector, amount, destination: 'top', tapped: false, shuffle: true, ...(zones ? { zones } : {}) } - } - if (/^shuffle and put (?:it|them|that card|those cards|the card|the chosen card) on top(?: of your library)?$/.test(destinationText)) { - return { op: 'search', player: 'you', selector, amount, destination: 'top', tapped: false, shuffle: true, ...(zones ? { zones } : {}) } - } - if (/^put (?:it|them|that card|those cards|the card|the chosen card) on top of your library, then shuffle$/.test(destinationText)) { - return { op: 'search', player: 'you', selector, amount, destination: 'top', tapped: false, shuffle: true, ...(zones ? { zones } : {}) } - } - - const split = destinationText.match(/^put one (.+?) and the other (.+?)(, then shuffle)?$/) - if (split && amount.kind === 'number' && amount.value >= 2) { - const first = parseSearchDestination(split[1].trim()) - const second = parseSearchDestination(split[2].trim()) - if (first && second) { - return { - op: 'search', - player: 'you', - selector, - amount, - destination: first.destination, - tapped: first.tapped, - shuffle: Boolean(split[3]), - split: second, - ...(zones ? { zones } : {}), - } - } - } - - const put = destinationText.match( - /^put (?:it|them|that card|those cards|the chosen card) (into your hand|onto the battlefield(?: tapped)?|into your graveyard|on top of your library|on the bottom of your library)(?: under your control)?(?:, then shuffle)?$/, - ) - if (!put) continue - - const parsedDestination = parseSearchDestination(put[1]) - if (!parsedDestination) continue - shuffle = /then shuffle$/.test(destinationText) - return { - op: 'search', - player: 'you', - selector, - amount, - destination: parsedDestination.destination, - tapped: parsedDestination.tapped, - shuffle, - ...(zones ? { zones } : {}), - } - } - - return undefined -} - -function parseEffect(text: string): Effect | Effect[] | undefined { +export function parseEffect(text: string): Effect | Effect[] | undefined { const sentence = text.trim().replace(/\.$/, '') const search = parseSearch(sentence) @@ -577,6 +57,108 @@ function parseEffect(text: string): Effect | Effect[] | undefined { } } + match = sentence.match(/^prevent all damage (?:that )?(?:a|an) (.+?) source of your choice would deal(?: this turn)?$/) + if (match) { + const color = ({ white: 'W', blue: 'U', black: 'B', red: 'R', green: 'G' } as Record)[match[1]] + const selector = color ? { colors: [color] } : parseSelector(match[1]) + if (selector) { + return { + op: 'prevent_damage', + target: { kind: 'any' }, + amount: 'all', + duration: 'until_end_of_turn', + global: true, + source: { kind: 'object', selector, mode: 'target' }, + } + } + } + + match = sentence.match(/^prevent all damage (?:that )?a source of your choice would deal(?: this turn)?$/) + if (match) { + return { + op: 'prevent_damage', + target: { kind: 'any' }, + amount: 'all', + duration: 'until_end_of_turn', + global: true, + source: { kind: 'object', selector: {}, mode: 'target' }, + } + } + + match = sentence.match(/^prevent all damage (?:that )?(?:target creature|a creature of your choice) would deal(?: this turn)?$/) + if (match) { + return { + op: 'prevent_damage', + target: { kind: 'any' }, + amount: 'all', + duration: 'until_end_of_turn', + global: true, + source: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }, + } + } + + match = sentence.match(/^the next time (target creature|a source of your choice) would deal damage(?: this turn)?, prevent that damage$/) + if (match) { + return { + op: 'prevent_damage', + target: { kind: 'any' }, + amount: 'all', + duration: 'until_end_of_turn', + global: true, + source: match[1] === 'target creature' + ? { kind: 'object', selector: { types: ['creature'] }, mode: 'target' } + : { kind: 'object', selector: {}, mode: 'target' }, + } + } + + match = sentence.match(/^prevent all (combat )?damage that would be dealt to (.+?)(?: this turn)? by (.+?)(?: this turn)?$/) + if (match) { + const target = parseTarget(match[2]) + const selector = parseSelector(match[3]) + if (target && selector) { + return { + op: 'prevent_damage', + target, + amount: 'all', + combatOnly: Boolean(match[1]) || undefined, + duration: 'until_end_of_turn', + sourceSelector: selector, + } + } + } + + match = sentence.match(/^prevent all (combat )?damage that would be dealt by (.+?)(?: this turn)?$/) + if (match) { + const selector = parseSelector(match[2]) + if (selector) { + return { + op: 'prevent_damage', + target: { kind: 'any' }, + amount: 'all', + combatOnly: Boolean(match[1]) || undefined, + duration: 'until_end_of_turn', + global: true, + sourceSelector: selector, + } + } + } + + match = sentence.match(/^prevent the next (\w+) damage that would be dealt by (.+?)(?: this turn)?$/) + if (match) { + const amount = parseValue(match[1]) + const selector = parseSelector(match[2]) + if (amount && selector) { + return { + op: 'prevent_damage', + target: { kind: 'any' }, + amount, + duration: 'until_end_of_turn', + global: true, + sourceSelector: selector, + } + } + } + match = sentence.match( /^prevent (all|the next (\w+)) (combat )?damage(?: that would be dealt(?: to (.+?))?)?(?: this turn)?$/, ) @@ -591,6 +173,7 @@ function parseEffect(text: string): Effect | Effect[] | undefined { amount, combatOnly: Boolean(match[3]) || undefined, duration: 'until_end_of_turn', + global: match[4] ? undefined : true, } } } @@ -628,14 +211,14 @@ function parseEffect(text: string): Effect | Effect[] | undefined { } } - match = sentence.match(/^this deals (?:(\w+) damage|damage equal to (its power|its toughness)) to (.+)$/) + match = sentence.match(/^this deals (?:(\w+(?: \w+)?) damage|damage equal to (its power|its toughness)) to (.+)$/) if (match) { const amount = match[1] ? parseValue(match[1]) : parseValue(match[2]) const target = parseTarget(match[3]) if (amount && target) return { op: 'damage', target, amount } } - match = sentence.match(/^(.+?) deals (?:(\w+) damage|damage equal to (its power|its toughness)) to (.+)$/) + match = sentence.match(/^(.+?) deals (?:(\w+(?: \w+)?) damage|damage equal to (its power|its toughness)) to (.+)$/) if (match) { const source = parseGroupTarget(match[1]) const amount = match[2] ? parseValue(match[2]) : parseValue(match[3]) @@ -643,13 +226,26 @@ function parseEffect(text: string): Effect | Effect[] | undefined { if (source && amount && target) return { op: 'damage', target, amount, source } } - match = sentence.match(/^you gain (?:(\w+) life|life equal to (.+))$/) + match = sentence.match(/^the next time (?:a source(?: of your choice)?|an instant or sorcery spell|a creature) would deal damage to (you|target creature|any target)(?: this turn)?, prevent that damage$/) + if (match) { + const target = parseTarget(match[1]) + if (target) { + return { + op: 'prevent_damage', + target, + amount: 'all', + duration: 'until_end_of_turn', + } + } + } + + match = sentence.match(/^you gain (?:(\w+|that much) life|life equal to (.+))$/) if (match) { const amount = match[1] ? parseValue(match[1]) : parseValue(match[2]) if (amount) return { op: 'life', player: 'you', amount, mode: 'gain' } } - match = sentence.match(/^gain (?:(\w+) life|life equal to (.+))$/) + match = sentence.match(/^gain (?:(\w+|that much) life|life equal to (.+))$/) if (match) { const amount = match[1] ? parseValue(match[1]) : parseValue(match[2]) if (amount) return { op: 'life', player: 'you', amount, mode: 'gain' } @@ -662,7 +258,7 @@ function parseEffect(text: string): Effect | Effect[] | undefined { if (player?.kind === 'player' && amount) return { op: 'life', player: player.who, amount, mode: 'gain' } } - match = sentence.match(/^you lose (\w+) life$/) + match = sentence.match(/^you lose (?:(\w+|that much) life)$/) if (match) { const amount = parseValue(match[1]) if (amount) return { op: 'life', player: 'you', amount, mode: 'lose' } @@ -674,7 +270,7 @@ function parseEffect(text: string): Effect | Effect[] | undefined { if (amount) return { op: 'life', player: 'you', amount, mode: 'lose' } } - match = sentence.match(/^(target player|target opponent|that player|each player|each opponent) loses (\w+) life$/) + match = sentence.match(/^(target player|target opponent|that player|each player|each opponent) loses (?:(\w+|that much) life)$/) if (match) { const player = parseTarget(match[1]) const amount = parseValue(match[2]) @@ -764,6 +360,18 @@ function parseEffect(text: string): Effect | Effect[] | undefined { if (amount && target) return { op: 'remove_counters', target, counter: match[2], amount } } + match = sentence.match(/^double the number of (each kind of counter|(.+?) counters?) on (.+)$/) + if (match) { + const target = parseGroupTarget(match[3]) + if (target) { + return { + op: 'double_counters', + target, + ...(match[2] ? { counter: match[2] } : {}), + } + } + } + match = sentence.match(/^create (?:(\w+) )?(?:a |an )?tokens? that(?:'s| is) a copy of (.+)$/) if (match) { let targetText = match[2].trim() @@ -1039,6 +647,18 @@ function parseEffect(text: string): Effect | Effect[] | undefined { } } + match = sentence.match(/^add (one|two|three|four|five|x) mana of the chosen color$/) + if (match) { + const amount = parseValue(match[1]) + if (amount) { + return { + op: 'add_mana', + player: 'you', + mana: { kind: 'any_color', amount, oneColor: true, restriction: 'chosen color' }, + } + } + } + match = sentence.match(/^(scry|surveil) (\w+)$/) if (match) { const amount = parseValue(match[2]) @@ -1154,1029 +774,7 @@ function parseEffect(text: string): Effect | Effect[] | undefined { return undefined } -function parseEffectSentence(text: string): Effect[] | undefined { - const emblem = text.trim().match(/^you get an emblem with "(.+)"$/i) - if (emblem) return [{ op: 'emblem', text: emblem[1] }] - - let sentence = lowerText(text).trim().replace(/\.$/, '') - sentence = sentence.replace(/^then /, '') - - const scaled = sentence.match(/^(.+?) for each (.+)$/) - if (scaled) { - const selector = forEachSelector(scaled[2]) - const base = parseEffect(scaled[1]) - if (selector && base && !Array.isArray(base)) { - const effect = scaleEffect(base, selector) - if (effect) return [effect] - } - return undefined - } - - const whereX = sentence.match(/^(.+?), where x is the number of (.+)$/) - if (whereX) { - const selector = parseSelector(whereX[2]) - const base = parseEffect(whereX[1]) - if (selector && base && !Array.isArray(base)) { - return [replaceX(base, { kind: 'count', selector })] - } - return undefined - } - - const direct = parseEffect(sentence) - if (direct) return Array.isArray(direct) ? direct : [direct] - - if (sentence.includes(' and ')) { const parts = sentence.split(' and ') - if (parts.length === 2) { - const first = parseEffectSentence(parts[0]) - const second = parseEffectSentence(parts[1]) - if (first && second) return [...first, ...second] - } - } - - if (sentence.includes(', then ')) { - const parts = sentence.split(', then ') - const effects: Effect[] = [] - for (const part of parts) { - const parsed = parseEffectSentence(part) - if (!parsed) return undefined - effects.push(...parsed) - } - return effects - } - - return undefined -} - -function replaceX(effect: Effect, value: Value): Effect { - const replace = (current: Value): Value => (current.kind === 'x' ? value : current) - switch (effect.op) { - case 'damage': - return { ...effect, amount: replace(effect.amount) } - case 'draw': - case 'mill': - case 'life': - return { ...effect, amount: replace(effect.amount) } - case 'put_counters': - case 'remove_counters': - return { ...effect, amount: replace(effect.amount) } - case 'create_token': - return { ...effect, amount: replace(effect.amount) } - case 'pump': - return { ...effect, power: replace(effect.power), toughness: replace(effect.toughness) } - case 'search': - return { ...effect, amount: replace(effect.amount) } - default: - return effect - } -} - -const PRIMARY_TARGET_OPS = new Set([ - 'pump', - 'grant', - 'set_pt', - 'gain_control', - 'tap', - 'untap', - 'destroy', - 'exile', - 'return_to_hand', - 'return_to_battlefield', - 'sacrifice', - 'put_counters', - 'attach', - 'regenerate', -]) - -function primaryTargetOf(effects: Effect[]): Target | undefined { - for (const effect of effects) { - if (!('target' in effect) || !PRIMARY_TARGET_OPS.has(effect.op)) continue - const target = (effect as { target: Target }).target - if ( - target.kind === 'object' || - target.kind === 'self' || - target.kind === 'trigger_subject' || - target.kind === 'previous_target' - ) { - return target - } - } - return undefined -} - -function parsePick(text: string): Value | undefined { - if (text === 'any number') return { kind: 'any_number' } - return parseValue(text) -} - -function parseDig(text: string): Effect | undefined { - const reorder = text.match( - /^look at the top (\w+) cards? of (your|target player's) library, then put them back in any order(?:\. you may (?:have that player )?shuffle)?$/, - ) - if (reorder) { - const amount = parseValue(reorder[1]) - if (!amount) return undefined - return { - op: 'look_top', - player: reorder[2] === 'your' ? 'you' : 'target_player', - amount, - reorder: true, - } - } - - const prefix = text.match(/^look at the top (\w+) cards? of your library\. (.+)$/) - if (!prefix) return undefined - const amount = parseValue(prefix[1]) - if (!amount) return undefined - const body = prefix[2].trim().replace(/\.$/, '') - - let match = body.match( - /^put (up to )?(one|two|three|four|five|six|seven|eight|nine|ten|\d+|any number) (?:of them|of those cards) into your hand and the (?:other|rest)(?: of those cards)? (on the bottom of your library(?: in (any|a random) order)?|into your graveyard|on top of your library(?: in any order)?)$/, - ) - if (match) { - const pick = parsePick(match[2]) - if (pick) { - const destination = match[3] - const rest = destination.startsWith('on the bottom') - ? 'bottom' - : destination.startsWith('into your graveyard') - ? 'graveyard' - : 'top' - const order = /in a random order$/.test(destination) ? 'random' : 'any' - return { - op: 'dig', - player: 'you', - amount, - pick, - upTo: Boolean(match[1]) || undefined, - to: 'hand', - rest, - order, - } - } - } - - match = body.match( - /^(you may )?reveal (?:up to )?(one|two|three|four|five|\d+)? ?(.+?) from among them and put (?:it|them) into your hand\. put the rest (on the bottom of your library(?: in (any|a random) order)?|into your graveyard)$/, - ) - if (match) { - const selector = parseSelector(match[3]) - const pick = match[2] ? parsePick(match[2]) : ({ kind: 'number', value: 1 } as Value) - if (selector && pick) { - const destination = match[4] - const rest = destination.startsWith('on the bottom') ? 'bottom' : 'graveyard' - const order = /in a random order$/.test(destination) ? 'random' : 'any' - return { - op: 'dig', - player: 'you', - amount, - pick, - upTo: /^(?:you may )?reveal up to /.test(body) || undefined, - pickSelector: selector, - to: 'hand', - rest, - order, - optional: Boolean(match[1]) || undefined, - } - } - } - - match = body.match( - /^put up to (one|two|three|four|five|\d+) (.+?) from among them onto the battlefield( tapped)?(?: and the rest on the bottom of your library(?: in (any|a random) order)?|\. put the rest on the bottom of your library(?: in (any|a random) order)?)$/, - ) - if (match) { - const selector = parseSelector(match[2]) - const pick = parsePick(match[1]) - if (selector && pick) { - return { - op: 'dig', - player: 'you', - amount, - pick, - upTo: true, - pickSelector: selector, - to: 'battlefield', - tapped: Boolean(match[3]) || undefined, - rest: 'bottom', - order: /in a random order$/.test(body) ? 'random' : 'any', - } - } - } - - match = body.match( - /^(you may )?put (any number|one|two|three|four|five|\d+) of them into your hand and the rest into your graveyard$/, - ) - if (match) { - const pick = parsePick(match[2]) - if (pick) { - return { - op: 'dig', - player: 'you', - amount, - pick, - to: 'hand', - rest: 'graveyard', - optional: Boolean(match[1]) || undefined, - } - } - } - - return undefined -} - -function parseEffects(text: string): { effects: Effect[]; optional: boolean } | undefined { - let rest = text.trim().replace(/\.$/, '') - let optional = false - if (/^you may /i.test(rest)) { - optional = true - rest = rest.slice(8) - } - - const leading = takeLeadingDuration(rest) - rest = leading.rest - - const dig = parseDig(rest) - if (dig) return { effects: [dig], optional: optional || (dig.op === 'dig' && Boolean(dig.optional)) } - - const sentences = splitSentences(rest) - if (!sentences.length) return undefined - if (leading.duration) sentences[0] = `${sentences[0].replace(/\.$/, '')} ${leading.duration}` - - const effects: Effect[] = [] - let previousTarget: Target | undefined - for (const rawSentence of sentences) { - let sentence = rawSentence - .replace(/^when you do, /i, 'if you do, ') - .replace(/^when you don't, /i, "if you don't, ") - const leadingIt = /^it\b/i.test(sentence) - if (previousTarget && leadingIt) { - sentence = `the chosen target${sentence.slice(2)}` - } - if (previousTarget) { - sentence = sentence - .replace(/\bthat creature\b/gi, 'the chosen target') - .replace(/\bit\b(?!['’]s)/gi, 'the chosen target') - } - const spend = sentence.match(/^spend this mana only to (.+)$/i) - if (spend) { - const last = effects[effects.length - 1] - if (last?.op === 'add_mana') { - last.mana.restriction = spend[1] - continue - } - return undefined - } - - // The search already shuffles; the sentence only spells out when. - if (/^if you search your library this way, shuffle\.?$/i.test(sentence)) { - const last = effects[effects.length - 1] - if (last?.op !== 'search') return undefined - last.shuffle = true - continue - } - - const conditional = sentence.match(/^if (.+?), (.+)$/i) - if (conditional) { - const raw = conditional[1].trim().toLowerCase() - const condition: Condition | undefined = - raw === 'you do' - ? { kind: 'if_you_do' } - : raw === "you don't" || raw === 'you do not' - ? { kind: 'if_you_dont' } - : parseCondition(conditional[1]) - if (condition) { - let inner = parseEffectSentence(conditional[2]) - if (!inner && /^you may /i.test(conditional[2])) { - inner = parseEffectSentence(conditional[2].slice(8)) - } - if (inner) { - effects.push({ op: 'conditional', condition, effects: inner }) - continue - } - } - return undefined - } - - const otherwise = sentence.match(/^otherwise, (.+)$/i) - if (otherwise) { - let inner = parseEffectSentence(otherwise[1]) - if (!inner && /^you may /i.test(otherwise[1])) { - inner = parseEffectSentence(otherwise[1].slice(8)) - } - if (inner) { - effects.push({ op: 'conditional', condition: { kind: 'otherwise' }, effects: inner }) - continue - } - return undefined - } - - const trailingIf = sentence.match(/^(.+?) if (.+)$/i) - if (trailingIf) { - const condition = parseCondition(trailingIf[2]) - const inner = condition ? parseEffectSentence(trailingIf[1]) : undefined - if (condition && inner) { - effects.push({ op: 'conditional', condition, effects: inner }) - continue - } - } - - let parsed: Effect[] | undefined - if (/, then /i.test(sentence)) { - const parts = sentence.split(/,\s+then\s+/i) - const combined: Effect[] = [] - for (const part of parts) { - const inner = parseEffectSentence(part) - if (!inner) { - combined.length = 0 - break - } - combined.push(...inner) - } - if (combined.length) parsed = combined - } - if (!parsed) parsed = parseEffectSentence(sentence) - if (!parsed && /^you may /i.test(sentence)) { - parsed = parseEffectSentence(sentence.slice(8)) - if (parsed) optional = true - } - if (!parsed) return undefined - if (!leadingIt) { - const newTarget = primaryTargetOf(parsed) - if (newTarget) previousTarget = newTarget - } - effects.push(...parsed) - } - - return { effects, optional } -} - -function resolveIt(text: string, pronoun: string): string { - if (/^it\b/i.test(text)) return `${pronoun}${text.slice(2)}` - if (/\b(?:target|that|those)\b/.test(text)) return text - // A card/token/permanent mentioned in the effect introduces a new referent; - // replacing "it" there would guess. Leave it unsupported instead. - if (/\b(?:card|cards|token|tokens|permanent|permanents|creature|creatures|spell|spells)\b/.test(text)) return text - return text.replace(/\bit\b/g, pronoun) -} - -function parseTriggerPrefix(text: string): { event: TriggerEvent; rest: string } | undefined { - let rest = text.trim() - - let match = rest.match(/^when(?:ever)? this (enters|dies|attacks|blocks|leaves the battlefield)(?: the battlefield)?, (.+)$/) - if (match) { - const kind = match[1] as 'enters' | 'dies' | 'attacks' | 'blocks' | 'leaves the battlefield' - const eventKind = kind === 'leaves the battlefield' ? 'leaves_battlefield' : kind - return { event: { kind: eventKind, subject: { kind: 'self' } } as TriggerEvent, rest: match[2] } - } - - match = rest.match(/^when(?:ever)? this becomes level (\d+), (.+)$/) - if (match) { - return { event: { kind: 'becomes_level', level: Number(match[1]) }, rest: match[2] } - } - - match = rest.match(/^when(?:ever)? this enters or attacks, (.+)$/) - if (match) return { event: { kind: 'enters_or_attacks', subject: { kind: 'self' } }, rest: match[1] } - - match = rest.match(/^when(?:ever)? this enters or dies, (.+)$/) - if (match) return { event: { kind: 'enters_or_dies', subject: { kind: 'self' } }, rest: match[1] } - - match = rest.match(/^when(?:ever)? this attacks or blocks, (.+)$/) - if (match) return { event: { kind: 'attacks_or_blocks', subject: { kind: 'self' } }, rest: match[1] } - - match = rest.match(/^when(?:ever)? this blocks or becomes blocked(?: by a creature)?, (.+)$/) - if (match) return { event: { kind: 'blocks', subject: { kind: 'self' } }, rest: match[1] } - - match = rest.match(/^when(?:ever)? this becomes blocked(?: by a creature)?, (.+)$/) - if (match) return { event: { kind: 'blocks', subject: { kind: 'self' } }, rest: match[1] } - - match = rest.match(/^when(?:ever)? this deals (combat )?damage to (a player|an opponent|a creature|a planeswalker|one or more players|you), (.+)$/) - if (match) { - const recipient = - match[2] === 'a creature' || match[2] === 'a planeswalker' - ? 'permanent' - : 'player' - return { - event: { - kind: 'deals_damage', - subject: { kind: 'self' }, - recipient, - combat: Boolean(match[1]), - }, - rest: match[3], - } - } - - match = rest.match(/^when(?:ever)? this becomes the target of (?:a spell or ability|a spell|an ability)(?: an opponent controls)?, (.+)$/) - if (match) { - return { event: { kind: 'becomes_target', subject: { kind: 'self' } }, rest: match[1] } - } - - match = rest.match(/^when(?:ever)? this is put into a graveyard from (?:the battlefield|anywhere), (.+)$/) - if (match) { - return { event: { kind: 'dies', subject: { kind: 'self' } }, rest: match[1] } - } - - match = rest.match(/^whenever (you|an opponent|a player) (gains?|loses?) life, (.+)$/) - if (match) { - const who = match[1] === 'you' ? 'you' : match[1] === 'an opponent' ? 'opponent' : 'each_player' - const mode = match[2].startsWith('gain') ? 'gain' : 'lose' - return { event: { kind: 'life', who, mode }, rest: match[3] } - } - - match = rest.match(/^whenever (you|an opponent|a player) draws? (.+?), (.+)$/) - if (match) { - const who = match[1] === 'you' ? 'you' : match[1] === 'an opponent' ? 'opponent' : 'each_player' - const clause = match[2].trim() - let ordinal: number | undefined - const ordinalMatch = clause.match(/^(?:your|their) (\w+) card each turn$/) - if (ordinalMatch) { - ordinal = parseNumber(ordinalMatch[1]) - if (ordinal === undefined) return undefined - } else if (!/^(?:a card|their card|one or more cards|a card this turn)$/.test(clause)) { - return undefined - } - return { event: { kind: 'draw', who, ordinal }, rest: match[3] } - } - - match = rest.match(/^at the beginning of (your|each player's|each opponent's|each|the) upkeep, (.+)$/) - if (match) { - const who = match[1] === 'your' ? 'you' : 'each_player' - return { event: { kind: 'upkeep', who }, rest: match[2] } - } - - match = rest.match(/^at the beginning of (your|each player's|each opponent's|each|the) end step, (.+)$/) - if (match) { - const who = match[1] === 'your' ? 'you' : 'each_player' - return { event: { kind: 'end_step', who }, rest: match[2] } - } - - match = rest.match(/^at the beginning of combat on (your|each player's|each opponent's) turn, (.+)$/) - if (match) { - const who = match[1] === 'your' ? 'you' : 'each_player' - return { event: { kind: 'begin_combat', who }, rest: match[2] } - } - - match = rest.match(/^at the beginning of (your|each player's|each opponent's) (first|postcombat) main phase, (.+)$/) - if (match) { - const who = match[1] === 'your' ? 'you' : 'each_player' - return { - event: { kind: 'main_phase', who, phase: match[2] === 'first' ? 'first' : 'postcombat' }, - rest: match[3], - } - } - - match = rest.match(/^whenever (you|an opponent|a player) casts?(?: or cop(y|ies))? (.+?), (.+)$/) - if (match) { - let spellText = match[3].trim() - const who = match[1] === 'you' ? 'you' : match[1] === 'an opponent' ? 'opponent' : 'each_player' - const orCopy = Boolean(match[2]) - let ordinal: number | undefined - const nth = spellText.match(/^(?:your|their) (\w+) spell each turn$/) - if (nth) { - ordinal = parseNumber(nth[1]) - if (ordinal === undefined) return undefined - spellText = 'a spell' - } - let targetsSelf = false - if (/ that targets this$/.test(spellText)) { - targetsSelf = true - spellText = spellText.replace(/ that targets this$/, '') - } - const spell = spellText === 'a spell' || spellText === 'spell' - ? { types: [] } - : parseSelector(spellText.replace(/ spells?$/, '')) - if (spell) { - return { - event: { kind: 'cast', who, spell, targetsSelf: targetsSelf || undefined, ordinal, orCopy: orCopy || undefined }, - rest: match[4], - } - } - } - - match = rest.match(/^whenever (?:one or more )?(.+?) counters? are put on (.+?), (.+)$/) - if (match) { - const subject = parseSubject(match[2]) - if (subject) { - return { event: { kind: 'counter_placed', subject, counter: match[1] }, rest: match[3] } - } - } - - match = rest.match(/^whenever (?:one or more )?(.+?) deals? (combat )?damage to (a player|a player or battle|an opponent|a creature|a planeswalker|you), (.+)$/) - if (match) { - const subject = parseSubject(match[1]) - const recipient = - match[3] === 'a creature' || match[3] === 'a planeswalker' - ? 'permanent' - : 'player' - if (subject) { - return { - event: { kind: 'deals_damage', subject, recipient, combat: Boolean(match[2]) }, - rest: match[4], - } - } - } - - match = rest.match(/^when(?:ever)? (?:one or more )?(.+?) (enters?|dies?|attacks?|blocks?|leaves? the battlefield), (.+)$/) - if (match) { - const subject = parseSubject(match[1]) - if (subject) { - const raw = match[2] - const kind = raw.startsWith('enter') - ? 'enters' - : raw.startsWith('die') - ? 'dies' - : raw.startsWith('attack') - ? 'attacks' - : raw.startsWith('block') - ? 'blocks' - : 'leaves_battlefield' - return { event: { kind, subject } as TriggerEvent, rest: match[3] } - } - } - - return undefined -} - -function parseStaticTarget(text: string): Target | undefined { - if (text.trim() === 'this') return { kind: 'self' } - const direct = parseTarget(text) - if (direct && direct.kind === 'object') return { ...direct, mode: 'each' } - const selector = parseSelector(text) - if (selector) return { kind: 'object', selector, mode: 'each' } - return undefined -} - -/** "Each spell you cast that's X" and "X spells and Y spells" reduce on a union. */ -function parseCostReductionTarget(text: string): Target | undefined { - const eachSpell = text.match(/^each spell you cast that(?:'s| is) (.+)$/) - const normalized = eachSpell - ? `${eachSpell[1].replace(/^an? /, '')} spells you cast` - : text - const target = parseStaticTarget(normalized) - if (!target || target.kind !== 'object') return target - if (!/\band\b|,/.test(normalized)) return target - - target.selector.match = 'any' - // parseSelector infers one type from the first subtype; a mixed list has none. - if ((target.selector.subtypes?.length ?? 0) > 1) target.selector.types = [] - return target -} - -function parseStaticEffects(text: string): StaticEffect[] | undefined { - const sentence = text - .trim() - .replace(/\.$/, '') - // Clarifies how a colored cost reduction works; our symbols do exactly this. - .replace(/\. this effect reduces only the amount of colored mana you pay$/, '') - - let match = sentence.match(/^(?:its|this's) (base )?power and toughness are each equal to (.+)$/) - if (match) { - const value = parseValue(match[2]) - if (value) { - return [{ - op: 'set_pt', - target: { kind: 'self' }, - power: value, - toughness: value, - base: Boolean(match[1]) || undefined, - }] - } - } - - match = sentence.match(/^(?:its|this's) (base )?power is equal to (.+)$/) - if (match) { - const value = parseValue(match[2]) - if (value) { - return [{ op: 'set_pt', target: { kind: 'self' }, power: value, base: Boolean(match[1]) || undefined }] - } - } - - match = sentence.match(/^(?:its|this's) (base )?toughness is equal to (.+)$/) - if (match) { - const value = parseValue(match[2]) - if (value) { - return [{ op: 'set_pt', target: { kind: 'self' }, toughness: value, base: Boolean(match[1]) || undefined }] - } - } - - match = sentence.match(/^(.+?) (?:gets|get) ([+-]\w+)\/([+-]\w+) for each (.+)$/) - if (match) { - const target = parseStaticTarget(match[1]) - const power = valueWithSign(match[2]) - const toughness = valueWithSign(match[3]) - const selector = forEachSelector(match[4]) - if (target && power && toughness && selector) { - const count: Value = { kind: 'count', selector } - const scaled = (value: Value): Value | undefined => { - if (value.kind !== 'number' || (value.value !== 0 && value.value !== 1)) return undefined - return value.value === 1 ? count : value - } - const scaledPower = scaled(power) - const scaledToughness = scaled(toughness) - if (scaledPower && scaledToughness) { - return [{ op: 'pump', target, power: scaledPower, toughness: scaledToughness }] - } - } - } - - match = sentence.match(/^(.+?) (?:gets|get) ([+-]\w+)\/([+-]\w+) and (?:has|have) "(.+)"$/) - if (match) { - const target = parseStaticTarget(match[1]) - const power = valueWithSign(match[2]) - const toughness = valueWithSign(match[3]) - if (target && power && toughness) { - const ability = compileLine(match[4], 'Quoted', new Set(), false) - if (ability.kind !== 'unsupported') { - return [ - { op: 'pump', target, power, toughness }, - { op: 'grant_ability', target, ability }, - ] - } - } - } - - match = sentence.match(/^(.+?) (?:gets|get) ([+-]\w+)\/([+-]\w+) and (?:has|have) (.+)$/) - if (match) { - const target = parseStaticTarget(match[1]) - const power = valueWithSign(match[2]) - const toughness = valueWithSign(match[3]) - const keywords = parseKeywordLine(match[4], new Set()) - if (target && power && toughness && keywords) { - return [ - { op: 'pump', target, power, toughness }, - ...keywords.map(keyword => ({ - op: 'grant' as const, - target, - keyword: keyword.keyword, - value: keyword.value, - })), - ] - } - } - - match = sentence.match(/^(.+?) (?:gets|get) ([+-]\w+)\/([+-]\w+)$/) - if (match) { - const target = parseStaticTarget(match[1]) - const power = valueWithSign(match[2]) - const toughness = valueWithSign(match[3]) - if (target && power && toughness) return [{ op: 'pump', target, power, toughness }] - } - - match = sentence.match(/^(.+?) (?:has|have) "(.+)"$/) - if (match) { - const target = parseStaticTarget(match[1]) - if (target) { - const ability = compileLine(match[2], 'Quoted', new Set(), false) - if (ability.kind !== 'unsupported') return [{ op: 'grant_ability', target, ability }] - } - } - - match = sentence.match(/^(.+?) (?:has|have) (.+)$/) - if (match) { - const target = parseStaticTarget(match[1]) - const keywords = parseKeywordLine(match[2], new Set()) - if (target && keywords) { - return keywords.map(keyword => ({ - op: 'grant', - target, - keyword: keyword.keyword, - value: keyword.value, - })) - } - } - - if (sentence === 'you have no maximum hand size') { - return [{ - op: 'restriction', - target: { kind: 'player', who: 'you', mode: 'target' }, - rule: 'no_max_hand_size', - }] - } - - if (sentence === 'you may look at the top card of your library any time') { - return [{ - op: 'restriction', - target: { kind: 'player', who: 'you', mode: 'target' }, - rule: 'may_look_at_top', - }] - } - - if (sentence === 'this can be your commander') { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'can_be_commander' }] - } - - if (sentence === 'you may choose not to untap this during your untap step') { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'may_choose_not_to_untap' }] - } - - if (sentence === 'this enters prepared') { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'enters_prepared' }] - } - - if (sentence === 'if this is in your opening hand, you may begin the game with it on the battlefield') { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'begin_on_battlefield' }] - } - - if (sentence === 'this can block only creatures with flying') { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'can_block_only_flying' }] - } - - if (sentence === "this cannot be blocked by more than one creature") { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_be_blocked_by_more_than_one' }] - } - - if (sentence === "this can't be blocked by more than one creature") { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_be_blocked_by_more_than_one' }] - } - - if (sentence === 'this cannot attack alone') { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_attack_alone' }] - } - - if (sentence === 'this cannot block alone') { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_block_alone' }] - } - - if (sentence === 'this must be blocked if able' || sentence === 'all creatures able to block this do so') { - return [{ op: 'restriction', target: { kind: 'self' }, rule: 'must_be_blocked' }] - } - - if (sentence === 'you may play an additional land on each of your turns') { - return [{ - op: 'restriction', - target: { kind: 'player', who: 'you', mode: 'target' }, - rule: 'additional_land_drop', - value: { kind: 'number', value: 1 }, - }] - } - - match = sentence.match(/^this cannot be blocked by creatures with power (\w+) or (greater|more|less)$/) - if (match) { - const value = parseValue(match[1]) - if (value) { - return [{ - op: 'restriction', - target: { kind: 'self' }, - rule: 'cant_be_blocked_by_power', - value, - comparison: match[2] === 'less' ? 'or_less' : 'or_greater', - }] - } - } - - match = sentence.match(/^this cannot attack unless defending player controls (.+)$/) - if (match) { - const selector = parseSelector(match[1]) - if (selector) { - return [{ - op: 'restriction', - target: { kind: 'self' }, - rule: 'cant_attack_unless', - condition: { kind: 'defending_player_controls', selector }, - }] - } - } - - if (sentence === 'you control enchanted creature') { - const target = parseStaticTarget('enchanted creature') - if (target) return [{ op: 'control', target }] - } - - match = sentence.match(/^as this enters, choose (?:a|an) (.+)$/) - if (match) { - const what = - match[1] === 'creature type' - ? 'creature_type' - : match[1] === 'color' - ? 'color' - : match[1] === 'card name' - ? 'card_name' - : match[1] === 'player' - ? 'player' - : match[1] === 'opponent' - ? 'opponent' - : match[1] === 'number' - ? 'number' - : undefined - if (what) return [{ op: 'choose', what }] - } - - match = sentence.match(/^if an effect would create one or more (tokens?|creature tokens?) under your control, it creates (twice|three times) that many of those tokens instead$/) - if (match) { - return [{ - op: 'token_multiplier', - multiplier: match[2] === 'twice' ? 2 : 3, - who: 'you', - ...(match[1] === 'creature tokens' ? { creatureOnly: true } : {}), - }] - } - - match = sentence.match(/^if one or more (tokens?|creature tokens?) would be created( under your control)?, (twice|three times) that many of those tokens are created instead$/) - if (match) { - return [{ - op: 'token_multiplier', - multiplier: match[3] === 'twice' ? 2 : 3, - who: match[2] ? 'you' : 'each_player', - ...(match[1] === 'creature tokens' ? { creatureOnly: true } : {}), - }] - } - - match = sentence.match(/^if this would be put into (?:a|your) graveyard from anywhere, exile it instead$/) - if (match) { - return [{ op: 'replacement', what: 'dies', instead: 'exile', target: { kind: 'self' } }] - } - - match = sentence.match(/^if this would leave the battlefield, exile it instead$/) - if (match) { - return [{ op: 'replacement', what: 'leaves_battlefield', instead: 'exile', target: { kind: 'self' } }] - } - - if (sentence === 'if a card or token would be put into a graveyard from anywhere, exile it instead') { - return [{ op: 'exile_instead_of_graveyard' }] - } - - match = sentence.match(/^if a card would be put into (an opponent's|your) graveyard from anywhere, exile it instead$/) - if (match) { - return [{ op: 'exile_instead_of_graveyard', owner: match[1] === 'your' ? 'you' : 'opponent' }] - } - - match = sentence.match(/^if (an opponent|you) would search (?:a|their) library, that player searches the top (\w+) cards? of that library instead$/) - if (match) { - const amount = parseValue(match[2]) - if (amount) return [{ op: 'search_restriction', who: match[1] === 'you' ? 'you' : 'opponent', amount }] - } - - match = sentence.match(/^activated abilities of (.+?) cannot be activated$/) - if (match) { - const target = parseStaticTarget(match[1]) - if (target) return [{ op: 'restriction', target, rule: 'cant_activate' }] - } - - match = sentence.match(/^(noncreature|creature) spells cost (\{[^}]+\}) more to cast$/) - if (match) { - const amount = parseValue(match[2].slice(1, -1)) - if (amount) return [{ op: 'cost_increase', amount, spellType: match[1] === 'creature' ? 'creature' : 'noncreature' }] - } - - let costText = sentence - let costCondition: Condition | undefined - let costAmount: Value | undefined - const costWhereX = costText.match(/^(.+?), where x is (.+)$/) - if (costWhereX) { - const value = parseValue(costWhereX[2]) - if (value) { - costText = costWhereX[1] - costAmount = value - } - } - const costIf = costText.match(/^(.+?) if (.+)$/) - if (costIf) { - const parsed = parseCondition(costIf[2]) - if (parsed) { - costText = costIf[1] - costCondition = parsed - } - } - match = costText.match(/^(.+?) costs? ((?:\{[^}]+\})+) less to cast(?: for each (.+))?$/) - if (match) { - const target = parseCostReductionTarget(match[1]) - let amount: Value | undefined = costAmount - let symbols: string | undefined - if (!amount && match[3]) { - const selector = parseSelector(match[3]) - if (selector) amount = { kind: 'count', selector } - } else if (!amount) { - const parts = [...match[2].matchAll(/\{([^}]+)\}/g)].map(symbol => symbol[1]) - if (parts.some(part => /[WUBRGC]/i.test(part))) symbols = match[2].toUpperCase() - else if (parts[0]) amount = parseValue(parts[0].toLowerCase()) - } - if (target && (amount || symbols)) { - return [{ - op: 'cost_reduction', - target, - ...(amount ? { amount } : {}), - ...(symbols ? { symbols } : {}), - ...(costCondition ? { condition: costCondition } : {}), - }] - } - } - - match = sentence.match(/^(.+?) cannot attack or block$/) - if (match) { - const target = parseStaticTarget(match[1]) - if (target) { - return [ - { op: 'restriction', target, rule: 'cant_attack' }, - { op: 'restriction', target, rule: 'cant_block' }, - ] - } - } - - match = sentence.match(/^(.+?) cannot attack$/) - if (match) { - const target = parseStaticTarget(match[1]) - if (target) return [{ op: 'restriction', target, rule: 'cant_attack' }] - } - - match = sentence.match(/^(.+?) cannot block$/) - if (match) { - const target = parseStaticTarget(match[1]) - if (target) return [{ op: 'restriction', target, rule: 'cant_block' }] - } - - match = sentence.match(/^(.+?) cannot be blocked$/) - if (match) { - const target = parseStaticTarget(match[1]) - if (target) return [{ op: 'restriction', target, rule: 'cant_be_blocked' }] - } - - match = sentence.match(/^(.+?) cannot be countered$/) - if (match) { - const target = parseStaticTarget(match[1]) - if (target) return [{ op: 'restriction', target, rule: 'cant_be_countered' }] - } - - match = sentence.match(/^(.+?) does not untap during (?:its controller's|your) untap step$/) - if (match) { - const target = parseStaticTarget(match[1]) - if (target) return [{ op: 'restriction', target, rule: 'doesnt_untap' }] - } - - match = sentence.match(/^(.+?) attacks each combat if able$/) - if (match) { - const target = parseStaticTarget(match[1]) - if (target) return [{ op: 'restriction', target, rule: 'must_attack' }] - } - - if (sentence === 'this enters tapped') { - return [{ op: 'enters_tapped', target: { kind: 'self' } }] - } - match = sentence.match(/^as this enters, you may pay (\w+) life\. if you don't, it enters tapped$/) - if (match) { - const amount = parseValue(match[1]) - if (amount) return [{ op: 'enters_tapped', target: { kind: 'self' }, unlessCost: { kind: 'pay_life', amount } }] - } - const entersTappedUnless = sentence.match(/^this enters tapped unless (.+)$/) - if (entersTappedUnless) { - const unless = parseCondition(entersTappedUnless[1]) - if (unless) return [{ op: 'enters_tapped', target: { kind: 'self' }, unless }] - } - - match = sentence.match(/^(.+?) enters with (?:(\w+) )?(?:additional )?(.+?) counters? on it(?: for each (.+))?$/) - if (match) { - const target = parseStaticTarget(match[1]) - let amount = match[2] ? parseValue(match[2]) : ({ kind: 'number', value: 1 } as Value) - if (match[4]) { - const selector = parseSelector(match[4]) - if (selector) amount = { kind: 'count', selector } - } - if (target && amount) { - return [{ op: 'enters_with_counters', target, counter: match[3], amount }] - } - } - - return undefined -} - -function parseStaticAbility(text: string): { effects: StaticEffect[]; condition?: Condition } | undefined { - let rest = text.trim().replace(/\.$/, '') - - // A leading duration makes this a one-shot effect, not a continuous one. - if (takeLeadingDuration(rest).duration) return undefined - - let condition: Condition | undefined - const conditionPrefix = rest.match(/^(?:during your turn|as long as it is your turn), (.+)$/) - if (conditionPrefix) { - condition = { kind: 'your_turn' } - rest = conditionPrefix[1] - } else { - const longAsPrefix = rest.match(/^as long as (.+?), (.+)$/) - if (longAsPrefix) { - condition = parseCondition(longAsPrefix[1]) - if (!condition) return undefined - rest = longAsPrefix[2] - } else { - const conditionSuffix = rest.match(/^(.+?) as long as (.+)$/) - if (conditionSuffix) { - condition = parseCondition(conditionSuffix[2]) - if (!condition) return undefined - rest = conditionSuffix[1] - } else { - const ifSuffix = rest.match(/^(.+?) if (.+)$/) - if (ifSuffix) { - const parsed = parseCondition(ifSuffix[2]) - if (parsed) { - condition = parsed - rest = ifSuffix[1] - } - } - } - } - } - - const effects = parseStaticEffects(rest) - return effects ? { effects, condition } : undefined -} - +/** Replaces a bare pronoun with the target introduced by the previous clause. */ function parseActivatedAbility(text: string): Ability | undefined { const colon = text.indexOf(':') if (colon < 0) return undefined @@ -2229,7 +827,7 @@ function parseActivatedAbility(text: string): Ability | undefined { if (/\bAny player may activate\b/i.test(effectText)) return undefined if (!effectText) return undefined - const parsed = parseEffects(resolveIt(effectText, 'this')) + const parsed = parseEffects(effectText, 'this') if (!parsed) return undefined return { @@ -2244,7 +842,7 @@ function parseActivatedAbility(text: string): Ability | undefined { } } -function compileLine(rawLine: string, name: string, known: Set, isSpell: boolean): Ability { +export function compileLine(rawLine: string, name: string, known: Set, isSpell: boolean): Ability { const line = normalize(rawLine, name) if (!line) return { kind: 'unsupported', reason: 'empty', text: rawLine } @@ -2280,7 +878,7 @@ function compileLine(rawLine: string, name: string, known: Set, isSpell: const chapter = body.match(/^([ivx]+(?:, [ivx]+)*) — (.+)$/i) if (chapter) { - const effects = parseEffects(resolveIt(chapter[2], 'this')) + const effects = parseEffects(chapter[2], 'this') if (!effects) return { kind: 'unsupported', reason: 'saga effect', text: line } return { kind: 'chapter', @@ -2337,10 +935,9 @@ function compileLine(rawLine: string, name: string, known: Set, isSpell: effectText = conditional[2] } + const frequency = stripTriggerFrequency(effectText) const pronoun = 'subject' in trigger.event ? 'the triggering object' : 'this' - effectText = resolveIt(effectText, pronoun) - - const effects = parseEffects(effectText) + const effects = parseEffects(frequency.text, pronoun) if (!effects) return { kind: 'unsupported', reason: 'trigger effect', text: line } return { @@ -2349,6 +946,7 @@ function compileLine(rawLine: string, name: string, known: Set, isSpell: condition, effects: effects.effects, optional: effects.optional, + oncePerTurn: frequency.oncePerTurn || undefined, text: line, } } @@ -2367,7 +965,7 @@ function compileLine(rawLine: string, name: string, known: Set, isSpell: } if (isSpell) { - const spellEffects = parseEffects(resolveIt(lower, 'this')) + const spellEffects = parseEffects(lower, 'this') if (spellEffects) { return { kind: 'spell', @@ -2434,7 +1032,7 @@ function compileModalGroup( const modes: Effect[][] = [] for (const bullet of bullets) { const body = normalize(bullet.replace(/^[•·]\s*/, '').trim(), name) - const parsed = parseEffects(resolveIt(body, 'this')) + const parsed = parseEffects(body, 'this') if (!parsed) return { kind: 'unsupported', reason: 'modal effect', text } modes.push(parsed.effects) } @@ -2551,3 +1149,4 @@ export function compileCard(card: Card): CompiledCard { export function compileText(text: string, name = 'Test Card', keywords: string[] = [], typeLine = 'Instant'): Ability[] { return compileFace({ name, oracle_text: text, type_line: typeLine }, keywords).abilities } + diff --git a/backend/src/effects/format.ts b/backend/src/effects/format.ts index dac4e42..9314979 100644 --- a/backend/src/effects/format.ts +++ b/backend/src/effects/format.ts @@ -178,6 +178,8 @@ export function formatTarget(target: Target): string { return 'triggerSubject' case 'previous_target': return 'previousTarget' + case 'damaged': + return 'damagedTarget' case 'any': return 'anyTarget' case 'player_or_planeswalker': @@ -313,6 +315,8 @@ export function formatEffect(effect: Effect): string { return `putCounters(${formatTarget(effect.target)}, ${quote(effect.counter)}, ${formatValue(effect.amount)})` case 'remove_counters': return `removeCounters(${formatTarget(effect.target)}, ${quote(effect.counter)}, ${formatValue(effect.amount)})` + case 'double_counters': + return `doubleCounters(${formatTarget(effect.target)}${effect.counter ? `, ${quote(effect.counter)}` : ''})` case 'proliferate': return 'proliferate()' case 'create_token': @@ -378,6 +382,9 @@ export function formatEffect(effect: Effect): string { case 'prevent_damage': return `preventDamage(${formatTarget(effect.target)}, ${effect.amount === 'all' ? quote('all') : formatValue(effect.amount)}${optionArg([ ['combatOnly', effect.combatOnly ? 'true' : undefined], + ['global', effect.global ? 'true' : undefined], + ['source', effect.source ? formatTarget(effect.source) : undefined], + ['sourceSelector', effect.sourceSelector ? formatSelector(effect.sourceSelector) : undefined], ['duration', formatDuration(effect.duration)], ])})` case 'gain_control': @@ -422,6 +429,10 @@ export function formatEffect(effect: Effect): string { return `hideaway(${formatValue(effect.amount)})` case 'play_exiled': return `playExiled(${formatPlayer(effect.player)}${optionArg([['free', effect.free ? 'true' : undefined]])})` + case 'impulse': + return `impulse(${formatPlayer(effect.player)}, ${formatValue(effect.amount)}${effect.faceDown ? ', { faceDown: true }' : ''})` + case 'exile_instead_of_dying': + return `exileInsteadOfDying(${formatTarget(effect.target)})` } } @@ -441,6 +452,10 @@ function formatCondition(condition: Condition): string { return 'sourceUntapped()' case 'source_attacking': return 'sourceAttacking()' + case 'source_equipped': + return 'sourceEquipped()' + case 'source_enchanted': + return 'sourceEnchanted()' case 'life_at_least': return `lifeAtLeast(${formatPlayer(condition.player)}, ${condition.amount})` case 'life_at_most': @@ -648,6 +663,14 @@ function formatStaticEffect(effect: StaticEffect): string { ['target', effect.target ? formatTarget(effect.target) : undefined], ['instead', quote(effect.instead)], ])})` + case 'replacement_amount': + return `replacementAmount(${quote(effect.what)}, ${effect.multiplier}${optionArg([ + ['add', effect.add !== undefined ? String(effect.add) : undefined], + ['combatOnly', effect.combatOnly ? 'true' : undefined], + ['noncombatOnly', effect.noncombatOnly ? 'true' : undefined], + ['sourceColor', effect.sourceColor ? quote(effect.sourceColor) : undefined], + ['controller', effect.controller === 'you' ? quote('you') : undefined], + ])})` case 'cost_reduction': return `costReduction(${formatTarget(effect.target)}, ${effect.symbols ? quote(effect.symbols) : effect.amount ? formatValue(effect.amount) : '0'}${optionArg([['condition', effect.condition ? formatCondition(effect.condition) : undefined]])})` case 'cost_increase': @@ -661,6 +684,22 @@ function formatStaticEffect(effect: StaticEffect): string { ['who', effect.who === 'each_player' ? quote('each_player') : undefined], ['creatureOnly', effect.creatureOnly ? 'true' : undefined], ])})` + case 'prevent_damage': + return `preventDamage(${formatTarget(effect.target)}, ${effect.amount === 'all' ? quote('all') : formatValue(effect.amount)}${optionArg([ + ['combatOnly', effect.combatOnly ? 'true' : undefined], + ['global', effect.global ? 'true' : undefined], + ['sourceSelector', effect.sourceSelector ? formatSelector(effect.sourceSelector) : undefined], + ['duration', formatDuration(effect.duration)], + ])})` + case 'counter_multiplier': + return `counterMultiplier(${formatTarget(effect.target)}, ${effect.multiplier}${optionArg([ + ['counter', effect.counter ? quote(effect.counter) : undefined], + ['add', effect.add !== undefined ? String(effect.add) : undefined], + ])})` + case 'token_replacement': + return `tokenReplacement([${effect.from.map(quote).join(', ')}], [${effect.tokens.map(formatToken).join(', ')}]${optionArg([ + ['who', effect.who === 'each_player' ? quote('each_player') : undefined], + ])})` } } diff --git a/backend/src/effects/parse.ts b/backend/src/effects/parse.ts index 2c533db..8437923 100644 --- a/backend/src/effects/parse.ts +++ b/backend/src/effects/parse.ts @@ -178,6 +178,7 @@ export function parseValue(text: string): Value | undefined { if (trimmed === 'x') return { kind: 'x' } if (trimmed === 'that much' || trimmed === 'that many') return { kind: 'event_amount' } + if (trimmed === 'the damage prevented this way' || trimmed === 'the life lost this way') return { kind: 'event_amount' } if (/^(its|this creature's|this permanent's) power$/.test(trimmed)) return { kind: 'source_power' } if (/^(its|this creature's|this permanent's) toughness$/.test(trimmed)) return { kind: 'source_toughness' } @@ -703,6 +704,8 @@ export function parseCondition(text: string): Condition | undefined { if (trimmed === 'this is tapped') return { kind: 'source_tapped' } if (trimmed === 'this is untapped') return { kind: 'source_untapped' } if (trimmed === 'this is attacking') return { kind: 'source_attacking' } + if (trimmed === 'this is equipped') return { kind: 'source_equipped' } + if (trimmed === 'this is enchanted') return { kind: 'source_enchanted' } if (trimmed === 'this was kicked' || trimmed === 'it was kicked') return { kind: 'was_kicked' } if (trimmed === 'this attacked this turn') return { kind: 'attacked_this_turn' } if (trimmed === 'you attacked this turn') return { kind: 'you_attacked_this_turn' } diff --git a/backend/src/effects/source-abilities.ts b/backend/src/effects/source-abilities.ts new file mode 100644 index 0000000..ae4b017 --- /dev/null +++ b/backend/src/effects/source-abilities.ts @@ -0,0 +1,176 @@ +// Safe JavaScript card source. A card implementation is a module-shaped +// expression that calls the builder API below: +// +// export default [ +// triggered(when.enters(permanents.withType('creature')), () => { +// gainLife(you, 1) +// }), +// ] +// +// The source is tokenized, parsed and evaluated against that API only. It is +// never passed to eval or new Function, so a saved override cannot run code. + +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + PlayerRef, + SearchDestination, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from './types.js' + +import { SIMPLE_KEYWORDS } from './compile.js' +import { singularize } from './parse.js' +import { Selector, PLAYER_REFS, DURATIONS, ZONES, SEARCH_DESTINATIONS, COLOR_CODES, CHOICES, RESTRICTION_RULES, REPLACEMENT_WHATS, REPLACEMENT_RESULTS, TRIGGER_PLAYERS, VALUE_KINDS, EFFECT_OPS, STATIC_OPS, COST_KINDS, CONDITION_KINDS, TRIGGER_KINDS, ABILITY_KINDS, expectKind, isRecord, asRecord, asString, asNumber, asBoolean, optionalString, stringArray, asPlayer, asTriggerPlayer, asDuration, asZone, asSearchDestination, asValue, asSelector, isTarget, asTarget, asEffects, asEffect, asStaticEffects, asStaticEffect, asCosts, asCost, asCondition, asTrigger, asAbility, asAbilityArray, asOptions } from './source-validation.js' + +import { self, triggerSubject, previousTarget, anyTarget, targetPlayerOrPlaneswalker, targetOptions, target, each, pick, divided, targetSpell, targetAbility, X, itsPower, itsToughness, count, cardsInHand, maxCardsInHand, maxOpponentCount, totalManaValue, totalPower, anyNumber, eventAmount, mana, anyColor, asToken, CopyOf, copyOf, manaCost, tapCost, untapCost, tapOther, energyCost, loyalty, payLife, discardCost, sacrificeCost, sacrificeSelf, exileSelf, exileFromGraveyard, reveal, choice, returnToHandCost, behold, waterbend, blight, chooseCost, putCounterCost, removeCountersCost, forage, collectEvidence, millCost } from './source-values.js' + +export function parseKeywordText(text: string): KeywordAbility { + const trimmed = text.trim() + const lower = trimmed.toLowerCase() + const simple = [...SIMPLE_KEYWORDS.entries()].sort((a, b) => b[0].length - a[0].length) + for (const [key, keyword] of simple) { + if (lower === key) return { kind: 'keyword', keyword: trimmed } + if (lower.startsWith(`${key} `)) return { kind: 'keyword', keyword, value: trimmed.slice(key.length + 1) } + } + const match = trimmed.match(/^(\S+)(?: (.+))?$/) + if (!match) return { kind: 'keyword', keyword: trimmed } + return { + kind: 'keyword', + keyword: match[1].charAt(0).toUpperCase() + match[1].slice(1), + ...(match[2] ? { value: match[2] } : {}), + } +} + +export function keyword(name: unknown, value?: unknown): Ability { + return { + kind: 'keyword', + keyword: asString(name, 'keyword'), + ...(value !== undefined ? { value: asString(value, 'keyword value') } : {}), + } +} + +export function keywords(...items: unknown[]): Ability { + return { + kind: 'keywords', + keywords: items.map(item => { + if (isRecord(item) && item.kind === 'keyword') return item as unknown as KeywordAbility + return parseKeywordText(asString(item, 'keyword')) + }), + } +} + +export function triggered(event: unknown, effects: unknown, options?: unknown): Ability { + const data = asOptions(options) + return { + kind: 'triggered', + event: asTrigger(event), + effects: asEffects(effects), + ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), + optional: data.optional === true, + text: 'Triggered ability', + } +} + +export function activated(costs: unknown, effects: unknown, options?: unknown): Ability { + const data = asOptions(options) + const timing = data.timing + if (timing !== undefined && timing !== 'instant' && timing !== 'sorcery') { + throw new Error('timing must be instant or sorcery') + } + return { + kind: 'activated', + costs: asCosts(costs), + effects: asEffects(effects), + ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), + ...(timing ? { timing } : {}), + ...(data.activationsPerTurn !== undefined + ? { activationsPerTurn: asNumber(data.activationsPerTurn, 'activations per turn') } + : {}), + optional: data.optional === true, + text: 'Activated ability', + } +} + +export function staticAbility(effects: unknown, options?: unknown): Ability { + const data = asOptions(options) + return { + kind: 'static', + effects: asStaticEffects(effects), + ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), + text: 'Static ability', + } +} + +export function spell(effects: unknown, options?: unknown): Ability { + return { + kind: 'spell', + effects: asEffects(effects), + optional: asOptions(options).optional === true, + text: 'Spell effect', + } +} + +export function additionalCost(costs: unknown, options?: unknown): Ability { + return { + kind: 'additional_cost', + costs: asCosts(costs), + optional: asOptions(options).optional === true, + text: 'Additional cost', + } +} + +export function alternativeCost(costs: unknown, options?: unknown): Ability { + const data = asOptions(options) + return { + kind: 'alternative_cost', + costs: asCosts(costs), + ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), + text: 'Alternative cost', + } +} + +export function overload(cost: unknown): Ability { + return { kind: 'overload', cost: asString(cost, 'overload cost'), text: 'Overload' } +} + +export function chapter(chapters: unknown, effects: unknown, options?: unknown): Ability { + if (!Array.isArray(chapters)) throw new Error('chapter() expects an array of chapter numbers') + return { + kind: 'chapter', + chapters: chapters.map(entry => asString(entry, 'chapter').toUpperCase()), + effects: asEffects(effects), + optional: asOptions(options).optional === true, + text: 'Chapter ability', + } +} + +export function levelBand(min: unknown, max: unknown, power?: unknown, toughness?: unknown): Ability { + return { + kind: 'level_band', + min: asNumber(min, 'minimum level'), + ...(max !== null && max !== undefined ? { max: asNumber(max, 'maximum level') } : {}), + ...(power !== undefined ? { power: asValue(power) } : {}), + ...(toughness !== undefined ? { toughness: asValue(toughness) } : {}), + text: 'Level band', + } +} + +export function levelPt(power: unknown, toughness: unknown): Ability { + return { kind: 'level_pt', power: asValue(power), toughness: asValue(toughness), text: 'Level P/T' } +} + +export function unsupported(reason: unknown, text: unknown): Ability { + return { kind: 'unsupported', reason: asString(reason, 'reason'), text: asString(text, 'text') } +} + diff --git a/backend/src/effects/source-api.ts b/backend/src/effects/source-api.ts new file mode 100644 index 0000000..cc3a721 --- /dev/null +++ b/backend/src/effects/source-api.ts @@ -0,0 +1,297 @@ +// Safe JavaScript card source. A card implementation is a module-shaped +// expression that calls the builder API below: +// +// export default [ +// triggered(when.enters(permanents.withType('creature')), () => { +// gainLife(you, 1) +// }), +// ] +// +// The source is tokenized, parsed and evaluated against that API only. It is +// never passed to eval or new Function, so a saved override cannot run code. + +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + PlayerRef, + SearchDestination, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from './types.js' + +import { SIMPLE_KEYWORDS } from './compile.js' +import { singularize } from './parse.js' +import { Selector, PLAYER_REFS, DURATIONS, ZONES, SEARCH_DESTINATIONS, COLOR_CODES, CHOICES, RESTRICTION_RULES, REPLACEMENT_WHATS, REPLACEMENT_RESULTS, TRIGGER_PLAYERS, VALUE_KINDS, EFFECT_OPS, STATIC_OPS, COST_KINDS, CONDITION_KINDS, TRIGGER_KINDS, ABILITY_KINDS, expectKind, isRecord, asRecord, asString, asNumber, asBoolean, optionalString, stringArray, asPlayer, asTriggerPlayer, asDuration, asZone, asSearchDestination, asValue, asSelector, isTarget, asTarget, asEffects, asEffect, asStaticEffects, asStaticEffect, asCosts, asCost, asCondition, asTrigger, asAbility, asAbilityArray, asOptions } from './source-validation.js' + +import { self, triggerSubject, previousTarget, anyTarget, targetPlayerOrPlaneswalker, targetOptions, target, each, pick, divided, targetSpell, targetAbility, X, itsPower, itsToughness, count, cardsInHand, maxCardsInHand, maxOpponentCount, totalManaValue, totalPower, anyNumber, eventAmount, mana, anyColor, asToken, CopyOf, copyOf, manaCost, tapCost, untapCost, tapOther, energyCost, loyalty, payLife, discardCost, sacrificeCost, sacrificeSelf, exileSelf, exileFromGraveyard, reveal, choice, returnToHandCost, behold, waterbend, blight, chooseCost, putCounterCost, removeCountersCost, forage, collectEvidence, millCost } from './source-values.js' +import { damage, damageDivided, draw, discard, mill, gainLife, loseLife, pump, setPt, grant, putCounters, doubleCounters, removeCounters, proliferate, createToken, destroy, exile, sacrifice, counter, returnToHand, returnToBattlefield, putOnTop, tap, untap, scry, surveil, search, shuffle, addMana, fight, regenerate, energy, attach, restrict, keywordAction, preventDamage, gainControl, emblem, transform, pay, ifThen, modal, lookTop, schedule, levelUp, putFromAmong, dig, exileGraveyards, hideaway, playExiled, impulse, exileInsteadOfDying } from './source-effects.js' +import { staticPump, staticGrant, staticRestrict, staticSetPt, grantAbility, entersTapped, entersWithCounters, control, choose, replace, replacementAmount, tokenMultiplier, counterMultiplier, tokenReplacement, costReduction, costIncrease, searchRestriction, exileInsteadOfGraveyard } from './source-static.js' +import { trigger, createWhen, condition, youControl, opponentControls, yourTurn, notYourTurn, sourceTapped, sourceUntapped, sourceAttacking, sourceEquipped, sourceEnchanted, lifeAtLeast, lifeAtMost, lifeAboveStarting, cardsInGraveyard, handEmpty, creatureDiedThisTurn, youGainedLifeThisTurn, youDrewCardsThisTurn, spellsCastLastTurn, noSpellsLastTurn, attackedThisTurn, youAttackedThisTurn, defendingPlayerControls, targets, wasKicked, youCastIt, inGraveyard, onBattlefield, monarch, initiative, citysBlessing, suspended, bargained, wasCreature, opponentLostLifeThisTurn, lifeChangedThisTurn, descendedThisTurn, permanentLeftBattlefieldThisTurn, nonlandPermanentsEnteredThisTurn, attackedWithTotalPower, yourCreaturesTotalPower, opponentControlsMoreLands, distinctPowers, graveyardCardTypes, noObjects, cardsInHandAtMost, notTheirTurn, noAttackers, opponentPoison, tributeNotPaid, hadCounters, manaFromTreasure, manaSpent, noManaSpent, manaSymbolSpent, kickedWith, moreCardsThanEachOpponent, firstCombatPhase, notToken, castSpellThisTurn, fullParty, graveyardCount, creaturePowerGreaterThanBase, ifYouDo, ifYouDont, otherwise, youControlCommander, distinctNames, opponentDamagedThisTurn, attackedWithCreatures, libraryAtMost } from './source-conditions.js' +import { parseKeywordText, keyword, keywords, triggered, activated, staticAbility, spell, additionalCost, alternativeCost, overload, chapter, levelBand, levelPt, unsupported } from './source-abilities.js' +import { CardSection, Face, Faces, card, face, faces } from './source-card.js' + +export function createApi(): Record { + return Object.assign(Object.create(null), { + // players + you: 'you', + opponent: 'opponent', + eachOpponent: 'each_opponent', + eachPlayer: 'each_player', + targetPlayer: 'target_player', + thatPlayer: 'that_player', + itsController: 'its_controller', + itsOwner: 'its_owner', + + // selectors + permanents: new Selector(), + cards: new Selector(), + creatures: new Selector({ types: ['creature'] }), + + // targets + self, + triggerSubject, + previousTarget, + anyTarget, + targetPlayerOrPlaneswalker, + target, + each, + pick, + divided, + targetSpell, + targetAbility, + + // values + X, + itsPower, + itsToughness, + count, + cardsInHand, + maxCardsInHand, + maxOpponentCount, + totalManaValue, + totalPower, + anyNumber, + eventAmount, + + // durations + permanent: 'permanent', + untilEndOfTurn: 'until_end_of_turn', + untilYourNextTurn: 'until_your_next_turn', + untilEndOfYourNextTurn: 'until_end_of_your_next_turn', + untilEndOfCombat: 'until_end_of_combat', + untilControllersNextUntapStep: 'until_controllers_next_untap_step', + whileSourceOnBattlefield: 'while_source_on_battlefield', + + // mana and tokens + mana, + anyColor, + token: asToken, + copyOf, + + // costs + manaCost, + tapCost, + untapCost, + tapOther, + energyCost, + loyalty, + payLife, + discardCost, + sacrificeCost, + sacrificeSelf, + exileSelf, + exileFromGraveyard, + reveal, + choice, + returnToHandCost, + behold, + waterbend, + blight, + chooseCost, + putCounterCost, + removeCountersCost, + forage, + collectEvidence, + millCost, + + // effects + damage, + damageDivided, + draw, + discard, + mill, + gainLife, + loseLife, + pump, + setPt, + grant, + putCounters, + removeCounters, + doubleCounters, + proliferate, + createToken, + destroy, + exile, + sacrifice, + counter, + returnToHand, + returnToBattlefield, + putOnTop, + tap, + untap, + scry, + surveil, + search, + shuffle, + addMana, + fight, + regenerate, + energy, + attach, + restrict, + keywordAction, + preventDamage, + gainControl, + emblem, + transform, + pay, + ifThen, + modal, + lookTop, + schedule, + levelUp, + putFromAmong, + dig, + exileGraveyards, + hideaway, + playExiled, + impulse, + exileInsteadOfDying, + + // static effects + staticPump, + staticGrant, + staticRestrict, + staticSetPt, + grantAbility, + entersTapped, + entersWithCounters, + control, + choose, + replace, + costReduction, + costIncrease, + searchRestriction, + exileInsteadOfGraveyard, + tokenMultiplier, + counterMultiplier, + tokenReplacement, + replacementAmount, + + // abilities + keyword, + keywords, + triggered, + activated, + staticAbility, + spell, + additionalCost, + alternativeCost, + overload, + chapter, + levelBand, + levelPt, + unsupported, + + // triggers + when: createWhen(), + + // conditions + youControl, + opponentControls, + yourTurn, + notYourTurn, + sourceTapped, + sourceUntapped, + sourceAttacking, + sourceEquipped, + sourceEnchanted, + lifeAtLeast, + lifeAtMost, + lifeAboveStarting, + cardsInGraveyard, + handEmpty, + creatureDiedThisTurn, + youGainedLifeThisTurn, + youDrewCardsThisTurn, + spellsCastLastTurn, + noSpellsLastTurn, + attackedThisTurn, + youAttackedThisTurn, + defendingPlayerControls, + targets, + wasKicked, + youCastIt, + inGraveyard, + onBattlefield, + monarch, + initiative, + citysBlessing, + suspended, + bargained, + wasCreature, + opponentLostLifeThisTurn, + lifeChangedThisTurn, + descendedThisTurn, + permanentLeftBattlefieldThisTurn, + nonlandPermanentsEnteredThisTurn, + attackedWithTotalPower, + yourCreaturesTotalPower, + opponentControlsMoreLands, + distinctPowers, + graveyardCardTypes, + noObjects, + cardsInHandAtMost, + notTheirTurn, + noAttackers, + opponentPoison, + tributeNotPaid, + hadCounters, + manaFromTreasure, + manaSpent, + noManaSpent, + manaSymbolSpent, + kickedWith, + moreCardsThanEachOpponent, + firstCombatPhase, + notToken, + castSpellThisTurn, + fullParty, + graveyardCount, + creaturePowerGreaterThanBase, + ifYouDo, + ifYouDont, + otherwise, + youControlCommander, + distinctNames, + opponentDamagedThisTurn, + attackedWithCreatures, + libraryAtMost, + + // card sections + card, + face, + faces, + }) +} + diff --git a/backend/src/effects/source-card.ts b/backend/src/effects/source-card.ts new file mode 100644 index 0000000..d418f26 --- /dev/null +++ b/backend/src/effects/source-card.ts @@ -0,0 +1,94 @@ +// Safe JavaScript card source. A card implementation is a module-shaped +// expression that calls the builder API below: +// +// export default [ +// triggered(when.enters(permanents.withType('creature')), () => { +// gainLife(you, 1) +// }), +// ] +// +// The source is tokenized, parsed and evaluated against that API only. It is +// never passed to eval or new Function, so a saved override cannot run code. + +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + PlayerRef, + SearchDestination, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from './types.js' + +import { SIMPLE_KEYWORDS } from './compile.js' +import { singularize } from './parse.js' +import { Selector, PLAYER_REFS, DURATIONS, ZONES, SEARCH_DESTINATIONS, COLOR_CODES, CHOICES, RESTRICTION_RULES, REPLACEMENT_WHATS, REPLACEMENT_RESULTS, TRIGGER_PLAYERS, VALUE_KINDS, EFFECT_OPS, STATIC_OPS, COST_KINDS, CONDITION_KINDS, TRIGGER_KINDS, ABILITY_KINDS, expectKind, isRecord, asRecord, asString, asNumber, asBoolean, optionalString, stringArray, asPlayer, asTriggerPlayer, asDuration, asZone, asSearchDestination, asValue, asSelector, isTarget, asTarget, asEffects, asEffect, asStaticEffects, asStaticEffect, asCosts, asCost, asCondition, asTrigger, asAbility, asAbilityArray, asOptions } from './source-validation.js' + + +export class CardSection { + readonly typeLine?: string + readonly abilities: Ability[] + + constructor(typeLineOrAbilities: unknown, abilities?: unknown) { + if (abilities === undefined) { + this.abilities = asAbilityArray(typeLineOrAbilities) + } else { + this.typeLine = asString(typeLineOrAbilities, 'card type line') + this.abilities = asAbilityArray(abilities) + } + } +} + +export class Face { + readonly name: string + readonly typeLine?: string + readonly abilities: Ability[] + + constructor(name: unknown, typeLineOrAbilities: unknown, abilities?: unknown) { + this.name = asString(name, 'face name') + if (abilities === undefined) { + this.abilities = asAbilityArray(typeLineOrAbilities) + } else { + this.typeLine = asString(typeLineOrAbilities, 'face type line') + this.abilities = asAbilityArray(abilities) + } + } +} + +export class Faces { + readonly faces: Face[] + + constructor(faces: unknown[]) { + this.faces = faces.map(face => { + if (!(face instanceof Face)) throw new Error('faces() expects face(...) entries') + return face + }) + } +} + +/** Top-level card section: card('Creature — Human', [...abilities]). */ +export function card(typeLineOrAbilities: unknown, abilities?: unknown): CardSection { + return new CardSection(typeLineOrAbilities, abilities) +} + +export function face(name: unknown, typeLineOrAbilities: unknown, abilities?: unknown): Face { + return new Face(name, typeLineOrAbilities, abilities) +} + +export function faces(...entries: unknown[]): Faces { + return new Faces(entries) +} + +// --------------------------------------------------------------------------- +// API and entry point +// --------------------------------------------------------------------------- + diff --git a/backend/src/effects/source-conditions.ts b/backend/src/effects/source-conditions.ts new file mode 100644 index 0000000..4f674d9 --- /dev/null +++ b/backend/src/effects/source-conditions.ts @@ -0,0 +1,400 @@ +// Safe JavaScript card source. A card implementation is a module-shaped +// expression that calls the builder API below: +// +// export default [ +// triggered(when.enters(permanents.withType('creature')), () => { +// gainLife(you, 1) +// }), +// ] +// +// The source is tokenized, parsed and evaluated against that API only. It is +// never passed to eval or new Function, so a saved override cannot run code. + +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + PlayerRef, + SearchDestination, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from './types.js' + +import { SIMPLE_KEYWORDS } from './compile.js' +import { singularize } from './parse.js' +import { Selector, PLAYER_REFS, DURATIONS, ZONES, SEARCH_DESTINATIONS, COLOR_CODES, CHOICES, RESTRICTION_RULES, REPLACEMENT_WHATS, REPLACEMENT_RESULTS, TRIGGER_PLAYERS, VALUE_KINDS, EFFECT_OPS, STATIC_OPS, COST_KINDS, CONDITION_KINDS, TRIGGER_KINDS, ABILITY_KINDS, expectKind, isRecord, asRecord, asString, asNumber, asBoolean, optionalString, stringArray, asPlayer, asTriggerPlayer, asDuration, asZone, asSearchDestination, asValue, asSelector, isTarget, asTarget, asEffects, asEffect, asStaticEffects, asStaticEffect, asCosts, asCost, asCondition, asTrigger, asAbility, asAbilityArray, asOptions } from './source-validation.js' + +import { self, triggerSubject, previousTarget, anyTarget, targetPlayerOrPlaneswalker, targetOptions, target, each, pick, divided, targetSpell, targetAbility, X, itsPower, itsToughness, count, cardsInHand, maxCardsInHand, maxOpponentCount, totalManaValue, totalPower, anyNumber, eventAmount, mana, anyColor, asToken, CopyOf, copyOf, manaCost, tapCost, untapCost, tapOther, energyCost, loyalty, payLife, discardCost, sacrificeCost, sacrificeSelf, exileSelf, exileFromGraveyard, reveal, choice, returnToHandCost, behold, waterbend, blight, chooseCost, putCounterCost, removeCountersCost, forage, collectEvidence, millCost } from './source-values.js' + +export function trigger(kind: T['kind'], fields: Omit): T { + return { kind, ...fields } as T +} + +export function createWhen(): Record { + return Object.assign(Object.create(null), { + enters: (subject: unknown) => trigger('enters', { subject: asTarget(subject) }), + dies: (subject: unknown) => trigger('dies', { subject: asTarget(subject) }), + attacks: (subject: unknown) => trigger('attacks', { subject: asTarget(subject) }), + blocks: (subject: unknown) => trigger('blocks', { subject: asTarget(subject) }), + attacksOrBlocks: (subject: unknown) => trigger('attacks_or_blocks', { subject: asTarget(subject) }), + entersOrAttacks: (subject: unknown) => trigger('enters_or_attacks', { subject: asTarget(subject) }), + entersOrDies: (subject: unknown) => trigger('enters_or_dies', { subject: asTarget(subject) }), + leavesBattlefield: (subject: unknown) => trigger('leaves_battlefield', { subject: asTarget(subject) }), + dealsDamage: (subject: unknown, recipient: unknown, options?: unknown) => { + if (recipient !== 'player' && recipient !== 'creature' && recipient !== 'permanent' && recipient !== 'any') { + throw new Error('dealsDamage() recipient must be player, creature, permanent or any') + } + return trigger('deals_damage', { + subject: asTarget(subject), + recipient, + combat: asOptions(options).combat === true, + }) + }, + upkeep: (who: unknown) => trigger('upkeep', { who: asTriggerPlayer(who) }), + endStep: (who: unknown) => trigger('end_step', { who: asTriggerPlayer(who) }), + beginCombat: (who: unknown) => trigger('begin_combat', { who: asTriggerPlayer(who) }), + firstMainPhase: (who: unknown) => trigger('main_phase', { who: asTriggerPlayer(who), phase: 'first' }), + postcombatMainPhase: (who: unknown) => trigger('main_phase', { who: asTriggerPlayer(who), phase: 'postcombat' }), + cast: (who: unknown, spell?: unknown, options?: unknown) => { + let selector: ObjectSelector = { types: [] } + let data: Record = Object.create(null) as Record + if (spell instanceof Selector) { + selector = asSelector(spell) + } else if (isRecord(spell) && !('targetsSelf' in spell) && !('orCopy' in spell) && !('ordinal' in spell)) { + selector = asSelector(spell) + } else if (spell !== undefined) { + data = asOptions(spell) + } + data = { ...data, ...asOptions(options) } + return trigger('cast', { + who: asTriggerPlayer(who), + spell: selector, + ...(data.targetsSelf === true ? { targetsSelf: true } : {}), + ...(data.orCopy === true ? { orCopy: true } : {}), + ...(data.ordinal !== undefined ? { ordinal: asNumber(data.ordinal, 'ordinal') } : {}), + }) + }, + becomesLevel: (level: unknown) => trigger('becomes_level', { level: asNumber(level, 'level') }), + draw: (who: unknown, ordinal?: unknown) => trigger('draw', { + who: asTriggerPlayer(who), + ...(ordinal !== undefined ? { ordinal: asNumber(ordinal, 'ordinal') } : {}), + }), + counterPlaced: (subject: unknown, counter?: unknown) => trigger('counter_placed', { + subject: asTarget(subject), + ...(counter !== undefined ? { counter: asString(counter, 'counter') } : {}), + }), + becomesTarget: (subject: unknown) => trigger('becomes_target', { subject: asTarget(subject) }), + lifeGained: (who: unknown) => trigger('life', { who: asTriggerPlayer(who), mode: 'gain' }), + lifeLost: (who: unknown) => trigger('life', { who: asTriggerPlayer(who), mode: 'lose' }), + }) +} + +// --------------------------------------------------------------------------- +// Conditions +// --------------------------------------------------------------------------- + +export function condition(kind: T['kind'], fields: Omit = {} as Omit): T { + return { kind, ...fields } as T +} + +export function youControl(selector: unknown, atLeast?: unknown): Condition { + return condition('you_control', { + selector: asSelector(selector), + ...(atLeast !== undefined ? { atLeast: asNumber(atLeast, 'count') } : {}), + }) +} + +export function opponentControls(selector: unknown, atLeast?: unknown): Condition { + return condition('opponent_controls', { + selector: asSelector(selector), + ...(atLeast !== undefined ? { atLeast: asNumber(atLeast, 'count') } : {}), + }) +} + +export function yourTurn(): Condition { + return condition('your_turn') +} + +export function notYourTurn(): Condition { + return condition('not_your_turn') +} + +export function sourceTapped(): Condition { + return condition('source_tapped') +} + +export function sourceUntapped(): Condition { + return condition('source_untapped') +} + +export function sourceAttacking(): Condition { + return condition('source_attacking') +} + +export function sourceEquipped(): Condition { + return condition('source_equipped') +} + +export function sourceEnchanted(): Condition { + return condition('source_enchanted') +} + +export function lifeAtLeast(player: unknown, amount: unknown): Condition { + return condition('life_at_least', { player: asPlayer(player), amount: asNumber(amount, 'life') }) +} + +export function lifeAtMost(player: unknown, amount: unknown): Condition { + return condition('life_at_most', { player: asPlayer(player), amount: asNumber(amount, 'life') }) +} + +export function lifeAboveStarting(player: unknown, amount: unknown): Condition { + return condition('life_above_starting', { player: asPlayer(player), amount: asNumber(amount, 'life') }) +} + +export function cardsInGraveyard(player: unknown, atLeast: unknown): Condition { + return condition('cards_in_graveyard', { player: asPlayer(player), atLeast: asNumber(atLeast, 'count') }) +} + +export function handEmpty(player: unknown): Condition { + return condition('hand_empty', { player: asPlayer(player) }) +} + +export function creatureDiedThisTurn(controller?: unknown): Condition { + if (controller !== undefined && controller !== 'you' && controller !== 'opponent') { + throw new Error('creatureDiedThisTurn() expects you or opponent') + } + return condition('creature_died_this_turn', controller ? { controller } : {}) +} + +export function youGainedLifeThisTurn(atLeast?: unknown): Condition { + return condition('you_gained_life_this_turn', atLeast === undefined ? {} : { atLeast: asNumber(atLeast, 'life') }) +} + +export function youDrewCardsThisTurn(atLeast?: unknown): Condition { + return condition('you_drew_cards_this_turn', atLeast === undefined ? {} : { atLeast: asNumber(atLeast, 'count') }) +} + +export function spellsCastLastTurn(who: unknown, atLeast: unknown): Condition { + if (who !== 'you' && who !== 'opponent' && who !== 'each_player' && who !== 'a_player') { + throw new Error('spellsCastLastTurn() expects a spell caster') + } + return condition('spells_cast_last_turn', { who, atLeast: asNumber(atLeast, 'count') }) +} + +export function noSpellsLastTurn(): Condition { + return condition('no_spells_last_turn') +} + +export function attackedThisTurn(): Condition { + return condition('attacked_this_turn') +} + +export function youAttackedThisTurn(): Condition { + return condition('you_attacked_this_turn') +} + +export function defendingPlayerControls(selector: unknown): Condition { + return condition('defending_player_controls', { selector: asSelector(selector) }) +} + +export function targets(selector: unknown): Condition { + return condition('targets', { selector: asSelector(selector) }) +} + +export function wasKicked(): Condition { + return condition('was_kicked') +} + +export function youCastIt(options?: unknown): Condition { + return condition('cast', asOptions(options).fromHand === true ? { fromHand: true } : {}) +} + +export function inGraveyard(): Condition { + return condition('in_graveyard') +} + +export function onBattlefield(): Condition { + return condition('on_battlefield') +} + +export function monarch(): Condition { + return condition('monarch') +} + +export function initiative(): Condition { + return condition('initiative') +} + +export function citysBlessing(): Condition { + return condition('citys_blessing') +} + +export function suspended(): Condition { + return condition('suspended') +} + +export function bargained(): Condition { + return condition('bargained') +} + +export function wasCreature(): Condition { + return condition('was_creature') +} + +export function opponentLostLifeThisTurn(): Condition { + return condition('opponent_lost_life_this_turn') +} + +export function lifeChangedThisTurn(): Condition { + return condition('life_changed_this_turn') +} + +export function descendedThisTurn(): Condition { + return condition('descended_this_turn') +} + +export function permanentLeftBattlefieldThisTurn(): Condition { + return condition('permanent_left_battlefield_this_turn', { controller: 'you' }) +} + +export function nonlandPermanentsEnteredThisTurn(atLeast: unknown): Condition { + return condition('nonland_permanents_entered_this_turn', { atLeast: asNumber(atLeast, 'count') }) +} + +export function attackedWithTotalPower(atLeast: unknown): Condition { + return condition('attacked_with_total_power', { atLeast: asNumber(atLeast, 'power') }) +} + +export function yourCreaturesTotalPower(atLeast: unknown): Condition { + return condition('total_power', { controller: 'you', atLeast: asNumber(atLeast, 'power') }) +} + +export function opponentControlsMoreLands(): Condition { + return condition('opponent_controls_more_lands') +} + +export function distinctPowers(atLeast: unknown): Condition { + return condition('distinct_powers', { atLeast: asNumber(atLeast, 'count') }) +} + +export function graveyardCardTypes(atLeast: unknown): Condition { + return condition('graveyard_card_types', { atLeast: asNumber(atLeast, 'count') }) +} + +export function noObjects(selector: unknown): Condition { + return condition('no_objects', { selector: asSelector(selector) }) +} + +export function cardsInHandAtMost(who: unknown, atMost: unknown): Condition { + return condition('cards_in_hand_at_most', { who: asPlayer(who), atMost: asNumber(atMost, 'count') }) +} + +export function notTheirTurn(): Condition { + return condition('not_their_turn') +} + +export function noAttackers(): Condition { + return condition('no_attackers') +} + +export function opponentPoison(atLeast: unknown): Condition { + return condition('opponent_poison', { atLeast: asNumber(atLeast, 'poison') }) +} + +export function tributeNotPaid(): Condition { + return condition('tribute_not_paid') +} + +export function hadCounters(counter?: unknown): Condition { + return condition('had_counters', counter === undefined ? {} : { counter: asString(counter, 'counter') }) +} + +export function manaFromTreasure(): Condition { + return condition('mana_from_treasure') +} + +export function manaSpent(atLeast: unknown): Condition { + return condition('mana_spent', { atLeast: asNumber(atLeast, 'mana') }) +} + +export function noManaSpent(): Condition { + return condition('no_mana_spent') +} + +export function manaSymbolSpent(symbols: unknown): Condition { + return condition('mana_symbol_spent', { symbols: asString(symbols, 'mana symbols') }) +} + +export function kickedWith(cost: unknown): Condition { + return condition('kicked_with', { cost: asString(cost, 'kicker cost') }) +} + +export function moreCardsThanEachOpponent(): Condition { + return condition('more_cards_than_each_opponent') +} + +export function firstCombatPhase(): Condition { + return condition('first_combat_phase') +} + +export function notToken(): Condition { + return condition('not_token') +} + +export function castSpellThisTurn(options?: unknown): Condition { + return condition('cast_spell_this_turn', asOptions(options).noncreature === true ? { noncreature: true } : {}) +} + +export function fullParty(): Condition { + return condition('full_party') +} + +export function graveyardCount(selector: unknown, atLeast: unknown): Condition { + return condition('graveyard_count', { selector: asSelector(selector), atLeast: asNumber(atLeast, 'count') }) +} + +export function creaturePowerGreaterThanBase(stat: unknown): Condition { + if (stat !== 'power' && stat !== 'toughness') throw new Error('creaturePowerGreaterThanBase() expects power or toughness') + return condition('creature_power_greater_than_base', { controller: 'you', stat }) +} + +export function ifYouDo(): Condition { + return condition('if_you_do') +} + +export function ifYouDont(): Condition { + return condition('if_you_dont') +} + +export function otherwise(): Condition { + return condition('otherwise') +} + +export function youControlCommander(): Condition { + return condition('you_control_commander') +} + +export function distinctNames(selector: unknown, atLeast: unknown): Condition { + return condition('distinct_names', { selector: asSelector(selector), atLeast: asNumber(atLeast, 'count') }) +} + +export function opponentDamagedThisTurn(atLeast: unknown): Condition { + return condition('opponent_damaged_this_turn', { atLeast: asNumber(atLeast, 'damage') }) +} + +export function attackedWithCreatures(atLeast: unknown): Condition { + return condition('attacked_with_creatures', { atLeast: asNumber(atLeast, 'count') }) +} + +export function libraryAtMost(atMost: unknown): Condition { + return condition('library_at_most', { atMost: asNumber(atMost, 'cards') }) +} diff --git a/backend/src/effects/source-effects.ts b/backend/src/effects/source-effects.ts new file mode 100644 index 0000000..0e47ff0 --- /dev/null +++ b/backend/src/effects/source-effects.ts @@ -0,0 +1,431 @@ +// Safe JavaScript card source. A card implementation is a module-shaped +// expression that calls the builder API below: +// +// export default [ +// triggered(when.enters(permanents.withType('creature')), () => { +// gainLife(you, 1) +// }), +// ] +// +// The source is tokenized, parsed and evaluated against that API only. It is +// never passed to eval or new Function, so a saved override cannot run code. + +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + PlayerRef, + SearchDestination, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from './types.js' + +import { SIMPLE_KEYWORDS } from './compile.js' +import { singularize } from './parse.js' +import { Selector, PLAYER_REFS, DURATIONS, ZONES, SEARCH_DESTINATIONS, COLOR_CODES, CHOICES, RESTRICTION_RULES, REPLACEMENT_WHATS, REPLACEMENT_RESULTS, TRIGGER_PLAYERS, VALUE_KINDS, EFFECT_OPS, STATIC_OPS, COST_KINDS, CONDITION_KINDS, TRIGGER_KINDS, ABILITY_KINDS, expectKind, isRecord, asRecord, asString, asNumber, asBoolean, optionalString, stringArray, asPlayer, asTriggerPlayer, asDuration, asZone, asSearchDestination, asValue, asSelector, isTarget, asTarget, asEffects, asEffect, asStaticEffects, asStaticEffect, asCosts, asCost, asCondition, asTrigger, asAbility, asAbilityArray, asOptions } from './source-validation.js' + +import { self, triggerSubject, previousTarget, anyTarget, targetPlayerOrPlaneswalker, targetOptions, target, each, pick, divided, targetSpell, targetAbility, X, itsPower, itsToughness, count, cardsInHand, maxCardsInHand, maxOpponentCount, totalManaValue, totalPower, anyNumber, eventAmount, mana, anyColor, asToken, CopyOf, copyOf, manaCost, tapCost, untapCost, tapOther, energyCost, loyalty, payLife, discardCost, sacrificeCost, sacrificeSelf, exileSelf, exileFromGraveyard, reveal, choice, returnToHandCost, behold, waterbend, blight, chooseCost, putCounterCost, removeCountersCost, forage, collectEvidence, millCost } from './source-values.js' + +export function damage(targetValue: unknown, amount: unknown, source?: unknown): Effect { + return { + op: 'damage', + target: asTarget(targetValue), + amount: asValue(amount), + ...(source !== undefined ? { source: asTarget(source) } : {}), + } +} + +export function damageDivided(amount: unknown, targetValue: unknown): Effect { + return { op: 'damage_divided', amount: asValue(amount), target: asTarget(targetValue) } +} + +export function draw(player: unknown, amount: unknown): Effect { + return { op: 'draw', player: asPlayer(player), amount: asValue(amount) } +} + +export function discard(player: unknown, amount: unknown, options?: unknown): Effect { + return { + op: 'discard', + player: asPlayer(player), + amount: asValue(amount), + ...(asOptions(options).random === true ? { random: true } : {}), + } +} + +export function mill(player: unknown, amount: unknown): Effect { + return { op: 'mill', player: asPlayer(player), amount: asValue(amount) } +} + +export function gainLife(player: unknown, amount: unknown): Effect { + return { op: 'life', player: asPlayer(player), amount: asValue(amount), mode: 'gain' } +} + +export function loseLife(player: unknown, amount: unknown): Effect { + return { op: 'life', player: asPlayer(player), amount: asValue(amount), mode: 'lose' } +} + +export function pump(targetValue: unknown, power: unknown, toughness: unknown, duration?: unknown): Effect { + return { + op: 'pump', + target: asTarget(targetValue), + power: asValue(power), + toughness: asValue(toughness), + duration: asDuration(duration), + } +} + +export function setPt(targetValue: unknown, power: unknown, toughness: unknown, options?: unknown): Effect { + const data = asOptions(options) + return { + op: 'set_pt', + target: asTarget(targetValue), + power: asValue(power), + toughness: asValue(toughness), + duration: asDuration(data.duration), + } +} + +export function grant(targetValue: unknown, keyword: unknown, options?: unknown): Effect { + const data = asOptions(options) + return { + op: 'grant', + target: asTarget(targetValue), + keyword: asString(keyword, 'keyword'), + ...(data.value !== undefined ? { value: asString(data.value, 'keyword value') } : {}), + duration: asDuration(data.duration), + } +} + +export function putCounters(targetValue: unknown, counter: unknown, amount: unknown): Effect { + return { + op: 'put_counters', + target: asTarget(targetValue), + counter: asString(counter, 'counter'), + amount: asValue(amount), + } +} + +export function doubleCounters(targetValue: unknown, counter?: unknown): Effect { + return { + op: 'double_counters', + target: asTarget(targetValue), + ...(counter !== undefined ? { counter: asString(counter, 'counter') } : {}), + } +} + +export function removeCounters(targetValue: unknown, counter: unknown, amount: unknown): Effect { + return { + op: 'remove_counters', + target: asTarget(targetValue), + counter: asString(counter, 'counter'), + amount: asValue(amount), + } +} + +export function proliferate(): Effect { + return { op: 'proliferate' } +} + +export function createToken(player: unknown, amount: unknown, tokenValue: unknown, options?: unknown): Effect { + const attachTo = options && typeof options === 'object' && 'attachTo' in options + ? asTarget((options as { attachTo: unknown }).attachTo) + : undefined + if (tokenValue instanceof CopyOf) { + return { + op: 'create_token', + player: asPlayer(player), + amount: asValue(amount), + token: { types: [], subtypes: [], colors: [] }, + copyOf: tokenValue.target, + ...(tokenValue.notLegendary ? { notLegendary: true } : {}), + ...(attachTo ? { attachTo } : {}), + } + } + return { + op: 'create_token', + player: asPlayer(player), + amount: asValue(amount), + token: asToken(tokenValue), + ...(attachTo ? { attachTo } : {}), + } +} + +export function destroy(targetValue: unknown): Effect { + return { op: 'destroy', target: asTarget(targetValue) } +} + +export function exile(targetValue: unknown): Effect { + return { op: 'exile', target: asTarget(targetValue) } +} + +export function sacrifice(player: unknown, targetValue: unknown, unless?: unknown): Effect { + return { + op: 'sacrifice', + player: asPlayer(player), + target: asTarget(targetValue), + ...(unless !== undefined ? { unless: asCost(unless) } : {}), + } +} + +export function counter(what: unknown, targetValue: unknown, unless?: unknown): Effect { + if (what !== 'spell' && what !== 'ability') throw new Error('counter() expects "spell" or "ability"') + return { + op: 'counter', + what, + target: asTarget(targetValue), + ...(unless !== undefined ? { unless: asCost(unless) } : {}), + } +} + +export function returnToHand(targetValue: unknown): Effect { + return { op: 'return_to_hand', target: asTarget(targetValue) } +} + +export function returnToBattlefield(targetValue: unknown, options?: unknown): Effect { + const data = asOptions(options) + const counters = data.counters === undefined ? undefined : asRecord(data.counters, 'counters') + return { + op: 'return_to_battlefield', + target: asTarget(targetValue), + tapped: data.tapped === true, + ...(data.transformed === true ? { transformed: true } : {}), + ...(counters + ? { counters: { counter: asString(counters.counter, 'counter'), amount: asValue(counters.amount) } } + : {}), + } +} + +export function putOnTop(targetValue: unknown): Effect { + return { op: 'put_on_top', target: asTarget(targetValue) } +} + +export function tap(targetValue: unknown): Effect { + return { op: 'tap', target: asTarget(targetValue) } +} + +export function untap(targetValue: unknown): Effect { + return { op: 'untap', target: asTarget(targetValue) } +} + +export function scry(player: unknown, amount: unknown): Effect { + return { op: 'scry', player: asPlayer(player), amount: asValue(amount) } +} + +export function surveil(player: unknown, amount: unknown): Effect { + return { op: 'surveil', player: asPlayer(player), amount: asValue(amount) } +} + +export function search(player: unknown, selector: unknown, amount: unknown, options?: unknown): Effect { + const data = asOptions(options) + const split = data.split === undefined ? undefined : asRecord(data.split, 'split') + const zones = data.zones === undefined + ? undefined + : stringArray(data.zones, 'zones').map(zone => { + if (zone !== 'library' && zone !== 'graveyard') throw new Error('zones must be library or graveyard') + return zone + }) + return { + op: 'search', + player: asPlayer(player), + selector: asSelector(selector), + amount: asValue(amount), + destination: asSearchDestination(data.destination ?? 'hand'), + tapped: data.tapped === true, + shuffle: data.shuffle === true, + ...(zones ? { zones } : {}), + ...(split + ? { split: { destination: asSearchDestination(split.destination), tapped: split.tapped === true } } + : {}), + } +} + +export function shuffle(player: unknown): Effect { + return { op: 'shuffle', player: asPlayer(player) } +} + +export function addMana(player: unknown, manaValue: unknown): Effect { + const spec = typeof manaValue === 'string' ? mana(manaValue) : manaValue + if (!isRecord(spec) || (spec.kind !== 'symbols' && spec.kind !== 'any_color')) { + throw new Error('addMana() expects mana(...) or anyColor(...)') + } + return { op: 'add_mana', player: asPlayer(player), mana: spec as unknown as ManaSpec } +} + +export function fight(a: unknown, b: unknown): Effect { + return { op: 'fight', a: asTarget(a), b: asTarget(b) } +} + +export function regenerate(targetValue: unknown): Effect { + return { op: 'regenerate', target: asTarget(targetValue) } +} + +export function energy(player: unknown, amount: unknown): Effect { + return { op: 'energy', player: asPlayer(player), amount: asValue(amount) } +} + +export function attach(targetValue: unknown): Effect { + return { op: 'attach', target: asTarget(targetValue) } +} + +export function restrict(targetValue: unknown, rule: unknown, duration?: unknown): Effect { + const text = asString(rule, 'restriction rule') + if (!RESTRICTION_RULES.has(text)) throw new Error(`unknown restriction rule "${text}"`) + return { + op: 'restriction', + target: asTarget(targetValue), + rule: text as 'cant_attack' | 'cant_block' | 'doesnt_untap', + duration: asDuration(duration), + } +} + +export function keywordAction(action: unknown, options?: unknown): Effect { + const data = asOptions(options) + return { + op: 'keyword_action', + action: asString(action, 'action').replace(/_/g, ' '), + ...(data.target !== undefined ? { target: asTarget(data.target) } : {}), + ...(data.amount !== undefined ? { amount: asValue(data.amount) } : {}), + ...(data.detail !== undefined ? { detail: asString(data.detail, 'detail') } : {}), + } +} + +export function preventDamage(targetValue: unknown, amount: unknown, options?: unknown): Effect { + const data = asOptions(options) + return { + op: 'prevent_damage', + target: asTarget(targetValue), + amount: amount === 'all' ? 'all' : asValue(amount), + ...(data.combatOnly === true ? { combatOnly: true } : {}), + ...(data.global === true ? { global: true } : {}), + ...(data.source !== undefined ? { source: asTarget(data.source) } : {}), + ...(data.sourceSelector !== undefined ? { sourceSelector: asSelector(data.sourceSelector) } : {}), + duration: asDuration(data.duration), + } +} + +export function gainControl(targetValue: unknown, duration?: unknown): Effect { + return { op: 'gain_control', target: asTarget(targetValue), duration: asDuration(duration) } +} + +export function emblem(text: unknown): Effect { + return { op: 'emblem', text: asString(text, 'emblem text') } +} + +export function transform(targetValue: unknown): Effect { + return { op: 'transform', target: asTarget(targetValue) } +} + +export function pay(costs: unknown): Effect { + return { op: 'pay', costs: asCosts(costs) } +} + +export function ifThen(condition: unknown, effects: unknown): Effect { + return { op: 'conditional', condition: asCondition(condition), effects: asEffects(effects) } +} + +export function modal(min: unknown, max: unknown, modes: unknown): Effect { + if (!Array.isArray(modes)) throw new Error('modal() expects an array of modes') + return { + op: 'modal', + min: asNumber(min, 'minimum modes'), + max: asNumber(max, 'maximum modes'), + modes: modes.map(mode => asEffects(mode)), + } +} + +export function lookTop(player: unknown, amount: unknown, options?: unknown): Effect { + return { + op: 'look_top', + player: asPlayer(player), + amount: asValue(amount), + ...(asOptions(options).reorder === true ? { reorder: true } : {}), + } +} + +export function schedule(when: unknown, effects: unknown): Effect { + if (when !== 'next_upkeep' && when !== 'next_end_step') { + throw new Error('schedule() expects "next_upkeep" or "next_end_step"') + } + return { op: 'schedule', when, effects: asEffects(effects) } +} + +export function levelUp(level: unknown): Effect { + return { op: 'level_up', level: asNumber(level, 'level') } +} + +export function putFromAmong(player: unknown, amount: unknown, options?: unknown): Effect { + const data = asOptions(options) + return { + op: 'put_from_among', + player: asPlayer(player), + amount: asValue(amount), + ...(data.selector !== undefined ? { selector: asSelector(data.selector) } : {}), + destination: asSearchDestination(data.destination ?? 'hand'), + } +} + +export function dig(player: unknown, amount: unknown, options?: unknown): Effect { + const data = asOptions(options) + const to = data.to ?? 'hand' + const rest = data.rest ?? 'bottom' + if (to !== 'hand' && to !== 'battlefield') throw new Error('dig() to must be hand or battlefield') + if (rest !== 'bottom' && rest !== 'graveyard' && rest !== 'top') { + throw new Error('dig() rest must be bottom, graveyard or top') + } + return { + op: 'dig', + player: asPlayer(player), + amount: asValue(amount), + pick: asValue(data.pick ?? 1), + ...(data.upTo === true ? { upTo: true } : {}), + ...(data.pickSelector !== undefined ? { pickSelector: asSelector(data.pickSelector) } : {}), + to, + rest, + ...(data.order === 'any' || data.order === 'random' ? { order: data.order } : {}), + ...(data.optional === true ? { optional: true } : {}), + ...(data.tapped === true ? { tapped: true } : {}), + } +} + +export function exileGraveyards(): Effect { + return { op: 'exile_graveyards' } +} + +export function hideaway(amount: unknown): Effect { + return { op: 'hideaway', amount: asValue(amount) } +} + +export function playExiled(player: unknown, options?: unknown): Effect { + return { + op: 'play_exiled', + player: asPlayer(player), + ...(asOptions(options).free === true ? { free: true } : {}), + } +} + +export function exileInsteadOfDying(targetValue: unknown): Effect { + return { op: 'exile_instead_of_dying', target: asTarget(targetValue) } +} + +export function impulse(player: unknown, amount: unknown, options?: unknown): Effect { + return { + op: 'impulse', + player: asPlayer(player), + amount: asValue(amount), + ...(asOptions(options).faceDown === true ? { faceDown: true } : {}), + } +} + +// --------------------------------------------------------------------------- +// Static effects +// --------------------------------------------------------------------------- + diff --git a/backend/src/effects/source-static.ts b/backend/src/effects/source-static.ts new file mode 100644 index 0000000..b1809c3 --- /dev/null +++ b/backend/src/effects/source-static.ts @@ -0,0 +1,218 @@ +// Safe JavaScript card source. A card implementation is a module-shaped +// expression that calls the builder API below: +// +// export default [ +// triggered(when.enters(permanents.withType('creature')), () => { +// gainLife(you, 1) +// }), +// ] +// +// The source is tokenized, parsed and evaluated against that API only. It is +// never passed to eval or new Function, so a saved override cannot run code. + +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + PlayerRef, + SearchDestination, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from './types.js' + +import { SIMPLE_KEYWORDS } from './compile.js' +import { singularize } from './parse.js' +import { Selector, PLAYER_REFS, DURATIONS, ZONES, SEARCH_DESTINATIONS, COLOR_CODES, CHOICES, RESTRICTION_RULES, REPLACEMENT_WHATS, REPLACEMENT_RESULTS, TRIGGER_PLAYERS, VALUE_KINDS, EFFECT_OPS, STATIC_OPS, COST_KINDS, CONDITION_KINDS, TRIGGER_KINDS, ABILITY_KINDS, expectKind, isRecord, asRecord, asString, asNumber, asBoolean, optionalString, stringArray, asPlayer, asTriggerPlayer, asDuration, asZone, asSearchDestination, asValue, asSelector, isTarget, asTarget, asEffects, asEffect, asStaticEffects, asStaticEffect, asCosts, asCost, asCondition, asTrigger, asAbility, asAbilityArray, asOptions } from './source-validation.js' + +import { self, triggerSubject, previousTarget, anyTarget, targetPlayerOrPlaneswalker, targetOptions, target, each, pick, divided, targetSpell, targetAbility, X, itsPower, itsToughness, count, cardsInHand, maxCardsInHand, maxOpponentCount, totalManaValue, totalPower, anyNumber, eventAmount, mana, anyColor, asToken, CopyOf, copyOf, manaCost, tapCost, untapCost, tapOther, energyCost, loyalty, payLife, discardCost, sacrificeCost, sacrificeSelf, exileSelf, exileFromGraveyard, reveal, choice, returnToHandCost, behold, waterbend, blight, chooseCost, putCounterCost, removeCountersCost, forage, collectEvidence, millCost } from './source-values.js' + +export function staticPump(targetValue: unknown, power: unknown, toughness: unknown): StaticEffect { + return { op: 'pump', target: asTarget(targetValue), power: asValue(power), toughness: asValue(toughness) } +} + +export function staticGrant(targetValue: unknown, keyword: unknown, options?: unknown): StaticEffect { + const data = asOptions(options) + return { + op: 'grant', + target: asTarget(targetValue), + keyword: asString(keyword, 'keyword'), + ...(data.value !== undefined ? { value: asString(data.value, 'keyword value') } : {}), + } +} + +export function staticRestrict(targetValue: unknown, rule: unknown, options?: unknown): StaticEffect { + const data = asOptions(options) + const text = asString(rule, 'restriction rule') + return { + op: 'restriction', + target: asTarget(targetValue), + rule: text, + ...(data.value !== undefined ? { value: asValue(data.value) } : {}), + ...(data.comparison === 'or_greater' || data.comparison === 'or_less' ? { comparison: data.comparison } : {}), + ...(data.detail !== undefined ? { detail: asString(data.detail, 'detail') } : {}), + ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), + } +} + +export function staticSetPt(targetValue: unknown, power: unknown, toughness: unknown, options?: unknown): StaticEffect { + const data = asOptions(options) + return { + op: 'set_pt', + target: asTarget(targetValue), + ...(power !== null && power !== undefined ? { power: asValue(power) } : {}), + ...(toughness !== null && toughness !== undefined ? { toughness: asValue(toughness) } : {}), + ...(data.base === true ? { base: true } : {}), + } +} + +export function grantAbility(targetValue: unknown, ability: unknown): StaticEffect { + return { op: 'grant_ability', target: asTarget(targetValue), ability: asAbility(ability) } +} + +export function entersTapped(targetValue: unknown, options?: unknown): StaticEffect { + const data = asOptions(options) + return { + op: 'enters_tapped', + target: asTarget(targetValue), + ...(data.unless !== undefined ? { unless: asCondition(data.unless) } : {}), + ...(data.unlessCost !== undefined ? { unlessCost: asCost(data.unlessCost) } : {}), + } +} + +export function entersWithCounters(targetValue: unknown, counter: unknown, amount: unknown): StaticEffect { + return { + op: 'enters_with_counters', + target: asTarget(targetValue), + counter: asString(counter, 'counter'), + amount: asValue(amount), + } +} + +export function control(targetValue: unknown): StaticEffect { + return { op: 'control', target: asTarget(targetValue) } +} + +export function choose(what: unknown): StaticEffect { + const text = asString(what, 'choice') + if (!CHOICES.has(text)) throw new Error(`unknown choice "${text}"`) + return { op: 'choose', what: text as 'creature_type' | 'color' | 'card_name' | 'player' | 'opponent' | 'number' } +} + +export function replace(what: unknown, options?: unknown): StaticEffect { + const text = asString(what, 'replacement') + if (!REPLACEMENT_WHATS.has(text)) throw new Error(`unknown replacement "${text}"`) + const data = asOptions(options) + const instead = asString(data.instead, 'replacement result') + if (!REPLACEMENT_RESULTS.has(instead)) throw new Error(`unknown replacement result "${instead}"`) + return { + op: 'replacement', + what: text as 'dies' | 'leaves_battlefield' | 'discard' | 'draw', + instead: instead as 'exile' | 'return_to_hand' | 'return_to_library' | 'prevent', + ...(data.target !== undefined ? { target: asTarget(data.target) } : {}), + } +} + +export function replacementAmount(what: unknown, multiplier: unknown, options?: unknown): StaticEffect { + const text = asString(what, 'replacement amount') + if (text !== 'life_gain' && text !== 'damage' && text !== 'draw' && text !== 'energy') { + throw new Error(`unknown replacement amount "${text}"`) + } + const data = asOptions(options) + return { + op: 'replacement_amount', + what: text, + multiplier: asNumber(multiplier, 'replacement multiplier'), + ...(data.add !== undefined ? { add: asNumber(data.add, 'replacement add') } : {}), + ...(data.combatOnly === true ? { combatOnly: true } : {}), + ...(data.noncombatOnly === true ? { noncombatOnly: true } : {}), + ...(data.sourceColor !== undefined ? { sourceColor: asString(data.sourceColor, 'source color') } : {}), + ...(data.controller === 'you' ? { controller: 'you' as const } : {}), + } +} + +export function tokenReplacement(from: unknown, tokens: unknown, options?: unknown): StaticEffect { + const data = asOptions(options) + const names = Array.isArray(from) ? from.map(entry => asString(entry, 'token name')) : [] + const specs = Array.isArray(tokens) ? tokens.map(asToken) : [] + return { + op: 'token_replacement', + from: names, + tokens: specs, + ...(data.who === 'each_player' ? { who: 'each_player' as const } : {}), + } +} + +export function counterMultiplier(targetValue: unknown, multiplier: unknown, options?: unknown): StaticEffect { + const data = asOptions(options) + return { + op: 'counter_multiplier', + target: asTarget(targetValue), + multiplier: asNumber(multiplier, 'counter multiplier'), + ...(data.counter !== undefined ? { counter: asString(data.counter, 'counter') } : {}), + ...(data.add !== undefined ? { add: asNumber(data.add, 'counter add') } : {}), + } +} + +export function tokenMultiplier(multiplier: unknown, options?: unknown): StaticEffect { + const data = asOptions(options) + if (data.who !== undefined && data.who !== 'you' && data.who !== 'each_player') { + throw new Error("tokenMultiplier() who must be 'you' or 'each_player'") + } + return { + op: 'token_multiplier', + multiplier: asNumber(multiplier, 'token multiplier'), + who: data.who === 'each_player' ? 'each_player' : 'you', + ...(data.creatureOnly === true ? { creatureOnly: true } : {}), + } +} + +export function costReduction(targetValue: unknown, amount: unknown, options?: unknown): StaticEffect { + const data = asOptions(options) + return { + op: 'cost_reduction', + target: asTarget(targetValue), + ...(typeof amount === 'string' && /^(?:\{[^}]+\})+$/.test(amount) + ? { symbols: amount } + : { amount: asValue(amount) }), + ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), + } +} + +export function costIncrease(amount: unknown, options?: unknown): StaticEffect { + const data = asOptions(options) + const spellType = data.spellType + if (spellType !== undefined && spellType !== 'noncreature' && spellType !== 'creature') { + throw new Error('spellType must be noncreature or creature') + } + return { + op: 'cost_increase', + amount: asValue(amount), + ...(spellType ? { spellType } : {}), + } +} + +export function searchRestriction(who: unknown, amount: unknown): StaticEffect { + if (who !== 'opponent' && who !== 'you') throw new Error('searchRestriction() expects you or opponent') + return { op: 'search_restriction', who, amount: asValue(amount) } +} + +export function exileInsteadOfGraveyard(owner?: unknown): StaticEffect { + if (owner !== undefined && owner !== 'opponent' && owner !== 'you') { + throw new Error('exileInsteadOfGraveyard() expects you or opponent') + } + return { op: 'exile_instead_of_graveyard', ...(owner ? { owner } : {}) } +} + +// --------------------------------------------------------------------------- +// Triggers +// --------------------------------------------------------------------------- + diff --git a/backend/src/effects/source-validation.ts b/backend/src/effects/source-validation.ts new file mode 100644 index 0000000..85179e9 --- /dev/null +++ b/backend/src/effects/source-validation.ts @@ -0,0 +1,470 @@ +// Safe JavaScript card source. A card implementation is a module-shaped +// expression that calls the builder API below: +// +// export default [ +// triggered(when.enters(permanents.withType('creature')), () => { +// gainLife(you, 1) +// }), +// ] +// +// The source is tokenized, parsed and evaluated against that API only. It is +// never passed to eval or new Function, so a saved override cannot run code. + +import { singularize } from './parse.js' +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + PlayerRef, + SearchDestination, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from './types.js' + + +export const PLAYER_REFS = new Set([ + 'you', + 'opponent', + 'each_opponent', + 'each_player', + 'target_player', + 'that_player', + 'its_controller', + 'its_owner', +]) + +export const DURATIONS = new Set([ + 'permanent', + 'until_end_of_turn', + 'until_your_next_turn', + 'until_end_of_your_next_turn', + 'until_end_of_combat', + 'until_controllers_next_untap_step', + 'while_source_on_battlefield', +]) + +export const ZONES = new Set(['battlefield', 'hand', 'graveyard', 'library', 'exile', 'stack', 'command']) +export const SEARCH_DESTINATIONS = new Set(['hand', 'battlefield', 'graveyard', 'top', 'bottom']) + +export const COLOR_CODES: Record = { + white: 'W', + blue: 'U', + black: 'B', + red: 'R', + green: 'G', + colorless: 'C', +} + +export const CHOICES = new Set(['creature_type', 'color', 'card_name', 'player', 'opponent', 'number']) +export const RESTRICTION_RULES = new Set(['cant_attack', 'cant_block', 'doesnt_untap']) +export const REPLACEMENT_WHATS = new Set(['dies', 'leaves_battlefield', 'discard', 'draw']) +export const REPLACEMENT_RESULTS = new Set(['exile', 'return_to_hand', 'return_to_library', 'prevent']) +export const TRIGGER_PLAYERS = new Set(['you', 'opponent', 'each_player']) + +export const VALUE_KINDS = new Set([ + 'number', 'x', 'count', 'source_power', 'source_toughness', 'cards_in_hand', + 'max_cards_in_hand', 'max_opponent_count', 'total_mana_value', 'total_power', + 'any_number', 'event_amount', +]) + +export const EFFECT_OPS = new Set([ + 'damage', 'draw', 'discard', 'mill', 'life', 'pump', 'set_pt', 'grant', + 'put_counters', 'remove_counters', 'double_counters', 'proliferate', 'create_token', 'destroy', + 'exile', 'sacrifice', 'counter', 'return_to_hand', 'return_to_battlefield', + 'put_on_top', 'tap', 'untap', 'scry', 'surveil', 'search', 'shuffle', + 'add_mana', 'fight', 'regenerate', 'energy', 'attach', 'restriction', + 'keyword_action', 'prevent_damage', 'gain_control', 'emblem', 'transform', + 'pay', 'conditional', 'modal', 'look_top', 'schedule', 'level_up', + 'put_from_among', 'dig', 'damage_divided', 'exile_graveyards', 'hideaway', + 'play_exiled', 'impulse', 'exile_instead_of_dying', +]) + +export const STATIC_OPS = new Set([ + 'pump', 'grant', 'grant_ability', 'restriction', 'enters_tapped', + 'enters_with_counters', 'set_pt', 'control', 'choose', 'replacement', + 'cost_reduction', 'cost_increase', 'search_restriction', + 'exile_instead_of_graveyard', 'token_multiplier', 'replacement_amount', 'prevent_damage', 'counter_multiplier', 'token_replacement', +]) + +export const COST_KINDS = new Set([ + 'mana', 'tap', 'untap', 'tap_other', 'energy', 'loyalty', 'pay_life', + 'discard', 'sacrifice', 'sacrifice_self', 'exile_self', 'exile_from_graveyard', + 'reveal', 'choice', 'return_to_hand', 'behold', 'waterbend', 'blight', + 'choose', 'put_counter', 'remove_counters', 'forage', 'collect_evidence', 'mill', +]) + +export const CONDITION_KINDS = new Set([ + 'you_control', 'opponent_controls', 'your_turn', 'not_your_turn', + 'source_tapped', 'source_untapped', 'source_attacking', 'life_at_least', + 'life_at_most', 'life_above_starting', 'cards_in_graveyard', 'hand_empty', + 'creature_died_this_turn', 'you_gained_life_this_turn', 'you_drew_cards_this_turn', + 'spells_cast_last_turn', 'no_spells_last_turn', 'attacked_this_turn', + 'you_attacked_this_turn', 'defending_player_controls', 'targets', 'was_kicked', + 'cast', 'in_graveyard', 'on_battlefield', 'monarch', 'initiative', + 'citys_blessing', 'suspended', 'bargained', 'was_creature', + 'opponent_lost_life_this_turn', 'life_changed_this_turn', 'descended_this_turn', + 'permanent_left_battlefield_this_turn', 'nonland_permanents_entered_this_turn', + 'attacked_with_total_power', 'total_power', 'opponent_controls_more_lands', + 'distinct_powers', 'graveyard_card_types', 'no_objects', 'cards_in_hand_at_most', + 'not_their_turn', 'no_attackers', 'opponent_poison', 'tribute_not_paid', + 'had_counters', 'mana_from_treasure', 'mana_spent', 'no_mana_spent', + 'mana_symbol_spent', 'kicked_with', 'more_cards_than_each_opponent', + 'first_combat_phase', 'not_token', 'cast_spell_this_turn', 'full_party', + 'graveyard_count', 'creature_power_greater_than_base', 'if_you_do', + 'if_you_dont', 'otherwise', 'you_control_commander', 'distinct_names', + 'opponent_damaged_this_turn', 'attacked_with_creatures', 'library_at_most', +]) + +export const TRIGGER_KINDS = new Set([ + 'enters', 'dies', 'attacks', 'blocks', 'attacks_or_blocks', 'enters_or_attacks', + 'enters_or_dies', 'leaves_battlefield', 'deals_damage', 'upkeep', 'end_step', + 'begin_combat', 'main_phase', 'cast', 'becomes_level', 'draw', 'counter_placed', + 'becomes_target', 'life', +]) + +export const ABILITY_KINDS = new Set([ + 'keyword', 'keywords', 'triggered', 'activated', 'static', 'spell', + 'additional_cost', 'alternative_cost', 'overload', 'chapter', 'level_band', + 'level_pt', 'unsupported', +]) + +export function expectKind(value: unknown, allowed: Set, label: string, key = 'kind'): Record { + if (!isRecord(value) || typeof value[key] !== 'string' || !allowed.has(value[key] as string)) { + throw new Error(`expected ${label}`) + } + return value +} + + +export function isRecord(value: unknown): value is Record { + return value !== null && typeof value === 'object' && !Array.isArray(value) +} + +export function asRecord(value: unknown, label: string): Record { + if (!isRecord(value)) throw new Error(`${label} must be an object`) + return value +} + +export function asString(value: unknown, label: string): string { + if (typeof value !== 'string') throw new Error(`${label} must be a string`) + return value +} + +export function asNumber(value: unknown, label: string): number { + if (typeof value !== 'number' || !Number.isFinite(value)) throw new Error(`${label} must be a number`) + return value +} + +export function asBoolean(value: unknown, label: string): boolean { + if (typeof value !== 'boolean') throw new Error(`${label} must be true or false`) + return value +} + +export function optionalString(value: unknown, label: string): string | undefined { + if (value === undefined || value === null) return undefined + return asString(value, label) +} + +export function stringArray(value: unknown, label: string): string[] { + if (value === undefined || value === null) return [] + if (!Array.isArray(value)) throw new Error(`${label} must be an array`) + return value.map(entry => asString(entry, label)) +} + +export function asPlayer(value: unknown): PlayerRef { + if (typeof value === 'string' && PLAYER_REFS.has(value as PlayerRef)) return value as PlayerRef + throw new Error(`expected a player, got ${String(value)}`) +} + +export function asTriggerPlayer(value: unknown): 'you' | 'opponent' | 'each_player' { + if (typeof value === 'string' && TRIGGER_PLAYERS.has(value)) return value as 'you' | 'opponent' | 'each_player' + throw new Error(`expected you, opponent or eachPlayer, got ${String(value)}`) +} + +export function asDuration(value: unknown, fallback: Duration = 'permanent'): Duration { + if (value === undefined || value === null) return fallback + if (typeof value === 'string' && DURATIONS.has(value as Duration)) return value as Duration + throw new Error(`unknown duration "${String(value)}"`) +} + +export function asZone(value: unknown): Zone { + if (typeof value === 'string' && ZONES.has(value as Zone)) return value as Zone + throw new Error(`unknown zone "${String(value)}"`) +} + +export function asSearchDestination(value: unknown): SearchDestination { + if (typeof value === 'string' && SEARCH_DESTINATIONS.has(value as SearchDestination)) { + return value as SearchDestination + } + throw new Error(`unknown destination "${String(value)}"`) +} + +export function asValue(value: unknown): Value { + if (typeof value === 'number') return { kind: 'number', value } + if (isRecord(value) && typeof value.kind === 'string' && VALUE_KINDS.has(value.kind)) { + return value as unknown as Value + } + throw new Error('expected a value (number or value helper)') +} + +export function asSelector(value: unknown): ObjectSelector { + if (value instanceof Selector) return { ...value.fields } + if (isRecord(value)) return { ...value } as ObjectSelector + throw new Error('expected a selector') +} + +export function isTarget(value: unknown): value is Target { + return isRecord(value) && typeof value.kind === 'string' && [ + 'self', 'trigger_subject', 'previous_target', 'object', 'player', + 'player_or_planeswalker', 'any', 'spell', 'ability', 'divided', + ].includes(value.kind) +} + +export function asTarget(value: unknown): Target { + if (isTarget(value)) return value + throw new Error('expected a target') +} + +export function asEffects(value: unknown): Effect[] { + const resolved = typeof value === 'function' ? value() : value + if (!Array.isArray(resolved)) return [asEffect(resolved)] + return resolved.map(asEffect) +} + +export function asEffect(value: unknown): Effect { + return expectKind(value, EFFECT_OPS, 'an effect', 'op') as unknown as Effect +} + +export function asStaticEffects(value: unknown): StaticEffect[] { + const resolved = typeof value === 'function' ? value() : value + if (!Array.isArray(resolved)) return [asStaticEffect(resolved)] + return resolved.map(asStaticEffect) +} + +export function asStaticEffect(value: unknown): StaticEffect { + return expectKind(value, STATIC_OPS, 'a static effect', 'op') as unknown as StaticEffect +} + +export function asCosts(value: unknown): Cost[] { + if (!Array.isArray(value)) throw new Error('expected an array of costs') + return value.map(asCost) +} + +export function asCost(value: unknown): Cost { + return expectKind(value, COST_KINDS, 'a cost') as unknown as Cost +} + +export function asCondition(value: unknown): Condition { + return expectKind(value, CONDITION_KINDS, 'a condition') as unknown as Condition +} + +export function asTrigger(value: unknown): TriggerEvent { + return expectKind(value, TRIGGER_KINDS, 'a trigger event') as unknown as TriggerEvent +} + +export function asAbility(value: unknown): Ability { + return expectKind(value, ABILITY_KINDS, 'an ability') as unknown as Ability +} + +export function asAbilityArray(value: unknown): Ability[] { + if (!Array.isArray(value)) throw new Error('the implementation must be an array of abilities') + return value.map(asAbility) +} + +export function asOptions(value: unknown): Record { + if (value === undefined || value === null) return Object.create(null) as Record + return asRecord(value, 'options') +} + +// --------------------------------------------------------------------------- +// Selectors +// --------------------------------------------------------------------------- + +export class Selector { + readonly fields: ObjectSelector + + constructor(fields: ObjectSelector = {}) { + this.fields = fields + } + + private with(patch: Partial): Selector { + return new Selector({ ...this.fields, ...patch }) + } + + withType(...types: unknown[]): Selector { + return this.with({ + types: [...(this.fields.types ?? []), ...types.map(type => singularize(asString(type, 'type').toLowerCase()))], + }) + } + + withSupertype(...supertypes: unknown[]): Selector { + return this.with({ + supertypes: [ + ...(this.fields.supertypes ?? []), + ...supertypes.map(type => singularize(asString(type, 'supertype').toLowerCase())), + ], + }) + } + + withSubtype(...subtypes: unknown[]): Selector { + return this.with({ + subtypes: [ + ...(this.fields.subtypes ?? []), + ...subtypes.map(type => singularize(asString(type, 'subtype').toLowerCase())), + ], + }) + } + + withColor(...colors: unknown[]): Selector { + return this.with({ + colors: [ + ...(this.fields.colors ?? []), + ...colors.map(color => { + const text = asString(color, 'color').toLowerCase() + return COLOR_CODES[text] ?? text.toUpperCase() + }), + ], + }) + } + + withoutColor(...colors: unknown[]): Selector { + return this.with({ + excludeColors: [ + ...(this.fields.excludeColors ?? []), + ...colors.map(color => { + const text = asString(color, 'color').toLowerCase() + return COLOR_CODES[text] ?? text.toUpperCase() + }), + ], + }) + } + + matchingAny(): Selector { + return this.with({ match: 'any' }) + } + + withoutType(...types: unknown[]): Selector { + return this.with({ + excludeTypes: [ + ...(this.fields.excludeTypes ?? []), + ...types.map(type => singularize(asString(type, 'type').toLowerCase())), + ], + }) + } + + controlledBy(who: unknown): Selector { + if (who !== 'you' && who !== 'opponent' && who !== 'any') { + throw new Error('controlledBy() expects "you", "opponent" or "any"') + } + return this.with({ controller: who }) + } + + youControl(): Selector { + return this.with({ controller: 'you' }) + } + + opponentControls(): Selector { + return this.with({ controller: 'opponent' }) + } + + ownedBy(who: unknown): Selector { + if (who !== 'you' && who !== 'opponent') throw new Error('ownedBy() expects "you" or "opponent"') + return this.with({ owner: who }) + } + + other(): Selector { + return this.with({ other: true }) + } + + tapped(): Selector { + return this.with({ tapped: true }) + } + + untapped(): Selector { + return this.with({ tapped: false }) + } + + attacking(): Selector { + return this.with({ attacking: true }) + } + + token(): Selector { + return this.with({ token: true }) + } + + nontoken(): Selector { + return this.with({ token: false }) + } + + equipped(): Selector { + return this.with({ attached: 'equipped' }) + } + + enchanted(): Selector { + return this.with({ attached: 'enchanted' }) + } + + inZone(zone: unknown): Selector { + return this.with({ zone: asZone(zone) }) + } + + named(name: unknown): Selector { + return this.with({ name: asString(name, 'name') }) + } + + withCounter(counter: unknown, atLeast: unknown = 1): Selector { + return this.with({ counters: { counter: asString(counter, 'counter'), atLeast: asNumber(atLeast, 'counter count') } }) + } + + withKeyword(...keywords: unknown[]): Selector { + return this.with({ + keywords: [...(this.fields.keywords ?? []), ...keywords.map(keyword => asString(keyword, 'keyword'))], + }) + } + + withoutKeyword(...keywords: unknown[]): Selector { + return this.with({ + excludeKeywords: [ + ...(this.fields.excludeKeywords ?? []), + ...keywords.map(keyword => asString(keyword, 'keyword')), + ], + }) + } + + powerAtLeast(amount: unknown): Selector { + return this.with({ power: { ...(this.fields.power ?? {}), atLeast: asNumber(amount, 'power') } }) + } + + powerAtMost(amount: unknown): Selector { + return this.with({ power: { ...(this.fields.power ?? {}), atMost: asNumber(amount, 'power') } }) + } + + toughnessAtLeast(amount: unknown): Selector { + return this.with({ toughness: { ...(this.fields.toughness ?? {}), atLeast: asNumber(amount, 'toughness') } }) + } + + toughnessAtMost(amount: unknown): Selector { + return this.with({ toughness: { ...(this.fields.toughness ?? {}), atMost: asNumber(amount, 'toughness') } }) + } + + manaValueAtLeast(amount: unknown): Selector { + return this.with({ manaValue: { ...(this.fields.manaValue ?? {}), atLeast: asNumber(amount, 'mana value') } }) + } + + manaValueAtMost(amount: unknown): Selector { + return this.with({ manaValue: { ...(this.fields.manaValue ?? {}), atMost: asNumber(amount, 'mana value') } }) + } +} + +// --------------------------------------------------------------------------- +// Targets and values +// --------------------------------------------------------------------------- diff --git a/backend/src/effects/source-values.ts b/backend/src/effects/source-values.ts new file mode 100644 index 0000000..029705a --- /dev/null +++ b/backend/src/effects/source-values.ts @@ -0,0 +1,306 @@ +// Safe JavaScript card source. A card implementation is a module-shaped +// expression that calls the builder API below: +// +// export default [ +// triggered(when.enters(permanents.withType('creature')), () => { +// gainLife(you, 1) +// }), +// ] +// +// The source is tokenized, parsed and evaluated against that API only. It is +// never passed to eval or new Function, so a saved override cannot run code. + +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + KeywordAbility, + ManaSpec, + ObjectSelector, + PlayerRef, + SearchDestination, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from './types.js' + +import { SIMPLE_KEYWORDS } from './compile.js' +import { singularize } from './parse.js' +import { Selector, PLAYER_REFS, DURATIONS, ZONES, SEARCH_DESTINATIONS, COLOR_CODES, CHOICES, RESTRICTION_RULES, REPLACEMENT_WHATS, REPLACEMENT_RESULTS, TRIGGER_PLAYERS, VALUE_KINDS, EFFECT_OPS, STATIC_OPS, COST_KINDS, CONDITION_KINDS, TRIGGER_KINDS, ABILITY_KINDS, expectKind, isRecord, asRecord, asString, asNumber, asBoolean, optionalString, stringArray, asPlayer, asTriggerPlayer, asDuration, asZone, asSearchDestination, asValue, asSelector, isTarget, asTarget, asEffects, asEffect, asStaticEffects, asStaticEffect, asCosts, asCost, asCondition, asTrigger, asAbility, asAbilityArray, asOptions } from './source-validation.js' + + +export const self: Target = { kind: 'self' } +export const triggerSubject: Target = { kind: 'trigger_subject' } +export const previousTarget: Target = { kind: 'previous_target' } +export const anyTarget: Target = { kind: 'any' } +export const targetPlayerOrPlaneswalker: Target = { kind: 'player_or_planeswalker', mode: 'target' } + +export function targetOptions(value: unknown): Pick, 'count' | 'upTo' | 'includeSelf'> { + const options = asOptions(value) + return { + ...(options.count !== undefined ? { count: asNumber(options.count, 'count') } : {}), + ...(options.upTo !== undefined ? { upTo: asBoolean(options.upTo, 'upTo') } : {}), + ...(options.includeSelf !== undefined ? { includeSelf: asBoolean(options.includeSelf, 'includeSelf') } : {}), + } +} + +export function target(value: unknown, options?: unknown): Target { + if (typeof value === 'string' && PLAYER_REFS.has(value as PlayerRef)) { + return { kind: 'player', who: value as PlayerRef, mode: 'target' } + } + if (isTarget(value)) return value + return { kind: 'object', selector: asSelector(value), mode: 'target', ...targetOptions(options) } +} + +export function each(value: unknown, options?: unknown): Target { + if (typeof value === 'string' && PLAYER_REFS.has(value as PlayerRef)) { + return { kind: 'player', who: value as PlayerRef, mode: 'each' } + } + if (isTarget(value)) return value + return { kind: 'object', selector: asSelector(value), mode: 'each', ...targetOptions(options) } +} + +export function pick(value: unknown, options?: unknown): Target { + return { kind: 'object', selector: asSelector(value), mode: 'choose', ...targetOptions(options) } +} + +export function divided(max: unknown, selector?: unknown): Target { + if (max !== 'any' && typeof max !== 'number') throw new Error('divided() expects a number or "any"') + return { + kind: 'divided', + max: max === 'any' ? 'any' : asNumber(max, 'divided count'), + ...(selector !== undefined ? { selector: asSelector(selector) } : {}), + } +} + +export function targetSpell(selector?: unknown): Target { + return { kind: 'spell', selector: selector === undefined ? { types: [] } : asSelector(selector), mode: 'target' } +} + +export function targetAbility(selector?: unknown): Target { + return { kind: 'ability', mode: 'target', ...(selector !== undefined ? { selector: asSelector(selector) } : {}) } +} + +export const X: Value = { kind: 'x' } +export const itsPower: Value = { kind: 'source_power' } +export const itsToughness: Value = { kind: 'source_toughness' } + +export function count(selector: unknown): Value { + return { kind: 'count', selector: asSelector(selector) } +} + +export function cardsInHand(player: unknown): Value { + return { kind: 'cards_in_hand', player: asPlayer(player) } +} + +export function maxCardsInHand(): Value { + return { kind: 'max_cards_in_hand' } +} + +export function maxOpponentCount(selector: unknown): Value { + return { kind: 'max_opponent_count', selector: asSelector(selector) } +} + +export function totalManaValue(selector: unknown): Value { + return { kind: 'total_mana_value', selector: asSelector(selector) } +} + +export function totalPower(selector: unknown): Value { + return { kind: 'total_power', selector: asSelector(selector) } +} + +export function anyNumber(): Value { + return { kind: 'any_number' } +} + +export function eventAmount(): Value { + return { kind: 'event_amount' } +} + +// --------------------------------------------------------------------------- +// Mana, tokens and costs +// --------------------------------------------------------------------------- + +export function mana(symbols: unknown, options?: unknown): ManaSpec { + const text = asString(symbols, 'mana symbols') + const found = text.match(/\{[^}]+\}/g) + if (!found?.length) throw new Error('mana() expects symbols like "{2}{G}"') + const data = asOptions(options) + const restriction = optionalString(data.restriction, 'restriction') + return { + kind: 'symbols', + symbols: found, + ...(data.oneOf === true ? { oneOf: true } : {}), + ...(restriction ? { restriction } : {}), + } +} + +export function anyColor(amount: unknown, options?: unknown): ManaSpec { + const data = asOptions(options) + return { + kind: 'any_color', + amount: asValue(amount), + oneColor: data.oneColor === undefined ? false : asBoolean(data.oneColor, 'oneColor'), + ...(data.restriction !== undefined ? { restriction: asString(data.restriction, 'restriction') } : {}), + } +} + +export function asToken(value: unknown): TokenSpec { + const data = asRecord(value, 'token') + const types = stringArray(data.types, 'token types').map(type => singularize(type.toLowerCase())) + const subtypes = stringArray(data.subtypes, 'token subtypes').map(type => singularize(type.toLowerCase())) + const colors = stringArray(data.colors, 'token colors').map(color => COLOR_CODES[color.toLowerCase()] ?? color.toUpperCase()) + return { + ...(data.name !== undefined ? { name: asString(data.name, 'token name') } : {}), + types: types.length ? types : (data.power !== undefined ? ['creature'] : ['artifact']), + subtypes, + colors, + ...(data.power !== undefined ? { power: asValue(data.power) } : {}), + ...(data.toughness !== undefined ? { toughness: asValue(data.toughness) } : {}), + ...(data.keywords !== undefined ? { keywords: stringArray(data.keywords, 'token keywords') } : {}), + ...(data.tapped === undefined ? {} : { tapped: asBoolean(data.tapped, 'tapped') }), + } +} + +export class CopyOf { + readonly target: Target + readonly notLegendary: boolean + + constructor(targetValue: unknown, notLegendary: boolean) { + this.target = asTarget(targetValue) + this.notLegendary = notLegendary + } +} + +export function copyOf(targetValue: unknown, options?: unknown): CopyOf { + return new CopyOf(targetValue, asOptions(options).notLegendary === true) +} + +export function manaCost(symbols: unknown): Cost { + const spec = mana(symbols) + return { kind: 'mana', symbols: spec.kind === 'symbols' ? spec.symbols.join('') : '' } +} + +export function tapCost(): Cost { + return { kind: 'tap' } +} + +export function untapCost(): Cost { + return { kind: 'untap' } +} + +export function tapOther(selector: unknown): Cost { + return { kind: 'tap_other', selector: asSelector(selector) } +} + +export function energyCost(amount: unknown): Cost { + return { kind: 'energy', amount: asNumber(amount, 'energy') } +} + +export function loyalty(amount: unknown): Cost { + return { kind: 'loyalty', amount: asNumber(amount, 'loyalty') } +} + +export function payLife(amount: unknown): Cost { + return { kind: 'pay_life', amount: asValue(amount) } +} + +export function discardCost(amount: unknown, options?: unknown): Cost { + const data = asOptions(options) + return { + kind: 'discard', + amount: asValue(amount), + player: data.player === undefined ? 'you' : asPlayer(data.player), + ...(data.random === true ? { random: true } : {}), + } +} + +export function sacrificeCost(selector: unknown): Cost { + return { kind: 'sacrifice', selector: asSelector(selector) } +} + +export function sacrificeSelf(): Cost { + return { kind: 'sacrifice_self' } +} + +export function exileSelf(): Cost { + return { kind: 'exile_self' } +} + +export function exileFromGraveyard(selector: unknown, amount?: unknown): Cost { + return { + kind: 'exile_from_graveyard', + selector: asSelector(selector), + ...(amount !== undefined ? { amount: asValue(amount) } : {}), + } +} + +export function reveal(selector: unknown): Cost { + return { kind: 'reveal', selector: asSelector(selector) } +} + +export function choice(options: unknown): Cost { + if (!Array.isArray(options)) throw new Error('choice() expects an array of cost arrays') + return { + kind: 'choice', + options: options.map(option => { + if (!Array.isArray(option)) throw new Error('choice() expects an array of cost arrays') + return option.map(asCost) + }), + } +} + +export function returnToHandCost(selector: unknown): Cost { + return { kind: 'return_to_hand', selector: asSelector(selector) } +} + +export function behold(selector: unknown): Cost { + return { kind: 'behold', selector: asSelector(selector) } +} + +export function waterbend(amount: unknown): Cost { + return { kind: 'waterbend', amount: asValue(amount) } +} + +export function blight(amount: unknown): Cost { + return { kind: 'blight', amount: asValue(amount) } +} + +export function chooseCost(what: unknown): Cost { + return { kind: 'choose', what: asString(what, 'choice') } +} + +export function putCounterCost(counter: unknown, selector: unknown): Cost { + return { kind: 'put_counter', counter: asString(counter, 'counter'), selector: asSelector(selector) } +} + +export function removeCountersCost(counter: unknown, amount: unknown, selector?: unknown): Cost { + return { + kind: 'remove_counters', + counter: asString(counter, 'counter'), + amount: asValue(amount), + ...(selector !== undefined ? { selector: asSelector(selector) } : {}), + } +} + +export function forage(): Cost { + return { kind: 'forage' } +} + +export function collectEvidence(amount: unknown): Cost { + return { kind: 'collect_evidence', amount: asNumber(amount, 'evidence') } +} + +export function millCost(amount: unknown): Cost { + return { kind: 'mill', amount: asValue(amount) } +} + +// --------------------------------------------------------------------------- +// Effects +// --------------------------------------------------------------------------- + diff --git a/backend/src/effects/source.ts b/backend/src/effects/source.ts index bf7dea9..b8d5397 100644 --- a/backend/src/effects/source.ts +++ b/backend/src/effects/source.ts @@ -10,8 +10,6 @@ // The source is tokenized, parsed and evaluated against that API only. It is // never passed to eval or new Function, so a saved override cannot run code. -import { SIMPLE_KEYWORDS } from './compile.js' -import { singularize } from './parse.js' import type { Ability, Condition, @@ -461,2027 +459,9 @@ class Interpreter { // Values and validation helpers // --------------------------------------------------------------------------- -const PLAYER_REFS = new Set([ - 'you', - 'opponent', - 'each_opponent', - 'each_player', - 'target_player', - 'that_player', - 'its_controller', - 'its_owner', -]) - -const DURATIONS = new Set([ - 'permanent', - 'until_end_of_turn', - 'until_your_next_turn', - 'until_end_of_your_next_turn', - 'until_end_of_combat', - 'until_controllers_next_untap_step', - 'while_source_on_battlefield', -]) - -const ZONES = new Set(['battlefield', 'hand', 'graveyard', 'library', 'exile', 'stack', 'command']) -const SEARCH_DESTINATIONS = new Set(['hand', 'battlefield', 'graveyard', 'top', 'bottom']) - -const COLOR_CODES: Record = { - white: 'W', - blue: 'U', - black: 'B', - red: 'R', - green: 'G', - colorless: 'C', -} - -const CHOICES = new Set(['creature_type', 'color', 'card_name', 'player', 'opponent', 'number']) -const RESTRICTION_RULES = new Set(['cant_attack', 'cant_block', 'doesnt_untap']) -const REPLACEMENT_WHATS = new Set(['dies', 'leaves_battlefield', 'discard', 'draw']) -const REPLACEMENT_RESULTS = new Set(['exile', 'return_to_hand', 'return_to_library', 'prevent']) -const TRIGGER_PLAYERS = new Set(['you', 'opponent', 'each_player']) - -const VALUE_KINDS = new Set([ - 'number', 'x', 'count', 'source_power', 'source_toughness', 'cards_in_hand', - 'max_cards_in_hand', 'max_opponent_count', 'total_mana_value', 'total_power', - 'any_number', 'event_amount', -]) - -const EFFECT_OPS = new Set([ - 'damage', 'draw', 'discard', 'mill', 'life', 'pump', 'set_pt', 'grant', - 'put_counters', 'remove_counters', 'proliferate', 'create_token', 'destroy', - 'exile', 'sacrifice', 'counter', 'return_to_hand', 'return_to_battlefield', - 'put_on_top', 'tap', 'untap', 'scry', 'surveil', 'search', 'shuffle', - 'add_mana', 'fight', 'regenerate', 'energy', 'attach', 'restriction', - 'keyword_action', 'prevent_damage', 'gain_control', 'emblem', 'transform', - 'pay', 'conditional', 'modal', 'look_top', 'schedule', 'level_up', - 'put_from_among', 'dig', 'damage_divided', 'exile_graveyards', 'hideaway', - 'play_exiled', -]) - -const STATIC_OPS = new Set([ - 'pump', 'grant', 'grant_ability', 'restriction', 'enters_tapped', - 'enters_with_counters', 'set_pt', 'control', 'choose', 'replacement', - 'cost_reduction', 'cost_increase', 'search_restriction', - 'exile_instead_of_graveyard', 'token_multiplier', -]) - -const COST_KINDS = new Set([ - 'mana', 'tap', 'untap', 'tap_other', 'energy', 'loyalty', 'pay_life', - 'discard', 'sacrifice', 'sacrifice_self', 'exile_self', 'exile_from_graveyard', - 'reveal', 'choice', 'return_to_hand', 'behold', 'waterbend', 'blight', - 'choose', 'put_counter', 'remove_counters', 'forage', 'collect_evidence', 'mill', -]) - -const CONDITION_KINDS = new Set([ - 'you_control', 'opponent_controls', 'your_turn', 'not_your_turn', - 'source_tapped', 'source_untapped', 'source_attacking', 'life_at_least', - 'life_at_most', 'life_above_starting', 'cards_in_graveyard', 'hand_empty', - 'creature_died_this_turn', 'you_gained_life_this_turn', 'you_drew_cards_this_turn', - 'spells_cast_last_turn', 'no_spells_last_turn', 'attacked_this_turn', - 'you_attacked_this_turn', 'defending_player_controls', 'targets', 'was_kicked', - 'cast', 'in_graveyard', 'on_battlefield', 'monarch', 'initiative', - 'citys_blessing', 'suspended', 'bargained', 'was_creature', - 'opponent_lost_life_this_turn', 'life_changed_this_turn', 'descended_this_turn', - 'permanent_left_battlefield_this_turn', 'nonland_permanents_entered_this_turn', - 'attacked_with_total_power', 'total_power', 'opponent_controls_more_lands', - 'distinct_powers', 'graveyard_card_types', 'no_objects', 'cards_in_hand_at_most', - 'not_their_turn', 'no_attackers', 'opponent_poison', 'tribute_not_paid', - 'had_counters', 'mana_from_treasure', 'mana_spent', 'no_mana_spent', - 'mana_symbol_spent', 'kicked_with', 'more_cards_than_each_opponent', - 'first_combat_phase', 'not_token', 'cast_spell_this_turn', 'full_party', - 'graveyard_count', 'creature_power_greater_than_base', 'if_you_do', - 'if_you_dont', 'otherwise', 'you_control_commander', 'distinct_names', - 'opponent_damaged_this_turn', 'attacked_with_creatures', 'library_at_most', -]) - -const TRIGGER_KINDS = new Set([ - 'enters', 'dies', 'attacks', 'blocks', 'attacks_or_blocks', 'enters_or_attacks', - 'enters_or_dies', 'leaves_battlefield', 'deals_damage', 'upkeep', 'end_step', - 'begin_combat', 'main_phase', 'cast', 'becomes_level', 'draw', 'counter_placed', - 'becomes_target', 'life', -]) - -const ABILITY_KINDS = new Set([ - 'keyword', 'keywords', 'triggered', 'activated', 'static', 'spell', - 'additional_cost', 'alternative_cost', 'overload', 'chapter', 'level_band', - 'level_pt', 'unsupported', -]) - -function expectKind(value: unknown, allowed: Set, label: string, key = 'kind'): Record { - if (!isRecord(value) || typeof value[key] !== 'string' || !allowed.has(value[key] as string)) { - throw new Error(`expected ${label}`) - } - return value -} - - -function isRecord(value: unknown): value is Record { - return value !== null && typeof value === 'object' && !Array.isArray(value) -} - -function asRecord(value: unknown, label: string): Record { - if (!isRecord(value)) throw new Error(`${label} must be an object`) - return value -} - -function asString(value: unknown, label: string): string { - if (typeof value !== 'string') throw new Error(`${label} must be a string`) - return value -} - -function asNumber(value: unknown, label: string): number { - if (typeof value !== 'number' || !Number.isFinite(value)) throw new Error(`${label} must be a number`) - return value -} - -function asBoolean(value: unknown, label: string): boolean { - if (typeof value !== 'boolean') throw new Error(`${label} must be true or false`) - return value -} - -function optionalString(value: unknown, label: string): string | undefined { - if (value === undefined || value === null) return undefined - return asString(value, label) -} - -function stringArray(value: unknown, label: string): string[] { - if (value === undefined || value === null) return [] - if (!Array.isArray(value)) throw new Error(`${label} must be an array`) - return value.map(entry => asString(entry, label)) -} - -function asPlayer(value: unknown): PlayerRef { - if (typeof value === 'string' && PLAYER_REFS.has(value as PlayerRef)) return value as PlayerRef - throw new Error(`expected a player, got ${String(value)}`) -} - -function asTriggerPlayer(value: unknown): 'you' | 'opponent' | 'each_player' { - if (typeof value === 'string' && TRIGGER_PLAYERS.has(value)) return value as 'you' | 'opponent' | 'each_player' - throw new Error(`expected you, opponent or eachPlayer, got ${String(value)}`) -} - -function asDuration(value: unknown, fallback: Duration = 'permanent'): Duration { - if (value === undefined || value === null) return fallback - if (typeof value === 'string' && DURATIONS.has(value as Duration)) return value as Duration - throw new Error(`unknown duration "${String(value)}"`) -} - -function asZone(value: unknown): Zone { - if (typeof value === 'string' && ZONES.has(value as Zone)) return value as Zone - throw new Error(`unknown zone "${String(value)}"`) -} - -function asSearchDestination(value: unknown): SearchDestination { - if (typeof value === 'string' && SEARCH_DESTINATIONS.has(value as SearchDestination)) { - return value as SearchDestination - } - throw new Error(`unknown destination "${String(value)}"`) -} - -function asValue(value: unknown): Value { - if (typeof value === 'number') return { kind: 'number', value } - if (isRecord(value) && typeof value.kind === 'string' && VALUE_KINDS.has(value.kind)) { - return value as unknown as Value - } - throw new Error('expected a value (number or value helper)') -} - -function asSelector(value: unknown): ObjectSelector { - if (value instanceof Selector) return { ...value.fields } - if (isRecord(value)) return { ...value } as ObjectSelector - throw new Error('expected a selector') -} - -function isTarget(value: unknown): value is Target { - return isRecord(value) && typeof value.kind === 'string' && [ - 'self', 'trigger_subject', 'previous_target', 'object', 'player', - 'player_or_planeswalker', 'any', 'spell', 'ability', 'divided', - ].includes(value.kind) -} - -function asTarget(value: unknown): Target { - if (isTarget(value)) return value - throw new Error('expected a target') -} - -function asEffects(value: unknown): Effect[] { - const resolved = typeof value === 'function' ? value() : value - if (!Array.isArray(resolved)) return [asEffect(resolved)] - return resolved.map(asEffect) -} - -function asEffect(value: unknown): Effect { - return expectKind(value, EFFECT_OPS, 'an effect', 'op') as unknown as Effect -} - -function asStaticEffects(value: unknown): StaticEffect[] { - const resolved = typeof value === 'function' ? value() : value - if (!Array.isArray(resolved)) return [asStaticEffect(resolved)] - return resolved.map(asStaticEffect) -} - -function asStaticEffect(value: unknown): StaticEffect { - return expectKind(value, STATIC_OPS, 'a static effect', 'op') as unknown as StaticEffect -} - -function asCosts(value: unknown): Cost[] { - if (!Array.isArray(value)) throw new Error('expected an array of costs') - return value.map(asCost) -} - -function asCost(value: unknown): Cost { - return expectKind(value, COST_KINDS, 'a cost') as unknown as Cost -} - -function asCondition(value: unknown): Condition { - return expectKind(value, CONDITION_KINDS, 'a condition') as unknown as Condition -} - -function asTrigger(value: unknown): TriggerEvent { - return expectKind(value, TRIGGER_KINDS, 'a trigger event') as unknown as TriggerEvent -} - -function asAbility(value: unknown): Ability { - return expectKind(value, ABILITY_KINDS, 'an ability') as unknown as Ability -} - -function asAbilityArray(value: unknown): Ability[] { - if (!Array.isArray(value)) throw new Error('the implementation must be an array of abilities') - return value.map(asAbility) -} - -function asOptions(value: unknown): Record { - if (value === undefined || value === null) return Object.create(null) as Record - return asRecord(value, 'options') -} - -// --------------------------------------------------------------------------- -// Selectors -// --------------------------------------------------------------------------- - -class Selector { - readonly fields: ObjectSelector - - constructor(fields: ObjectSelector = {}) { - this.fields = fields - } - - private with(patch: Partial): Selector { - return new Selector({ ...this.fields, ...patch }) - } - - withType(...types: unknown[]): Selector { - return this.with({ - types: [...(this.fields.types ?? []), ...types.map(type => singularize(asString(type, 'type').toLowerCase()))], - }) - } - - withSupertype(...supertypes: unknown[]): Selector { - return this.with({ - supertypes: [ - ...(this.fields.supertypes ?? []), - ...supertypes.map(type => singularize(asString(type, 'supertype').toLowerCase())), - ], - }) - } - - withSubtype(...subtypes: unknown[]): Selector { - return this.with({ - subtypes: [ - ...(this.fields.subtypes ?? []), - ...subtypes.map(type => singularize(asString(type, 'subtype').toLowerCase())), - ], - }) - } - - withColor(...colors: unknown[]): Selector { - return this.with({ - colors: [ - ...(this.fields.colors ?? []), - ...colors.map(color => { - const text = asString(color, 'color').toLowerCase() - return COLOR_CODES[text] ?? text.toUpperCase() - }), - ], - }) - } - - withoutColor(...colors: unknown[]): Selector { - return this.with({ - excludeColors: [ - ...(this.fields.excludeColors ?? []), - ...colors.map(color => { - const text = asString(color, 'color').toLowerCase() - return COLOR_CODES[text] ?? text.toUpperCase() - }), - ], - }) - } - - matchingAny(): Selector { - return this.with({ match: 'any' }) - } - - withoutType(...types: unknown[]): Selector { - return this.with({ - excludeTypes: [ - ...(this.fields.excludeTypes ?? []), - ...types.map(type => singularize(asString(type, 'type').toLowerCase())), - ], - }) - } - - controlledBy(who: unknown): Selector { - if (who !== 'you' && who !== 'opponent' && who !== 'any') { - throw new Error('controlledBy() expects "you", "opponent" or "any"') - } - return this.with({ controller: who }) - } - - youControl(): Selector { - return this.with({ controller: 'you' }) - } - - opponentControls(): Selector { - return this.with({ controller: 'opponent' }) - } - - ownedBy(who: unknown): Selector { - if (who !== 'you' && who !== 'opponent') throw new Error('ownedBy() expects "you" or "opponent"') - return this.with({ owner: who }) - } - - other(): Selector { - return this.with({ other: true }) - } - - tapped(): Selector { - return this.with({ tapped: true }) - } - - untapped(): Selector { - return this.with({ tapped: false }) - } - - attacking(): Selector { - return this.with({ attacking: true }) - } - - token(): Selector { - return this.with({ token: true }) - } - - nontoken(): Selector { - return this.with({ token: false }) - } - - equipped(): Selector { - return this.with({ attached: 'equipped' }) - } - - enchanted(): Selector { - return this.with({ attached: 'enchanted' }) - } - - inZone(zone: unknown): Selector { - return this.with({ zone: asZone(zone) }) - } - - named(name: unknown): Selector { - return this.with({ name: asString(name, 'name') }) - } - - withCounter(counter: unknown, atLeast: unknown = 1): Selector { - return this.with({ counters: { counter: asString(counter, 'counter'), atLeast: asNumber(atLeast, 'counter count') } }) - } - - withKeyword(...keywords: unknown[]): Selector { - return this.with({ - keywords: [...(this.fields.keywords ?? []), ...keywords.map(keyword => asString(keyword, 'keyword'))], - }) - } - - withoutKeyword(...keywords: unknown[]): Selector { - return this.with({ - excludeKeywords: [ - ...(this.fields.excludeKeywords ?? []), - ...keywords.map(keyword => asString(keyword, 'keyword')), - ], - }) - } - - powerAtLeast(amount: unknown): Selector { - return this.with({ power: { ...(this.fields.power ?? {}), atLeast: asNumber(amount, 'power') } }) - } - - powerAtMost(amount: unknown): Selector { - return this.with({ power: { ...(this.fields.power ?? {}), atMost: asNumber(amount, 'power') } }) - } - - toughnessAtLeast(amount: unknown): Selector { - return this.with({ toughness: { ...(this.fields.toughness ?? {}), atLeast: asNumber(amount, 'toughness') } }) - } - - toughnessAtMost(amount: unknown): Selector { - return this.with({ toughness: { ...(this.fields.toughness ?? {}), atMost: asNumber(amount, 'toughness') } }) - } - - manaValueAtLeast(amount: unknown): Selector { - return this.with({ manaValue: { ...(this.fields.manaValue ?? {}), atLeast: asNumber(amount, 'mana value') } }) - } - - manaValueAtMost(amount: unknown): Selector { - return this.with({ manaValue: { ...(this.fields.manaValue ?? {}), atMost: asNumber(amount, 'mana value') } }) - } -} - -// --------------------------------------------------------------------------- -// Targets and values -// --------------------------------------------------------------------------- - -const self: Target = { kind: 'self' } -const triggerSubject: Target = { kind: 'trigger_subject' } -const previousTarget: Target = { kind: 'previous_target' } -const anyTarget: Target = { kind: 'any' } -const targetPlayerOrPlaneswalker: Target = { kind: 'player_or_planeswalker', mode: 'target' } - -function targetOptions(value: unknown): Pick, 'count' | 'upTo' | 'includeSelf'> { - const options = asOptions(value) - return { - ...(options.count !== undefined ? { count: asNumber(options.count, 'count') } : {}), - ...(options.upTo !== undefined ? { upTo: asBoolean(options.upTo, 'upTo') } : {}), - ...(options.includeSelf !== undefined ? { includeSelf: asBoolean(options.includeSelf, 'includeSelf') } : {}), - } -} - -function target(value: unknown, options?: unknown): Target { - if (typeof value === 'string' && PLAYER_REFS.has(value as PlayerRef)) { - return { kind: 'player', who: value as PlayerRef, mode: 'target' } - } - if (isTarget(value)) return value - return { kind: 'object', selector: asSelector(value), mode: 'target', ...targetOptions(options) } -} - -function each(value: unknown, options?: unknown): Target { - if (typeof value === 'string' && PLAYER_REFS.has(value as PlayerRef)) { - return { kind: 'player', who: value as PlayerRef, mode: 'each' } - } - if (isTarget(value)) return value - return { kind: 'object', selector: asSelector(value), mode: 'each', ...targetOptions(options) } -} - -function pick(value: unknown, options?: unknown): Target { - return { kind: 'object', selector: asSelector(value), mode: 'choose', ...targetOptions(options) } -} - -function divided(max: unknown, selector?: unknown): Target { - if (max !== 'any' && typeof max !== 'number') throw new Error('divided() expects a number or "any"') - return { - kind: 'divided', - max: max === 'any' ? 'any' : asNumber(max, 'divided count'), - ...(selector !== undefined ? { selector: asSelector(selector) } : {}), - } -} - -function targetSpell(selector?: unknown): Target { - return { kind: 'spell', selector: selector === undefined ? { types: [] } : asSelector(selector), mode: 'target' } -} - -function targetAbility(selector?: unknown): Target { - return { kind: 'ability', mode: 'target', ...(selector !== undefined ? { selector: asSelector(selector) } : {}) } -} - -const X: Value = { kind: 'x' } -const itsPower: Value = { kind: 'source_power' } -const itsToughness: Value = { kind: 'source_toughness' } - -function count(selector: unknown): Value { - return { kind: 'count', selector: asSelector(selector) } -} - -function cardsInHand(player: unknown): Value { - return { kind: 'cards_in_hand', player: asPlayer(player) } -} - -function maxCardsInHand(): Value { - return { kind: 'max_cards_in_hand' } -} - -function maxOpponentCount(selector: unknown): Value { - return { kind: 'max_opponent_count', selector: asSelector(selector) } -} - -function totalManaValue(selector: unknown): Value { - return { kind: 'total_mana_value', selector: asSelector(selector) } -} - -function totalPower(selector: unknown): Value { - return { kind: 'total_power', selector: asSelector(selector) } -} - -function anyNumber(): Value { - return { kind: 'any_number' } -} - -function eventAmount(): Value { - return { kind: 'event_amount' } -} - -// --------------------------------------------------------------------------- -// Mana, tokens and costs -// --------------------------------------------------------------------------- - -function mana(symbols: unknown, options?: unknown): ManaSpec { - const text = asString(symbols, 'mana symbols') - const found = text.match(/\{[^}]+\}/g) - if (!found?.length) throw new Error('mana() expects symbols like "{2}{G}"') - const data = asOptions(options) - const restriction = optionalString(data.restriction, 'restriction') - return { - kind: 'symbols', - symbols: found, - ...(data.oneOf === true ? { oneOf: true } : {}), - ...(restriction ? { restriction } : {}), - } -} - -function anyColor(amount: unknown, options?: unknown): ManaSpec { - const data = asOptions(options) - return { - kind: 'any_color', - amount: asValue(amount), - oneColor: data.oneColor === undefined ? false : asBoolean(data.oneColor, 'oneColor'), - ...(data.restriction !== undefined ? { restriction: asString(data.restriction, 'restriction') } : {}), - } -} - -function asToken(value: unknown): TokenSpec { - const data = asRecord(value, 'token') - const types = stringArray(data.types, 'token types').map(type => singularize(type.toLowerCase())) - const subtypes = stringArray(data.subtypes, 'token subtypes').map(type => singularize(type.toLowerCase())) - const colors = stringArray(data.colors, 'token colors').map(color => COLOR_CODES[color.toLowerCase()] ?? color.toUpperCase()) - return { - ...(data.name !== undefined ? { name: asString(data.name, 'token name') } : {}), - types: types.length ? types : (data.power !== undefined ? ['creature'] : ['artifact']), - subtypes, - colors, - ...(data.power !== undefined ? { power: asValue(data.power) } : {}), - ...(data.toughness !== undefined ? { toughness: asValue(data.toughness) } : {}), - ...(data.keywords !== undefined ? { keywords: stringArray(data.keywords, 'token keywords') } : {}), - ...(data.tapped === undefined ? {} : { tapped: asBoolean(data.tapped, 'tapped') }), - } -} - -class CopyOf { - readonly target: Target - readonly notLegendary: boolean - - constructor(targetValue: unknown, notLegendary: boolean) { - this.target = asTarget(targetValue) - this.notLegendary = notLegendary - } -} - -function copyOf(targetValue: unknown, options?: unknown): CopyOf { - return new CopyOf(targetValue, asOptions(options).notLegendary === true) -} - -function manaCost(symbols: unknown): Cost { - const spec = mana(symbols) - return { kind: 'mana', symbols: spec.kind === 'symbols' ? spec.symbols.join('') : '' } -} - -function tapCost(): Cost { - return { kind: 'tap' } -} - -function untapCost(): Cost { - return { kind: 'untap' } -} - -function tapOther(selector: unknown): Cost { - return { kind: 'tap_other', selector: asSelector(selector) } -} - -function energyCost(amount: unknown): Cost { - return { kind: 'energy', amount: asNumber(amount, 'energy') } -} - -function loyalty(amount: unknown): Cost { - return { kind: 'loyalty', amount: asNumber(amount, 'loyalty') } -} - -function payLife(amount: unknown): Cost { - return { kind: 'pay_life', amount: asValue(amount) } -} - -function discardCost(amount: unknown, options?: unknown): Cost { - const data = asOptions(options) - return { - kind: 'discard', - amount: asValue(amount), - player: data.player === undefined ? 'you' : asPlayer(data.player), - ...(data.random === true ? { random: true } : {}), - } -} - -function sacrificeCost(selector: unknown): Cost { - return { kind: 'sacrifice', selector: asSelector(selector) } -} - -function sacrificeSelf(): Cost { - return { kind: 'sacrifice_self' } -} - -function exileSelf(): Cost { - return { kind: 'exile_self' } -} - -function exileFromGraveyard(selector: unknown, amount?: unknown): Cost { - return { - kind: 'exile_from_graveyard', - selector: asSelector(selector), - ...(amount !== undefined ? { amount: asValue(amount) } : {}), - } -} - -function reveal(selector: unknown): Cost { - return { kind: 'reveal', selector: asSelector(selector) } -} - -function choice(options: unknown): Cost { - if (!Array.isArray(options)) throw new Error('choice() expects an array of cost arrays') - return { - kind: 'choice', - options: options.map(option => { - if (!Array.isArray(option)) throw new Error('choice() expects an array of cost arrays') - return option.map(asCost) - }), - } -} - -function returnToHandCost(selector: unknown): Cost { - return { kind: 'return_to_hand', selector: asSelector(selector) } -} - -function behold(selector: unknown): Cost { - return { kind: 'behold', selector: asSelector(selector) } -} - -function waterbend(amount: unknown): Cost { - return { kind: 'waterbend', amount: asValue(amount) } -} - -function blight(amount: unknown): Cost { - return { kind: 'blight', amount: asValue(amount) } -} - -function chooseCost(what: unknown): Cost { - return { kind: 'choose', what: asString(what, 'choice') } -} - -function putCounterCost(counter: unknown, selector: unknown): Cost { - return { kind: 'put_counter', counter: asString(counter, 'counter'), selector: asSelector(selector) } -} - -function removeCountersCost(counter: unknown, amount: unknown, selector?: unknown): Cost { - return { - kind: 'remove_counters', - counter: asString(counter, 'counter'), - amount: asValue(amount), - ...(selector !== undefined ? { selector: asSelector(selector) } : {}), - } -} - -function forage(): Cost { - return { kind: 'forage' } -} - -function collectEvidence(amount: unknown): Cost { - return { kind: 'collect_evidence', amount: asNumber(amount, 'evidence') } -} - -function millCost(amount: unknown): Cost { - return { kind: 'mill', amount: asValue(amount) } -} - -// --------------------------------------------------------------------------- -// Effects -// --------------------------------------------------------------------------- - -function damage(targetValue: unknown, amount: unknown, source?: unknown): Effect { - return { - op: 'damage', - target: asTarget(targetValue), - amount: asValue(amount), - ...(source !== undefined ? { source: asTarget(source) } : {}), - } -} - -function damageDivided(amount: unknown, targetValue: unknown): Effect { - return { op: 'damage_divided', amount: asValue(amount), target: asTarget(targetValue) } -} - -function draw(player: unknown, amount: unknown): Effect { - return { op: 'draw', player: asPlayer(player), amount: asValue(amount) } -} - -function discard(player: unknown, amount: unknown, options?: unknown): Effect { - return { - op: 'discard', - player: asPlayer(player), - amount: asValue(amount), - ...(asOptions(options).random === true ? { random: true } : {}), - } -} - -function mill(player: unknown, amount: unknown): Effect { - return { op: 'mill', player: asPlayer(player), amount: asValue(amount) } -} - -function gainLife(player: unknown, amount: unknown): Effect { - return { op: 'life', player: asPlayer(player), amount: asValue(amount), mode: 'gain' } -} - -function loseLife(player: unknown, amount: unknown): Effect { - return { op: 'life', player: asPlayer(player), amount: asValue(amount), mode: 'lose' } -} - -function pump(targetValue: unknown, power: unknown, toughness: unknown, duration?: unknown): Effect { - return { - op: 'pump', - target: asTarget(targetValue), - power: asValue(power), - toughness: asValue(toughness), - duration: asDuration(duration), - } -} - -function setPt(targetValue: unknown, power: unknown, toughness: unknown, options?: unknown): Effect { - const data = asOptions(options) - return { - op: 'set_pt', - target: asTarget(targetValue), - power: asValue(power), - toughness: asValue(toughness), - duration: asDuration(data.duration), - } -} - -function grant(targetValue: unknown, keyword: unknown, options?: unknown): Effect { - const data = asOptions(options) - return { - op: 'grant', - target: asTarget(targetValue), - keyword: asString(keyword, 'keyword'), - ...(data.value !== undefined ? { value: asString(data.value, 'keyword value') } : {}), - duration: asDuration(data.duration), - } -} - -function putCounters(targetValue: unknown, counter: unknown, amount: unknown): Effect { - return { - op: 'put_counters', - target: asTarget(targetValue), - counter: asString(counter, 'counter'), - amount: asValue(amount), - } -} - -function removeCounters(targetValue: unknown, counter: unknown, amount: unknown): Effect { - return { - op: 'remove_counters', - target: asTarget(targetValue), - counter: asString(counter, 'counter'), - amount: asValue(amount), - } -} - -function proliferate(): Effect { - return { op: 'proliferate' } -} - -function createToken(player: unknown, amount: unknown, tokenValue: unknown, options?: unknown): Effect { - const attachTo = options && typeof options === 'object' && 'attachTo' in options - ? asTarget((options as { attachTo: unknown }).attachTo) - : undefined - if (tokenValue instanceof CopyOf) { - return { - op: 'create_token', - player: asPlayer(player), - amount: asValue(amount), - token: { types: [], subtypes: [], colors: [] }, - copyOf: tokenValue.target, - ...(tokenValue.notLegendary ? { notLegendary: true } : {}), - ...(attachTo ? { attachTo } : {}), - } - } - return { - op: 'create_token', - player: asPlayer(player), - amount: asValue(amount), - token: asToken(tokenValue), - ...(attachTo ? { attachTo } : {}), - } -} - -function destroy(targetValue: unknown): Effect { - return { op: 'destroy', target: asTarget(targetValue) } -} - -function exile(targetValue: unknown): Effect { - return { op: 'exile', target: asTarget(targetValue) } -} - -function sacrifice(player: unknown, targetValue: unknown, unless?: unknown): Effect { - return { - op: 'sacrifice', - player: asPlayer(player), - target: asTarget(targetValue), - ...(unless !== undefined ? { unless: asCost(unless) } : {}), - } -} - -function counter(what: unknown, targetValue: unknown, unless?: unknown): Effect { - if (what !== 'spell' && what !== 'ability') throw new Error('counter() expects "spell" or "ability"') - return { - op: 'counter', - what, - target: asTarget(targetValue), - ...(unless !== undefined ? { unless: asCost(unless) } : {}), - } -} - -function returnToHand(targetValue: unknown): Effect { - return { op: 'return_to_hand', target: asTarget(targetValue) } -} - -function returnToBattlefield(targetValue: unknown, options?: unknown): Effect { - const data = asOptions(options) - const counters = data.counters === undefined ? undefined : asRecord(data.counters, 'counters') - return { - op: 'return_to_battlefield', - target: asTarget(targetValue), - tapped: data.tapped === true, - ...(data.transformed === true ? { transformed: true } : {}), - ...(counters - ? { counters: { counter: asString(counters.counter, 'counter'), amount: asValue(counters.amount) } } - : {}), - } -} - -function putOnTop(targetValue: unknown): Effect { - return { op: 'put_on_top', target: asTarget(targetValue) } -} - -function tap(targetValue: unknown): Effect { - return { op: 'tap', target: asTarget(targetValue) } -} - -function untap(targetValue: unknown): Effect { - return { op: 'untap', target: asTarget(targetValue) } -} - -function scry(player: unknown, amount: unknown): Effect { - return { op: 'scry', player: asPlayer(player), amount: asValue(amount) } -} - -function surveil(player: unknown, amount: unknown): Effect { - return { op: 'surveil', player: asPlayer(player), amount: asValue(amount) } -} - -function search(player: unknown, selector: unknown, amount: unknown, options?: unknown): Effect { - const data = asOptions(options) - const split = data.split === undefined ? undefined : asRecord(data.split, 'split') - const zones = data.zones === undefined - ? undefined - : stringArray(data.zones, 'zones').map(zone => { - if (zone !== 'library' && zone !== 'graveyard') throw new Error('zones must be library or graveyard') - return zone - }) - return { - op: 'search', - player: asPlayer(player), - selector: asSelector(selector), - amount: asValue(amount), - destination: asSearchDestination(data.destination ?? 'hand'), - tapped: data.tapped === true, - shuffle: data.shuffle === true, - ...(zones ? { zones } : {}), - ...(split - ? { split: { destination: asSearchDestination(split.destination), tapped: split.tapped === true } } - : {}), - } -} - -function shuffle(player: unknown): Effect { - return { op: 'shuffle', player: asPlayer(player) } -} - -function addMana(player: unknown, manaValue: unknown): Effect { - const spec = typeof manaValue === 'string' ? mana(manaValue) : manaValue - if (!isRecord(spec) || (spec.kind !== 'symbols' && spec.kind !== 'any_color')) { - throw new Error('addMana() expects mana(...) or anyColor(...)') - } - return { op: 'add_mana', player: asPlayer(player), mana: spec as unknown as ManaSpec } -} - -function fight(a: unknown, b: unknown): Effect { - return { op: 'fight', a: asTarget(a), b: asTarget(b) } -} - -function regenerate(targetValue: unknown): Effect { - return { op: 'regenerate', target: asTarget(targetValue) } -} - -function energy(player: unknown, amount: unknown): Effect { - return { op: 'energy', player: asPlayer(player), amount: asValue(amount) } -} - -function attach(targetValue: unknown): Effect { - return { op: 'attach', target: asTarget(targetValue) } -} - -function restrict(targetValue: unknown, rule: unknown, duration?: unknown): Effect { - const text = asString(rule, 'restriction rule') - if (!RESTRICTION_RULES.has(text)) throw new Error(`unknown restriction rule "${text}"`) - return { - op: 'restriction', - target: asTarget(targetValue), - rule: text as 'cant_attack' | 'cant_block' | 'doesnt_untap', - duration: asDuration(duration), - } -} - -function keywordAction(action: unknown, options?: unknown): Effect { - const data = asOptions(options) - return { - op: 'keyword_action', - action: asString(action, 'action').replace(/_/g, ' '), - ...(data.target !== undefined ? { target: asTarget(data.target) } : {}), - ...(data.amount !== undefined ? { amount: asValue(data.amount) } : {}), - ...(data.detail !== undefined ? { detail: asString(data.detail, 'detail') } : {}), - } -} - -function preventDamage(targetValue: unknown, amount: unknown, options?: unknown): Effect { - const data = asOptions(options) - return { - op: 'prevent_damage', - target: asTarget(targetValue), - amount: amount === 'all' ? 'all' : asValue(amount), - ...(data.combatOnly === true ? { combatOnly: true } : {}), - duration: asDuration(data.duration), - } -} - -function gainControl(targetValue: unknown, duration?: unknown): Effect { - return { op: 'gain_control', target: asTarget(targetValue), duration: asDuration(duration) } -} - -function emblem(text: unknown): Effect { - return { op: 'emblem', text: asString(text, 'emblem text') } -} - -function transform(targetValue: unknown): Effect { - return { op: 'transform', target: asTarget(targetValue) } -} - -function pay(costs: unknown): Effect { - return { op: 'pay', costs: asCosts(costs) } -} - -function ifThen(condition: unknown, effects: unknown): Effect { - return { op: 'conditional', condition: asCondition(condition), effects: asEffects(effects) } -} - -function modal(min: unknown, max: unknown, modes: unknown): Effect { - if (!Array.isArray(modes)) throw new Error('modal() expects an array of modes') - return { - op: 'modal', - min: asNumber(min, 'minimum modes'), - max: asNumber(max, 'maximum modes'), - modes: modes.map(mode => asEffects(mode)), - } -} - -function lookTop(player: unknown, amount: unknown, options?: unknown): Effect { - return { - op: 'look_top', - player: asPlayer(player), - amount: asValue(amount), - ...(asOptions(options).reorder === true ? { reorder: true } : {}), - } -} - -function schedule(when: unknown, effects: unknown): Effect { - if (when !== 'next_upkeep' && when !== 'next_end_step') { - throw new Error('schedule() expects "next_upkeep" or "next_end_step"') - } - return { op: 'schedule', when, effects: asEffects(effects) } -} - -function levelUp(level: unknown): Effect { - return { op: 'level_up', level: asNumber(level, 'level') } -} - -function putFromAmong(player: unknown, amount: unknown, options?: unknown): Effect { - const data = asOptions(options) - return { - op: 'put_from_among', - player: asPlayer(player), - amount: asValue(amount), - ...(data.selector !== undefined ? { selector: asSelector(data.selector) } : {}), - destination: asSearchDestination(data.destination ?? 'hand'), - } -} - -function dig(player: unknown, amount: unknown, options?: unknown): Effect { - const data = asOptions(options) - const to = data.to ?? 'hand' - const rest = data.rest ?? 'bottom' - if (to !== 'hand' && to !== 'battlefield') throw new Error('dig() to must be hand or battlefield') - if (rest !== 'bottom' && rest !== 'graveyard' && rest !== 'top') { - throw new Error('dig() rest must be bottom, graveyard or top') - } - return { - op: 'dig', - player: asPlayer(player), - amount: asValue(amount), - pick: asValue(data.pick ?? 1), - ...(data.upTo === true ? { upTo: true } : {}), - ...(data.pickSelector !== undefined ? { pickSelector: asSelector(data.pickSelector) } : {}), - to, - rest, - ...(data.order === 'any' || data.order === 'random' ? { order: data.order } : {}), - ...(data.optional === true ? { optional: true } : {}), - ...(data.tapped === true ? { tapped: true } : {}), - } -} - -function exileGraveyards(): Effect { - return { op: 'exile_graveyards' } -} - -function hideaway(amount: unknown): Effect { - return { op: 'hideaway', amount: asValue(amount) } -} - -function playExiled(player: unknown, options?: unknown): Effect { - return { - op: 'play_exiled', - player: asPlayer(player), - ...(asOptions(options).free === true ? { free: true } : {}), - } -} - -// --------------------------------------------------------------------------- -// Static effects -// --------------------------------------------------------------------------- - -function staticPump(targetValue: unknown, power: unknown, toughness: unknown): StaticEffect { - return { op: 'pump', target: asTarget(targetValue), power: asValue(power), toughness: asValue(toughness) } -} - -function staticGrant(targetValue: unknown, keyword: unknown, options?: unknown): StaticEffect { - const data = asOptions(options) - return { - op: 'grant', - target: asTarget(targetValue), - keyword: asString(keyword, 'keyword'), - ...(data.value !== undefined ? { value: asString(data.value, 'keyword value') } : {}), - } -} - -function staticRestrict(targetValue: unknown, rule: unknown, options?: unknown): StaticEffect { - const data = asOptions(options) - const text = asString(rule, 'restriction rule') - return { - op: 'restriction', - target: asTarget(targetValue), - rule: text, - ...(data.value !== undefined ? { value: asValue(data.value) } : {}), - ...(data.comparison === 'or_greater' || data.comparison === 'or_less' ? { comparison: data.comparison } : {}), - ...(data.detail !== undefined ? { detail: asString(data.detail, 'detail') } : {}), - ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), - } -} - -function staticSetPt(targetValue: unknown, power: unknown, toughness: unknown, options?: unknown): StaticEffect { - const data = asOptions(options) - return { - op: 'set_pt', - target: asTarget(targetValue), - ...(power !== null && power !== undefined ? { power: asValue(power) } : {}), - ...(toughness !== null && toughness !== undefined ? { toughness: asValue(toughness) } : {}), - ...(data.base === true ? { base: true } : {}), - } -} - -function grantAbility(targetValue: unknown, ability: unknown): StaticEffect { - return { op: 'grant_ability', target: asTarget(targetValue), ability: asAbility(ability) } -} - -function entersTapped(targetValue: unknown, options?: unknown): StaticEffect { - const data = asOptions(options) - return { - op: 'enters_tapped', - target: asTarget(targetValue), - ...(data.unless !== undefined ? { unless: asCondition(data.unless) } : {}), - ...(data.unlessCost !== undefined ? { unlessCost: asCost(data.unlessCost) } : {}), - } -} - -function entersWithCounters(targetValue: unknown, counter: unknown, amount: unknown): StaticEffect { - return { - op: 'enters_with_counters', - target: asTarget(targetValue), - counter: asString(counter, 'counter'), - amount: asValue(amount), - } -} - -function control(targetValue: unknown): StaticEffect { - return { op: 'control', target: asTarget(targetValue) } -} - -function choose(what: unknown): StaticEffect { - const text = asString(what, 'choice') - if (!CHOICES.has(text)) throw new Error(`unknown choice "${text}"`) - return { op: 'choose', what: text as 'creature_type' | 'color' | 'card_name' | 'player' | 'opponent' | 'number' } -} - -function replace(what: unknown, options?: unknown): StaticEffect { - const text = asString(what, 'replacement') - if (!REPLACEMENT_WHATS.has(text)) throw new Error(`unknown replacement "${text}"`) - const data = asOptions(options) - const instead = asString(data.instead, 'replacement result') - if (!REPLACEMENT_RESULTS.has(instead)) throw new Error(`unknown replacement result "${instead}"`) - return { - op: 'replacement', - what: text as 'dies' | 'leaves_battlefield' | 'discard' | 'draw', - instead: instead as 'exile' | 'return_to_hand' | 'return_to_library' | 'prevent', - ...(data.target !== undefined ? { target: asTarget(data.target) } : {}), - } -} - -function tokenMultiplier(multiplier: unknown, options?: unknown): StaticEffect { - const data = asOptions(options) - if (data.who !== undefined && data.who !== 'you' && data.who !== 'each_player') { - throw new Error("tokenMultiplier() who must be 'you' or 'each_player'") - } - return { - op: 'token_multiplier', - multiplier: asNumber(multiplier, 'token multiplier'), - who: data.who === 'each_player' ? 'each_player' : 'you', - ...(data.creatureOnly === true ? { creatureOnly: true } : {}), - } -} - -function costReduction(targetValue: unknown, amount: unknown, options?: unknown): StaticEffect { - const data = asOptions(options) - return { - op: 'cost_reduction', - target: asTarget(targetValue), - ...(typeof amount === 'string' && /^(?:\{[^}]+\})+$/.test(amount) - ? { symbols: amount } - : { amount: asValue(amount) }), - ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), - } -} - -function costIncrease(amount: unknown, options?: unknown): StaticEffect { - const data = asOptions(options) - const spellType = data.spellType - if (spellType !== undefined && spellType !== 'noncreature' && spellType !== 'creature') { - throw new Error('spellType must be noncreature or creature') - } - return { - op: 'cost_increase', - amount: asValue(amount), - ...(spellType ? { spellType } : {}), - } -} - -function searchRestriction(who: unknown, amount: unknown): StaticEffect { - if (who !== 'opponent' && who !== 'you') throw new Error('searchRestriction() expects you or opponent') - return { op: 'search_restriction', who, amount: asValue(amount) } -} - -function exileInsteadOfGraveyard(owner?: unknown): StaticEffect { - if (owner !== undefined && owner !== 'opponent' && owner !== 'you') { - throw new Error('exileInsteadOfGraveyard() expects you or opponent') - } - return { op: 'exile_instead_of_graveyard', ...(owner ? { owner } : {}) } -} - -// --------------------------------------------------------------------------- -// Triggers -// --------------------------------------------------------------------------- - -function trigger(kind: T['kind'], fields: Omit): T { - return { kind, ...fields } as T -} - -function createWhen(): Record { - return Object.assign(Object.create(null), { - enters: (subject: unknown) => trigger('enters', { subject: asTarget(subject) }), - dies: (subject: unknown) => trigger('dies', { subject: asTarget(subject) }), - attacks: (subject: unknown) => trigger('attacks', { subject: asTarget(subject) }), - blocks: (subject: unknown) => trigger('blocks', { subject: asTarget(subject) }), - attacksOrBlocks: (subject: unknown) => trigger('attacks_or_blocks', { subject: asTarget(subject) }), - entersOrAttacks: (subject: unknown) => trigger('enters_or_attacks', { subject: asTarget(subject) }), - entersOrDies: (subject: unknown) => trigger('enters_or_dies', { subject: asTarget(subject) }), - leavesBattlefield: (subject: unknown) => trigger('leaves_battlefield', { subject: asTarget(subject) }), - dealsDamage: (subject: unknown, recipient: unknown, options?: unknown) => { - if (recipient !== 'player' && recipient !== 'creature' && recipient !== 'permanent' && recipient !== 'any') { - throw new Error('dealsDamage() recipient must be player, creature, permanent or any') - } - return trigger('deals_damage', { - subject: asTarget(subject), - recipient, - combat: asOptions(options).combat === true, - }) - }, - upkeep: (who: unknown) => trigger('upkeep', { who: asTriggerPlayer(who) }), - endStep: (who: unknown) => trigger('end_step', { who: asTriggerPlayer(who) }), - beginCombat: (who: unknown) => trigger('begin_combat', { who: asTriggerPlayer(who) }), - firstMainPhase: (who: unknown) => trigger('main_phase', { who: asTriggerPlayer(who), phase: 'first' }), - postcombatMainPhase: (who: unknown) => trigger('main_phase', { who: asTriggerPlayer(who), phase: 'postcombat' }), - cast: (who: unknown, spell?: unknown, options?: unknown) => { - let selector: ObjectSelector = { types: [] } - let data: Record = Object.create(null) as Record - if (spell instanceof Selector) { - selector = asSelector(spell) - } else if (isRecord(spell) && !('targetsSelf' in spell) && !('orCopy' in spell) && !('ordinal' in spell)) { - selector = asSelector(spell) - } else if (spell !== undefined) { - data = asOptions(spell) - } - data = { ...data, ...asOptions(options) } - return trigger('cast', { - who: asTriggerPlayer(who), - spell: selector, - ...(data.targetsSelf === true ? { targetsSelf: true } : {}), - ...(data.orCopy === true ? { orCopy: true } : {}), - ...(data.ordinal !== undefined ? { ordinal: asNumber(data.ordinal, 'ordinal') } : {}), - }) - }, - becomesLevel: (level: unknown) => trigger('becomes_level', { level: asNumber(level, 'level') }), - draw: (who: unknown, ordinal?: unknown) => trigger('draw', { - who: asTriggerPlayer(who), - ...(ordinal !== undefined ? { ordinal: asNumber(ordinal, 'ordinal') } : {}), - }), - counterPlaced: (subject: unknown, counter?: unknown) => trigger('counter_placed', { - subject: asTarget(subject), - ...(counter !== undefined ? { counter: asString(counter, 'counter') } : {}), - }), - becomesTarget: (subject: unknown) => trigger('becomes_target', { subject: asTarget(subject) }), - lifeGained: (who: unknown) => trigger('life', { who: asTriggerPlayer(who), mode: 'gain' }), - lifeLost: (who: unknown) => trigger('life', { who: asTriggerPlayer(who), mode: 'lose' }), - }) -} - -// --------------------------------------------------------------------------- -// Conditions -// --------------------------------------------------------------------------- - -function condition(kind: T['kind'], fields: Omit = {} as Omit): T { - return { kind, ...fields } as T -} - -function youControl(selector: unknown, atLeast?: unknown): Condition { - return condition('you_control', { - selector: asSelector(selector), - ...(atLeast !== undefined ? { atLeast: asNumber(atLeast, 'count') } : {}), - }) -} - -function opponentControls(selector: unknown, atLeast?: unknown): Condition { - return condition('opponent_controls', { - selector: asSelector(selector), - ...(atLeast !== undefined ? { atLeast: asNumber(atLeast, 'count') } : {}), - }) -} - -function yourTurn(): Condition { - return condition('your_turn') -} - -function notYourTurn(): Condition { - return condition('not_your_turn') -} - -function sourceTapped(): Condition { - return condition('source_tapped') -} - -function sourceUntapped(): Condition { - return condition('source_untapped') -} - -function sourceAttacking(): Condition { - return condition('source_attacking') -} - -function lifeAtLeast(player: unknown, amount: unknown): Condition { - return condition('life_at_least', { player: asPlayer(player), amount: asNumber(amount, 'life') }) -} - -function lifeAtMost(player: unknown, amount: unknown): Condition { - return condition('life_at_most', { player: asPlayer(player), amount: asNumber(amount, 'life') }) -} - -function lifeAboveStarting(player: unknown, amount: unknown): Condition { - return condition('life_above_starting', { player: asPlayer(player), amount: asNumber(amount, 'life') }) -} - -function cardsInGraveyard(player: unknown, atLeast: unknown): Condition { - return condition('cards_in_graveyard', { player: asPlayer(player), atLeast: asNumber(atLeast, 'count') }) -} - -function handEmpty(player: unknown): Condition { - return condition('hand_empty', { player: asPlayer(player) }) -} - -function creatureDiedThisTurn(controller?: unknown): Condition { - if (controller !== undefined && controller !== 'you' && controller !== 'opponent') { - throw new Error('creatureDiedThisTurn() expects you or opponent') - } - return condition('creature_died_this_turn', controller ? { controller } : {}) -} - -function youGainedLifeThisTurn(atLeast?: unknown): Condition { - return condition('you_gained_life_this_turn', atLeast === undefined ? {} : { atLeast: asNumber(atLeast, 'life') }) -} - -function youDrewCardsThisTurn(atLeast?: unknown): Condition { - return condition('you_drew_cards_this_turn', atLeast === undefined ? {} : { atLeast: asNumber(atLeast, 'count') }) -} - -function spellsCastLastTurn(who: unknown, atLeast: unknown): Condition { - if (who !== 'you' && who !== 'opponent' && who !== 'each_player' && who !== 'a_player') { - throw new Error('spellsCastLastTurn() expects a spell caster') - } - return condition('spells_cast_last_turn', { who, atLeast: asNumber(atLeast, 'count') }) -} - -function noSpellsLastTurn(): Condition { - return condition('no_spells_last_turn') -} - -function attackedThisTurn(): Condition { - return condition('attacked_this_turn') -} - -function youAttackedThisTurn(): Condition { - return condition('you_attacked_this_turn') -} - -function defendingPlayerControls(selector: unknown): Condition { - return condition('defending_player_controls', { selector: asSelector(selector) }) -} - -function targets(selector: unknown): Condition { - return condition('targets', { selector: asSelector(selector) }) -} - -function wasKicked(): Condition { - return condition('was_kicked') -} - -function youCastIt(options?: unknown): Condition { - return condition('cast', asOptions(options).fromHand === true ? { fromHand: true } : {}) -} - -function inGraveyard(): Condition { - return condition('in_graveyard') -} - -function onBattlefield(): Condition { - return condition('on_battlefield') -} - -function monarch(): Condition { - return condition('monarch') -} - -function initiative(): Condition { - return condition('initiative') -} - -function citysBlessing(): Condition { - return condition('citys_blessing') -} - -function suspended(): Condition { - return condition('suspended') -} - -function bargained(): Condition { - return condition('bargained') -} - -function wasCreature(): Condition { - return condition('was_creature') -} - -function opponentLostLifeThisTurn(): Condition { - return condition('opponent_lost_life_this_turn') -} - -function lifeChangedThisTurn(): Condition { - return condition('life_changed_this_turn') -} - -function descendedThisTurn(): Condition { - return condition('descended_this_turn') -} - -function permanentLeftBattlefieldThisTurn(): Condition { - return condition('permanent_left_battlefield_this_turn', { controller: 'you' }) -} - -function nonlandPermanentsEnteredThisTurn(atLeast: unknown): Condition { - return condition('nonland_permanents_entered_this_turn', { atLeast: asNumber(atLeast, 'count') }) -} - -function attackedWithTotalPower(atLeast: unknown): Condition { - return condition('attacked_with_total_power', { atLeast: asNumber(atLeast, 'power') }) -} - -function yourCreaturesTotalPower(atLeast: unknown): Condition { - return condition('total_power', { controller: 'you', atLeast: asNumber(atLeast, 'power') }) -} - -function opponentControlsMoreLands(): Condition { - return condition('opponent_controls_more_lands') -} - -function distinctPowers(atLeast: unknown): Condition { - return condition('distinct_powers', { atLeast: asNumber(atLeast, 'count') }) -} - -function graveyardCardTypes(atLeast: unknown): Condition { - return condition('graveyard_card_types', { atLeast: asNumber(atLeast, 'count') }) -} - -function noObjects(selector: unknown): Condition { - return condition('no_objects', { selector: asSelector(selector) }) -} - -function cardsInHandAtMost(who: unknown, atMost: unknown): Condition { - return condition('cards_in_hand_at_most', { who: asPlayer(who), atMost: asNumber(atMost, 'count') }) -} - -function notTheirTurn(): Condition { - return condition('not_their_turn') -} - -function noAttackers(): Condition { - return condition('no_attackers') -} - -function opponentPoison(atLeast: unknown): Condition { - return condition('opponent_poison', { atLeast: asNumber(atLeast, 'poison') }) -} - -function tributeNotPaid(): Condition { - return condition('tribute_not_paid') -} - -function hadCounters(counter?: unknown): Condition { - return condition('had_counters', counter === undefined ? {} : { counter: asString(counter, 'counter') }) -} - -function manaFromTreasure(): Condition { - return condition('mana_from_treasure') -} - -function manaSpent(atLeast: unknown): Condition { - return condition('mana_spent', { atLeast: asNumber(atLeast, 'mana') }) -} - -function noManaSpent(): Condition { - return condition('no_mana_spent') -} - -function manaSymbolSpent(symbols: unknown): Condition { - return condition('mana_symbol_spent', { symbols: asString(symbols, 'mana symbols') }) -} - -function kickedWith(cost: unknown): Condition { - return condition('kicked_with', { cost: asString(cost, 'kicker cost') }) -} - -function moreCardsThanEachOpponent(): Condition { - return condition('more_cards_than_each_opponent') -} - -function firstCombatPhase(): Condition { - return condition('first_combat_phase') -} - -function notToken(): Condition { - return condition('not_token') -} - -function castSpellThisTurn(options?: unknown): Condition { - return condition('cast_spell_this_turn', asOptions(options).noncreature === true ? { noncreature: true } : {}) -} - -function fullParty(): Condition { - return condition('full_party') -} - -function graveyardCount(selector: unknown, atLeast: unknown): Condition { - return condition('graveyard_count', { selector: asSelector(selector), atLeast: asNumber(atLeast, 'count') }) -} - -function creaturePowerGreaterThanBase(stat: unknown): Condition { - if (stat !== 'power' && stat !== 'toughness') throw new Error('creaturePowerGreaterThanBase() expects power or toughness') - return condition('creature_power_greater_than_base', { controller: 'you', stat }) -} - -function ifYouDo(): Condition { - return condition('if_you_do') -} - -function ifYouDont(): Condition { - return condition('if_you_dont') -} - -function otherwise(): Condition { - return condition('otherwise') -} - -function youControlCommander(): Condition { - return condition('you_control_commander') -} - -function distinctNames(selector: unknown, atLeast: unknown): Condition { - return condition('distinct_names', { selector: asSelector(selector), atLeast: asNumber(atLeast, 'count') }) -} - -function opponentDamagedThisTurn(atLeast: unknown): Condition { - return condition('opponent_damaged_this_turn', { atLeast: asNumber(atLeast, 'damage') }) -} - -function attackedWithCreatures(atLeast: unknown): Condition { - return condition('attacked_with_creatures', { atLeast: asNumber(atLeast, 'count') }) -} - -function libraryAtMost(atMost: unknown): Condition { - return condition('library_at_most', { atMost: asNumber(atMost, 'cards') }) -} - -// --------------------------------------------------------------------------- -// Abilities and card sections -// --------------------------------------------------------------------------- - -function parseKeywordText(text: string): KeywordAbility { - const trimmed = text.trim() - const lower = trimmed.toLowerCase() - const simple = [...SIMPLE_KEYWORDS.entries()].sort((a, b) => b[0].length - a[0].length) - for (const [key, keyword] of simple) { - if (lower === key) return { kind: 'keyword', keyword: trimmed } - if (lower.startsWith(`${key} `)) return { kind: 'keyword', keyword, value: trimmed.slice(key.length + 1) } - } - const match = trimmed.match(/^(\S+)(?: (.+))?$/) - if (!match) return { kind: 'keyword', keyword: trimmed } - return { - kind: 'keyword', - keyword: match[1].charAt(0).toUpperCase() + match[1].slice(1), - ...(match[2] ? { value: match[2] } : {}), - } -} - -function keyword(name: unknown, value?: unknown): Ability { - return { - kind: 'keyword', - keyword: asString(name, 'keyword'), - ...(value !== undefined ? { value: asString(value, 'keyword value') } : {}), - } -} - -function keywords(...items: unknown[]): Ability { - return { - kind: 'keywords', - keywords: items.map(item => { - if (isRecord(item) && item.kind === 'keyword') return item as unknown as KeywordAbility - return parseKeywordText(asString(item, 'keyword')) - }), - } -} - -function triggered(event: unknown, effects: unknown, options?: unknown): Ability { - const data = asOptions(options) - return { - kind: 'triggered', - event: asTrigger(event), - effects: asEffects(effects), - ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), - optional: data.optional === true, - text: 'Triggered ability', - } -} - -function activated(costs: unknown, effects: unknown, options?: unknown): Ability { - const data = asOptions(options) - const timing = data.timing - if (timing !== undefined && timing !== 'instant' && timing !== 'sorcery') { - throw new Error('timing must be instant or sorcery') - } - return { - kind: 'activated', - costs: asCosts(costs), - effects: asEffects(effects), - ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), - ...(timing ? { timing } : {}), - ...(data.activationsPerTurn !== undefined - ? { activationsPerTurn: asNumber(data.activationsPerTurn, 'activations per turn') } - : {}), - optional: data.optional === true, - text: 'Activated ability', - } -} - -function staticAbility(effects: unknown, options?: unknown): Ability { - const data = asOptions(options) - return { - kind: 'static', - effects: asStaticEffects(effects), - ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), - text: 'Static ability', - } -} - -function spell(effects: unknown, options?: unknown): Ability { - return { - kind: 'spell', - effects: asEffects(effects), - optional: asOptions(options).optional === true, - text: 'Spell effect', - } -} - -function additionalCost(costs: unknown, options?: unknown): Ability { - return { - kind: 'additional_cost', - costs: asCosts(costs), - optional: asOptions(options).optional === true, - text: 'Additional cost', - } -} - -function alternativeCost(costs: unknown, options?: unknown): Ability { - const data = asOptions(options) - return { - kind: 'alternative_cost', - costs: asCosts(costs), - ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), - text: 'Alternative cost', - } -} - -function overload(cost: unknown): Ability { - return { kind: 'overload', cost: asString(cost, 'overload cost'), text: 'Overload' } -} - -function chapter(chapters: unknown, effects: unknown, options?: unknown): Ability { - if (!Array.isArray(chapters)) throw new Error('chapter() expects an array of chapter numbers') - return { - kind: 'chapter', - chapters: chapters.map(entry => asString(entry, 'chapter').toUpperCase()), - effects: asEffects(effects), - optional: asOptions(options).optional === true, - text: 'Chapter ability', - } -} - -function levelBand(min: unknown, max: unknown, power?: unknown, toughness?: unknown): Ability { - return { - kind: 'level_band', - min: asNumber(min, 'minimum level'), - ...(max !== null && max !== undefined ? { max: asNumber(max, 'maximum level') } : {}), - ...(power !== undefined ? { power: asValue(power) } : {}), - ...(toughness !== undefined ? { toughness: asValue(toughness) } : {}), - text: 'Level band', - } -} - -function levelPt(power: unknown, toughness: unknown): Ability { - return { kind: 'level_pt', power: asValue(power), toughness: asValue(toughness), text: 'Level P/T' } -} - -function unsupported(reason: unknown, text: unknown): Ability { - return { kind: 'unsupported', reason: asString(reason, 'reason'), text: asString(text, 'text') } -} - -class CardSection { - readonly typeLine?: string - readonly abilities: Ability[] - - constructor(typeLineOrAbilities: unknown, abilities?: unknown) { - if (abilities === undefined) { - this.abilities = asAbilityArray(typeLineOrAbilities) - } else { - this.typeLine = asString(typeLineOrAbilities, 'card type line') - this.abilities = asAbilityArray(abilities) - } - } -} - -class Face { - readonly name: string - readonly typeLine?: string - readonly abilities: Ability[] - - constructor(name: unknown, typeLineOrAbilities: unknown, abilities?: unknown) { - this.name = asString(name, 'face name') - if (abilities === undefined) { - this.abilities = asAbilityArray(typeLineOrAbilities) - } else { - this.typeLine = asString(typeLineOrAbilities, 'face type line') - this.abilities = asAbilityArray(abilities) - } - } -} - -class Faces { - readonly faces: Face[] - - constructor(faces: unknown[]) { - this.faces = faces.map(face => { - if (!(face instanceof Face)) throw new Error('faces() expects face(...) entries') - return face - }) - } -} - -/** Top-level card section: card('Creature — Human', [...abilities]). */ -function card(typeLineOrAbilities: unknown, abilities?: unknown): CardSection { - return new CardSection(typeLineOrAbilities, abilities) -} - -function face(name: unknown, typeLineOrAbilities: unknown, abilities?: unknown): Face { - return new Face(name, typeLineOrAbilities, abilities) -} - -function faces(...entries: unknown[]): Faces { - return new Faces(entries) -} - -// --------------------------------------------------------------------------- -// API and entry point -// --------------------------------------------------------------------------- - -function createApi(): Record { - return Object.assign(Object.create(null), { - // players - you: 'you', - opponent: 'opponent', - eachOpponent: 'each_opponent', - eachPlayer: 'each_player', - targetPlayer: 'target_player', - thatPlayer: 'that_player', - itsController: 'its_controller', - itsOwner: 'its_owner', - - // selectors - permanents: new Selector(), - cards: new Selector(), - creatures: new Selector({ types: ['creature'] }), - - // targets - self, - triggerSubject, - previousTarget, - anyTarget, - targetPlayerOrPlaneswalker, - target, - each, - pick, - divided, - targetSpell, - targetAbility, - - // values - X, - itsPower, - itsToughness, - count, - cardsInHand, - maxCardsInHand, - maxOpponentCount, - totalManaValue, - totalPower, - anyNumber, - eventAmount, - - // durations - permanent: 'permanent', - untilEndOfTurn: 'until_end_of_turn', - untilYourNextTurn: 'until_your_next_turn', - untilEndOfYourNextTurn: 'until_end_of_your_next_turn', - untilEndOfCombat: 'until_end_of_combat', - untilControllersNextUntapStep: 'until_controllers_next_untap_step', - whileSourceOnBattlefield: 'while_source_on_battlefield', - - // mana and tokens - mana, - anyColor, - token: asToken, - copyOf, - - // costs - manaCost, - tapCost, - untapCost, - tapOther, - energyCost, - loyalty, - payLife, - discardCost, - sacrificeCost, - sacrificeSelf, - exileSelf, - exileFromGraveyard, - reveal, - choice, - returnToHandCost, - behold, - waterbend, - blight, - chooseCost, - putCounterCost, - removeCountersCost, - forage, - collectEvidence, - millCost, - - // effects - damage, - damageDivided, - draw, - discard, - mill, - gainLife, - loseLife, - pump, - setPt, - grant, - putCounters, - removeCounters, - proliferate, - createToken, - destroy, - exile, - sacrifice, - counter, - returnToHand, - returnToBattlefield, - putOnTop, - tap, - untap, - scry, - surveil, - search, - shuffle, - addMana, - fight, - regenerate, - energy, - attach, - restrict, - keywordAction, - preventDamage, - gainControl, - emblem, - transform, - pay, - ifThen, - modal, - lookTop, - schedule, - levelUp, - putFromAmong, - dig, - exileGraveyards, - hideaway, - playExiled, - - // static effects - staticPump, - staticGrant, - staticRestrict, - staticSetPt, - grantAbility, - entersTapped, - entersWithCounters, - control, - choose, - replace, - costReduction, - costIncrease, - searchRestriction, - exileInsteadOfGraveyard, - tokenMultiplier, - - // abilities - keyword, - keywords, - triggered, - activated, - staticAbility, - spell, - additionalCost, - alternativeCost, - overload, - chapter, - levelBand, - levelPt, - unsupported, - - // triggers - when: createWhen(), - - // conditions - youControl, - opponentControls, - yourTurn, - notYourTurn, - sourceTapped, - sourceUntapped, - sourceAttacking, - lifeAtLeast, - lifeAtMost, - lifeAboveStarting, - cardsInGraveyard, - handEmpty, - creatureDiedThisTurn, - youGainedLifeThisTurn, - youDrewCardsThisTurn, - spellsCastLastTurn, - noSpellsLastTurn, - attackedThisTurn, - youAttackedThisTurn, - defendingPlayerControls, - targets, - wasKicked, - youCastIt, - inGraveyard, - onBattlefield, - monarch, - initiative, - citysBlessing, - suspended, - bargained, - wasCreature, - opponentLostLifeThisTurn, - lifeChangedThisTurn, - descendedThisTurn, - permanentLeftBattlefieldThisTurn, - nonlandPermanentsEnteredThisTurn, - attackedWithTotalPower, - yourCreaturesTotalPower, - opponentControlsMoreLands, - distinctPowers, - graveyardCardTypes, - noObjects, - cardsInHandAtMost, - notTheirTurn, - noAttackers, - opponentPoison, - tributeNotPaid, - hadCounters, - manaFromTreasure, - manaSpent, - noManaSpent, - manaSymbolSpent, - kickedWith, - moreCardsThanEachOpponent, - firstCombatPhase, - notToken, - castSpellThisTurn, - fullParty, - graveyardCount, - creaturePowerGreaterThanBase, - ifYouDo, - ifYouDont, - otherwise, - youControlCommander, - distinctNames, - opponentDamagedThisTurn, - attackedWithCreatures, - libraryAtMost, - - // card sections - card, - face, - faces, - }) -} +import { createApi } from './source-api.js' +import { CardSection, Face, Faces } from './source-card.js' +import { Selector, asAbilityArray } from './source-validation.js' export function parseCardSource(source: string): ParsedCardSource { if (!source.trim()) throw new SourceParseError('the implementation is empty', 1) @@ -2518,3 +498,4 @@ export function parseCardSource(source: string): ParsedCardSource { throw new SourceParseError(error instanceof Error ? error.message : String(error), 1) } } + diff --git a/backend/src/effects/types.ts b/backend/src/effects/types.ts index 0f2315a..ac591de 100644 --- a/backend/src/effects/types.ts +++ b/backend/src/effects/types.ts @@ -45,6 +45,7 @@ export type Target = | { kind: 'self' } | { kind: 'trigger_subject' } | { kind: 'previous_target' } + | { kind: 'damaged' } | { kind: 'object'; selector: ObjectSelector; mode: 'target' | 'each' | 'choose'; count?: number; upTo?: boolean; includeSelf?: boolean } | { kind: 'player'; who: PlayerRef; mode: 'target' | 'each' } | { kind: 'player_or_planeswalker'; mode: 'target' } @@ -131,6 +132,8 @@ export type Condition = | { kind: 'source_tapped' } | { kind: 'source_untapped' } | { kind: 'source_attacking' } + | { kind: 'source_equipped' } + | { kind: 'source_enchanted' } | { kind: 'life_at_least'; player: PlayerRef; amount: number } | { kind: 'life_at_most'; player: PlayerRef; amount: number } | { kind: 'life_above_starting'; player: PlayerRef; amount: number } @@ -226,6 +229,7 @@ export type Effect = | { op: 'grant'; target: Target; keyword: string; value?: string; duration: Duration } | { op: 'put_counters'; target: Target; counter: string; amount: Value } | { op: 'remove_counters'; target: Target; counter: string; amount: Value } + | { op: 'double_counters'; target: Target; counter?: string } | { op: 'proliferate' } | { op: 'create_token'; player: PlayerRef; amount: Value; token: TokenSpec; copyOf?: Target; notLegendary?: boolean; attachTo?: Target } | { op: 'destroy'; target: Target } @@ -248,7 +252,7 @@ export type Effect = | { op: 'attach'; target: Target } | { op: 'restriction'; target: Target; rule: 'cant_attack' | 'cant_block' | 'doesnt_untap'; duration: Duration } | { op: 'keyword_action'; action: string; amount?: Value; detail?: string; target?: Target } - | { op: 'prevent_damage'; target: Target; amount: Value | 'all'; combatOnly?: boolean; duration: Duration } + | { op: 'prevent_damage'; target: Target; amount: Value | 'all'; combatOnly?: boolean; duration: Duration; global?: boolean; then?: Effect[]; source?: Target; sourceSelector?: ObjectSelector } | { op: 'gain_control'; target: Target; duration: Duration } | { op: 'emblem'; text: string } | { op: 'transform'; target: Target } @@ -264,6 +268,8 @@ export type Effect = | { op: 'exile_graveyards' } | { op: 'hideaway'; amount: Value } | { op: 'play_exiled'; player: PlayerRef; free?: boolean } + | { op: 'impulse'; player: PlayerRef; amount: Value; faceDown?: boolean } + | { op: 'exile_instead_of_dying'; target: Target } export type StaticEffect = | { op: 'pump'; target: Target; power: Value; toughness: Value } @@ -276,11 +282,15 @@ export type StaticEffect = | { op: 'control'; target: Target } | { op: 'choose'; what: 'creature_type' | 'color' | 'card_name' | 'player' | 'opponent' | 'number' } | { op: 'replacement'; what: 'dies' | 'leaves_battlefield' | 'discard' | 'draw'; instead: 'exile' | 'return_to_hand' | 'return_to_library' | 'prevent'; target?: Target } + | { op: 'replacement_amount'; what: 'life_gain' | 'damage' | 'draw' | 'energy'; multiplier: number; add?: number; combatOnly?: boolean; noncombatOnly?: boolean; sourceColor?: string; controller?: 'you' | 'any' } | { op: 'cost_reduction'; target: Target; amount?: Value; symbols?: string; condition?: Condition } | { op: 'cost_increase'; amount: Value; spellType?: 'noncreature' | 'creature' } | { op: 'search_restriction'; who: 'opponent' | 'you'; amount: Value } | { op: 'exile_instead_of_graveyard'; owner?: 'opponent' | 'you' } | { op: 'token_multiplier'; multiplier: number; who: 'you' | 'each_player'; creatureOnly?: boolean } + | { op: 'prevent_damage'; target: Target; amount: Value | 'all'; combatOnly?: boolean; duration: Duration; global?: boolean; sourceSelector?: ObjectSelector } + | { op: 'counter_multiplier'; target: Target; counter?: string; multiplier: number; add?: number } + | { op: 'token_replacement'; from: string[]; tokens: TokenSpec[]; who?: 'you' | 'each_player' } export type Ability = | KeywordAbility @@ -294,6 +304,7 @@ export type Ability = condition?: Condition effects: Effect[] optional: boolean + oncePerTurn?: boolean text: string } | { diff --git a/backend/src/game/game-actions.ts b/backend/src/game/game-actions.ts new file mode 100644 index 0000000..b5cbea9 --- /dev/null +++ b/backend/src/game/game-actions.ts @@ -0,0 +1,970 @@ +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + ManaSpec, + ObjectSelector, + PlayerRef, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from '../effects/types.js' +import type { + ActionOptions, + CardDefinition, + CombatAttack, + CombatBlock, + GameObject, + GameConfig, + ManaColor, + ManaPool, + MulliganState, + PendingChoice, + PendingSearch, + Phase, + PlayerState, + StackItem, + Step, + TargetChoice, +} from './types.js' +import { CREATURE_TYPES } from './creature-types.js' +import { predefinedToken } from './tokens.js' + +import { GameError, ResolvedTarget, EventContext, EffectContext, ContinuousEffect, DamageShield, ManaCost, CostReduction, MANA_COLORS, COLOR_NAMES, emptyPool, parseManaCost, reduceManaSymbols, manaValueOf, colorOfSymbol, tokenCard, capitalize, tokenFace, mulberry32 } from './game-helpers.js' +import { GameEffects } from './game-effects.js' + +export abstract class GameActions extends GameEffects { + playLand(playerId: string, cardId: string): GameObject { + this.requirePriority(playerId) + const player = this.getPlayer(playerId) + if (this.activePlayer !== playerId) throw new GameError('Only the active player may play a land') + if (this.phase !== 'precombat_main' && this.phase !== 'postcombat_main') { + throw new GameError('Lands can only be played during a main phase') + } + if (this.stack.length) throw new GameError('Cannot play a land while the stack is not empty') + if (player.landPlayedThisTurn) throw new GameError('Already played a land this turn') + const object = this.getObject(cardId) + if (!player.hand.includes(cardId) && !this.playableFromExile(playerId, object)) { + throw new GameError('Card is not in hand') + } + if (!this.isLand(object)) throw new GameError('That card is not a land') + + player.landPlayedThisTurn = true + this.moveToZone(object, 'battlefield', { controller: playerId, silent: false }) + this.passesInRow = 0 + this.logMessage(`${player.name} plays ${object.definition.name}`) + this.runStateBasedActions() + return object + } + + castSpell(playerId: string, cardId: string, options: ActionOptions = {}): StackItem { + this.requirePriority(playerId) + if (this.status !== 'active') throw new GameError('Game is not active') + const player = this.getPlayer(playerId) + const fromCommand = player.command.includes(cardId) + const object = this.getObject(cardId) + if (!fromCommand && !player.hand.includes(cardId) && !this.playableFromExile(playerId, object)) { + throw new GameError('Card is not in hand') + } + if (fromCommand && !object.isCommander) throw new GameError('That card cannot be cast from the command zone') + if (this.isLand(object)) throw new GameError('Land cards are played, not cast') + if (!this.canCastAtThisTime(playerId, object)) { + throw new GameError('That spell cannot be cast right now') + } + + const abilities = object.definition.abilities ?? [] + const overload = abilities.find((ability): ability is Extract => ability.kind === 'overload') + if (options.overload && !overload) throw new GameError('That spell has no overload') + const baseEffects = abilities.filter((ability): ability is Extract => ability.kind === 'spell') + .flatMap(ability => ability.effects) + const effects = options.overload ? this.overloadEffects(baseEffects) : baseEffects + const targets = this.selectTargets(effects, object, playerId, options.targets ?? [], options.mode ?? 0) + const tax = fromCommand ? (player.commanderCasts[object.id] ?? 0) * 2 : 0 + const taxSymbols = '{2}'.repeat(tax / 2) + const extra = this.spellCostIncrease(object) + const alternative = this.alternativeCostFor(object) + if (options.overload && overload) { + this.payMana(playerId, `${this.reducedSpellCost(object, overload.cost)}${taxSymbols}${extra ? `{${extra}}` : ''}`, options.x ?? 0) + } else if (alternative) { + this.payAlternativeCost(alternative, playerId, object) + if (extra) this.payMana(playerId, `{${extra}}`, 0) + } else { + const cost = this.reducedSpellCost(object, object.definition.manaCost ?? '') + this.payMana(playerId, `${cost}${taxSymbols}${extra ? `{${extra}}` : ''}`, options.x ?? 0) + } + + this.moveToZone(object, 'stack', { controller: playerId, silent: true }) + if (fromCommand) player.commanderCasts[object.id] = (player.commanderCasts[object.id] ?? 0) + 1 + const item: StackItem = { + id: this.generateId('stack'), + kind: 'spell', + source: object, + controller: playerId, + label: object.definition.name, + effects, + targets, + x: options.x ?? 0, + mode: options.mode ?? 0, + optional: abilities.some(ability => ability.kind === 'spell' && ability.optional), + } + this.stack.push(item) + player.spellsCastThisTurn++ + this.passesInRow = 0 + this.priority = this.nextAlivePlayer(playerId) + this.dispatchEvent({ kind: 'cast', player: playerId, subject: object, spell: object, spellItem: item }) + this.logMessage(`${player.name} casts ${object.definition.name}`) + return item + } + + protected alternativeCostFor(object: GameObject): Extract | undefined { + return (object.definition.abilities ?? []).find(ability => + ability.kind === 'alternative_cost' + && (!ability.condition || this.checkCondition(ability.condition, object))) as + | Extract + | undefined + } + + protected payAlternativeCost( + ability: Extract, + playerId: string, + source: GameObject, + ): void { + if (!ability.costs.length) return + this.payCosts(ability.costs, playerId, source, this.contextFor(source, playerId, [], 0, 0)) + } + + protected spellCostIncrease(object: GameObject): number { + let extra = 0 + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'cost_increase') continue + if (effect.spellType === 'noncreature' && this.isCreature(object)) continue + if (effect.spellType === 'creature' && !this.isCreature(object)) continue + extra += this.value(effect.amount, this.staticContext(source)) + } + } + return extra + } + + // shortcut: only static reducers on the battlefield; a card's own "this spell + // costs less" text is not applied yet. Upgrade when self-cost cards matter. + protected spellCostReduction(object: GameObject): CostReduction { + const reduction: CostReduction = { generic: 0, colored: [] } + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'cost_reduction' || effect.target.kind !== 'object') continue + if (!this.matchesSelector(object, effect.target.selector, source, object.zone)) continue + if (effect.amount) reduction.generic += this.value(effect.amount, this.staticContext(source)) + if (effect.symbols) { + const cost = parseManaCost(effect.symbols) + reduction.generic += cost.generic + reduction.colored.push(...cost.colored) + } + } + } + return reduction + } + + protected reducedSpellCost(object: GameObject, symbols: string): string { + return reduceManaSymbols(symbols, this.spellCostReduction(object)) + } + + // shortcut: overload only widens top-level targets; modal/conditional nested + // effects keep their original targets. Upgrade when an overload card nests them. + protected overloadEffects(effects: Effect[]): Effect[] { + return effects.map(effect => ('target' in effect && effect.target + ? { ...effect, target: this.overloadTarget(effect.target) } + : effect)) + } + + protected overloadTarget(target: Target): Target { + if (target.kind === 'object' || target.kind === 'player' || target.kind === 'spell') { + return { ...target, mode: 'each' } + } + return target + } + + activateAbility(playerId: string, sourceId: string, abilityIndex: number, options: ActionOptions = {}): StackItem | undefined { + this.requirePriority(playerId) + const source = this.getObject(sourceId) + if (source.zone !== 'battlefield') throw new GameError('Ability source is not on the battlefield') + if (source.controller !== playerId) throw new GameError('You do not control that permanent') + if (this.hasRestriction(source, 'cant_activate')) throw new GameError('That permanent cannot activate abilities') + const ability = (source.definition.abilities ?? [])[abilityIndex] + if (!ability || ability.kind !== 'activated') throw new GameError('That is not an activated ability') + if (ability.condition && !this.checkCondition(ability.condition, source)) throw new GameError('Ability condition is not met') + if (ability.timing === 'sorcery' && !this.isMainPhaseWithEmptyStack(playerId)) { + throw new GameError('Activate only as a sorcery') + } + if (ability.costs.some(cost => cost.kind === 'tap') && this.isCreature(source) + && source.enteredTurn >= this.turn && !this.hasKeyword(source, 'Haste')) { + throw new GameError('That creature has summoning sickness') + } + const activations = source.activations[abilityIndex] ?? 0 + if (ability.activationsPerTurn !== undefined && activations >= ability.activationsPerTurn) { + throw new GameError('Ability activation limit reached') + } + if (options.manaColor && !this.manaColorChoices(source, abilityIndex)?.includes(options.manaColor)) { + throw new GameError('That ability cannot produce that mana') + } + + const targets = this.selectTargets(ability.effects, source, playerId, options.targets ?? [], options.mode ?? 0) + const context = this.contextFor(source, playerId, targets, options.x ?? 0, options.mode ?? 0) + context.manaColor = options.manaColor + this.payCosts(ability.costs, playerId, source, context) + source.activations[abilityIndex] = activations + 1 + + // Mana abilities bypass the stack, which also makes auto-payment possible. + if (ability.effects.length && ability.effects.every(effect => effect.op === 'add_mana')) { + this.applyEffects(context, ability.effects) + this.passesInRow = 0 + this.logMessage(`${this.getPlayer(playerId).name} activates ${source.definition.name}`) + return undefined + } + + const item: StackItem = { + id: this.generateId('stack'), + kind: 'ability', + source, + controller: playerId, + label: ability.text, + effects: ability.effects, + targets, + x: options.x ?? 0, + mode: options.mode ?? 0, + optional: ability.optional, + } + this.stack.push(item) + this.passesInRow = 0 + this.priority = this.nextAlivePlayer(playerId) + this.logMessage(`${this.getPlayer(playerId).name} activates ${source.definition.name}`) + return item + } + + /** + * Whether the player could legally play a card from hand or the command zone + * right now. Used for the client's playable state and for auto-passing. + */ + canPlayCard(playerId: string, cardId: string): boolean { + if (this.status !== 'active' || this.priority !== playerId || this.pendingSearch || this.pendingChoice) return false + const player = this.getPlayer(playerId) + const fromCommand = player.command.includes(cardId) + const object = this.getObject(cardId) + if (!fromCommand && !player.hand.includes(cardId) && !this.playableFromExile(playerId, object)) return false + if (fromCommand && !object.isCommander) return false + + if (this.isLand(object)) { + return this.activePlayer === playerId + && (this.phase === 'precombat_main' || this.phase === 'postcombat_main') + && !this.stack.length + && !player.landPlayedThisTurn + } + + if (!this.canCastAtThisTime(playerId, object)) return false + const tax = fromCommand ? (player.commanderCasts[cardId] ?? 0) * 2 : 0 + const extra = this.spellCostIncrease(object) + const alternative = this.alternativeCostFor(object) + if (alternative) { + for (const cost of alternative.costs) { + if (cost.kind !== 'mana' || !this.canAffordMana(playerId, cost.symbols, 0)) return false + } + } else if (!this.canAffordMana( + playerId, + `${this.reducedSpellCost(object, object.definition.manaCost ?? '')}${'{2}'.repeat(tax / 2)}${extra ? `{${extra}}` : ''}`, + 0, + )) { + return false + } + if (alternative && extra && !this.canAffordMana(playerId, `{${extra}}`, 0)) return false + return this.hasLegalTargets(object, playerId) + } + + /** Junk and other impulse effects grant a one-turn play permission from exile. */ + protected playableFromExile(playerId: string, object: GameObject): boolean { + return object.zone === 'exile' + && object.owner === playerId + && object.playableFromExileTurn === this.turn + } + + /** + * Finishes one pick of a paused library search. Searches pause when several + * cards match so the player chooses instead of taking the first one. + */ + chooseSearchCard(playerId: string, cardId: string): void { + const pending = this.pendingSearch + if (!pending) throw new GameError('No search is waiting for a choice') + if (this.pendingChoice) throw new GameError('Resolve the pending choice first') + if (pending.playerId !== playerId) throw new GameError('You are not searching your library') + const object = this.searchCandidates(playerId).find(candidate => candidate.id === cardId) + if (!object) throw new GameError('That card is not a legal choice') + + this.moveSearchedCard(object, playerId, pending.destination, pending.tapped) + pending.remaining-- + if (pending.remaining > 0 && pending.split) { + pending.destination = pending.split.destination + pending.tapped = pending.split.tapped + pending.split = undefined + } + if (pending.remaining <= 0 || !this.searchCandidates(playerId).length) { + this.pendingSearch = undefined + if (pending.shuffle) this.shuffleLibrary(this.getPlayer(playerId)) + this.priority = this.getPlayer(this.activePlayer).lost + ? this.nextAlivePlayer(this.activePlayer) + : this.activePlayer + } + this.runStateBasedActions() + } + + /** Cards the pending search may pick, in library order. Empty for other players. */ + searchCandidates(playerId: string): GameObject[] { + const pending = this.pendingSearch + if (!pending || pending.playerId !== playerId) return [] + return this.findSearchCandidates(playerId, pending.selector, pending.zones) + } + + /** + * Every card in the zones a pending search can look at, in search order. This + * is what the chooser sees while deciding; others get an empty list. + */ + searchPool(playerId: string): GameObject[] { + const pending = this.pendingSearch + if (!pending || pending.playerId !== playerId) return [] + return this.searchableObjects(playerId, pending.zones) + } + + /** + * Answers the hideaway look: exiles the chosen card linked to the source and + * puts the rest on the bottom of the library in a random order. + */ + chooseHideawayCard(playerId: string, cardId: string): void { + const pending = this.pendingChoice + if (!pending || pending.what !== 'hideaway') throw new GameError('No hideaway choice is waiting') + if (pending.playerId !== playerId) throw new GameError('You are not choosing this hideaway card') + const looked = (pending.cardIds ?? []).map(id => this.getObject(id)) + const hidden = looked.find(object => object.id === cardId && object.zone === 'library') + if (!hidden) throw new GameError('That card is not a legal choice') + + this.pendingChoices.shift() + this.moveToZone(hidden, 'exile', { silent: true }) + const source = this.objects.get(pending.sourceId) + if (hidden.zone === 'exile') { + hidden.faceDown = true + if (source) source.linkedExile = [...(source.linkedExile ?? []), hidden.id] + } + + const rest = looked.filter(object => object.id !== hidden.id) + for (let index = rest.length - 1; index > 0; index--) { + const swap = Math.floor(this.rng() * (index + 1)) + const temp = rest[index] + rest[index] = rest[swap] + rest[swap] = temp + } + for (const object of rest) this.moveToZone(object, 'library', { silent: true }) + this.logMessage(`${this.getPlayer(playerId).name} hides away a card`) + } + + /** + * Answers an "as this enters, choose a creature type" prompt. The match API + * uses the `choose_type` action. + */ + chooseCreatureType(playerId: string, type: string): void { + const pending = this.pendingChoice + if (!pending || pending.what !== 'creature_type') throw new GameError('No choice is waiting') + if (pending.playerId !== playerId) throw new GameError('You are not choosing this permanent\'s type') + const chosen = CREATURE_TYPES.find(entry => entry.toLowerCase() === type.trim().toLowerCase()) + if (!chosen) throw new GameError('Choose a creature type') + const object = this.objects.get(pending.sourceId) + if (!object || object.zone !== 'battlefield') throw new GameError('That permanent is no longer on the battlefield') + object.chosenCreatureType = chosen + this.pendingChoices.shift() + this.logMessage(`${this.getPlayer(playerId).name} chooses ${chosen} for ${object.definition.name}`) + } + + /** + * Answers an "as this enters, choose a color" prompt. The match API uses the + * `choose_color` action. + */ + chooseColor(playerId: string, color: string): void { + const pending = this.pendingChoice + if (!pending || pending.what !== 'color') throw new GameError('No color choice is waiting') + if (pending.playerId !== playerId) throw new GameError('You are not choosing this permanent\'s color') + const chosen = COLOR_NAMES[color.trim().toLowerCase()] + if (!chosen) throw new GameError('Choose a color') + const object = this.objects.get(pending.sourceId) + if (!object || object.zone !== 'battlefield') throw new GameError('That permanent is no longer on the battlefield') + object.chosenColor = chosen + this.pendingChoices.shift() + this.logMessage(`${this.getPlayer(playerId).name} chooses ${color} for ${object.definition.name}`) + } + + /** + * Answers a "you may ..." prompt for the top stack item. The match API uses + * the `choose_optional` action. + */ + chooseOptional(playerId: string, accept: boolean): void { + const pending = this.pendingChoice + if (!pending || pending.what !== 'optional') throw new GameError('No optional effect is waiting') + if (pending.playerId !== playerId) throw new GameError('You are not choosing this optional effect') + const item = this.stack[this.stack.length - 1] + if (!item) throw new GameError('No effect is waiting') + this.pendingChoices.shift() + item.optionalAccepted = accept + this.resolveTop() + } + + /** + * Answers an "as this enters, you may pay a cost; otherwise it enters tapped" + * replacement. The match API uses the `choose_cost` action. + */ + chooseCostPayment(playerId: string, pay: boolean): void { + const pending = this.pendingChoice + if (!pending || pending.what !== 'pay_cost' || !pending.cost) throw new GameError('No cost payment is waiting') + if (pending.playerId !== playerId) throw new GameError('You are not choosing this payment') + const object = this.objects.get(pending.sourceId) + if (object && object.zone === 'battlefield') { + if (pay) { + const context = this.contextFor(object, playerId, [], 0, 0) + if (!this.tryPayUnless(pending.cost, playerId, object, context)) throw new GameError('Cannot pay the cost') + this.pendingChoices.shift() + const detail = pending.amount === undefined ? 'the cost' : `${pending.amount} life` + this.logMessage(`${this.getPlayer(playerId).name} pays ${detail} for ${object.definition.name}`) + return + } + this.pendingChoices.shift() + object.tapped = true + this.logMessage(`${object.definition.name} enters tapped`) + return + } + this.pendingChoices.shift() + } + + protected selectTargets( + effects: Effect[], + source: GameObject, + controller: string, + provided: TargetChoice[], + mode: number, + ): TargetChoice[] { + const selected: TargetChoice[] = [] + const queue = [...provided] + + const take = (target: Target, playerOnly: 'opponent' | 'any' | undefined): void => { + if (target.kind === 'self' || target.kind === 'trigger_subject' || target.kind === 'previous_target' || target.kind === 'damaged') return + if (target.kind === 'object' && target.mode === 'each') return + if (target.kind === 'player' && target.mode === 'each') return + const count = target.kind === 'object' ? target.count ?? 1 : 1 + const upTo = target.kind === 'object' && Boolean(target.upTo) + for (let i = 0; i < count; i++) { + const explicit = queue.shift() + if (explicit) { + if (!this.targetChoiceMatches(explicit, target, source, playerOnly)) throw new GameError('Invalid target') + selected.push(explicit) + continue + } + const legal = this.legalTargets(target, source, controller, playerOnly) + if (!legal.length) { + if (upTo) break + throw new GameError('No legal target') + } + selected.push(legal[0]) + } + } + + const walk = (list: Effect[]): void => { + for (const effect of list) { + if (effect.op === 'conditional') { + walk(effect.effects) + continue + } + if (effect.op === 'modal') { + const chosen = effect.modes[mode] ?? effect.modes[0] ?? [] + walk(chosen) + continue + } + if ('player' in effect && (effect.player === 'target_player' || effect.player === 'opponent')) { + const who = effect.player === 'opponent' ? 'opponent' : 'any' + take({ kind: 'player', who: effect.player, mode: 'target' }, who) + } + if ('target' in effect && effect.target) take(effect.target, undefined) + if (effect.op === 'create_token') { + if (effect.copyOf) take(effect.copyOf, undefined) + if (effect.attachTo) take(effect.attachTo, undefined) + } + if (effect.op === 'fight') { + take(effect.a, undefined) + take(effect.b, undefined) + } + if (effect.op === 'damage_divided') take(effect.target, undefined) + } + } + walk(effects) + return selected + } + + /** Legal choices for a card's targets, so the UI can offer only real targets. */ + legalTargetsForCard(playerId: string, cardId: string): TargetChoice[] { + const source = this.objects.get(cardId) + if (!source) return [] + const effects = (source.definition.abilities ?? []) + .filter((ability): ability is Extract => ability.kind === 'spell') + .flatMap(ability => ability.effects) + return this.collectTargets(effects, source, playerId, 0) + } + + /** Legal choices for an activated ability's targets. */ + legalTargetsForAbility(playerId: string, sourceId: string, abilityIndex: number): TargetChoice[] { + const source = this.objects.get(sourceId) + const ability = source?.definition.abilities?.[abilityIndex] + if (!source || !ability || ability.kind !== 'activated') return [] + return this.collectTargets(ability.effects, source, playerId, 0) + } + + protected collectTargets( + effects: Effect[], + source: GameObject, + controller: string, + mode: number, + ): TargetChoice[] { + const choices = new Map() + const add = (target: Target, playerOnly?: 'opponent' | 'any'): void => { + if (target.kind === 'self' || target.kind === 'trigger_subject' || target.kind === 'previous_target' || target.kind === 'damaged') return + if ((target.kind === 'object' || target.kind === 'player') && target.mode === 'each') return + for (const choice of this.legalTargets(target, source, controller, playerOnly)) { + choices.set(`${choice.kind}:${choice.id}`, choice) + } + } + const walk = (list: Effect[]): void => { + for (const effect of list) { + if (effect.op === 'conditional') { + walk(effect.effects) + continue + } + if (effect.op === 'modal') { + walk(effect.modes[mode] ?? effect.modes[0] ?? []) + continue + } + if ('player' in effect && (effect.player === 'target_player' || effect.player === 'opponent')) { + add( + { kind: 'player', who: effect.player, mode: 'target' }, + effect.player === 'opponent' ? 'opponent' : 'any', + ) + } + if ('target' in effect && effect.target) add(effect.target) + if (effect.op === 'create_token') { + if (effect.copyOf) add(effect.copyOf) + if (effect.attachTo) add(effect.attachTo) + } + if (effect.op === 'fight') { + add(effect.a) + add(effect.b) + } + if (effect.op === 'damage_divided') add(effect.target) + } + } + walk(effects) + return [...choices.values()] + } + + protected legalTargets( + target: Target, + source: GameObject, + controller: string, + playerOnly: 'opponent' | 'any' | undefined, + ): TargetChoice[] { + switch (target.kind) { + case 'object': { + return this.objectsMatching(target.selector, source) + .map(object => ({ kind: 'object' as const, id: object.id })) + } + case 'player': { + const players = playerOnly === 'opponent' ? this.opponentsOf(controller) : this.alivePlayers().map(player => player.id) + return players.map(id => ({ kind: 'player' as const, id })) + } + case 'player_or_planeswalker': { + const choices: TargetChoice[] = this.opponentsOf(controller).map(id => ({ kind: 'player' as const, id })) + for (const object of this.battlefieldObjects()) { + if (this.hasType(object, 'planeswalker')) choices.push({ kind: 'object', id: object.id }) + } + return choices + } + case 'any': { + const choices: TargetChoice[] = this.opponentsOf(controller).map(id => ({ kind: 'player' as const, id })) + for (const object of this.battlefieldObjects()) choices.push({ kind: 'object', id: object.id }) + return choices + } + case 'spell': + return [...this.stack].reverse() + .filter(item => item.kind === 'spell' && this.matchesSelector(item.source, target.selector, source, 'stack')) + .map(item => ({ kind: 'spell' as const, id: item.id })) + case 'ability': + return [...this.stack].reverse() + .filter(item => item.kind === 'ability') + .map(item => ({ kind: 'spell' as const, id: item.id })) + case 'divided': + return this.opponentsOf(controller).map(id => ({ kind: 'player' as const, id })) + default: + return [] + } + } + + protected targetChoiceMatches( + choice: TargetChoice, + target: Target, + source: GameObject, + playerOnly: 'opponent' | 'any' | undefined, + ): boolean { + const isOpponent = (id: string): boolean => this.opponentsOf(source.controller).includes(id) + if (choice.kind === 'player') { + if (target.kind === 'any' || target.kind === 'player' || target.kind === 'player_or_planeswalker') { + return playerOnly !== 'opponent' || isOpponent(choice.id) + } + return false + } + if (choice.kind === 'object') { + const object = this.objects.get(choice.id) + if (!object) return false + if (target.kind === 'any' || target.kind === 'player_or_planeswalker') { + return target.kind === 'any' ? object.zone === 'battlefield' : this.hasType(object, 'planeswalker') + } + if (target.kind !== 'object') return false + return this.matchesSelector(object, target.selector, source) + } + if (choice.kind === 'spell') { + const item = this.findStackItem(choice.id) + if (!item) return false + if (target.kind === 'spell') { + return item.kind === 'spell' && this.matchesSelector(item.source, target.selector, source, 'stack') + } + return target.kind === 'ability' && item.kind === 'ability' + } + return false + } + + protected resolveTargets(context: EffectContext, target: Target): ResolvedTarget[] { + let result: ResolvedTarget[] = [] + switch (target.kind) { + case 'self': + result = [{ kind: 'object', object: context.source }] + break + case 'trigger_subject': + if (context.triggerSubject) result = [{ kind: 'object', object: context.triggerSubject }] + break + case 'previous_target': + if (context.lastTarget) result = [context.lastTarget] + break + case 'damaged': + result = (context.lastDamaged ?? []).map(object => ({ kind: 'object' as const, object })) + break + case 'object': + if (target.mode === 'each') { + result = this.objectsMatching(target.selector, context.source) + .map(object => ({ kind: 'object' as const, object })) + } else { + const count = target.count ?? 1 + for (let i = 0; i < count; i++) { + const choice = context.targets.shift() + if (!choice) break + if (choice.kind === 'object') { + const object = this.objects.get(choice.id) + if (object) result.push({ kind: 'object', object }) + } + } + } + break + case 'player': + if (target.mode === 'each') { + result = this.playersForEffect(target.who, context).map(id => ({ kind: 'player' as const, id })) + } else { + const choice = context.targets.shift() + if (choice?.kind === 'player') result = [{ kind: 'player', id: choice.id }] + else { + const id = this.playersForEffect(target.who, context)[0] + if (id) result = [{ kind: 'player', id }] + } + } + break + case 'player_or_planeswalker': + case 'any': { + const choice = context.targets.shift() + if (choice?.kind === 'player') result = [{ kind: 'player', id: choice.id }] + else if (choice?.kind === 'object') { + const object = this.objects.get(choice.id) + if (object) result = [{ kind: 'object', object }] + } + break + } + case 'spell': + case 'ability': { + const choice = context.targets.shift() + if (choice?.kind === 'spell') { + const item = this.findStackItem(choice.id) + if (item) result = [{ kind: 'stack', item }] + } + break + } + case 'divided': { + const choice = context.targets.shift() + if (choice?.kind === 'player') result = [{ kind: 'player', id: choice.id }] + else if (choice?.kind === 'object') { + const object = this.objects.get(choice.id) + if (object) result = [{ kind: 'object', object }] + } + break + } + } + if (result.length) context.lastTarget = result[0] + return result + } + + protected playersForEffect(ref: PlayerRef, context: EffectContext): string[] { + const controller = context.source.controller + switch (ref) { + case 'you': + return [controller] + case 'opponent': { + const choice = context.targets.shift() + if (choice?.kind === 'player') return [choice.id] + return [this.opponentsOf(controller)[0]].filter(Boolean) + } + case 'each_opponent': + return this.opponentsOf(controller) + case 'each_player': + return this.alivePlayers().map(player => player.id) + case 'target_player': { + const choice = context.targets.shift() + return [choice?.kind === 'player' ? choice.id : undefined].filter((id): id is string => Boolean(id)) + } + case 'that_player': + return [context.eventPlayer ?? this.opponentsOf(controller)[0]].filter(Boolean) + case 'its_controller': + return context.lastTarget?.kind === 'object' ? [context.lastTarget.object.controller] : [] + case 'its_owner': + return context.lastTarget?.kind === 'object' ? [context.lastTarget.object.owner] : [] + } + } + + protected playersForValue(ref: PlayerRef, context: EffectContext): string[] { + const controller = context.source.controller + switch (ref) { + case 'you': + return [controller] + case 'opponent': + return [this.opponentsOf(controller)[0]].filter(Boolean) + case 'each_opponent': + return this.opponentsOf(controller) + case 'each_player': + return this.alivePlayers().map(player => player.id) + case 'target_player': + return [context.lastTarget?.kind === 'player' ? context.lastTarget.id : this.opponentsOf(controller)[0]].filter(Boolean) + case 'that_player': + return [context.eventPlayer ?? this.opponentsOf(controller)[0]].filter(Boolean) + case 'its_controller': + return context.lastTarget?.kind === 'object' ? [context.lastTarget.object.controller] : [] + case 'its_owner': + return context.lastTarget?.kind === 'object' ? [context.lastTarget.object.owner] : [] + } + } + + // --------------------------------------------------------------------------- + // Effects + // --------------------------------------------------------------------------- + + protected payCosts(costs: Cost[], playerId: string, source: GameObject, context: EffectContext): void { + for (const cost of costs) { + if (cost.kind !== 'mana' && !this.canPayNonManaCost(cost, playerId, source)) { + throw new GameError('Cannot pay ability cost') + } + } + for (const cost of costs) { + if (cost.kind === 'mana') this.payMana(playerId, cost.symbols, context.x) + else this.payNonManaCost(cost, playerId, source, context) + } + } + + protected canPayNonManaCost(cost: Cost, playerId: string, source: GameObject): boolean { + const player = this.getPlayer(playerId) + switch (cost.kind) { + case 'tap': + return !source.tapped + case 'untap': + return source.tapped + case 'tap_other': + return this.objectsMatching(cost.selector, source).some(object => !object.tapped) + case 'energy': + return player.energy >= cost.amount + case 'pay_life': + return player.life >= this.value(cost.amount, this.staticContext(source)) + case 'discard': + return player.hand.length >= this.value(cost.amount, this.staticContext(source)) + case 'sacrifice': + return this.objectsMatching(cost.selector, source).length > 0 + case 'sacrifice_self': + return source.zone === 'battlefield' + case 'exile_self': + return source.zone === 'graveyard' + case 'exile_from_graveyard': + return this.objectsMatching(cost.selector, source).length > 0 + case 'return_to_hand': + return this.objectsMatching(cost.selector, source).length > 0 + case 'put_counter': + return this.objectsMatching(cost.selector, source).length > 0 + case 'remove_counters': { + const amount = this.value(cost.amount, this.staticContext(source)) + const objects = cost.selector ? this.objectsMatching(cost.selector, source) : [source] + return objects.some(object => (object.counters[cost.counter] ?? 0) >= amount) + } + case 'mill': + return player.library.length >= (cost.amount.kind === 'number' ? cost.amount.value : 0) + case 'choice': + return cost.options.some(option => option.every(entry => entry.kind === 'mana' || this.canPayNonManaCost(entry, playerId, source))) + case 'waterbend': + return this.canPayMana(player, parseManaCost('{0}', 0)) + case 'reveal': + case 'behold': + case 'choose': + return true + default: + return false + } + } + + protected payNonManaCost(cost: Cost, playerId: string, source: GameObject, context: EffectContext): void { + const player = this.getPlayer(playerId) + switch (cost.kind) { + case 'tap': + source.tapped = true + return + case 'untap': + source.tapped = false + return + case 'tap_other': { + const target = this.objectsMatching(cost.selector, source).find(object => !object.tapped) + if (!target) throw new GameError('No permanent to tap') + target.tapped = true + return + } + case 'energy': + player.energy -= cost.amount + return + case 'loyalty': + this.addCounters(source, 'loyalty', cost.amount, true) + return + case 'pay_life': + this.loseLife(playerId, this.value(cost.amount, context)) + return + case 'discard': { + const amount = this.value(cost.amount, context) + this.discardCards(playerId, amount, cost.random, context) + return + } + case 'sacrifice': { + const target = this.objectsMatching(cost.selector, source)[0] + if (!target) throw new GameError('No permanent to sacrifice') + this.moveToZone(target, 'graveyard', { silent: false }) + return + } + case 'sacrifice_self': + this.moveToZone(source, 'graveyard', { silent: false }) + return + case 'exile_self': + this.moveToZone(source, 'exile', { silent: false }) + return + case 'exile_from_graveyard': { + const target = this.objectsMatching(cost.selector, source)[0] + if (!target) throw new GameError('No card to exile') + this.moveToZone(target, 'exile', { silent: false }) + return + } + case 'return_to_hand': { + const target = this.objectsMatching(cost.selector, source)[0] + if (!target) throw new GameError('No permanent to return') + this.moveToZone(target, 'hand', { silent: false }) + return + } + case 'put_counter': { + const target = this.objectsMatching(cost.selector, source)[0] + if (!target) throw new GameError('No permanent for counter') + this.addCounters(target, cost.counter, 1) + return + } + case 'remove_counters': { + const amount = this.value(cost.amount, context) + const objects = cost.selector ? this.objectsMatching(cost.selector, source) : [source] + const target = objects.find(object => (object.counters[cost.counter] ?? 0) >= amount) + if (!target) throw new GameError('No counters to remove') + target.counters[cost.counter] = Math.max(0, (target.counters[cost.counter] ?? 0) - amount) + return + } + case 'mill': + this.millCards(playerId, this.value(cost.amount, context)) + return + case 'reveal': + case 'behold': + case 'choose': + return + case 'choice': { + const option = cost.options.find(entries => entries.every(entry => entry.kind === 'mana' || this.canPayNonManaCost(entry, playerId, source))) + if (!option) throw new GameError('No payable cost choice') + this.payCosts(option, playerId, source, context) + return + } + case 'waterbend': + case 'blight': + case 'forage': + case 'collect_evidence': + throw new GameError(`Unsupported cost: ${cost.kind}`) + default: + throw new GameError(`Unsupported cost: ${(cost as { kind: string }).kind}`) + } + } + + // --------------------------------------------------------------------------- + // Targeting + // --------------------------------------------------------------------------- + + protected hasLegalTargets(source: GameObject, playerId: string, effects?: Effect[]): boolean { + const list = effects ?? (source.definition.abilities ?? []) + .filter((ability): ability is Extract => ability.kind === 'spell') + .flatMap(ability => ability.effects) + try { + this.selectTargets(list, source, playerId, [], 0) + return true + } catch (error) { + if (error instanceof GameError) return false + throw error + } + } + + protected isActivatedAbilityPlayable( + playerId: string, + source: GameObject, + index: number, + ability: Extract, + ): boolean { + if (source.zone !== 'battlefield' || source.controller !== playerId) return false + if (this.hasRestriction(source, 'cant_activate')) return false + if (ability.condition && !this.checkCondition(ability.condition, source)) return false + if (ability.timing === 'sorcery' && !this.isMainPhaseWithEmptyStack(playerId)) return false + if (ability.costs.some(cost => cost.kind === 'tap') && this.isCreature(source) + && source.enteredTurn >= this.turn && !this.hasKeyword(source, 'Haste')) { + return false + } + if (ability.activationsPerTurn !== undefined + && (source.activations[index] ?? 0) >= ability.activationsPerTurn) { + return false + } + for (const cost of ability.costs) { + if (cost.kind === 'mana') { + if (!this.canAffordMana(playerId, cost.symbols, 0)) return false + } else if (!this.canPayNonManaCost(cost, playerId, source)) { + return false + } + } + return this.hasLegalTargets(source, playerId, ability.effects) + } +} diff --git a/backend/src/game/game-base.ts b/backend/src/game/game-base.ts new file mode 100644 index 0000000..7c79fca --- /dev/null +++ b/backend/src/game/game-base.ts @@ -0,0 +1,468 @@ +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + ManaSpec, + ObjectSelector, + PlayerRef, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from '../effects/types.js' +import type { + ActionOptions, + CardDefinition, + CombatAttack, + CombatBlock, + GameObject, + GameConfig, + ManaColor, + ManaPool, + MulliganState, + PendingChoice, + PendingSearch, + Phase, + PlayerState, + StackItem, + Step, + TargetChoice, +} from './types.js' +import { CREATURE_TYPES } from './creature-types.js' +import { predefinedToken } from './tokens.js' + +import { GameError, ResolvedTarget, EventContext, EffectContext, ContinuousEffect, DamageShield, ManaCost, CostReduction, MANA_COLORS, COLOR_NAMES, emptyPool, parseManaCost, reduceManaSymbols, manaValueOf, colorOfSymbol, tokenCard, capitalize, tokenFace, mulberry32 } from './game-helpers.js' + +/** + * A deliberately small but real Magic rules engine: zones, priority, the stack, + * turn phases, combat, state-based actions, mana, triggered/activated/static + * abilities, and an interpreter for the compiled card-effect AST. + */ +export abstract class GameBase { + readonly players: PlayerState[] + + readonly objects = new Map() + + readonly stack: StackItem[] = [] + + readonly log: string[] = [] + + turn = 0 + + activePlayer = '' + + phase: Phase = 'beginning' + + step: Step = 'untap' + + priority = '' + + status: 'not_started' | 'mulligan' | 'active' | 'finished' = 'not_started' + winner?: string + + /** Opening-hand choices, keyed by player id. */ + readonly mulligans = new Map() + /** Blocks all other actions until the searching player picks a card. */ + pendingSearch?: PendingSearch + + /** "As this enters, choose..." prompts, in entry order. */ + readonly pendingChoices: PendingChoice[] = [] + + get pendingChoice(): PendingChoice | undefined { + return this.pendingChoices[0] + } + + protected readonly config: GameConfig + + protected readonly rng: () => number + + protected readonly startingHandSize: number + + protected readonly firstPlayer: string + + protected readonly continuousEffects: ContinuousEffect[] = [] + + protected readonly damageShields: DamageShield[] = [] + + protected passesInRow = 0 + + protected blockersDeclared = new Set() + + protected nextId = 0 + + protected autoManaDepth = 0 + + protected autoAdvanceDepth = 0 + + protected statDepth = 0 + + protected keywordDepth = 0 + + protected combatDamageDone = false + + protected readonly triggeredThisTurn = new Set() + + constructor(config: GameConfig) { + if (config.players.length < 2) throw new GameError('A game needs at least two players') + const ids = new Set(config.players.map(player => player.id)) + if (ids.size !== config.players.length) throw new GameError('Player ids must be unique') + + this.config = config + this.startingHandSize = config.startingHandSize ?? 7 + this.firstPlayer = config.firstPlayer ?? config.players[0].id + if (!ids.has(this.firstPlayer)) throw new GameError(`Unknown first player: ${this.firstPlayer}`) + this.rng = config.seed === undefined ? Math.random : mulberry32(config.seed) + + const startingLife = config.startingLife ?? 40 + this.players = config.players.map(player => ({ + id: player.id, + name: player.name ?? player.id, + life: player.life ?? startingLife, + lost: false, + manaPool: emptyPool(), + library: [], + hand: [], + graveyard: [], + exile: [], + battlefield: [], + command: [], + commanderDamage: {}, + commanderCasts: {}, + landPlayedThisTurn: false, + cardsDrawnThisTurn: 0, + lifeGainedThisTurn: 0, + spellsCastThisTurn: 0, + creaturesDiedThisTurn: 0, + nonlandPermanentsEnteredThisTurn: 0, + attackedThisTurn: false, + creaturesAttackedThisTurn: 0, + damageTakenThisTurn: 0, + energy: 0, + poison: 0, + })) + for (const player of this.players) { + this.mulligans.set(player.id, { count: 0, kept: false, bottom: 0 }) + } + + for (const playerConfig of config.players) { + for (const definition of playerConfig.deck) { + const object = this.createObject(definition, playerConfig.id) + this.getPlayer(playerConfig.id).library.push(object.id) + } + if (config.commander && playerConfig.commander) { + const commander = this.createObject(playerConfig.commander, playerConfig.id) + commander.isCommander = true + commander.zone = 'command' + this.getPlayer(playerConfig.id).command.push(commander.id) + this.getPlayer(playerConfig.id).commanderId = commander.id + } + } + } + + get player(): PlayerState { + return this.getPlayer(this.activePlayer) + } + + getPlayer(id: string): PlayerState { + const player = this.players.find(entry => entry.id === id) + if (!player) throw new GameError(`Unknown player: ${id}`) + return player + } + + getObject(id: string): GameObject { + const object = this.objects.get(id) + if (!object) throw new GameError(`Unknown object: ${id}`) + return object + } + + protected createObject(definition: CardDefinition, owner: string): GameObject { + const object: GameObject = { + id: this.generateId('card'), + definition, + owner, + controller: owner, + zone: 'library', + tapped: false, + damage: 0, + deathtouched: false, + counters: {}, + isToken: false, + enteredTurn: 0, + blockedBy: [], + attachments: [], + regenerationShields: 0, + activations: {}, + } + this.objects.set(object.id, object) + return object + } + + protected generateId(prefix: string): string { + this.nextId++ + return `${prefix}_${this.nextId}` + } + + protected logMessage(message: string): void { + this.log.push(message) + } + + abstract start(): void; + abstract keepHand(playerId: string): void; + abstract mulligan(playerId: string): void; + abstract putOnBottom(playerId: string, cardId: string): void; + protected abstract requireMulligan(playerId: string): MulliganState; + protected abstract beginGame(): void; + abstract addCard( + playerId: string, + definition: CardDefinition, + zone: Zone, + options?: { controller?: string; tapped?: boolean; silent?: boolean }, + ): GameObject; + abstract movePermanent(playerId: string, cardId: string, x: number, y: number): void; + abstract moveToZone( + objectOrId: GameObject | string, + zone: Zone, + options?: { controller?: string; tapped?: boolean; silent?: boolean; toTop?: boolean }, + ): GameObject; + abstract getPower(objectOrId: GameObject | string): number; + abstract getToughness(objectOrId: GameObject | string): number; + abstract hasKeyword(objectOrId: GameObject | string, keyword: string): boolean; + abstract playLand(playerId: string, cardId: string): GameObject; + abstract castSpell(playerId: string, cardId: string, options: ActionOptions ): StackItem; + protected abstract alternativeCostFor(object: GameObject): Extract | undefined; + protected abstract payAlternativeCost( + ability: Extract, + playerId: string, + source: GameObject, + ): void; + protected abstract spellCostIncrease(object: GameObject): number; + protected abstract spellCostReduction(object: GameObject): CostReduction; + protected abstract reducedSpellCost(object: GameObject, symbols: string): string; + protected abstract overloadEffects(effects: Effect[]): Effect[]; + protected abstract overloadTarget(target: Target): Target; + abstract activateAbility(playerId: string, sourceId: string, abilityIndex: number, options: ActionOptions ): StackItem | undefined; + abstract declareAttackers(playerId: string, attacks: CombatAttack[]): void; + abstract concede(playerId: string): void; + abstract declareBlockers(playerId: string, blocks: CombatBlock[]): void; + protected abstract defendingPlayers(): Set; + protected abstract finishBlocking(): void; + abstract resolveCombatDamage(): void; + abstract pass(playerId?: string): void; + abstract resolveStack(): void; + abstract endTurn(playerId: string): void; + abstract canPlayCard(playerId: string, cardId: string): boolean; + protected abstract playableFromExile(playerId: string, object: GameObject): boolean; + abstract chooseSearchCard(playerId: string, cardId: string): void; + abstract searchCandidates(playerId: string): GameObject[]; + abstract searchPool(playerId: string): GameObject[]; + abstract chooseHideawayCard(playerId: string, cardId: string): void; + abstract chooseCreatureType(playerId: string, type: string): void; + abstract chooseColor(playerId: string, color: string): void; + abstract chooseOptional(playerId: string, accept: boolean): void; + abstract chooseCostPayment(playerId: string, pay: boolean): void; + abstract autoAdvance(): void; + protected abstract beginTurn(): void; + protected abstract finishTurn(): void; + protected abstract advancePhase(): void; + protected abstract clearCombat(): void; + protected abstract resolveTop(): void; + protected abstract counterStackItem(item: StackItem): void; + protected abstract canCastAtThisTime(playerId: string, object: GameObject): boolean; + protected abstract isMainPhaseWithEmptyStack(playerId: string): boolean; + protected abstract payMana(playerId: string, symbols: string, x: number): void; + protected abstract canPayMana(player: PlayerState, cost: ManaCost): boolean; + protected abstract deductMana(player: PlayerState, cost: ManaCost): void; + protected abstract autoTapForMana(player: PlayerState, cost: ManaCost): void; + protected abstract findFreeManaAbility(source: GameObject): { index: number; ability: Extract } | undefined; + protected abstract activateManaSource(source: GameObject, cost: ManaCost): void; + protected abstract manaAbilityColor( + source: GameObject, + ability: Extract, + player: PlayerState, + cost: ManaCost, + ): ManaColor | undefined; + abstract manaColorChoices(source: GameObject, abilityIndex: number): ManaColor[] | undefined; + protected abstract manaAbilityAllowedColors( + source: GameObject, + ability: Extract, + ): Set | undefined; + protected abstract neededColor(player: PlayerState, cost: ManaCost, allowed?: Set): ManaColor | undefined; + protected abstract addMana(playerId: string, mana: ManaSpec, preferred?: ManaColor, source?: GameObject): void; + protected abstract landManaColors(playerId: string, opponentsOnly: boolean, seen?: Set): Set; + protected abstract anyColorRestrictionColors( + mana: ManaSpec, + playerId: string, + seen?: Set, + source?: GameObject, + ): Set | undefined; + protected abstract payCosts(costs: Cost[], playerId: string, source: GameObject, context: EffectContext): void; + protected abstract canPayNonManaCost(cost: Cost, playerId: string, source: GameObject): boolean; + protected abstract payNonManaCost(cost: Cost, playerId: string, source: GameObject, context: EffectContext): void; + protected abstract selectTargets( + effects: Effect[], + source: GameObject, + controller: string, + provided: TargetChoice[], + mode: number, + ): TargetChoice[]; + abstract legalTargetsForCard(playerId: string, cardId: string): TargetChoice[]; + abstract legalTargetsForAbility(playerId: string, sourceId: string, abilityIndex: number): TargetChoice[]; + protected abstract collectTargets( + effects: Effect[], + source: GameObject, + controller: string, + mode: number, + ): TargetChoice[]; + protected abstract legalTargets( + target: Target, + source: GameObject, + controller: string, + playerOnly: 'opponent' | 'any' | undefined, + ): TargetChoice[]; + protected abstract targetChoiceMatches( + choice: TargetChoice, + target: Target, + source: GameObject, + playerOnly: 'opponent' | 'any' | undefined, + ): boolean; + protected abstract resolveTargets(context: EffectContext, target: Target): ResolvedTarget[]; + protected abstract playersForEffect(ref: PlayerRef, context: EffectContext): string[]; + protected abstract playersForValue(ref: PlayerRef, context: EffectContext): string[]; + protected abstract applyEffects(context: EffectContext, effects: Effect[]): void; + protected abstract hideaway(context: EffectContext, effect: Extract): void; + protected abstract playExiledCard(playerId: string, object: GameObject, free: boolean | undefined): boolean; + protected abstract explore(context: EffectContext, effect: Extract): void; + protected abstract incubate(context: EffectContext, amount: Value | undefined): void; + protected abstract impulse(context: EffectContext): void; + protected abstract dig( + context: EffectContext, + effect: Extract, + ): void; + protected abstract tryPayUnless(cost: Cost, playerId: string | undefined, source: GameObject, context: EffectContext): boolean; + protected abstract addContinuousEffect( + source: GameObject, + controller: string, + effect: Extract, + affectedIds: string[], + duration: Duration, + ): void; + protected abstract continuousContext(effect: ContinuousEffect): EffectContext; + protected abstract staticContext(source: GameObject): EffectContext; + protected abstract contextFor( + source: GameObject, + controller: string, + targets: TargetChoice[], + x: number, + mode: number, + triggerSubject?: GameObject, + eventPlayer?: string, + eventAmount?: number, + ): EffectContext; + protected abstract value(value: Value, context: EffectContext): number; + protected abstract preventedAmount(target: ResolvedTarget, amount: number, combat: boolean, source?: GameObject): number; + /** Applies "if ... would ..., instead ..." amount replacements. */ + protected abstract replacementAmount( + what: 'life_gain' | 'damage' | 'draw' | 'energy', + playerId: string, + amount: number, + source?: GameObject, + combat?: boolean, + ): number; + protected abstract damageTarget( + target: ResolvedTarget, + amount: number, + source: GameObject, + combat: boolean, + ): void; + protected abstract destroyPermanent(object: GameObject): void; + protected abstract createToken(playerId: string, spec: TokenSpec, context: EffectContext): GameObject; + protected abstract createTokenCopy(playerId: string, source: GameObject, notLegendary?: boolean): GameObject; + protected abstract attach(source: GameObject, target: GameObject): void; + protected abstract addCounters(object: GameObject, counter: string, amount: number, silent?: boolean): void; + protected abstract dispatchEvent(event: EventContext): void; + protected abstract matchesTrigger(event: EventContext, trigger: TriggerEvent, source: GameObject): boolean; + protected abstract subjectMatches(target: Target, source: GameObject, event: EventContext): boolean; + protected abstract whoMatches(who: 'you' | 'opponent' | 'each_player', source: GameObject, eventPlayer: string | undefined): boolean; + protected abstract staticAbilities(): { source: GameObject; ability: Extract }[]; + protected abstract staticTargets(source: GameObject, target: Target): GameObject[]; + protected abstract tokenMultiplier(playerId: string, creatureToken: boolean): number; + protected abstract exilesInsteadOfGraveyard(object: GameObject): boolean; + protected abstract applyEntersReplacements(object: GameObject): void; + protected abstract queueEnterChoices(object: GameObject): void; + protected abstract hasRestriction(object: GameObject, rule: string): boolean; + protected abstract checkCondition(condition: Condition, source: GameObject, context?: EffectContext): boolean; + protected abstract dealCombatDamage(): void; + protected abstract dealCombatDamageRound(firstStrike: boolean): void; + protected abstract damageDefender(attacker: GameObject, amount: number): void; + protected abstract requireCanAttack(attacker: GameObject, playerId: string): void; + protected abstract hasMeaningfulAction(playerId: string): boolean; + protected abstract isActivatedAbilityPlayable( + playerId: string, + source: GameObject, + index: number, + ability: Extract, + ): boolean; + protected abstract hasLegalTargets(source: GameObject, playerId: string, effects?: Effect[]): boolean; + protected abstract canAffordMana(playerId: string, symbols: string, x: number): boolean; + protected abstract canAttackWithAny(playerId: string): boolean; + protected abstract canBlockWithAny(playerId: string): boolean; + protected abstract handleLeavesBattlefield(object: GameObject, destination: Zone): void; + protected abstract runStateBasedActions(): void; + protected abstract losePlayer(playerId: string): void; + protected abstract gainLife(playerId: string, amount: number): void; + protected abstract loseLife(playerId: string, amount: number): void; + protected abstract drawCard(playerId: string, silent: boolean): void; + protected abstract drawCards(playerId: string, amount: number): void; + protected abstract discardCards(playerId: string, amount: number, random: boolean | undefined, context: EffectContext): void; + protected abstract millCards(playerId: string, amount: number): void; + protected abstract searchLibrary( + playerId: string, + selector: ObjectSelector, + amount: number, + destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom', + tapped: boolean, + shuffle: boolean, + zones?: ('library' | 'graveyard')[], + split?: { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean }, + ): void; + protected abstract findSearchCandidates( + playerId: string, + selector: ObjectSelector, + zones?: ('library' | 'graveyard')[], + ): GameObject[]; + protected abstract searchableObjects(playerId: string, zones?: ('library' | 'graveyard')[]): GameObject[]; + protected abstract moveSearchedCard( + object: GameObject, + playerId: string, + destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom', + tapped: boolean, + ): void; + protected abstract searchLibraryLimit(playerId: string): number | undefined; + protected abstract shuffleLibrary(player: PlayerState): void; + protected abstract removeFromZone(object: GameObject): void; + protected abstract objectsMatching(selector: ObjectSelector, source: GameObject, zoneOverride?: Zone): GameObject[]; + protected abstract matchesSelector(object: GameObject, selector: ObjectSelector, source: GameObject, zoneOverride?: Zone): boolean; + protected abstract isCreature(object: GameObject): boolean; + protected abstract isLand(object: GameObject): boolean; + protected abstract isInstant(object: GameObject): boolean; + protected abstract isInstantOrSorcery(object: GameObject): boolean; + protected abstract isPermanent(object: GameObject): boolean; + protected abstract hasType(object: GameObject, type: string): boolean; + protected abstract hasKeywordForDefinition(definition: CardDefinition, keyword: string): boolean; + protected abstract battlefieldObjects(): GameObject[]; + protected abstract alivePlayers(): PlayerState[]; + protected abstract opponentsOf(playerId: string): string[]; + protected abstract nextAlivePlayer(playerId: string): string; + protected abstract requirePriority(playerId: string): void; + protected abstract emptyManaPools(): void; + protected abstract removeExpiringEffects(playerId: string): void; + protected abstract removeEndOfNextTurnEffects(playerId: string): void; + protected abstract removeEffectsByDuration(duration: Duration): void; + protected abstract counterStat(counters: Record, stat: 'power' | 'toughness'): number; + protected abstract findStackItem(id: string): StackItem | undefined; + protected abstract playerSource(playerId: string): GameObject; +} diff --git a/backend/src/game/game-combat.ts b/backend/src/game/game-combat.ts new file mode 100644 index 0000000..4bb652a --- /dev/null +++ b/backend/src/game/game-combat.ts @@ -0,0 +1,309 @@ +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + ManaSpec, + ObjectSelector, + PlayerRef, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from '../effects/types.js' +import type { + ActionOptions, + CardDefinition, + CombatAttack, + CombatBlock, + GameObject, + GameConfig, + ManaColor, + ManaPool, + MulliganState, + PendingChoice, + PendingSearch, + Phase, + PlayerState, + StackItem, + Step, + TargetChoice, +} from './types.js' +import { CREATURE_TYPES } from './creature-types.js' +import { predefinedToken } from './tokens.js' + +import { GameError, ResolvedTarget, EventContext, EffectContext, ContinuousEffect, DamageShield, ManaCost, CostReduction, MANA_COLORS, COLOR_NAMES, emptyPool, parseManaCost, reduceManaSymbols, manaValueOf, colorOfSymbol, tokenCard, capitalize, tokenFace, mulberry32 } from './game-helpers.js' +import { GameMana } from './game-mana.js' + +export abstract class GameCombat extends GameMana { + /** Declares attackers, beginning combat first if necessary. */ + declareAttackers(playerId: string, attacks: CombatAttack[]): void { + this.requirePriority(playerId) + if (this.stack.length) throw new GameError('Cannot declare attackers while the stack is not empty') + if (this.activePlayer !== playerId) throw new GameError('Only the active player can attack') + if (this.phase === 'precombat_main') { + this.phase = 'combat' + this.step = 'declare_attackers' + this.dispatchEvent({ kind: 'begin_combat', player: playerId }) + } + if (this.phase !== 'combat' || this.step !== 'declare_attackers') { + throw new GameError('Not in the declare attackers step') + } + + const seen = new Set() + for (const attack of attacks) { + if (seen.has(attack.attackerId)) throw new GameError('A creature can only attack once') + seen.add(attack.attackerId) + const attacker = this.getObject(attack.attackerId) + this.requireCanAttack(attacker, playerId) + const defender = this.getPlayer(attack.defenderId) + if (defender.id === playerId) throw new GameError('A player cannot attack themselves') + if (attacks.length === 1 && this.hasRestriction(attacker, 'cant_attack_alone')) { + throw new GameError('That creature cannot attack alone') + } + attacker.attacking = attack.defenderId + if (!this.hasKeyword(attacker, 'Vigilance')) attacker.tapped = true + this.getPlayer(playerId).attackedThisTurn = true + this.getPlayer(playerId).creaturesAttackedThisTurn++ + this.dispatchEvent({ kind: 'attacks', player: playerId, subject: attacker }) + } + + this.step = attacks.length ? 'declare_blockers' : 'end_combat' + this.blockersDeclared.clear() + this.passesInRow = 0 + this.priority = this.nextAlivePlayer(playerId) + this.logMessage(`${this.getPlayer(playerId).name} attacks with ${attacks.length} creature(s)`) + } + + /** Declares blockers for the current combat. */ + declareBlockers(playerId: string, blocks: CombatBlock[]): void { + if (this.phase !== 'combat' || this.step !== 'declare_blockers') throw new GameError('Not in the declare blockers step') + if (this.stack.length) throw new GameError('Cannot declare blockers while the stack is not empty') + if (this.pendingSearch) throw new GameError('Choose a card from your library first') + if (this.pendingChoice) throw new GameError('Resolve the pending choice first') + if (this.priority !== playerId) throw new GameError('You do not have priority') + + const seen = new Set() + for (const block of blocks) { + if (seen.has(block.blockerId)) throw new GameError('A creature can only block once') + seen.add(block.blockerId) + const blocker = this.getObject(block.blockerId) + const attacker = this.getObject(block.attackerId) + if (blocker.controller !== playerId) throw new GameError('You do not control that blocker') + if (blocker.zone !== 'battlefield' || attacker.zone !== 'battlefield') throw new GameError('Object is not on the battlefield') + if (!this.isCreature(blocker)) throw new GameError('Only creatures can block') + if (blocker.tapped) throw new GameError('Tapped creatures cannot block') + if (blocker.blocking) throw new GameError('Creature is already blocking') + if (attacker.attacking !== playerId) throw new GameError('That creature is not attacking you') + if (this.hasRestriction(blocker, 'cant_block')) throw new GameError('That creature cannot block') + if (blocks.length === 1 && this.hasRestriction(blocker, 'cant_block_alone')) { + throw new GameError('That creature cannot block alone') + } + if (this.hasRestriction(attacker, 'cant_be_blocked')) throw new GameError('That creature cannot be blocked') + if (attacker.blockedBy.length > 0 && this.hasRestriction(attacker, 'cant_be_blocked_by_more_than_one')) { + throw new GameError('That creature cannot be blocked by more than one creature') + } + for (const effect of this.restrictionEffects(attacker, 'cant_be_blocked_by_power')) { + const limit = effect.value ? this.value(effect.value, this.staticContext(attacker)) : 0 + const power = this.getPower(blocker) + if (effect.comparison === 'or_less' ? power <= limit : power >= limit) { + throw new GameError('That creature cannot block this attacker') + } + } + if (this.hasRestriction(blocker, 'can_block_only_flying') && !this.hasKeyword(attacker, 'Flying')) { + throw new GameError('That creature can block only flyers') + } + if (this.hasKeyword(attacker, 'Flying') && !this.hasKeyword(blocker, 'Flying') && !this.hasKeyword(blocker, 'Reach')) { + throw new GameError('That creature cannot block a flyer') + } + blocker.blocking = attacker.id + attacker.blockedBy.push(blocker.id) + this.dispatchEvent({ kind: 'blocks', player: playerId, subject: blocker }) + } + + this.blockersDeclared.add(playerId) + this.logMessage(`${this.getPlayer(playerId).name} declares ${blocks.length} blocker(s)`) + if ([...this.defendingPlayers()].every(id => this.blockersDeclared.has(id))) { + this.finishBlocking() + } else { + this.passesInRow = 0 + this.priority = this.nextAlivePlayer(playerId) + } + } + + protected defendingPlayers(): Set { + return new Set(this.battlefieldObjects() + .filter(object => object.attacking) + .map(object => object.attacking as string)) + } + + protected finishBlocking(): void { + this.step = 'combat_damage' + this.combatDamageDone = false + this.passesInRow = 0 + this.priority = this.activePlayer + } + + /** Resolves the combat damage step. Also runs automatically when both players pass. */ + resolveCombatDamage(): void { + if (this.phase !== 'combat' || this.step !== 'combat_damage') throw new GameError('Not in the combat damage step') + if (this.combatDamageDone) throw new GameError('Combat damage has already been dealt') + this.combatDamageDone = true + this.dealCombatDamage() + this.runStateBasedActions() + } + + protected dealCombatDamage(): void { + const attackers = this.battlefieldObjects().filter(object => object.attacking) + const anyFirstStrike = attackers.some(object => this.hasKeyword(object, 'First strike') || this.hasKeyword(object, 'Double strike')) + || attackers.some(object => object.blockedBy + .map(id => this.objects.get(id)) + .some(blocker => blocker && (this.hasKeyword(blocker, 'First strike') || this.hasKeyword(blocker, 'Double strike')))) + + if (anyFirstStrike) this.dealCombatDamageRound(true) + this.dealCombatDamageRound(false) + this.step = 'end_combat' + this.passesInRow = 0 + this.priority = this.activePlayer + } + + protected dealCombatDamageRound(firstStrike: boolean): void { + for (const attacker of this.battlefieldObjects()) { + if (attacker.zone !== 'battlefield' || !attacker.attacking) continue + const doubleStrike = this.hasKeyword(attacker, 'Double strike') + const first = this.hasKeyword(attacker, 'First strike') + if (firstStrike ? (!first && !doubleStrike) : (first && !doubleStrike)) continue + + let power = this.getPower(attacker) + const blockers = attacker.blockedBy + .map(id => this.objects.get(id)) + .filter((object): object is GameObject => Boolean(object && object.zone === 'battlefield' && object.blocking === attacker.id)) + const deathtouch = this.hasKeyword(attacker, 'Deathtouch') + const trample = this.hasKeyword(attacker, 'Trample') + + if (!blockers.length) { + this.damageDefender(attacker, power) + } else { + let remaining = power + for (let index = 0; index < blockers.length && remaining > 0; index++) { + const blocker = blockers[index] + const lethal = deathtouch ? 1 : Math.max(0, this.getToughness(blocker) - blocker.damage) + const assign = index === blockers.length - 1 && !trample + ? remaining + : Math.min(remaining, Math.max(lethal, 1)) + if (assign <= 0) continue + this.damageTarget({ kind: 'object', object: blocker }, assign, attacker, true) + remaining -= assign + } + if (trample && remaining > 0) this.damageDefender(attacker, remaining) + + for (const blocker of blockers) { + if (blocker.zone !== 'battlefield' || blocker.blocking !== attacker.id) continue + const blockerDouble = this.hasKeyword(blocker, 'Double strike') + const blockerFirst = this.hasKeyword(blocker, 'First strike') + if (firstStrike ? (!blockerFirst && !blockerDouble) : (blockerFirst && !blockerDouble)) continue + this.damageTarget({ kind: 'object', object: attacker }, this.getPower(blocker), blocker, true) + } + } + } + this.runStateBasedActions() + } + + protected damageDefender(attacker: GameObject, amount: number): void { + const defenderId = attacker.attacking + if (!defenderId) return + const player = this.players.find(entry => entry.id === defenderId) + if (player) { + this.damageTarget({ kind: 'player', id: player.id }, amount, attacker, true) + return + } + const permanent = this.objects.get(defenderId) + if (permanent?.zone === 'battlefield') { + this.damageTarget({ kind: 'object', object: permanent }, amount, attacker, true) + } + } + + protected requireCanAttack(attacker: GameObject, playerId: string): void { + if (attacker.zone !== 'battlefield') throw new GameError('Attacker is not on the battlefield') + if (attacker.controller !== playerId) throw new GameError('You do not control that creature') + if (!this.isCreature(attacker)) throw new GameError('Only creatures can attack') + if (attacker.tapped) throw new GameError('Tapped creatures cannot attack') + if (attacker.enteredTurn >= this.turn && !this.hasKeyword(attacker, 'Haste')) { + throw new GameError('That creature has summoning sickness') + } + if (this.hasRestriction(attacker, 'cant_attack')) throw new GameError('That creature cannot attack') + } + + protected canAttackWithAny(playerId: string): boolean { + return this.battlefieldObjects().some(object => { + try { + this.requireCanAttack(object, playerId) + return true + } catch (error) { + if (error instanceof GameError) return false + throw error + } + }) + } + + /** Restriction effects with the given rule that currently affect an object. */ + protected restrictionEffects(object: GameObject, rule: string): Extract[] { + const found: Extract[] = [] + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'restriction' || effect.rule !== rule) continue + if (this.staticTargets(source, effect.target).some(target => target.id === object.id)) found.push(effect) + } + } + for (const continuous of this.continuousEffects) { + if (continuous.effect.op !== 'restriction' || continuous.effect.rule !== rule) continue + if (continuous.affectedIds.includes(object.id)) found.push(continuous.effect) + } + return found + } + + protected canBlockWithAny(playerId: string): boolean { + const attackers = this.battlefieldObjects().filter(object => object.attacking === playerId) + if (!attackers.length) return false + return this.battlefieldObjects().some(blocker => { + if (blocker.controller !== playerId) return false + if (!this.isCreature(blocker) || blocker.tapped || blocker.blocking) return false + if (this.hasRestriction(blocker, 'cant_block')) return false + return attackers.some(attacker => { + if (this.hasRestriction(attacker, 'cant_be_blocked')) return false + if (this.hasRestriction(blocker, 'can_block_only_flying') && !this.hasKeyword(attacker, 'Flying')) return false + const blockedByPower = this.restrictionEffects(attacker, 'cant_be_blocked_by_power').some(effect => { + const limit = effect.value ? this.value(effect.value, this.staticContext(attacker)) : 0 + const power = this.getPower(blocker) + return effect.comparison === 'or_less' ? power <= limit : power >= limit + }) + if (blockedByPower) return false + return !this.hasKeyword(attacker, 'Flying') + || this.hasKeyword(blocker, 'Flying') + || this.hasKeyword(blocker, 'Reach') + }) + }) + } + + // --------------------------------------------------------------------------- + // Zones, state-based actions, and utilities + // --------------------------------------------------------------------------- + + protected clearCombat(): void { + this.blockersDeclared.clear() + for (const object of this.objects.values()) { + if (object.zone !== 'battlefield') continue + object.attacking = undefined + object.blockedBy = [] + object.blocking = undefined + } + this.combatDamageDone = false + } + + // --------------------------------------------------------------------------- + // Stack + // --------------------------------------------------------------------------- +} diff --git a/backend/src/game/game-effects.ts b/backend/src/game/game-effects.ts new file mode 100644 index 0000000..687b822 --- /dev/null +++ b/backend/src/game/game-effects.ts @@ -0,0 +1,1220 @@ +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + ManaSpec, + ObjectSelector, + PlayerRef, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from '../effects/types.js' +import type { + ActionOptions, + CardDefinition, + CombatAttack, + CombatBlock, + GameObject, + GameConfig, + ManaColor, + ManaPool, + MulliganState, + PendingChoice, + PendingSearch, + Phase, + PlayerState, + StackItem, + Step, + TargetChoice, +} from './types.js' +import { CREATURE_TYPES } from './creature-types.js' +import { predefinedToken } from './tokens.js' + +import { GameError, ResolvedTarget, EventContext, EffectContext, ContinuousEffect, DamageShield, ManaCost, CostReduction, MANA_COLORS, COLOR_NAMES, emptyPool, parseManaCost, reduceManaSymbols, manaValueOf, colorOfSymbol, tokenCard, capitalize, tokenFace, mulberry32 } from './game-helpers.js' +import { GameZones } from './game-zones.js' + +export abstract class GameEffects extends GameZones { + private readonly preventedFollowUps: { shield: DamageShield; amount: number }[] = [] + + protected applyEffects(context: EffectContext, effects: Effect[]): void { + for (const effect of effects) { + if (this.status === 'finished') return + switch (effect.op) { + case 'damage': { + const targets = this.resolveTargets(context, effect.target) + const amount = Math.max(0, this.value(effect.amount, context)) + let source = context.source + if (effect.source) { + const sourceTarget = this.resolveTargets(context, effect.source)[0] + if (sourceTarget?.kind === 'object') source = sourceTarget.object + } + for (const target of targets) this.damageTarget(target, amount, source, false) + context.lastDamaged = targets.filter((target): target is Extract => target.kind === 'object').map(target => target.object) + break + } + case 'draw': { + const amount = this.value(effect.amount, context) + for (const playerId of this.playersForEffect(effect.player, context)) this.drawCards(playerId, amount) + break + } + case 'discard': { + const amount = this.value(effect.amount, context) + for (const playerId of this.playersForEffect(effect.player, context)) { + this.discardCards(playerId, amount, effect.random, context) + } + break + } + case 'mill': { + const amount = this.value(effect.amount, context) + for (const playerId of this.playersForEffect(effect.player, context)) this.millCards(playerId, amount) + break + } + case 'life': { + const amount = this.value(effect.amount, context) + for (const playerId of this.playersForEffect(effect.player, context)) { + if (effect.mode === 'gain') this.gainLife(playerId, amount) + else this.loseLife(playerId, amount) + } + break + } + case 'pump': { + const targets = this.resolveTargets(context, effect.target) + const ids = targets.filter((target): target is Extract => target.kind === 'object') + .map(target => target.object.id) + this.addContinuousEffect(context.source, context.controller, effect, ids, effect.duration) + break + } + case 'set_pt': { + const targets = this.resolveTargets(context, effect.target) + const ids = targets.filter((target): target is Extract => target.kind === 'object') + .map(target => target.object.id) + this.addContinuousEffect(context.source, context.controller, effect, ids, effect.duration) + break + } + case 'grant': { + const targets = this.resolveTargets(context, effect.target) + const ids = targets.filter((target): target is Extract => target.kind === 'object') + .map(target => target.object.id) + this.addContinuousEffect(context.source, context.controller, effect, ids, effect.duration) + break + } + case 'put_counters': { + const amount = this.value(effect.amount, context) + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind === 'object') this.addCounters(target.object, effect.counter, amount) + } + break + } + case 'remove_counters': { + const amount = this.value(effect.amount, context) + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind !== 'object') continue + target.object.counters[effect.counter] = Math.max(0, (target.object.counters[effect.counter] ?? 0) - amount) + } + break + } + case 'double_counters': { + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind !== 'object') continue + const counters = target.object.counters + for (const key of effect.counter ? [effect.counter] : Object.keys(counters)) { + counters[key] = (counters[key] ?? 0) * 2 + } + } + break + } + case 'proliferate': { + for (const object of this.battlefieldObjects()) { + for (const counter of Object.keys(object.counters)) { + if (object.counters[counter] > 0) object.counters[counter]++ + } + } + break + } + case 'create_token': { + const amount = Math.max(0, this.value(effect.amount, context)) + const players = this.playersForEffect(effect.player, context) + const created: GameObject[] = [] + for (const playerId of players) { + const source = effect.copyOf + ? this.resolveTargets(context, effect.copyOf).find(target => target.kind === 'object') + : undefined + const creatureToken = source?.kind === 'object' + ? this.isCreature(source.object) + : effect.token.types.includes('creature') + const count = amount * this.tokenMultiplier(playerId, creatureToken) + const replacement = effect.copyOf ? undefined : this.tokenReplacement(playerId, effect.token) + const specs = replacement ?? [effect.token] + for (let i = 0; i < count; i++) { + if (effect.copyOf) { + if (source?.kind === 'object') created.push(this.createTokenCopy(playerId, source.object, effect.notLegendary)) + } else { + for (const spec of specs) created.push(this.createToken(playerId, spec, context)) + } + } + } + if (created.length) context.lastTarget = { kind: 'object', object: created[created.length - 1] } + if (effect.attachTo) { + const target = this.resolveTargets(context, effect.attachTo)[0] + if (target?.kind === 'object') { + for (const token of created) this.attach(token, target.object) + } + } + break + } + case 'destroy': { + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind === 'object') this.destroyPermanent(target.object) + } + break + } + case 'exile': { + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind === 'object') this.moveToZone(target.object, 'exile', { silent: false }) + } + break + } + case 'exile_graveyards': { + for (const player of this.players) { + for (const id of [...player.graveyard]) this.moveToZone(id, 'exile', { silent: false }) + } + break + } + case 'sacrifice': { + const players = this.playersForEffect(effect.player, context) + if (effect.unless && this.tryPayUnless(effect.unless, players[0], context.source, context)) break + const targets = this.resolveTargets(context, effect.target) + for (const target of targets) { + if (target.kind === 'object' && players.includes(target.object.controller)) { + this.moveToZone(target.object, 'graveyard', { silent: false }) + } + } + break + } + case 'counter': { + if (effect.unless && this.tryPayUnless(effect.unless, context.controller, context.source, context)) break + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind !== 'stack') continue + const spellSource = target.item.source + const intrinsic = (spellSource.definition.abilities ?? []).some(ability => + ability.kind === 'static' + && ability.effects.some(effect => effect.op === 'restriction' + && effect.rule === 'cant_be_countered' + && effect.target.kind === 'self')) + if (intrinsic || this.hasRestriction(spellSource, 'cant_be_countered')) continue + this.counterStackItem(target.item) + } + break + } + case 'return_to_hand': { + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind === 'object') this.moveToZone(target.object, 'hand', { silent: false }) + } + break + } + case 'return_to_battlefield': { + const targets = this.resolveTargets(context, effect.target) + for (const target of targets) { + if (target.kind !== 'object') continue + this.moveToZone(target.object, 'battlefield', { + controller: context.controller, + tapped: effect.tapped, + silent: false, + }) + if (effect.counters) { + this.addCounters(target.object, effect.counters.counter, this.value(effect.counters.amount, context)) + } + } + break + } + case 'put_on_top': { + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind === 'object') this.moveToZone(target.object, 'library', { toTop: true, silent: false }) + } + break + } + case 'tap': { + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind === 'object') target.object.tapped = true + } + break + } + case 'untap': { + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind === 'object') target.object.tapped = false + } + break + } + case 'scry': + case 'surveil': + break + case 'search': { + const amount = Math.max(0, this.value(effect.amount, context)) + for (const playerId of this.playersForEffect(effect.player, context)) { + this.searchLibrary(playerId, effect.selector, amount, effect.destination, effect.tapped, effect.shuffle, effect.zones, effect.split) + } + break + } + case 'shuffle': { + for (const playerId of this.playersForEffect(effect.player, context)) this.shuffleLibrary(this.getPlayer(playerId)) + break + } + case 'add_mana': { + for (const playerId of this.playersForEffect(effect.player, context)) this.addMana(playerId, effect.mana, context.manaColor, context.source) + break + } + case 'fight': { + const a = this.resolveTargets(context, effect.a)[0] + const b = this.resolveTargets(context, effect.b)[0] + if (a?.kind === 'object' && b?.kind === 'object') { + const aPower = this.getPower(a.object) + const bPower = this.getPower(b.object) + this.damageTarget({ kind: 'object', object: a.object }, bPower, b.object, false) + this.damageTarget({ kind: 'object', object: b.object }, aPower, a.object, false) + } + break + } + case 'regenerate': { + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind === 'object') target.object.regenerationShields++ + } + break + } + case 'energy': { + for (const playerId of this.playersForEffect(effect.player, context)) { + this.getPlayer(playerId).energy += this.replacementAmount('energy', playerId, this.value(effect.amount, context)) + } + break + } + case 'attach': { + const target = this.resolveTargets(context, effect.target)[0] + if (target?.kind === 'object') this.attach(context.source, target.object) + break + } + case 'restriction': { + const targets = this.resolveTargets(context, effect.target) + const ids = targets.filter((target): target is Extract => target.kind === 'object') + .map(target => target.object.id) + this.addContinuousEffect(context.source, context.controller, effect, ids, effect.duration) + break + } + case 'keyword_action': + if (effect.action === 'explore') this.explore(context, effect) + else if (effect.action === 'incubate') this.incubate(context, effect.amount) + else if (effect.action === 'impulse') this.impulse(context) + break + case 'prevent_damage': { + const recipients = effect.global ? [] : this.resolveTargets(context, effect.target) + const ids = new Set(recipients + .flatMap(target => target.kind === 'player' ? [target.id] : target.kind === 'object' ? [target.object.id] : [])) + if (!effect.global && !ids.size) break + let sourceIds: Set | undefined + if (effect.source) { + const chosen = this.resolveTargets(context, effect.source) + .flatMap(target => target.kind === 'object' ? [target.object.id] : []) + if (!chosen.length) break + sourceIds = new Set(chosen) + } + this.damageShields.push({ + ids, + global: Boolean(effect.global), + ...(sourceIds ? { sourceIds } : {}), + ...(effect.sourceSelector ? { sourceSelector: effect.sourceSelector } : {}), + remaining: effect.amount === 'all' ? 'all' : Math.max(0, this.value(effect.amount, context)), + combatOnly: Boolean(effect.combatOnly), + ...(effect.then ? { then: effect.then } : {}), + sourceId: context.source.id, + controller: context.controller, + targets: [...context.targets], + ...(recipients.find(target => target.kind !== 'stack') + ? { lastTarget: recipients.find(target => target.kind !== 'stack') } + : {}), + }) + break + } + case 'gain_control': + case 'emblem': + case 'schedule': + case 'level_up': + case 'put_from_among': + case 'look_top': + break + case 'transform': { + const target = this.resolveTargets(context, effect.target)[0] + if (target?.kind === 'object' && target.object.backFace) { + const front = target.object.definition + target.object.definition = target.object.backFace + target.object.backFace = front + this.logMessage(`${target.object.definition.name} transforms`) + } + break + } + case 'pay': + try { + this.payCosts(effect.costs, context.controller, context.source, context) + } catch { + // "You may pay" — doing nothing is the legal choice when it is not payable. + } + break + case 'conditional': + if (this.checkCondition(effect.condition, context.source, context)) this.applyEffects(context, effect.effects) + break + case 'modal': { + const chosen = effect.modes[context.mode] ?? effect.modes[0] + if (chosen) this.applyEffects(context, chosen) + break + } + case 'dig': + this.dig(context, effect) + break + case 'damage_divided': { + const targets = this.resolveTargets(context, effect.target) + const amount = this.value(effect.amount, context) + if (targets.length) { + const each = Math.floor(amount / targets.length) + for (const target of targets) this.damageTarget(target, each, context.source, false) + } + break + } + case 'hideaway': + this.hideaway(context, effect) + break + case 'play_exiled': { + const playerId = this.playersForEffect(effect.player, context)[0] + const cardId = context.source.linkedExile?.find(id => this.getObject(id).zone === 'exile') + if (!playerId || !cardId) break + const object = this.getObject(cardId) + if (this.playExiledCard(playerId, object, effect.free)) { + context.source.linkedExile = context.source.linkedExile?.filter(id => id !== cardId) + } + break + } + case 'exile_instead_of_dying': { + for (const target of this.resolveTargets(context, effect.target)) { + if (target.kind === 'object') target.object.exileOnDeathTurn = this.turn + } + break + } + case 'impulse': { + const playerId = this.playersForEffect(effect.player, context)[0] + if (!playerId) break + const player = this.getPlayer(playerId) + const amount = this.value(effect.amount, context) + for (const id of player.library.slice(0, amount)) { + const card = this.getObject(id) + this.moveToZone(card, 'exile', { silent: true }) + if (card.zone !== 'exile') continue + card.faceDown = Boolean(effect.faceDown) + card.playableFromExileTurn = this.turn + this.logMessage(`${player.name} exiles ${card.definition.name} and may play it this turn`) + } + break + } + } + } + } + + protected hideaway(context: EffectContext, effect: Extract): void { + // The exiled card stays face down and is linked to the source until played. + const player = this.getPlayer(context.controller) + const amount = this.value(effect.amount, context) + const looked = player.library.slice(0, amount).map(id => this.getObject(id)) + if (!looked.length) return + if (looked.length === 1) { + this.moveToZone(looked[0], 'exile', { silent: true }) + if (looked[0].zone === 'exile') { + looked[0].faceDown = true + context.source.linkedExile = [...(context.source.linkedExile ?? []), looked[0].id] + } + this.logMessage(`${player.name} hides away a card`) + return + } + + this.pendingChoices.push({ + playerId: context.controller, + sourceId: context.source.id, + what: 'hideaway', + cardIds: looked.map(object => object.id), + }) + this.logMessage(`${player.name} looks at the top ${looked.length} cards of their library`) + } + + protected playExiledCard(playerId: string, object: GameObject, free: boolean | undefined): boolean { + if (!free) return false + if (this.isLand(object)) { + const player = this.getPlayer(playerId) + if (player.landPlayedThisTurn || !this.isMainPhaseWithEmptyStack(playerId)) return false + player.landPlayedThisTurn = true + this.moveToZone(object, 'battlefield', { controller: playerId, silent: false }) + this.logMessage(`${this.getPlayer(playerId).name} plays ${object.definition.name} from exile`) + return true + } + if (!this.canCastAtThisTime(playerId, object)) return false + + const effects = (object.definition.abilities ?? []) + .filter((ability): ability is Extract => ability.kind === 'spell') + .flatMap(ability => ability.effects) + let targets: TargetChoice[] + try { + targets = this.selectTargets(effects, object, playerId, [], 0) + } catch { + return false + } + + this.moveToZone(object, 'stack', { controller: playerId, silent: true }) + const item: StackItem = { + id: this.generateId('stack'), + kind: 'spell', + source: object, + controller: playerId, + label: object.definition.name, + effects, + targets, + x: 0, + mode: 0, + optional: (object.definition.abilities ?? []).some(ability => ability.kind === 'spell' && ability.optional), + } + this.stack.push(item) + this.getPlayer(playerId).spellsCastThisTurn++ + this.passesInRow = 0 + this.priority = this.nextAlivePlayer(playerId) + this.dispatchEvent({ kind: 'cast', player: playerId, subject: object, spell: object, spellItem: item }) + this.logMessage(`${this.getPlayer(playerId).name} casts ${object.definition.name} from exile`) + return true + } + + protected explore(context: EffectContext, effect: Extract): void { + const target = effect.target ? this.resolveTargets(context, effect.target)[0] : undefined + if (target?.kind !== 'object') return + const player = this.getPlayer(context.controller) + const cardId = player.library[0] + if (!cardId) return + const card = this.getObject(cardId) + if (this.isLand(card)) { + this.moveToZone(card, 'hand', { silent: false }) + this.logMessage(`${player.name} explores and puts ${card.definition.name} into their hand`) + return + } + this.addCounters(target.object, '+1/+1', 1) + // shortcut: the explored card always goes to the graveyard instead of + // asking whether to put it on top. Upgrade when the choice matters. + this.moveToZone(card, 'graveyard', { silent: false }) + this.logMessage(`${player.name} explores with ${target.object.definition.name}`) + } + + protected incubate(context: EffectContext, amount: Value | undefined): void { + const counters = amount ? Math.max(0, this.value(amount, context)) : 0 + const count = this.tokenMultiplier(context.controller, false) + for (let i = 0; i < count; i++) { + const token = this.createToken(context.controller, { + types: ['artifact'], + subtypes: ['incubator'], + colors: [], + }, context) + this.addCounters(token, '+1/+1', counters) + } + } + + protected impulse(context: EffectContext): void { + const player = this.getPlayer(context.controller) + const cardId = player.library[0] + if (!cardId) return + const card = this.getObject(cardId) + this.moveToZone(card, 'exile', { silent: false }) + card.playableFromExileTurn = this.turn + this.logMessage(`${player.name} exiles ${card.definition.name} and may play it this turn`) + } + + protected dig( + context: EffectContext, + effect: Extract, + ): void { + const player = this.getPlayer(context.controller) + const amount = this.value(effect.amount, context) + const top = player.library.slice(0, amount).map(id => this.getObject(id)) + const pickCount = this.value(effect.pick, context) + const picked = top.filter(object => !effect.pickSelector || this.matchesSelector(object, effect.pickSelector, context.source, 'library')) + .slice(0, pickCount) + for (const object of picked) { + if (effect.to === 'battlefield') { + this.moveToZone(object, 'battlefield', { controller: context.controller, tapped: effect.tapped, silent: false }) + } else { + this.moveToZone(object, 'hand', { silent: false }) + } + } + for (const object of top) { + if (picked.includes(object)) continue + if (effect.rest === 'graveyard') this.moveToZone(object, 'graveyard', { silent: false }) + else if (effect.rest === 'bottom') this.moveToZone(object, 'library', { silent: true }) + else this.moveToZone(object, 'library', { toTop: true, silent: true }) + } + } + + protected tryPayUnless(cost: Cost, playerId: string | undefined, source: GameObject, context: EffectContext): boolean { + if (!playerId) return false + try { + if (cost.kind === 'mana') { + this.payMana(playerId, cost.symbols, context.x) + } else { + if (!this.canPayNonManaCost(cost, playerId, source)) return false + this.payNonManaCost(cost, playerId, source, context) + } + return true + } catch { + return false + } + } + + protected addContinuousEffect( + source: GameObject, + controller: string, + effect: Extract, + affectedIds: string[], + duration: Duration, + ): void { + this.continuousEffects.push({ + id: this.generateId('effect'), + sourceId: source.id, + controller, + effect, + affectedIds, + duration, + createdTurn: this.turn, + }) + } + + protected continuousContext(effect: ContinuousEffect): EffectContext { + const source = this.objects.get(effect.sourceId) ?? this.playerSource(effect.controller) + return this.contextFor(source, effect.controller, [], 0, 0) + } + + protected staticContext(source: GameObject): EffectContext { + return this.contextFor(source, source.controller, [], 0, 0) + } + + protected contextFor( + source: GameObject, + controller: string, + targets: TargetChoice[], + x: number, + mode: number, + triggerSubject?: GameObject, + eventPlayer?: string, + eventAmount?: number, + ): EffectContext { + return { source, controller, targets: [...targets], x, mode, triggerSubject, eventPlayer, eventAmount } + } + + protected value(value: Value, context: EffectContext): number { + switch (value.kind) { + case 'number': + return value.value + case 'x': + return context.x + case 'count': + return this.objectsMatching(value.selector, context.source).length + case 'source_power': + return this.getPower(context.source) + case 'source_toughness': + return this.getToughness(context.source) + case 'cards_in_hand': { + const playerId = this.playersForValue(value.player, context)[0] + return playerId ? this.getPlayer(playerId).hand.length : 0 + } + case 'max_cards_in_hand': + return Math.max(...this.alivePlayers().map(player => player.hand.length), 0) + case 'max_opponent_count': + return Math.max(...this.opponentsOf(context.source.controller).map(playerId => this.objectsMatching(value.selector, context.source) + .filter(object => object.controller === playerId).length), 0) + case 'total_mana_value': + return this.objectsMatching(value.selector, context.source) + .reduce((total, object) => total + manaValueOf(object.definition), 0) + case 'total_power': + return this.objectsMatching(value.selector, context.source) + .reduce((total, object) => total + this.getPower(object), 0) + case 'any_number': + return 0 + case 'event_amount': + return context.eventAmount ?? 0 + } + } + + /** + * Applies replacement effects that double/add to life gain, damage, or draws. + * Only the controller of the effect is affected; damage looks at the source's + * controller, which is what "a source you control" means. + */ + protected replacementAmount( + what: 'life_gain' | 'damage' | 'draw' | 'energy', + playerId: string, + amount: number, + source?: GameObject, + combat?: boolean, + ): number { + let result = amount + for (const { source: staticSource, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'replacement_amount' || effect.what !== what) continue + const appliesTo = what === 'damage' + ? (effect.controller === 'you' ? source?.controller === staticSource.controller : true) + : staticSource.controller === playerId + if (!appliesTo) continue + if (effect.sourceColor && !source?.definition.colors?.includes(effect.sourceColor)) continue + if (effect.combatOnly && !combat) continue + if (effect.noncombatOnly && combat) continue + result = result * effect.multiplier + (effect.add ?? 0) + } + } + return result + } + + /** Continuous "prevent all damage" statics, such as protection from artifact creatures. */ + private staticPreventionApplies(target: ResolvedTarget, source: GameObject | undefined, combat: boolean): boolean { + for (const { source: origin, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'prevent_damage' || effect.amount !== 'all') continue + if (effect.combatOnly && !combat) continue + if (effect.sourceSelector && (!source || !this.matchesSelector(source, effect.sourceSelector, origin))) continue + if (effect.global) return true + if (target.kind === 'object') { + if (this.staticTargets(origin, effect.target).some(object => object.id === target.object.id)) return true + } else if (target.kind === 'player' && effect.target.kind === 'player') { + if (effect.target.who === 'you' ? target.id === origin.controller : true) return true + } + } + } + return false + } + + /** Consumes active prevention shields and returns the damage that gets through. */ + protected preventedAmount(target: ResolvedTarget, amount: number, combat: boolean, source?: GameObject): number { + if (target.kind === 'stack') return amount + const staticPrevented = this.staticPreventionApplies(target, source, combat) + if (!this.damageShields.length && !staticPrevented) return amount + if (staticPrevented) return 0 + const id = target.kind === 'player' ? target.id : target.object.id + let remaining = amount + for (const shield of this.damageShields) { + if (remaining <= 0) break + if (shield.combatOnly && !combat) continue + if (shield.sourceIds && (!source || !shield.sourceIds.has(source.id))) continue + if (shield.sourceSelector) { + const origin = shield.sourceId ? this.objects.get(shield.sourceId) : undefined + if (!source || !origin || !this.matchesSelector(source, shield.sourceSelector, origin)) continue + } + if (!shield.global && !shield.ids.has(id)) continue + const used = shield.remaining === 'all' ? remaining : Math.min(remaining, shield.remaining) + if (used > 0 && shield.then) this.preventedFollowUps.push({ shield, amount: used }) + if (shield.remaining === 'all') { + remaining = 0 + continue + } + shield.remaining -= used + remaining -= used + } + for (let i = this.damageShields.length - 1; i >= 0; i--) { + const shield = this.damageShields[i] + if (shield.remaining !== 'all' && shield.remaining <= 0) this.damageShields.splice(i, 1) + } + return remaining + } + + /** Runs "If damage is prevented this way, ..." effects after a prevention. */ + private flushPreventionFollowUps(): void { + while (this.preventedFollowUps.length) { + const entry = this.preventedFollowUps.shift() + if (!entry?.shield.then) continue + const source = entry.shield.sourceId ? this.objects.get(entry.shield.sourceId) : undefined + if (!source) continue + const context = this.contextFor( + source, + entry.shield.controller ?? source.controller, + [...(entry.shield.targets ?? [])], + 0, + 0, + undefined, + undefined, + entry.amount, + ) + if (entry.shield.lastTarget) context.lastTarget = entry.shield.lastTarget + this.applyEffects(context, entry.shield.then) + } + } + + protected damageTarget( + target: ResolvedTarget, + amount: number, + source: GameObject, + combat: boolean, + ): void { + amount = this.replacementAmount('damage', source.controller, amount, source, combat) + amount = this.preventedAmount(target, amount, combat, source) + this.flushPreventionFollowUps() + if (amount <= 0) return + if (target.kind === 'player') { + if (combat && source.isCommander) { + const defender = this.getPlayer(target.id) + defender.commanderDamage[source.id] = (defender.commanderDamage[source.id] ?? 0) + amount + } + this.getPlayer(target.id).damageTakenThisTurn += amount + this.loseLife(target.id, amount) + this.dispatchEvent({ kind: 'deals_damage', player: source.controller, subject: source, recipient: 'player', amount, combat }) + } else if (target.kind === 'object') { + const object = target.object + if (object.zone !== 'battlefield') return + object.damage += amount + if (this.hasKeyword(source, 'Deathtouch')) object.deathtouched = true + this.dispatchEvent({ + kind: 'deals_damage', + player: source.controller, + subject: source, + recipient: this.isCreature(object) ? 'creature' : 'permanent', + amount, + combat, + }) + } + if (this.hasKeyword(source, 'Lifelink')) this.gainLife(source.controller, amount) + } + + protected destroyPermanent(object: GameObject): void { + if (object.zone !== 'battlefield') return + if (this.hasKeyword(object, 'Indestructible')) return + if (object.regenerationShields > 0) { + object.regenerationShields-- + object.tapped = true + object.damage = 0 + object.deathtouched = false + object.attacking = undefined + object.blockedBy = [] + object.blocking = undefined + return + } + this.moveToZone(object, 'graveyard', { silent: false }) + } + + protected createToken(playerId: string, spec: TokenSpec, context: EffectContext): GameObject { + const card = tokenCard({ + ...spec, + power: spec.power ? this.value(spec.power, context) : undefined, + toughness: spec.toughness ? this.value(spec.toughness, context) : undefined, + }) + const player = this.getPlayer(playerId) + const object: GameObject = { + id: this.generateId('token'), + definition: card.definition, + backFace: card.backFace, + owner: playerId, + controller: playerId, + zone: 'battlefield', + tapped: false, + damage: 0, + deathtouched: false, + counters: {}, + isToken: true, + token: spec, + enteredTurn: this.turn, + blockedBy: [], + attachments: [], + regenerationShields: 0, + activations: {}, + } + this.objects.set(object.id, object) + this.moveToZone(object, 'battlefield', { controller: playerId, tapped: spec.tapped ?? false, silent: false }) + return object + } + + protected createTokenCopy(playerId: string, source: GameObject, notLegendary = false): GameObject { + const definition = notLegendary + ? { ...source.definition, typeLine: source.definition.typeLine.replace(/\bLegendary\s+/i, '') } + : source.definition + const object: GameObject = { + id: this.generateId('token'), + definition, + backFace: source.backFace, + owner: playerId, + controller: playerId, + zone: 'battlefield', + tapped: false, + damage: 0, + deathtouched: false, + counters: {}, + isToken: true, + token: source.token, + enteredTurn: this.turn, + blockedBy: [], + attachments: [], + regenerationShields: 0, + activations: {}, + } + this.objects.set(object.id, object) + this.moveToZone(object, 'battlefield', { controller: playerId, tapped: false, silent: false }) + return object + } + + protected attach(source: GameObject, target: GameObject): void { + if (source.attachedTo) { + const previous = this.objects.get(source.attachedTo) + if (previous) previous.attachments = previous.attachments.filter(id => id !== source.id) + } + source.attachedTo = target.id + if (!target.attachments.includes(source.id)) target.attachments.push(source.id) + } + + private replacedCounterAmount(object: GameObject, counter: string, amount: number): number { + let result = amount + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'counter_multiplier') continue + if (effect.counter && effect.counter.toLowerCase() !== counter.toLowerCase()) continue + if (!this.staticTargets(source, effect.target).some(target => target.id === object.id)) continue + result = result * effect.multiplier + (effect.add ?? 0) + } + } + return result + } + + protected addCounters(object: GameObject, counter: string, amount: number, silent = false): void { + if (amount === 0) return + amount = this.replacedCounterAmount(object, counter, amount) + object.counters[counter] = Math.max(0, (object.counters[counter] ?? 0) + amount) + if (!silent) this.dispatchEvent({ kind: 'counter_placed', player: object.controller, subject: object, amount, counter }) + } + + // --------------------------------------------------------------------------- + // Triggers, statics, and conditions + // --------------------------------------------------------------------------- + + protected dispatchEvent(event: EventContext): void { + if (this.status !== 'active') return + const sources = this.battlefieldObjects() + if (event.subject && event.subject.zone !== 'battlefield' && !sources.includes(event.subject)) { + sources.push(event.subject) + } + sources.sort((a, b) => { + const aFirst = a.controller === this.activePlayer ? 0 : 1 + const bFirst = b.controller === this.activePlayer ? 0 : 1 + return aFirst - bFirst + }) + + let added = 0 + for (const source of sources) { + for (const [index, ability] of (source.definition.abilities ?? []).entries()) { + if (ability.kind !== 'triggered') continue + if (ability.condition) { + if (ability.condition.kind === 'event_subject_toughness_at_most') { + if (!event.subject || this.getToughness(event.subject) > ability.condition.amount) continue + } else if (!this.checkCondition(ability.condition, source)) continue + } + if (!this.matchesTrigger(event, ability.event, source)) continue + const onceKey = `${source.id}:${index}` + if (ability.oncePerTurn && this.triggeredThisTurn.has(onceKey)) continue + let targets: TargetChoice[] + try { + targets = this.selectTargets(ability.effects, source, source.controller, [], 0) + } catch { + continue + } + if (ability.oncePerTurn) this.triggeredThisTurn.add(onceKey) + this.stack.push({ + id: this.generateId('stack'), + kind: 'ability', + source, + controller: source.controller, + label: ability.text, + effects: ability.effects, + targets, + x: 0, + mode: 0, + triggerSubject: event.subject, + eventPlayer: event.player, + eventAmount: event.amount, + optional: ability.optional, + }) + added++ + } + } + if (added) { + this.passesInRow = 0 + this.priority = this.activePlayer + } + } + + protected matchesTrigger(event: EventContext, trigger: TriggerEvent, source: GameObject): boolean { + switch (trigger.kind) { + case 'enters': + case 'dies': + case 'attacks': + case 'blocks': + case 'leaves_battlefield': + return event.kind === trigger.kind && this.subjectMatches(trigger.subject, source, event) + case 'enters_or_attacks': + return (event.kind === 'enters' || event.kind === 'attacks') + && this.subjectMatches(trigger.subject, source, event) + case 'enters_or_dies': + return (event.kind === 'enters' || event.kind === 'dies') + && this.subjectMatches(trigger.subject, source, event) + case 'attacks_or_blocks': + return (event.kind === 'attacks' || event.kind === 'blocks') + && this.subjectMatches(trigger.subject, source, event) + case 'counter_placed': + return event.kind === 'counter_placed' + && this.subjectMatches(trigger.subject, source, event) + && (!trigger.counter || trigger.counter === event.counter) + case 'upkeep': + case 'end_step': + case 'begin_combat': + return event.kind === trigger.kind && this.whoMatches(trigger.who, source, event.player) + case 'main_phase': + return event.kind === 'main_phase' && this.whoMatches(trigger.who, source, event.player) + case 'cast': + if (event.kind !== 'cast' || !event.spell) return false + if (!this.whoMatches(trigger.who, source, event.player)) return false + if (!this.matchesSelector(event.spell, trigger.spell, source, 'stack')) return false + if (trigger.targetsSelf && !(event.spellItem?.targets.some(choice => choice.kind === 'object' && choice.id === source.id))) { + return false + } + return true + case 'draw': + if (event.kind !== 'draw' || !this.whoMatches(trigger.who, source, event.player)) return false + return !trigger.ordinal || trigger.ordinal === event.ordinal + case 'life': + if (event.kind !== 'life' || !this.whoMatches(trigger.who, source, event.player)) return false + return trigger.mode === event.mode + case 'deals_damage': + if (event.kind !== 'deals_damage' || !this.subjectMatches(trigger.subject, source, event)) return false + if (trigger.combat && !event.combat) return false + return trigger.recipient === 'any' || trigger.recipient === event.recipient + case 'becomes_target': + case 'becomes_level': + return false + } + } + + protected subjectMatches(target: Target, source: GameObject, event: EventContext): boolean { + if (!event.subject) return false + if (target.kind === 'self' || target.kind === 'trigger_subject') return event.subject.id === source.id + if (target.kind !== 'object') return false + if (target.selector.other && event.subject.id === source.id && !target.includeSelf) return false + return this.matchesSelector(event.subject, target.selector, source, event.subject.zone) + } + + protected whoMatches(who: 'you' | 'opponent' | 'each_player', source: GameObject, eventPlayer: string | undefined): boolean { + if (who === 'each_player') return true + if (!eventPlayer) return false + return who === 'you' ? source.controller === eventPlayer : source.controller !== eventPlayer + } + + protected staticAbilities(): { source: GameObject; ability: Extract }[] { + const result: { source: GameObject; ability: Extract }[] = [] + for (const source of this.battlefieldObjects()) { + for (const ability of source.definition.abilities ?? []) { + if (ability.kind !== 'static') continue + if (ability.condition && !this.checkCondition(ability.condition, source)) continue + result.push({ source, ability }) + } + } + return result + } + + protected staticTargets(source: GameObject, target: Target): GameObject[] { + if (target.kind === 'self') return [source] + if (target.kind !== 'object') return [] + return this.objectsMatching(target.selector, source) + } + + /** Tokens that replace a token creation, such as Food -> Food and Treasure. */ + protected tokenReplacement(playerId: string, spec: TokenSpec): TokenSpec[] | undefined { + const name = (spec.name ?? spec.subtypes[0] ?? '').toLowerCase() + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'token_replacement') continue + if (effect.who === 'you' && source.controller !== playerId) continue + if (!effect.from.some(entry => entry.toLowerCase() === name)) continue + return effect.tokens + } + } + return undefined + } + + /** Product of every token-doubling replacement that applies to this creation. */ + protected tokenMultiplier(playerId: string, creatureToken: boolean): number { + let multiplier = 1 + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'token_multiplier') continue + if (effect.who === 'you' && source.controller !== playerId) continue + if (effect.creatureOnly && !creatureToken) continue + multiplier *= effect.multiplier + } + } + return multiplier + } + + protected exilesInsteadOfGraveyard(object: GameObject): boolean { + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'exile_instead_of_graveyard') continue + if (effect.owner === 'opponent' && object.owner === source.controller) continue + if (effect.owner === 'you' && object.owner !== source.controller) continue + return true + } + } + return false + } + + protected applyEntersReplacements(object: GameObject): void { + for (const staticSource of this.staticAbilities()) { + for (const effect of staticSource.ability.effects) { + if (effect.op === 'enters_tapped') { + if (effect.unless && this.checkCondition(effect.unless, staticSource.source)) continue + if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue + if (effect.unlessCost && !object.tapped) { + const context = this.staticContext(staticSource.source) + this.pendingChoices.push({ + playerId: object.controller, + sourceId: object.id, + what: 'pay_cost', + cost: effect.unlessCost, + amount: effect.unlessCost.kind === 'pay_life' ? this.value(effect.unlessCost.amount, context) : undefined, + }) + continue + } + object.tapped = true + } else if (effect.op === 'enters_with_counters') { + if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue + const amount = this.value(effect.amount, this.staticContext(staticSource.source)) + this.addCounters(object, effect.counter, amount, true) + } + } + } + } + + /** Queues the "as this enters, choose a creature type or color" prompt for a new permanent. */ + protected queueEnterChoices(object: GameObject): void { + for (const ability of object.definition.abilities ?? []) { + if (ability.kind !== 'static') continue + if (ability.effects.some(effect => effect.op === 'choose' && effect.what === 'creature_type')) { + this.pendingChoices.push({ playerId: object.controller, sourceId: object.id, what: 'creature_type' }) + return + } + if (ability.effects.some(effect => effect.op === 'choose' && effect.what === 'color')) { + this.pendingChoices.push({ playerId: object.controller, sourceId: object.id, what: 'color' }) + return + } + } + } + + protected hasRestriction(object: GameObject, rule: string): boolean { + for (const staticSource of this.staticAbilities()) { + for (const effect of staticSource.ability.effects) { + if (effect.op !== 'restriction' || (effect.rule !== rule && !effect.rule.startsWith(`${rule}_`))) continue + if (this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) return true + } + } + for (const continuous of this.continuousEffects) { + if (continuous.effect.op !== 'restriction' || continuous.effect.rule !== rule) continue + if (continuous.affectedIds.includes(object.id)) return true + } + return false + } + + protected checkCondition(condition: Condition, source: GameObject, context?: EffectContext): boolean { + const controller = source.controller + switch (condition.kind) { + case 'if_you_do': + return context ? context.optionalTaken !== false : false + case 'if_you_dont': + case 'otherwise': + return context ? context.optionalTaken === false : false + case 'you_control': + return this.objectsMatching(condition.selector, source).filter(object => object.controller === controller).length + >= (condition.atLeast ?? 1) + case 'opponent_controls': + return this.opponentsOf(controller).some(playerId => this.objectsMatching(condition.selector, source) + .some(object => object.controller === playerId)) + case 'your_turn': + return this.activePlayer === controller + case 'not_your_turn': + return this.activePlayer !== controller + case 'source_tapped': + return source.tapped + case 'source_untapped': + return !source.tapped + case 'source_attacking': + return Boolean(source.attacking) + case 'source_equipped': + return source.attachments.some(id => this.getObject(id).definition.typeLine.toLowerCase().includes('equipment')) + case 'source_enchanted': + return source.attachments.some(id => this.getObject(id).definition.typeLine.toLowerCase().includes('aura')) + case 'life_at_least': + return this.playersForValue(condition.player, this.staticContext(source)) + .some(playerId => this.getPlayer(playerId).life >= condition.amount) + case 'life_at_most': + return this.playersForValue(condition.player, this.staticContext(source)) + .some(playerId => this.getPlayer(playerId).life <= condition.amount) + case 'cards_in_graveyard': + return this.playersForValue(condition.player, this.staticContext(source)) + .some(playerId => this.getPlayer(playerId).graveyard.length >= condition.atLeast) + case 'hand_empty': + return this.playersForValue(condition.player, this.staticContext(source)) + .some(playerId => this.getPlayer(playerId).hand.length === 0) + case 'creature_died_this_turn': + return this.getPlayer(controller).creaturesDiedThisTurn > 0 + case 'you_gained_life_this_turn': + return this.getPlayer(controller).lifeGainedThisTurn >= (condition.atLeast ?? 1) + case 'you_drew_cards_this_turn': + return this.getPlayer(controller).cardsDrawnThisTurn >= (condition.atLeast ?? 1) + case 'attacked_this_turn': + return this.getPlayer(controller).attackedThisTurn + case 'you_attacked_this_turn': + return this.getPlayer(controller).attackedThisTurn + case 'attacked_with_creatures': + return this.getPlayer(controller).creaturesAttackedThisTurn >= condition.atLeast + case 'opponent_damaged_this_turn': + return this.opponentsOf(controller) + .some(playerId => this.getPlayer(playerId).damageTakenThisTurn >= condition.atLeast) + case 'library_at_most': + return this.alivePlayers().some(player => player.library.length <= condition.atMost) + case 'no_objects': + return this.objectsMatching(condition.selector, source).length === 0 + case 'cards_in_hand_at_most': { + const players = this.playersForValue(condition.who, this.staticContext(source)) + const check = (playerId: string): boolean => this.getPlayer(playerId).hand.length <= condition.atMost + return condition.who === 'each_player' || condition.who === 'each_opponent' + ? players.every(check) + : players.some(check) + } + case 'on_battlefield': + return source.zone === 'battlefield' + case 'in_graveyard': + return source.zone === 'graveyard' + case 'not_token': + return !source.isToken + case 'full_party': + return false + case 'you_control_commander': + return this.battlefieldObjects().some(object => object.controller === controller && object.isCommander) + case 'distinct_names': + return new Set(this.objectsMatching(condition.selector, source) + .filter(object => object.controller === controller) + .map(object => object.definition.name.toLowerCase())).size >= condition.atLeast + case 'total_power': + return this.battlefieldObjects() + .filter(object => object.controller === controller && this.isCreature(object)) + .reduce((total, object) => total + this.getPower(object), 0) >= condition.atLeast + case 'event_subject_toughness_at_most': + return false + default: + return false + } + } + + // --------------------------------------------------------------------------- + // Combat damage + // --------------------------------------------------------------------------- +} diff --git a/backend/src/game/game-helpers.ts b/backend/src/game/game-helpers.ts new file mode 100644 index 0000000..7565a07 --- /dev/null +++ b/backend/src/game/game-helpers.ts @@ -0,0 +1,270 @@ +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + ManaSpec, + ObjectSelector, + PlayerRef, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from '../effects/types.js' +import type { + ActionOptions, + CardDefinition, + CombatAttack, + CombatBlock, + GameObject, + GameConfig, + ManaColor, + ManaPool, + MulliganState, + PendingChoice, + PendingSearch, + Phase, + PlayerState, + StackItem, + Step, + TargetChoice, +} from './types.js' +import { CREATURE_TYPES } from './creature-types.js' +import { predefinedToken } from './tokens.js' + + +export type ResolvedTarget = + | { kind: 'player'; id: string } + | { kind: 'object'; object: GameObject } + | { kind: 'stack'; item: StackItem } + +export interface EventContext { + kind: TriggerEvent['kind'] + player?: string + subject?: GameObject + amount?: number + counter?: string + ordinal?: number + mode?: 'gain' | 'lose' + recipient?: 'player' | 'creature' | 'permanent' | 'any' + combat?: boolean + spell?: GameObject + spellItem?: StackItem +} + +export interface EffectContext { + source: GameObject + controller: string + targets: TargetChoice[] + lastTarget?: ResolvedTarget + /** Objects dealt damage by the most recent damage effect, for "dealt damage this way". */ + lastDamaged?: GameObject[] + triggerSubject?: GameObject + eventPlayer?: string + eventAmount?: number + x: number + mode: number + /** Color picked for a mana ability, so choice effects produce it. */ + manaColor?: ManaColor + /** Whether the "you may" branch was taken; undefined means no branch was offered. */ + optionalTaken?: boolean +} + +export interface ContinuousEffect { + id: string + sourceId: string + controller: string + effect: Extract + affectedIds: string[] + duration: Duration + createdTurn: number +} + +export interface DamageShield { + /** Object or player ids this shield covers; empty with `global` covers everything. */ + ids: Set + global: boolean + /** When set, only damage dealt by these source objects is prevented. */ + sourceIds?: Set + /** When set, only damage from sources matching this selector is prevented. */ + sourceSelector?: ObjectSelector + remaining: number | 'all' + combatOnly: boolean + /** "If damage is prevented this way, ..." follow-up. */ + then?: Effect[] + sourceId?: string + controller?: string + /** Target choices left over when the shield was made, for its follow-up. */ + targets?: TargetChoice[] + /** Recipient the shield was made for, so "that creature" resolves in the follow-up. */ + lastTarget?: ResolvedTarget +} + +export interface ManaCost { + generic: number + colored: ManaColor[] + hybrid: { colors: ManaColor[]; life: number }[] +} + +export const MANA_COLORS: ManaColor[] = ['W', 'U', 'B', 'R', 'G', 'C'] +export const COLOR_NAMES: Record = { + white: 'W', + blue: 'U', + black: 'B', + red: 'R', + green: 'G', + colorless: 'C', +} + +export function emptyPool(): ManaPool { + return { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 } +} + +export function parseManaCost(symbols: string, x = 0): ManaCost { + const cost: ManaCost = { generic: 0, colored: [], hybrid: [] } + for (const match of symbols.matchAll(/\{([^}]+)\}/g)) { + const symbol = match[1].toUpperCase() + if (/^\d+$/.test(symbol)) { + cost.generic += Number(symbol) + } else if (symbol === 'X') { + cost.generic += x + } else if (symbol === 'S') { + cost.colored.push('C') + } else if (/^[WUBRGC]$/.test(symbol)) { + cost.colored.push(symbol as ManaColor) + } else if (symbol.includes('/')) { + const parts = symbol.split('/') + const colors = parts + .filter(part => /^[WUBRG]$/.test(part)) + .map(part => part as ManaColor) + if (colors.length) cost.hybrid.push({ colors, life: parts.includes('P') ? 2 : 0 }) + else cost.generic += 1 + } else { + cost.generic += 1 + } + } + return cost +} + +export interface CostReduction { + generic: number + colored: ManaColor[] +} + +/** + * Generic reductions only remove generic mana; colored ones remove matching pips. + * shortcut: hybrid and phyrexian pips are not reduced; upgrade when a card needs it. + */ +export function reduceManaSymbols(symbols: string, reduction: CostReduction): string { + let generic = reduction.generic + const colored = [...reduction.colored] + const result: string[] = [] + for (const match of symbols.matchAll(/\{([^}]+)\}/g)) { + const symbol = match[1].toUpperCase() + if (/^\d+$/.test(symbol) && generic > 0) { + const remaining = Math.max(0, Number(symbol) - generic) + generic = Math.max(0, generic - Number(symbol)) + if (remaining > 0) result.push(`{${remaining}}`) + continue + } + const index = colored.indexOf(symbol as ManaColor) + if (index >= 0) { + colored.splice(index, 1) + continue + } + result.push(`{${match[1]}}`) + } + return result.join('') +} + +export function manaValueOf(definition: CardDefinition): number { + if (definition.manaValue !== undefined) return definition.manaValue + const cost = parseManaCost(definition.manaCost ?? '') + return cost.generic + cost.colored.length + cost.hybrid.length +} + +export function colorOfSymbol(symbol: string): ManaColor { + const bare = symbol.replace(/[{}]/g, '').toUpperCase() + if (bare === 'S') return 'C' + if (/^[WUBRGC]$/.test(bare)) return bare as ManaColor + return 'C' +} + +export function tokenCard(token: { + name?: string + types: string[] + subtypes: string[] + colors: string[] + power?: number + toughness?: number + keywords?: string[] +}): { definition: CardDefinition; backFace?: CardDefinition } { + const predefined = predefinedToken(token) + const types = predefined?.types ?? token.types + const subtypes = predefined?.subtypes ?? token.subtypes + const colors = [...new Set([...(predefined?.colors ?? []), ...token.colors])] + const keywords = [...(predefined?.keywords ?? []), ...(token.keywords ?? [])] + const definition = tokenFace({ + name: predefined?.name ?? token.name ?? (subtypes.map(capitalize).join(' ') || 'Token'), + types, + subtypes, + colors, + power: token.power ?? predefined?.power, + toughness: token.toughness ?? predefined?.toughness, + keywords, + abilities: predefined?.abilities, + }) + const backFace = predefined?.backFace + ? tokenFace({ ...predefined.backFace, keywords: predefined.backFace.keywords ?? [] }) + : undefined + return { definition, backFace } +} + +export function capitalize(word: string): string { + return word[0]?.toUpperCase() + word.slice(1) +} + +export function tokenFace(fields: { + name: string + types: string[] + subtypes: string[] + colors: string[] + power?: number + toughness?: number + keywords?: string[] + abilities?: Ability[] +}): CardDefinition { + return { + oracleId: `token:${fields.name}`, + name: fields.name, + typeLine: [fields.types.join(' '), fields.subtypes.length ? `— ${fields.subtypes.join(' ')}` : ''].join(' ').trim(), + manaValue: 0, + colors: fields.colors, + power: fields.power, + toughness: fields.toughness, + abilities: [ + ...(fields.abilities ?? []), + ...(fields.keywords ?? []).map(keyword => ({ kind: 'keyword' as const, keyword })), + ], + } +} + + + +export class GameError extends Error {} + + +export function mulberry32(seed: number): () => number { + let state = seed >>> 0 + return () => { + state = (state + 0x6d2b79f5) >>> 0 + let value = state + value = Math.imul(value ^ (value >>> 15), value | 1) + value ^= value + Math.imul(value ^ (value >>> 7), value | 61) + return ((value ^ (value >>> 14)) >>> 0) / 4294967296 + } +} + diff --git a/backend/src/game/game-mana.ts b/backend/src/game/game-mana.ts new file mode 100644 index 0000000..7888372 --- /dev/null +++ b/backend/src/game/game-mana.ts @@ -0,0 +1,369 @@ +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + ManaSpec, + ObjectSelector, + PlayerRef, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from '../effects/types.js' +import type { + ActionOptions, + CardDefinition, + CombatAttack, + CombatBlock, + GameObject, + GameConfig, + ManaColor, + ManaPool, + MulliganState, + PendingChoice, + PendingSearch, + Phase, + PlayerState, + StackItem, + Step, + TargetChoice, +} from './types.js' +import { CREATURE_TYPES } from './creature-types.js' +import { predefinedToken } from './tokens.js' + +import { GameError, ResolvedTarget, EventContext, EffectContext, ContinuousEffect, DamageShield, ManaCost, CostReduction, MANA_COLORS, COLOR_NAMES, emptyPool, parseManaCost, reduceManaSymbols, manaValueOf, colorOfSymbol, tokenCard, capitalize, tokenFace, mulberry32 } from './game-helpers.js' +import { GameStats } from './game-stats.js' + +export abstract class GameMana extends GameStats { + protected payMana(playerId: string, symbols: string, x: number): void { + if (!symbols) return + const player = this.getPlayer(playerId) + const cost = parseManaCost(symbols, x) + const pool = { ...player.manaPool } + const tapped = player.battlefield + .map(id => this.objects.get(id)) + .filter((object): object is GameObject => Boolean(object?.tapped)) + .map(object => object.id) + this.autoTapForMana(player, cost) + if (!this.canPayMana(player, cost)) { + player.manaPool = pool + for (const id of player.battlefield) { + const object = this.objects.get(id) + if (object) object.tapped = tapped.includes(id) + } + throw new GameError('Not enough mana') + } + this.deductMana(player, cost) + } + + protected canPayMana(player: PlayerState, cost: ManaCost): boolean { + const pool = { ...player.manaPool } + const payColor = (color: ManaColor): boolean => { + if (pool[color] <= 0) return false + pool[color]-- + return true + } + for (const color of cost.colored) { + if (!payColor(color)) return false + } + for (const hybrid of cost.hybrid) { + const color = hybrid.colors.find(entry => pool[entry] > 0) + if (color) pool[color]-- + else if (!(hybrid.life > 0 && player.life >= hybrid.life)) return false + } + const remaining = MANA_COLORS.reduce((total, color) => total + pool[color], 0) + return remaining >= cost.generic + } + + protected deductMana(player: PlayerState, cost: ManaCost): void { + for (const color of cost.colored) player.manaPool[color]-- + for (const hybrid of cost.hybrid) { + const color = hybrid.colors.find(entry => player.manaPool[entry] > 0) + if (color) player.manaPool[color]-- + else if (hybrid.life > 0) this.loseLife(player.id, hybrid.life) + else throw new GameError('Not enough mana') + } + let generic = cost.generic + for (const color of MANA_COLORS) { + const used = Math.min(player.manaPool[color], generic) + player.manaPool[color] -= used + generic -= used + } + if (generic > 0) throw new GameError('Not enough mana') + } + + protected autoTapForMana(player: PlayerState, cost: ManaCost): void { + if (this.autoManaDepth > 0) return + let guard = 0 + while (!this.canPayMana(player, cost) && guard++ < 25) { + const source = this.players + .flatMap(entry => entry.battlefield) + .map(id => this.objects.get(id)) + .map(object => { + if (!object || object.zone !== 'battlefield' || object.controller !== player.id || object.tapped) return undefined + const found = this.findFreeManaAbility(object) + if (!found) return undefined + return { object, allowed: this.manaAbilityAllowedColors(object, found.ability) } + }) + .filter((entry): entry is { object: GameObject; allowed: Set | undefined } => Boolean(entry)) + .filter(entry => this.neededColor(player, cost, entry.allowed) !== undefined) + .sort((a, b) => (a.allowed?.size ?? Number.MAX_SAFE_INTEGER) - (b.allowed?.size ?? Number.MAX_SAFE_INTEGER))[0]?.object + if (!source) break + this.autoManaDepth++ + try { + this.activateManaSource(source, cost) + } finally { + this.autoManaDepth-- + } + } + } + + protected findFreeManaAbility(source: GameObject): { index: number; ability: Extract } | undefined { + const abilities = source.definition.abilities ?? [] + for (let index = 0; index < abilities.length; index++) { + const ability = abilities[index] + if (ability.kind !== 'activated') continue + if (!ability.effects.length || !ability.effects.every(effect => effect.op === 'add_mana')) continue + if (ability.costs.length !== 1 || ability.costs[0].kind !== 'tap') continue + if (source.tapped) continue + if (this.isCreature(source) && source.enteredTurn >= this.turn && !this.hasKeyword(source, 'Haste')) continue + return { index, ability } + } + return undefined + } + + protected activateManaSource(source: GameObject, cost: ManaCost): void { + const found = this.findFreeManaAbility(source) + if (!found) return + const player = this.getPlayer(source.controller) + const color = this.manaAbilityColor(source, found.ability, player, cost) + if (!color) return + for (const entry of found.ability.costs) { + if (entry.kind === 'tap') source.tapped = true + } + for (const effect of found.ability.effects) { + if (effect.op === 'add_mana') this.addMana(source.controller, effect.mana, color, source) + } + } + + protected manaAbilityColor( + source: GameObject, + ability: Extract, + player: PlayerState, + cost: ManaCost, + ): ManaColor | undefined { + return this.neededColor(player, cost, this.manaAbilityAllowedColors(source, ability)) + } + + /** + * Colors a mana ability lets its controller choose between. Undefined when + * the ability has no choice, such as fixed or single-color mana. + */ + manaColorChoices(source: GameObject, abilityIndex: number): ManaColor[] | undefined { + const ability = (source.definition.abilities ?? [])[abilityIndex] + if (!ability || ability.kind !== 'activated') return undefined + let colors: ManaColor[] | undefined + for (const effect of ability.effects) { + if (effect.op !== 'add_mana') continue + if (effect.mana.kind === 'symbols' && effect.mana.oneOf) { + colors = [...new Set(effect.mana.symbols.map(colorOfSymbol))] + } else if (effect.mana.kind === 'any_color') { + const allowed = this.anyColorRestrictionColors(effect.mana, source.controller, undefined, source) + colors = allowed + ? MANA_COLORS.filter(color => color !== 'C' && allowed.has(color)) + : ['W', 'U', 'B', 'R', 'G'] + } + } + return colors && colors.length > 1 ? colors : undefined + } + + protected manaAbilityAllowedColors( + source: GameObject, + ability: Extract, + ): Set | undefined { + for (const effect of ability.effects) { + if (effect.op !== 'add_mana') continue + if (effect.mana.kind === 'symbols' && effect.mana.oneOf) { + return new Set(effect.mana.symbols.map(colorOfSymbol)) + } + return this.anyColorRestrictionColors(effect.mana, source.controller, undefined, source) + } + return undefined + } + + protected neededColor(player: PlayerState, cost: ManaCost, allowed?: Set): ManaColor | undefined { + for (const color of cost.colored) { + if (player.manaPool[color] > 0) continue + return allowed && !allowed.has(color) ? undefined : color + } + for (const hybrid of cost.hybrid) { + if (hybrid.colors.some(color => player.manaPool[color] > 0)) continue + return hybrid.colors.find(color => !allowed || allowed.has(color)) + } + if (allowed) return MANA_COLORS.find(color => allowed.has(color)) + return 'W' + } + + protected addMana(playerId: string, mana: ManaSpec, preferred?: ManaColor, source?: GameObject): void { + const player = this.getPlayer(playerId) + if (mana.kind === 'symbols') { + if (mana.oneOf) { + const colors = mana.symbols.map(colorOfSymbol) + const color = preferred && colors.includes(preferred) ? preferred : colors[0] + if (color) player.manaPool[color]++ + return + } + for (const symbol of mana.symbols) player.manaPool[colorOfSymbol(symbol)]++ + return + } + const amount = this.value(mana.amount, { + source: this.playerSource(playerId), + controller: playerId, + targets: [], + x: 0, + mode: 0, + }) + const allowed = this.anyColorRestrictionColors(mana, playerId, undefined, source) + if (allowed?.size === 0) return + let color: ManaColor = preferred ?? 'W' + if (allowed && !allowed.has(color)) { + color = MANA_COLORS.find(entry => allowed.has(entry)) ?? 'W' + } + for (let i = 0; i < amount; i++) player.manaPool[color]++ + } + + /** + * Colors a land could produce for an "any color that a land ... could + * produce" restriction. Colorless and snow are not colors. + */ + protected landManaColors(playerId: string, opponentsOnly: boolean, seen = new Set()): Set { + const colors = new Set() + const opponents = this.opponentsOf(playerId) + for (const object of this.battlefieldObjects()) { + if (!this.isLand(object) || seen.has(object.id)) continue + if (opponentsOnly ? !opponents.includes(object.controller) : object.controller !== playerId) continue + seen.add(object.id) + for (const ability of object.definition.abilities ?? []) { + if (ability.kind !== 'activated') continue + for (const effect of ability.effects) { + if (effect.op !== 'add_mana') continue + if (effect.mana.kind === 'symbols') { + for (const symbol of effect.mana.symbols) { + for (const letter of symbol.match(/[WUBRG]/gi) ?? []) colors.add(letter.toUpperCase() as ManaColor) + } + } else { + const nested = this.anyColorRestrictionColors(effect.mana, object.controller, seen) + if (nested) { + for (const color of nested) colors.add(color) + } else { + for (const color of MANA_COLORS) if (color !== 'C') colors.add(color) + } + } + } + } + seen.delete(object.id) + } + return colors + } + + /** The colors an any-color mana source may produce, when the restriction is known. */ + protected anyColorRestrictionColors( + mana: ManaSpec, + playerId: string, + seen?: Set, + source?: GameObject, + ): Set | undefined { + if (mana.kind !== 'any_color') return undefined + if (mana.restriction === 'chosen color') { + return source?.chosenColor ? new Set([source.chosenColor]) : new Set() + } + if (mana.restriction === 'a land an opponent controls could produce') { + return this.landManaColors(playerId, true, seen) + } + if (mana.restriction === 'a land you control could produce') { + return this.landManaColors(playerId, false, seen) + } + if (mana.restriction === "commander's color identity") { + const commander = this.objects.get(this.getPlayer(playerId).commanderId ?? '') + const identity = commander?.definition.colorIdentity ?? [] + return new Set(identity.filter((color): color is ManaColor => /^[WUBRG]$/.test(color))) + } + return undefined + } + + /** + * Affordability check that mirrors auto-tapping without changing the game. + * shortcut: only land-based any_color restrictions are modelled; mana + * restricted by a commander identity or a spell type is still flexible. + */ + protected canAffordMana(playerId: string, symbols: string, x: number): boolean { + if (!symbols) return true + const player = this.getPlayer(playerId) + const cost = parseManaCost(symbols, x) + const pool = { ...player.manaPool } + let flexible = 0 + const restricted: { colors: Set; amount: number }[] = [] + for (const object of this.battlefieldObjects()) { + if (object.controller !== playerId) continue + const found = this.findFreeManaAbility(object) + if (!found) continue + for (const effect of found.ability.effects) { + if (effect.op !== 'add_mana') continue + if (effect.mana.kind === 'symbols') { + for (const symbol of effect.mana.symbols) pool[colorOfSymbol(symbol)]++ + } else { + const amount = this.value(effect.mana.amount, { + source: object, + controller: playerId, + targets: [], + x: 0, + mode: 0, + }) + const allowed = this.anyColorRestrictionColors(effect.mana, playerId) + if (!allowed) flexible += amount + else if (allowed.size) restricted.push({ colors: allowed, amount }) + } + } + } + + let life = player.life + restricted.sort((a, b) => a.colors.size - b.colors.size) + const take = (color: ManaColor): boolean => { + if (pool[color] > 0) { + pool[color]-- + return true + } + const source = restricted.find(entry => entry.amount > 0 && entry.colors.has(color)) + if (source) { + source.amount-- + return true + } + if (flexible > 0) { + flexible-- + return true + } + return false + } + + for (const color of cost.colored) { + if (!take(color)) return false + } + for (const hybrid of cost.hybrid) { + if (hybrid.colors.some(take)) continue + if (!(hybrid.life > 0 && life >= hybrid.life)) return false + life -= hybrid.life + } + const remaining = MANA_COLORS.reduce((total, color) => total + pool[color], 0) + + flexible + + restricted.reduce((total, entry) => total + entry.amount, 0) + return remaining >= cost.generic + } + + protected emptyManaPools(): void { + for (const player of this.players) player.manaPool = emptyPool() + } +} diff --git a/backend/src/game/game-stats.ts b/backend/src/game/game-stats.ts new file mode 100644 index 0000000..367610e --- /dev/null +++ b/backend/src/game/game-stats.ts @@ -0,0 +1,306 @@ +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + ManaSpec, + ObjectSelector, + PlayerRef, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from '../effects/types.js' +import type { + ActionOptions, + CardDefinition, + CombatAttack, + CombatBlock, + GameObject, + GameConfig, + ManaColor, + ManaPool, + MulliganState, + PendingChoice, + PendingSearch, + Phase, + PlayerState, + StackItem, + Step, + TargetChoice, +} from './types.js' +import { CREATURE_TYPES } from './creature-types.js' +import { predefinedToken } from './tokens.js' + +import { GameError, ResolvedTarget, EventContext, EffectContext, ContinuousEffect, DamageShield, ManaCost, CostReduction, MANA_COLORS, COLOR_NAMES, emptyPool, parseManaCost, reduceManaSymbols, manaValueOf, colorOfSymbol, tokenCard, capitalize, tokenFace, mulberry32 } from './game-helpers.js' +import { GameBase } from './game-base.js' + +export abstract class GameStats extends GameBase { + getPower(objectOrId: GameObject | string): number { + const object = typeof objectOrId === 'string' ? this.getObject(objectOrId) : objectOrId + const base = object.definition.power ?? 0 + if (this.statDepth > 0) return base + this.statDepth++ + try { + let power = base + let toughness = object.definition.toughness ?? 0 + + for (const staticSource of this.staticAbilities()) { + for (const effect of staticSource.ability.effects) { + if (effect.op !== 'set_pt') continue + if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue + if (effect.power) power = this.value(effect.power, this.staticContext(staticSource.source)) + if (effect.toughness) toughness = this.value(effect.toughness, this.staticContext(staticSource.source)) + } + } + for (const continuous of this.continuousEffects) { + if (continuous.effect.op !== 'set_pt' || !continuous.affectedIds.includes(object.id)) continue + const context = this.continuousContext(continuous) + if (continuous.effect.power) power = this.value(continuous.effect.power, context) + if (continuous.effect.toughness) toughness = this.value(continuous.effect.toughness, context) + } + + const counterPower = this.counterStat(object.counters, 'power') + const counterToughness = this.counterStat(object.counters, 'toughness') + power += counterPower + toughness += counterToughness + + for (const staticSource of this.staticAbilities()) { + for (const effect of staticSource.ability.effects) { + if (effect.op !== 'pump') continue + if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue + const context = this.staticContext(staticSource.source) + power += this.value(effect.power, context) + toughness += this.value(effect.toughness, context) + } + } + for (const continuous of this.continuousEffects) { + if (continuous.effect.op !== 'pump' || !continuous.affectedIds.includes(object.id)) continue + const context = this.continuousContext(continuous) + power += this.value(continuous.effect.power, context) + toughness += this.value(continuous.effect.toughness, context) + } + return power + } finally { + this.statDepth-- + } + } + + getToughness(objectOrId: GameObject | string): number { + const object = typeof objectOrId === 'string' ? this.getObject(objectOrId) : objectOrId + const base = object.definition.toughness ?? 0 + if (this.statDepth > 0) return base + this.statDepth++ + try { + let power = base + let toughness = object.definition.toughness ?? 0 + + for (const staticSource of this.staticAbilities()) { + for (const effect of staticSource.ability.effects) { + if (effect.op !== 'set_pt') continue + if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue + if (effect.power) power = this.value(effect.power, this.staticContext(staticSource.source)) + if (effect.toughness) toughness = this.value(effect.toughness, this.staticContext(staticSource.source)) + } + } + for (const continuous of this.continuousEffects) { + if (continuous.effect.op !== 'set_pt' || !continuous.affectedIds.includes(object.id)) continue + const context = this.continuousContext(continuous) + if (continuous.effect.power) power = this.value(continuous.effect.power, context) + if (continuous.effect.toughness) toughness = this.value(continuous.effect.toughness, context) + } + + toughness += this.counterStat(object.counters, 'toughness') + + for (const staticSource of this.staticAbilities()) { + for (const effect of staticSource.ability.effects) { + if (effect.op !== 'pump') continue + if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue + toughness += this.value(effect.toughness, this.staticContext(staticSource.source)) + } + } + for (const continuous of this.continuousEffects) { + if (continuous.effect.op !== 'pump' || !continuous.affectedIds.includes(object.id)) continue + toughness += this.value(continuous.effect.toughness, this.continuousContext(continuous)) + } + return toughness + } finally { + this.statDepth-- + } + } + + hasKeyword(objectOrId: GameObject | string, keyword: string): boolean { + const object = typeof objectOrId === 'string' ? this.getObject(objectOrId) : objectOrId + const wanted = keyword.toLowerCase() + if (this.keywordDepth > 0) { + for (const ability of object.definition.abilities ?? []) { + if (ability.kind === 'keyword' && ability.keyword.toLowerCase() === wanted) return true + } + return false + } + this.keywordDepth++ + try { + for (const ability of object.definition.abilities ?? []) { + if (ability.kind === 'keyword' && ability.keyword.toLowerCase() === wanted) return true + if (ability.kind === 'keywords' && ability.keywords.some(entry => entry.keyword.toLowerCase() === wanted)) { + return true + } + } + for (const staticSource of this.staticAbilities()) { + for (const effect of staticSource.ability.effects) { + if (effect.op !== 'grant' || effect.keyword.toLowerCase() !== wanted) continue + if (this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) return true + } + } + for (const continuous of this.continuousEffects) { + if (continuous.effect.op !== 'grant' || continuous.effect.keyword.toLowerCase() !== wanted) continue + if (continuous.affectedIds.includes(object.id)) return true + } + return false + } finally { + this.keywordDepth-- + } + } + + protected hasKeywordForDefinition(definition: CardDefinition, keyword: string): boolean { + const wanted = keyword.toLowerCase() + for (const ability of definition.abilities ?? []) { + if (ability.kind === 'keyword' && ability.keyword.toLowerCase() === wanted) return true + if (ability.kind === 'keywords' && ability.keywords.some(entry => entry.keyword.toLowerCase() === wanted)) return true + } + return false + } + + protected isCreature(object: GameObject): boolean { + return this.hasType(object, 'creature') + } + + protected isLand(object: GameObject): boolean { + return this.hasType(object, 'land') + } + + protected isInstant(object: GameObject): boolean { + return this.hasType(object, 'instant') + } + + protected isInstantOrSorcery(object: GameObject): boolean { + return this.hasType(object, 'instant') || this.hasType(object, 'sorcery') + } + + protected isPermanent(object: GameObject): boolean { + if (this.isInstantOrSorcery(object)) return false + return ['creature', 'artifact', 'enchantment', 'planeswalker', 'battle', 'land'] + .some(type => this.hasType(object, type)) + } + + protected hasType(object: GameObject, type: string): boolean { + const words = object.definition.typeLine.toLowerCase().split(/[\s—–\-/,()]+/) + return words.includes(type.toLowerCase()) + } + + protected battlefieldObjects(): GameObject[] { + return [...this.objects.values()].filter(object => object.zone === 'battlefield') + } + + protected alivePlayers(): PlayerState[] { + return this.players.filter(player => !player.lost) + } + + protected opponentsOf(playerId: string): string[] { + return this.alivePlayers().filter(player => player.id !== playerId).map(player => player.id) + } + + protected nextAlivePlayer(playerId: string): string { + const start = this.players.findIndex(player => player.id === playerId) + for (let offset = 1; offset <= this.players.length; offset++) { + const player = this.players[(start + offset) % this.players.length] + if (!player.lost) return player.id + } + return playerId + } + + protected counterStat(counters: Record, stat: 'power' | 'toughness'): number { + let total = 0 + for (const [counter, count] of Object.entries(counters)) { + const match = counter.match(/^([+-])(\d+)\/([+-])(\d+)$/) + if (!match) continue + const value = stat === 'power' ? `${match[1]}${match[2]}` : `${match[3]}${match[4]}` + total += Number(value) * count + } + return total + } + + protected objectsMatching(selector: ObjectSelector, source: GameObject, zoneOverride?: Zone): GameObject[] { + const zone = zoneOverride ?? selector.zone ?? 'battlefield' + return [...this.objects.values()].filter(object => this.matchesSelector(object, selector, source, zone)) + } + + protected matchesSelector(object: GameObject, selector: ObjectSelector, source: GameObject, zoneOverride?: Zone): boolean { + const zone = zoneOverride ?? selector.zone ?? 'battlefield' + if (object.zone !== zone) return false + if (selector.other && object.id === source.id) return false + + const typeLine = object.definition.typeLine.toLowerCase() + const words = new Set(typeLine.split(/[\s—–\-/,()]+/).filter(Boolean)) + const matchesWords = (values: string[]): boolean => { + const matches = values.map(value => words.has(value.toLowerCase())) + return selector.match === 'any' ? matches.some(Boolean) : matches.every(Boolean) + } + // "Permanent" is a zone property, not a word on the type line. + const types = selector.types?.filter(type => type.toLowerCase() !== 'permanent') + if (types?.length && !matchesWords(types)) return false + if (selector.excludeTypes?.some(type => words.has(type.toLowerCase()))) return false + if (selector.supertypes?.length && !matchesWords(selector.supertypes)) return false + if (selector.subtypes?.length && !matchesWords(selector.subtypes)) return false + + if (selector.controller === 'you' && object.controller !== source.controller) return false + if (selector.controller === 'opponent' && object.controller === source.controller) return false + if (selector.owner === 'you' && object.owner !== source.controller) return false + if (selector.owner === 'opponent' && object.owner === source.controller) return false + + const colors = object.definition.colors ?? [] + if (selector.colors?.length) { + const matches = selector.colors.map(color => colors.includes(color)) + if (selector.match === 'any' ? !matches.some(Boolean) : !matches.every(Boolean)) return false + } + if (selector.excludeColors?.some(color => color === 'C' ? colors.length === 0 : colors.includes(color))) return false + if (selector.tapped !== undefined && object.tapped !== selector.tapped) return false + if (selector.attacking !== undefined && Boolean(object.attacking) !== selector.attacking) return false + if (selector.token !== undefined && object.isToken !== selector.token) return false + if (selector.name && object.definition.name.toLowerCase() !== selector.name.toLowerCase()) return false + if (selector.counters) { + const count = object.counters[selector.counters.counter] ?? 0 + if (count < selector.counters.atLeast) return false + } + if (selector.power) { + const power = this.getPower(object) + if (selector.power.atLeast !== undefined && power < selector.power.atLeast) return false + if (selector.power.atMost !== undefined && power > selector.power.atMost) return false + } + if (selector.toughness) { + const toughness = this.getToughness(object) + if (selector.toughness.atLeast !== undefined && toughness < selector.toughness.atLeast) return false + if (selector.toughness.atMost !== undefined && toughness > selector.toughness.atMost) return false + } + if (selector.manaValue) { + const value = manaValueOf(object.definition) + if (selector.manaValue.atLeast !== undefined && value < selector.manaValue.atLeast) return false + if (selector.manaValue.atMost !== undefined && value > selector.manaValue.atMost) return false + } + if (selector.keywords?.some(keyword => !this.hasKeyword(object, keyword))) return false + if (selector.excludeKeywords?.some(keyword => this.hasKeyword(object, keyword))) return false + if (selector.attached) { + const attached = [...this.objects.values()].some(attachment => attachment.attachedTo === object.id + && (selector.attached === 'equipped' ? this.hasType(attachment, 'equipment') : this.hasType(attachment, 'aura'))) + if (!attached) return false + } + return true + } + + // --------------------------------------------------------------------------- + // Rules helpers + // --------------------------------------------------------------------------- +} diff --git a/backend/src/game/game-turn.ts b/backend/src/game/game-turn.ts new file mode 100644 index 0000000..7b16187 --- /dev/null +++ b/backend/src/game/game-turn.ts @@ -0,0 +1,485 @@ +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + ManaSpec, + ObjectSelector, + PlayerRef, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from '../effects/types.js' +import type { + ActionOptions, + CardDefinition, + CombatAttack, + CombatBlock, + GameObject, + GameConfig, + ManaColor, + ManaPool, + MulliganState, + PendingChoice, + PendingSearch, + Phase, + PlayerState, + StackItem, + Step, + TargetChoice, +} from './types.js' +import { CREATURE_TYPES } from './creature-types.js' +import { predefinedToken } from './tokens.js' + +import { GameError, ResolvedTarget, EventContext, EffectContext, ContinuousEffect, DamageShield, ManaCost, CostReduction, MANA_COLORS, COLOR_NAMES, emptyPool, parseManaCost, reduceManaSymbols, manaValueOf, colorOfSymbol, tokenCard, capitalize, tokenFace, mulberry32 } from './game-helpers.js' +import { GameActions } from './game-actions.js' + +export class GameTurn extends GameActions { + /** + * Starts the game, shuffles libraries, and draws opening hands. With mulligans + * enabled, turn 1 waits until every player keeps; otherwise it begins immediately. + */ + start(): void { + if (this.status !== 'not_started') throw new GameError('Game already started') + for (const player of this.players) this.shuffleLibrary(player) + for (const player of this.players) { + for (let i = 0; i < this.startingHandSize; i++) { + if (!player.library.length) break + this.drawCard(player.id, true) + } + } + + if (!this.config.mulligans) { + this.beginGame() + return + } + this.status = 'mulligan' + this.turn = 1 + this.activePlayer = this.firstPlayer + } + + /** Keeps the opening hand; turn 1 begins once every living player has kept. */ + keepHand(playerId: string): void { + const mulligan = this.requireMulligan(playerId) + if (mulligan.kept) throw new GameError('You already kept your hand') + if (mulligan.bottom > 0) throw new GameError('Put your cards on the bottom first') + mulligan.kept = true + const player = this.getPlayer(playerId) + this.logMessage(`${player.name} keeps their hand${mulligan.count ? ` after ${mulligan.count} mulligan${mulligan.count === 1 ? '' : 's'}` : ''}`) + if (this.players.every(entry => entry.lost || this.mulligans.get(entry.id)?.kept)) this.beginGame() + } + + /** Shuffles the hand back and draws a new one; each mulligan bottoms one more card. */ + mulligan(playerId: string): void { + const mulligan = this.requireMulligan(playerId) + if (mulligan.kept) throw new GameError('You already kept your hand') + if (mulligan.bottom > 0) throw new GameError('Put your cards on the bottom first') + const player = this.getPlayer(playerId) + for (const id of [...player.hand]) this.moveToZone(id, 'library', { silent: true }) + this.shuffleLibrary(player) + for (let i = 0; i < this.startingHandSize; i++) { + if (!player.library.length) break + this.drawCard(player.id, true) + } + mulligan.count++ + mulligan.bottom = Math.min(Math.max(0, mulligan.count - 1), player.hand.length) + this.logMessage(`${player.name} mulligans${mulligan.bottom + ? ` and puts ${mulligan.bottom} card${mulligan.bottom === 1 ? '' : 's'} on the bottom` + : ''}`) + } + + /** Puts one card from a mulliganed opening hand on the bottom of the library. */ + putOnBottom(playerId: string, cardId: string): void { + const mulligan = this.requireMulligan(playerId) + if (mulligan.kept) throw new GameError('You already kept your hand') + if (mulligan.bottom <= 0) throw new GameError('You have no cards to put on the bottom') + const player = this.getPlayer(playerId) + if (!player.hand.includes(cardId)) throw new GameError('Card is not in hand') + this.moveToZone(cardId, 'library', { silent: true }) + mulligan.bottom-- + } + + protected requireMulligan(playerId: string): MulliganState { + if (this.status !== 'mulligan') throw new GameError('The game is not in its mulligan step') + const player = this.getPlayer(playerId) + if (player.lost) throw new GameError('You have left the game') + const mulligan = this.mulligans.get(playerId) + if (!mulligan) throw new GameError(`Unknown player: ${playerId}`) + return mulligan + } + + protected beginGame(): void { + // Leyline-style "begin the game with it on the battlefield" cards. + for (const player of this.players) { + if (player.lost) continue + for (const id of [...player.hand]) { + const object = this.getObject(id) + const beginsOnBattlefield = (object.definition.abilities ?? []).some(ability => + ability.kind === 'static' && ability.effects.some(effect => + effect.op === 'restriction' && effect.rule === 'begin_on_battlefield')) + if (beginsOnBattlefield) this.moveToZone(object, 'battlefield', { controller: player.id, silent: true }) + } + } + + this.status = 'active' + this.turn = 1 + this.activePlayer = this.firstPlayer + this.beginTurn() + } + + /** Marks a player as having forfeited. */ + concede(playerId: string): void { + if (this.status !== 'active' && this.status !== 'mulligan') throw new GameError('Game is not active') + this.losePlayer(playerId) + if (this.priority === playerId) this.priority = this.nextAlivePlayer(playerId) + } + + /** Passes priority. When all players pass, the top of the stack resolves or the phase advances. */ + pass(playerId?: string): void { + if (this.status !== 'active') throw new GameError('Game is not active') + if (this.pendingSearch) throw new GameError('Choose a card from your library first') + if (this.pendingChoice) throw new GameError('Resolve the pending choice first') + const actual = playerId ?? this.priority + if (this.priority !== actual) throw new GameError('You do not have priority') + const alive = this.alivePlayers().length + this.passesInRow++ + + if (!this.stack.length && this.phase === 'combat' && this.step === 'declare_blockers') { + const defenders = this.defendingPlayers() + if (defenders.has(actual)) this.blockersDeclared.add(actual) + if ([...defenders].every(id => this.blockersDeclared.has(id))) { + this.finishBlocking() + } else { + this.priority = this.nextAlivePlayer(actual) + } + return + } + + if (this.stack.length) { + if (this.passesInRow >= alive) { + this.passesInRow = 0 + this.resolveTop() + this.priority = this.getPlayer(this.activePlayer).lost ? this.nextAlivePlayer(this.activePlayer) : this.activePlayer + } else { + this.priority = this.nextAlivePlayer(actual) + } + return + } + + if (this.passesInRow >= alive) { + this.passesInRow = 0 + this.advancePhase() + } else { + this.priority = this.nextAlivePlayer(actual) + } + } + + /** Convenience for tests and scripted games: resolve the stack without advancing phases. */ + resolveStack(): void { + let guard = 0 + while (this.stack.length && this.status === 'active' && !this.pendingSearch && !this.pendingChoice + && guard++ < 1000) { + this.pass(this.priority) + } + } + + /** Ends the active player's turn, skipping any remaining combat. */ + endTurn(playerId: string): void { + this.requirePriority(playerId) + if (playerId !== this.activePlayer) throw new GameError('Only the active player can end the turn') + if (this.stack.length) throw new GameError('Cannot end the turn while the stack is not empty') + this.clearCombat() + this.phase = 'ending' + this.step = 'end_step' + this.dispatchEvent({ kind: 'end_step', player: playerId }) + this.resolveStack() + if (this.status !== 'active' || this.pendingSearch || this.pendingChoice) return + this.finishTurn() + } + + /** + * Passes priority for players who cannot do anything meaningful. Stops at the + * first player who can act, or when the turn ends, so turns never run on. + */ + autoAdvance(): void { + if (this.status !== 'active' || this.pendingSearch || this.pendingChoice || this.autoAdvanceDepth > 0) return + this.autoAdvanceDepth++ + const turn = this.turn + try { + let guard = 0 + while (this.status === 'active' && !this.pendingSearch && !this.pendingChoice + && this.turn === turn && guard++ < 100) { + const actor = this.priority + if (!actor || this.hasMeaningfulAction(actor)) break + this.pass(actor) + } + } finally { + this.autoAdvanceDepth-- + } + } + + // --------------------------------------------------------------------------- + // Turn structure + // --------------------------------------------------------------------------- + + protected beginTurn(): void { + const player = this.getPlayer(this.activePlayer) + this.phase = 'beginning' + this.step = 'untap' + this.passesInRow = 0 + this.priority = player.id + player.landPlayedThisTurn = false + player.cardsDrawnThisTurn = 0 + player.lifeGainedThisTurn = 0 + player.spellsCastThisTurn = 0 + player.creaturesDiedThisTurn = 0 + player.nonlandPermanentsEnteredThisTurn = 0 + player.attackedThisTurn = false + player.creaturesAttackedThisTurn = 0 + player.damageTakenThisTurn = 0 + player.manaPool = emptyPool() + this.triggeredThisTurn.clear() + + this.removeExpiringEffects(player.id) + for (const id of [...player.battlefield]) { + const object = this.objects.get(id) + if (!object || object.zone !== 'battlefield') continue + if (!this.hasRestriction(object, 'doesnt_untap')) object.tapped = false + } + + this.step = 'upkeep' + this.dispatchEvent({ kind: 'upkeep', player: player.id }) + if (this.status !== 'active') return + + this.step = 'draw' + if (!this.skipsDrawStep(player.id)) this.drawCard(player.id, false) + if (this.status !== 'active') return + + this.phase = 'precombat_main' + this.step = 'main' + this.priority = player.id + this.passesInRow = 0 + } + + /** True when a permanent that player controls replaces their draw step. */ + private skipsDrawStep(playerId: string): boolean { + for (const { source, ability } of this.staticAbilities()) { + if (source.controller !== playerId) continue + for (const effect of ability.effects) { + if (effect.op !== 'restriction' || effect.rule !== 'skip_draw_step') continue + if (effect.target.kind === 'player' && (effect.target.who === 'you' || effect.target.who === 'each_player')) { + return true + } + } + } + return false + } + + protected finishTurn(): void { + const player = this.getPlayer(this.activePlayer) + while (player.hand.length > 7) { + const cardId = player.hand[player.hand.length - 1] + this.moveToZone(cardId, 'graveyard', { silent: true }) + } + for (const object of this.objects.values()) { + if (object.zone === 'battlefield') { + object.damage = 0 + object.deathtouched = false + } + } + this.removeEffectsByDuration('until_end_of_turn') + // shortcut: every prevention shield expires at end of turn; upgrade when a + // permanent prevention effect is parsed (currently only one-shot shields). + this.damageShields.length = 0 + this.removeEndOfNextTurnEffects(player.id) + this.clearCombat() + for (const entry of this.players) entry.manaPool = emptyPool() + + if (this.status !== 'active') return + this.turn++ + this.activePlayer = this.nextAlivePlayer(this.activePlayer) + this.beginTurn() + } + + protected advancePhase(): void { + if (this.status !== 'active') return + if (this.stack.length) return + this.emptyManaPools() + + if (this.step === 'main' && this.phase === 'precombat_main') { + this.phase = 'combat' + this.step = 'begin_combat' + this.dispatchEvent({ kind: 'begin_combat', player: this.activePlayer }) + this.step = 'declare_attackers' + this.priority = this.activePlayer + this.passesInRow = 0 + return + } + if (this.step === 'declare_attackers') { + this.step = 'end_combat' + this.passesInRow = 0 + this.priority = this.activePlayer + return + } + if (this.step === 'declare_blockers') { + this.step = 'combat_damage' + this.combatDamageDone = false + this.passesInRow = 0 + this.priority = this.activePlayer + return + } + if (this.step === 'combat_damage') { + this.combatDamageDone = true + this.dealCombatDamage() + this.runStateBasedActions() + this.passesInRow = 0 + this.priority = this.activePlayer + return + } + if (this.step === 'end_combat') { + this.clearCombat() + this.removeEffectsByDuration('until_end_of_combat') + this.phase = 'postcombat_main' + this.step = 'main' + this.passesInRow = 0 + this.priority = this.activePlayer + return + } + if (this.step === 'main' && this.phase === 'postcombat_main') { + this.phase = 'ending' + this.step = 'end_step' + this.dispatchEvent({ kind: 'end_step', player: this.activePlayer }) + this.passesInRow = 0 + this.priority = this.activePlayer + return + } + if (this.step === 'end_step') { + this.finishTurn() + } + } + + protected resolveTop(): void { + const top = this.stack[this.stack.length - 1] + if (!top) return + if (top.optional && top.optionalAccepted === undefined) { + this.pendingChoices.push({ + playerId: top.controller, + sourceId: top.source.id, + what: 'optional', + label: top.label, + }) + return + } + const item = this.stack.pop() + if (!item) return + if (item.kind === 'spell' && item.source.zone !== 'stack') return + + const context = this.contextFor( + item.source, + item.controller, + item.targets, + item.x, + item.mode, + item.triggerSubject, + item.eventPlayer, + item.eventAmount, + ) + context.optionalTaken = item.optionalAccepted !== false + // Declining a "you may" still runs the "If you don't/Otherwise" branches. + // shortcut: optionality covers the whole effect list, not just its first + // sentence; upgrade when a card mixes an optional sentence with an + // unconditional later sentence. + const declined = item.optionalAccepted === false + const effects = declined + ? item.effects.filter(effect => effect.op === 'conditional' + && (effect.condition.kind === 'if_you_dont' || effect.condition.kind === 'otherwise')) + : item.effects + + if (item.kind === 'spell') { + if (this.isPermanent(item.source)) { + if (item.source.zone === 'stack') { + this.moveToZone(item.source, 'battlefield', { controller: item.controller, silent: false }) + } + this.applyEffects(context, effects) + } else { + this.applyEffects(context, effects) + if (item.source.zone === 'stack') this.moveToZone(item.source, 'graveyard', { silent: true }) + } + } else { + this.applyEffects(context, effects) + } + + this.logMessage(`Resolved ${item.label}`) + this.runStateBasedActions() + } + + protected counterStackItem(item: StackItem): void { + const index = this.stack.indexOf(item) + if (index >= 0) this.stack.splice(index, 1) + if (item.kind === 'spell' && item.source.zone === 'stack') { + this.moveToZone(item.source, 'graveyard', { silent: true }) + } + this.logMessage(`Countered ${item.label}`) + } + + // --------------------------------------------------------------------------- + // Casting, mana, and costs + // --------------------------------------------------------------------------- + + protected canCastAtThisTime(playerId: string, object: GameObject): boolean { + const instant = this.isInstant(object) + const flash = this.hasKeywordForDefinition(object.definition, 'Flash') + if (instant || flash) return true + return this.isMainPhaseWithEmptyStack(playerId) + } + + protected isMainPhaseWithEmptyStack(playerId: string): boolean { + return this.activePlayer === playerId + && (this.phase === 'precombat_main' || this.phase === 'postcombat_main') + && this.step === 'main' + && this.stack.length === 0 + } + + protected requirePriority(playerId: string): void { + if (this.status !== 'active') throw new GameError('Game is not active') + if (this.pendingSearch) throw new GameError('Choose a card from your library first') + if (this.pendingChoice) throw new GameError('Resolve the pending choice first') + if (this.priority !== playerId) throw new GameError('You do not have priority') + } + + protected hasMeaningfulAction(playerId: string): boolean { + if (this.status !== 'active' || this.priority !== playerId || this.pendingChoice) return false + const player = this.getPlayer(playerId) + if (player.lost) return false + + if (this.phase === 'combat' && this.step === 'declare_attackers' && !this.stack.length + && this.activePlayer === playerId && this.canAttackWithAny(playerId)) { + return true + } + if (this.phase === 'combat' && this.step === 'declare_blockers' && !this.stack.length + && this.canBlockWithAny(playerId)) { + return true + } + + if ([...player.hand, ...player.command, ...player.exile].some(id => this.canPlayCard(playerId, id))) return true + + for (const id of player.battlefield) { + const object = this.objects.get(id) + if (!object) continue + const abilities = object.definition.abilities ?? [] + for (let index = 0; index < abilities.length; index++) { + const ability = abilities[index] + if (ability.kind !== 'activated') continue + // Mana abilities alone do not advance the game; counting them would + // stop auto-pass on every untapped land. + if (ability.effects.length && ability.effects.every(effect => effect.op === 'add_mana')) continue + if (this.isActivatedAbilityPlayable(playerId, object, index, ability)) return true + } + } + return false + } +} diff --git a/backend/src/game/game-zones.ts b/backend/src/game/game-zones.ts new file mode 100644 index 0000000..038574a --- /dev/null +++ b/backend/src/game/game-zones.ts @@ -0,0 +1,479 @@ +import type { + Ability, + Condition, + Cost, + Duration, + Effect, + ManaSpec, + ObjectSelector, + PlayerRef, + StaticEffect, + Target, + TokenSpec, + TriggerEvent, + Value, + Zone, +} from '../effects/types.js' +import type { + ActionOptions, + CardDefinition, + CombatAttack, + CombatBlock, + GameObject, + GameConfig, + ManaColor, + ManaPool, + MulliganState, + PendingChoice, + PendingSearch, + Phase, + PlayerState, + StackItem, + Step, + TargetChoice, +} from './types.js' +import { CREATURE_TYPES } from './creature-types.js' +import { predefinedToken } from './tokens.js' + +import { GameError, ResolvedTarget, EventContext, EffectContext, ContinuousEffect, DamageShield, ManaCost, CostReduction, MANA_COLORS, COLOR_NAMES, emptyPool, parseManaCost, reduceManaSymbols, manaValueOf, colorOfSymbol, tokenCard, capitalize, tokenFace, mulberry32 } from './game-helpers.js' +import { GameCombat } from './game-combat.js' + +export abstract class GameZones extends GameCombat { + /** + * Adds a card directly to a zone. Intended for setup, tests, and future + * deck-building flows; by default no enter/leave triggers fire. + */ + addCard( + playerId: string, + definition: CardDefinition, + zone: Zone, + options: { controller?: string; tapped?: boolean; silent?: boolean } = {}, + ): GameObject { + const object = this.createObject(definition, playerId) + this.moveToZone(object, zone, { ...options, silent: options.silent ?? true }) + return object + } + + /** Purely cosmetic board layout: normalized center within the controller's mat. */ + movePermanent(playerId: string, cardId: string, x: number, y: number): void { + const object = this.getObject(cardId) + if (object.zone !== 'battlefield') throw new GameError('That card is not on the battlefield') + if (object.controller !== playerId) throw new GameError('You do not control that permanent') + if (!Number.isFinite(x) || !Number.isFinite(y)) throw new GameError('Invalid position') + object.position = { + x: Math.min(1, Math.max(0, x)), + y: Math.min(1, Math.max(0, y)), + } + } + + /** Moves an object to a zone, firing leave/enter triggers unless silenced. */ + moveToZone( + objectOrId: GameObject | string, + zone: Zone, + options: { controller?: string; tapped?: boolean; silent?: boolean; toTop?: boolean } = {}, + ): GameObject { + const object = typeof objectOrId === 'string' ? this.getObject(objectOrId) : objectOrId + // A commander may go to the command zone instead of the graveyard, exile, + // hand, or library. This engine always takes that replacement. + let destination: Zone = object.isCommander && zone !== 'battlefield' && zone !== 'stack' && zone !== 'command' + ? 'command' + : zone + if (destination === 'graveyard' && this.exilesInsteadOfGraveyard(object)) destination = 'exile' + if (destination === 'graveyard' && object.exileOnDeathTurn === this.turn && this.isCreature(object)) destination = 'exile' + const from = object.zone + this.removeFromZone(object) + object.zone = destination + if (destination !== 'exile') object.faceDown = undefined + + if (destination === 'battlefield') { + object.controller = options.controller ?? object.owner + object.tapped = options.tapped ?? false + object.damage = 0 + object.deathtouched = false + object.attacking = undefined + object.blockedBy = [] + object.blocking = undefined + object.activations = {} + object.chosenCreatureType = undefined + object.chosenColor = undefined + object.enteredTurn = this.turn + object.exileOnDeathTurn = undefined + this.getPlayer(object.controller).battlefield.push(object.id) + if (from !== 'battlefield') { + if (this.turn > 0 && !this.isLand(object)) { + this.getPlayer(object.controller).nonlandPermanentsEnteredThisTurn++ + } + if (!options.silent) { + this.applyEntersReplacements(object) + this.queueEnterChoices(object) + this.dispatchEvent({ kind: 'enters', player: object.controller, subject: object }) + } + } + } else { + object.position = undefined + object.controller = object.owner + object.chosenCreatureType = undefined + object.chosenColor = undefined + const owner = this.getPlayer(object.owner) + if (destination === 'hand') owner.hand.push(object.id) + else if (destination === 'graveyard') owner.graveyard.push(object.id) + else if (destination === 'exile') owner.exile.push(object.id) + else if (destination === 'command') { + object.tapped = false + owner.command.push(object.id) + } else if (destination === 'library') { + if (options.toTop) owner.library.unshift(object.id) + else owner.library.push(object.id) + } + } + + if (from === 'battlefield' && destination !== 'battlefield') { + this.handleLeavesBattlefield(object, destination) + } + + if (object.isToken && from === 'battlefield' && destination !== 'battlefield') { + this.objects.delete(object.id) + } + + return object + } + + protected handleLeavesBattlefield(object: GameObject, destination: Zone): void { + if (object.attachedTo) { + const attached = this.objects.get(object.attachedTo) + if (attached) attached.attachments = attached.attachments.filter(id => id !== object.id) + object.attachedTo = undefined + } + for (const attachmentId of [...object.attachments]) { + const attachment = this.objects.get(attachmentId) + if (attachment) attachment.attachedTo = undefined + } + object.attachments = [] + object.attacking = undefined + object.blockedBy = [] + object.blocking = undefined + object.linkedExile = undefined + + for (let index = this.continuousEffects.length - 1; index >= 0; index--) { + const effect = this.continuousEffects[index] + if (effect.sourceId !== object.id) continue + if (effect.duration === 'permanent' || effect.duration === 'while_source_on_battlefield') { + this.continuousEffects.splice(index, 1) + } + } + + if (destination === 'graveyard' && this.isCreature(object)) { + this.getPlayer(object.controller).creaturesDiedThisTurn++ + this.dispatchEvent({ kind: 'dies', player: object.controller, subject: object }) + } + this.dispatchEvent({ kind: 'leaves_battlefield', player: object.controller, subject: object }) + } + + protected runStateBasedActions(): void { + if (this.status !== 'active') return + let changed = true + let guard = 0 + while (changed && guard++ < 50 && this.status === 'active') { + changed = false + for (const player of this.players) { + if (!player.lost && (player.life <= 0 || player.poison >= 10 + || Object.values(player.commanderDamage).some(damage => damage >= 21))) { + this.losePlayer(player.id) + changed = true + } + } + if (this.status !== 'active') return + for (const id of [...this.battlefieldObjects().map(object => object.id)]) { + const object = this.objects.get(id) + if (!object || object.zone !== 'battlefield' || !this.isCreature(object)) continue + const lethal = this.getToughness(object) <= 0 + || object.damage >= this.getToughness(object) + || (object.deathtouched && object.damage > 0) + if (!lethal) continue + if (this.hasKeyword(object, 'Indestructible')) continue + if (object.regenerationShields > 0) { + object.regenerationShields-- + object.tapped = true + object.damage = 0 + object.deathtouched = false + object.attacking = undefined + object.blockedBy = [] + object.blocking = undefined + } else { + this.moveToZone(object, 'graveyard', { silent: false }) + } + changed = true + } + for (const player of this.alivePlayers()) { + const legends = new Map() + for (const object of this.battlefieldObjects()) { + if (object.controller !== player.id || !/\blegendary\b/i.test(object.definition.typeLine)) continue + const name = object.definition.name.toLowerCase() + legends.set(name, [...(legends.get(name) ?? []), object]) + } + for (const copies of legends.values()) { + // shortcut: keeps the first copy found, not the player's choice; ask when the API can pause for it + for (const extra of copies.slice(1)) { + this.moveToZone(extra, 'graveyard', { silent: false }) + changed = true + } + } + } + } + } + + protected losePlayer(playerId: string): void { + const player = this.getPlayer(playerId) + if (player.lost) return + player.lost = true + this.logMessage(`${player.name} loses the game`) + const alive = this.alivePlayers() + if (alive.length <= 1) { + this.status = 'finished' + this.winner = alive[0]?.id + if (this.winner) this.logMessage(`${this.getPlayer(this.winner).name} wins`) + } + } + + protected gainLife(playerId: string, amount: number): void { + amount = this.replacementAmount('life_gain', playerId, amount) + if (amount <= 0) return + const player = this.getPlayer(playerId) + if (player.lost) return + player.life += amount + player.lifeGainedThisTurn += amount + this.dispatchEvent({ kind: 'life', player: playerId, amount, mode: 'gain' }) + } + + protected loseLife(playerId: string, amount: number): void { + if (amount <= 0) return + const player = this.getPlayer(playerId) + if (player.lost) return + player.life -= amount + this.dispatchEvent({ kind: 'life', player: playerId, amount, mode: 'lose' }) + this.runStateBasedActions() + } + + protected drawCard(playerId: string, silent: boolean): void { + const count = this.replacementAmount('draw', playerId, 1) + for (let i = 0; i < count; i++) this.drawOne(playerId, silent) + } + + private drawOne(playerId: string, silent: boolean): void { + const player = this.getPlayer(playerId) + if (player.lost) return + if (!player.library.length) { + this.losePlayer(playerId) + return + } + const id = player.library.shift() + if (!id) return + player.hand.push(id) + const object = this.getObject(id) + object.zone = 'hand' + object.controller = playerId + player.cardsDrawnThisTurn++ + if (!silent) { + this.dispatchEvent({ kind: 'draw', player: playerId, amount: 1, ordinal: player.cardsDrawnThisTurn }) + } + } + + protected drawCards(playerId: string, amount: number): void { + for (let i = 0; i < amount; i++) this.drawCard(playerId, false) + } + + protected discardCards(playerId: string, amount: number, random: boolean | undefined, context: EffectContext): void { + const player = this.getPlayer(playerId) + for (let i = 0; i < amount && player.hand.length; i++) { + const index = random ? Math.floor(this.rng() * player.hand.length) : 0 + const id = player.hand[index] + this.moveToZone(id, 'graveyard', { silent: false }) + } + void context + } + + protected millCards(playerId: string, amount: number): void { + const player = this.getPlayer(playerId) + for (let i = 0; i < amount && player.library.length; i++) { + const id = player.library[0] + this.moveToZone(id, 'graveyard', { silent: true }) + } + } + + protected searchLibrary( + playerId: string, + selector: ObjectSelector, + amount: number, + destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom', + tapped: boolean, + shuffle: boolean, + zones?: ('library' | 'graveyard')[], + split?: { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean }, + ): void { + // shortcut: a search only pauses itself; later effects in the same ability + // still run before the pick, and a second search in that ability is skipped. + // Most search lines are a single effect. + if (this.pendingSearch) return + const player = this.getPlayer(playerId) + // Searching then shuffling is the same as shuffling first when the picked + // cards go on top, and it keeps the shuffle from burying them again. + if (shuffle && (destination === 'top' || split?.destination === 'top')) { + this.shuffleLibrary(player) + shuffle = false + } + let remaining = amount + let first = true + while (remaining > 0) { + const pickDestination = first ? destination : (split?.destination ?? destination) + const pickTapped = first ? tapped : (split?.tapped ?? tapped) + const candidates = this.findSearchCandidates(playerId, selector, zones) + if (!candidates.length) break + if (candidates.length > 1) { + this.pendingSearch = { + playerId, + selector, + remaining, + destination: pickDestination, + tapped: pickTapped, + shuffle, + zones, + ...(first && split && remaining > 1 ? { split } : {}), + } + return + } + this.moveSearchedCard(candidates[0], playerId, pickDestination, pickTapped) + remaining-- + first = false + } + if (shuffle) this.shuffleLibrary(player) + } + + protected findSearchCandidates( + playerId: string, + selector: ObjectSelector, + zones?: ('library' | 'graveyard')[], + ): GameObject[] { + const source = this.playerSource(playerId) + return this.searchableObjects(playerId, zones) + .filter(object => this.matchesSelector(object, selector, source, object.zone)) + } + + protected searchableObjects(playerId: string, zones?: ('library' | 'graveyard')[]): GameObject[] { + const player = this.getPlayer(playerId) + const allowed = zones ?? ['library'] + const libraryLimit = this.searchLibraryLimit(playerId) + const ids = allowed.includes('library') + ? player.library.slice(0, libraryLimit ?? player.library.length) + : [] + if (allowed.includes('graveyard')) ids.push(...player.graveyard) + return ids.map(id => this.getObject(id)).filter(object => object.owner === playerId) + } + + protected moveSearchedCard( + object: GameObject, + playerId: string, + destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom', + tapped: boolean, + ): void { + if (destination === 'battlefield') { + this.moveToZone(object, 'battlefield', { controller: playerId, tapped, silent: false }) + } else if (destination === 'hand') { + this.moveToZone(object, 'hand', { silent: false }) + } else if (destination === 'graveyard') { + this.moveToZone(object, 'graveyard', { silent: false }) + } else if (destination === 'top') { + this.moveToZone(object, 'library', { toTop: true, silent: false }) + } else { + this.moveToZone(object, 'library', { silent: false }) + } + } + + // shortcut: the limit is recomputed after each pick, so a multi-card search + // can see one new card per pick. Upgrade when a card searches for several + // cards while Aven Mindcensor is out. + protected searchLibraryLimit(playerId: string): number | undefined { + let limit: number | undefined + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'search_restriction') continue + const applies = effect.who === 'you' ? playerId === source.controller : playerId !== source.controller + if (!applies) continue + const amount = this.value(effect.amount, this.staticContext(source)) + limit = limit === undefined ? amount : Math.min(limit, amount) + } + } + return limit + } + + protected shuffleLibrary(player: PlayerState): void { + for (let index = player.library.length - 1; index > 0; index--) { + const swap = Math.floor(this.rng() * (index + 1)) + const temp = player.library[index] + player.library[index] = player.library[swap] + player.library[swap] = temp + } + } + + protected removeFromZone(object: GameObject): void { + const owner = this.getPlayer(object.owner) + if (object.zone === 'battlefield') { + const controller = this.getPlayer(object.controller) + controller.battlefield = controller.battlefield.filter(id => id !== object.id) + } else if (object.zone === 'hand') owner.hand = owner.hand.filter(id => id !== object.id) + else if (object.zone === 'graveyard') owner.graveyard = owner.graveyard.filter(id => id !== object.id) + else if (object.zone === 'exile') owner.exile = owner.exile.filter(id => id !== object.id) + else if (object.zone === 'command') owner.command = owner.command.filter(id => id !== object.id) + else if (object.zone === 'library') owner.library = owner.library.filter(id => id !== object.id) + } + + protected removeExpiringEffects(playerId: string): void { + for (let index = this.continuousEffects.length - 1; index >= 0; index--) { + const effect = this.continuousEffects[index] + if ((effect.duration === 'until_your_next_turn' || effect.duration === 'until_controllers_next_untap_step') + && effect.controller === playerId) { + this.continuousEffects.splice(index, 1) + } + } + } + + /** "Until the end of your next turn" skips the turn the effect was created in. */ + protected removeEndOfNextTurnEffects(playerId: string): void { + for (let index = this.continuousEffects.length - 1; index >= 0; index--) { + const effect = this.continuousEffects[index] + if (effect.duration === 'until_end_of_your_next_turn' && effect.controller === playerId + && effect.createdTurn !== this.turn) { + this.continuousEffects.splice(index, 1) + } + } + } + + protected removeEffectsByDuration(duration: Duration): void { + for (let index = this.continuousEffects.length - 1; index >= 0; index--) { + if (this.continuousEffects[index].duration === duration) this.continuousEffects.splice(index, 1) + } + } + + protected findStackItem(id: string): StackItem | undefined { + return this.stack.find(item => item.id === id) ?? this.stack.find(item => item.source.id === id) + } + + protected playerSource(playerId: string): GameObject { + return { + id: `player:${playerId}`, + definition: { oracleId: `player:${playerId}`, name: this.getPlayer(playerId).name, typeLine: '' }, + owner: playerId, + controller: playerId, + zone: 'battlefield', + tapped: false, + damage: 0, + deathtouched: false, + counters: {}, + isToken: false, + enteredTurn: 0, + blockedBy: [], + attachments: [], + regenerationShields: 0, + activations: {}, + } + } +} diff --git a/backend/src/game/game.ts b/backend/src/game/game.ts index bfe8b1d..ca05705 100644 --- a/backend/src/game/game.ts +++ b/backend/src/game/game.ts @@ -1,3879 +1,5 @@ -import type { - Ability, - Condition, - Cost, - Duration, - Effect, - ManaSpec, - ObjectSelector, - PlayerRef, - StaticEffect, - Target, - TokenSpec, - TriggerEvent, - Value, - Zone, -} from '../effects/types.js' -import type { - ActionOptions, - CardDefinition, - CombatAttack, - CombatBlock, - GameObject, - GameConfig, - ManaColor, - ManaPool, - MulliganState, - PendingChoice, - PendingSearch, - Phase, - PlayerState, - StackItem, - Step, - TargetChoice, -} from './types.js' -import { CREATURE_TYPES } from './creature-types.js' -import { predefinedToken } from './tokens.js' +import { GameTurn } from './game-turn.js' -export class GameError extends Error {} +export { GameError } from './game-helpers.js' -type ResolvedTarget = - | { kind: 'player'; id: string } - | { kind: 'object'; object: GameObject } - | { kind: 'stack'; item: StackItem } - -interface EventContext { - kind: TriggerEvent['kind'] - player?: string - subject?: GameObject - amount?: number - counter?: string - ordinal?: number - mode?: 'gain' | 'lose' - recipient?: 'player' | 'creature' | 'permanent' | 'any' - combat?: boolean - spell?: GameObject - spellItem?: StackItem -} - -interface EffectContext { - source: GameObject - controller: string - targets: TargetChoice[] - lastTarget?: ResolvedTarget - triggerSubject?: GameObject - eventPlayer?: string - eventAmount?: number - x: number - mode: number - /** Color picked for a mana ability, so choice effects produce it. */ - manaColor?: ManaColor -} - -interface ContinuousEffect { - id: string - sourceId: string - controller: string - effect: Extract - affectedIds: string[] - duration: Duration - createdTurn: number -} - -interface ManaCost { - generic: number - colored: ManaColor[] - hybrid: { colors: ManaColor[]; life: number }[] -} - -const MANA_COLORS: ManaColor[] = ['W', 'U', 'B', 'R', 'G', 'C'] -const COLOR_NAMES: Record = { - white: 'W', - blue: 'U', - black: 'B', - red: 'R', - green: 'G', - colorless: 'C', -} - -function emptyPool(): ManaPool { - return { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 } -} - -function parseManaCost(symbols: string, x = 0): ManaCost { - const cost: ManaCost = { generic: 0, colored: [], hybrid: [] } - for (const match of symbols.matchAll(/\{([^}]+)\}/g)) { - const symbol = match[1].toUpperCase() - if (/^\d+$/.test(symbol)) { - cost.generic += Number(symbol) - } else if (symbol === 'X') { - cost.generic += x - } else if (symbol === 'S') { - cost.colored.push('C') - } else if (/^[WUBRGC]$/.test(symbol)) { - cost.colored.push(symbol as ManaColor) - } else if (symbol.includes('/')) { - const parts = symbol.split('/') - const colors = parts - .filter(part => /^[WUBRG]$/.test(part)) - .map(part => part as ManaColor) - if (colors.length) cost.hybrid.push({ colors, life: parts.includes('P') ? 2 : 0 }) - else cost.generic += 1 - } else { - cost.generic += 1 - } - } - return cost -} - -interface CostReduction { - generic: number - colored: ManaColor[] -} - -/** - * Generic reductions only remove generic mana; colored ones remove matching pips. - * shortcut: hybrid and phyrexian pips are not reduced; upgrade when a card needs it. - */ -function reduceManaSymbols(symbols: string, reduction: CostReduction): string { - let generic = reduction.generic - const colored = [...reduction.colored] - const result: string[] = [] - for (const match of symbols.matchAll(/\{([^}]+)\}/g)) { - const symbol = match[1].toUpperCase() - if (/^\d+$/.test(symbol) && generic > 0) { - const remaining = Math.max(0, Number(symbol) - generic) - generic = Math.max(0, generic - Number(symbol)) - if (remaining > 0) result.push(`{${remaining}}`) - continue - } - const index = colored.indexOf(symbol as ManaColor) - if (index >= 0) { - colored.splice(index, 1) - continue - } - result.push(`{${match[1]}}`) - } - return result.join('') -} - -function manaValueOf(definition: CardDefinition): number { - if (definition.manaValue !== undefined) return definition.manaValue - const cost = parseManaCost(definition.manaCost ?? '') - return cost.generic + cost.colored.length + cost.hybrid.length -} - -function colorOfSymbol(symbol: string): ManaColor { - const bare = symbol.replace(/[{}]/g, '').toUpperCase() - if (bare === 'S') return 'C' - if (/^[WUBRGC]$/.test(bare)) return bare as ManaColor - return 'C' -} - -function tokenCard(token: { - name?: string - types: string[] - subtypes: string[] - colors: string[] - power?: number - toughness?: number - keywords?: string[] -}): { definition: CardDefinition; backFace?: CardDefinition } { - const predefined = predefinedToken(token) - const types = predefined?.types ?? token.types - const subtypes = predefined?.subtypes ?? token.subtypes - const colors = [...new Set([...(predefined?.colors ?? []), ...token.colors])] - const keywords = [...(predefined?.keywords ?? []), ...(token.keywords ?? [])] - const definition = tokenFace({ - name: predefined?.name ?? token.name ?? (subtypes.map(capitalize).join(' ') || 'Token'), - types, - subtypes, - colors, - power: token.power ?? predefined?.power, - toughness: token.toughness ?? predefined?.toughness, - keywords, - abilities: predefined?.abilities, - }) - const backFace = predefined?.backFace - ? tokenFace({ ...predefined.backFace, keywords: predefined.backFace.keywords ?? [] }) - : undefined - return { definition, backFace } -} - -function capitalize(word: string): string { - return word[0]?.toUpperCase() + word.slice(1) -} - -function tokenFace(fields: { - name: string - types: string[] - subtypes: string[] - colors: string[] - power?: number - toughness?: number - keywords?: string[] - abilities?: Ability[] -}): CardDefinition { - return { - oracleId: `token:${fields.name}`, - name: fields.name, - typeLine: [fields.types.join(' '), fields.subtypes.length ? `— ${fields.subtypes.join(' ')}` : ''].join(' ').trim(), - manaValue: 0, - colors: fields.colors, - power: fields.power, - toughness: fields.toughness, - abilities: [ - ...(fields.abilities ?? []), - ...(fields.keywords ?? []).map(keyword => ({ kind: 'keyword' as const, keyword })), - ], - } -} - - -/** - * A deliberately small but real Magic rules engine: zones, priority, the stack, - * turn phases, combat, state-based actions, mana, triggered/activated/static - * abilities, and an interpreter for the compiled card-effect AST. - */ -export class Game { - readonly players: PlayerState[] - readonly objects = new Map() - readonly stack: StackItem[] = [] - readonly log: string[] = [] - - turn = 0 - activePlayer = '' - phase: Phase = 'beginning' - step: Step = 'untap' - priority = '' - status: 'not_started' | 'mulligan' | 'active' | 'finished' = 'not_started' - winner?: string - /** Opening-hand choices, keyed by player id. */ - readonly mulligans = new Map() - /** Blocks all other actions until the searching player picks a card. */ - pendingSearch?: PendingSearch - /** "As this enters, choose..." prompts, in entry order. */ - readonly pendingChoices: PendingChoice[] = [] - - get pendingChoice(): PendingChoice | undefined { - return this.pendingChoices[0] - } - - private readonly config: GameConfig - private readonly rng: () => number - private readonly startingHandSize: number - private readonly firstPlayer: string - private readonly continuousEffects: ContinuousEffect[] = [] - private passesInRow = 0 - private blockersDeclared = new Set() - private nextId = 0 - private autoManaDepth = 0 - private autoAdvanceDepth = 0 - private statDepth = 0 - private keywordDepth = 0 - private combatDamageDone = false - - constructor(config: GameConfig) { - if (config.players.length < 2) throw new GameError('A game needs at least two players') - const ids = new Set(config.players.map(player => player.id)) - if (ids.size !== config.players.length) throw new GameError('Player ids must be unique') - - this.config = config - this.startingHandSize = config.startingHandSize ?? 7 - this.firstPlayer = config.firstPlayer ?? config.players[0].id - if (!ids.has(this.firstPlayer)) throw new GameError(`Unknown first player: ${this.firstPlayer}`) - this.rng = config.seed === undefined ? Math.random : mulberry32(config.seed) - - const startingLife = config.startingLife ?? 40 - this.players = config.players.map(player => ({ - id: player.id, - name: player.name ?? player.id, - life: player.life ?? startingLife, - lost: false, - manaPool: emptyPool(), - library: [], - hand: [], - graveyard: [], - exile: [], - battlefield: [], - command: [], - commanderDamage: {}, - commanderCasts: {}, - landPlayedThisTurn: false, - cardsDrawnThisTurn: 0, - lifeGainedThisTurn: 0, - spellsCastThisTurn: 0, - creaturesDiedThisTurn: 0, - nonlandPermanentsEnteredThisTurn: 0, - attackedThisTurn: false, - creaturesAttackedThisTurn: 0, - damageTakenThisTurn: 0, - energy: 0, - poison: 0, - })) - for (const player of this.players) { - this.mulligans.set(player.id, { count: 0, kept: false, bottom: 0 }) - } - - for (const playerConfig of config.players) { - for (const definition of playerConfig.deck) { - const object = this.createObject(definition, playerConfig.id) - this.getPlayer(playerConfig.id).library.push(object.id) - } - if (config.commander && playerConfig.commander) { - const commander = this.createObject(playerConfig.commander, playerConfig.id) - commander.isCommander = true - commander.zone = 'command' - this.getPlayer(playerConfig.id).command.push(commander.id) - this.getPlayer(playerConfig.id).commanderId = commander.id - } - } - } - - get player(): PlayerState { - return this.getPlayer(this.activePlayer) - } - - getPlayer(id: string): PlayerState { - const player = this.players.find(entry => entry.id === id) - if (!player) throw new GameError(`Unknown player: ${id}`) - return player - } - - getObject(id: string): GameObject { - const object = this.objects.get(id) - if (!object) throw new GameError(`Unknown object: ${id}`) - return object - } - - /** - * Starts the game, shuffles libraries, and draws opening hands. With mulligans - * enabled, turn 1 waits until every player keeps; otherwise it begins immediately. - */ - start(): void { - if (this.status !== 'not_started') throw new GameError('Game already started') - for (const player of this.players) this.shuffleLibrary(player) - for (const player of this.players) { - for (let i = 0; i < this.startingHandSize; i++) { - if (!player.library.length) break - this.drawCard(player.id, true) - } - } - - if (!this.config.mulligans) { - this.beginGame() - return - } - this.status = 'mulligan' - this.turn = 1 - this.activePlayer = this.firstPlayer - } - - /** Keeps the opening hand; turn 1 begins once every living player has kept. */ - keepHand(playerId: string): void { - const mulligan = this.requireMulligan(playerId) - if (mulligan.kept) throw new GameError('You already kept your hand') - if (mulligan.bottom > 0) throw new GameError('Put your cards on the bottom first') - mulligan.kept = true - const player = this.getPlayer(playerId) - this.logMessage(`${player.name} keeps their hand${mulligan.count ? ` after ${mulligan.count} mulligan${mulligan.count === 1 ? '' : 's'}` : ''}`) - if (this.players.every(entry => entry.lost || this.mulligans.get(entry.id)?.kept)) this.beginGame() - } - - /** Shuffles the hand back and draws a new one; each mulligan bottoms one more card. */ - mulligan(playerId: string): void { - const mulligan = this.requireMulligan(playerId) - if (mulligan.kept) throw new GameError('You already kept your hand') - if (mulligan.bottom > 0) throw new GameError('Put your cards on the bottom first') - const player = this.getPlayer(playerId) - for (const id of [...player.hand]) this.moveToZone(id, 'library', { silent: true }) - this.shuffleLibrary(player) - for (let i = 0; i < this.startingHandSize; i++) { - if (!player.library.length) break - this.drawCard(player.id, true) - } - mulligan.count++ - mulligan.bottom = Math.min(Math.max(0, mulligan.count - 1), player.hand.length) - this.logMessage(`${player.name} mulligans${mulligan.bottom - ? ` and puts ${mulligan.bottom} card${mulligan.bottom === 1 ? '' : 's'} on the bottom` - : ''}`) - } - - /** Puts one card from a mulliganed opening hand on the bottom of the library. */ - putOnBottom(playerId: string, cardId: string): void { - const mulligan = this.requireMulligan(playerId) - if (mulligan.kept) throw new GameError('You already kept your hand') - if (mulligan.bottom <= 0) throw new GameError('You have no cards to put on the bottom') - const player = this.getPlayer(playerId) - if (!player.hand.includes(cardId)) throw new GameError('Card is not in hand') - this.moveToZone(cardId, 'library', { silent: true }) - mulligan.bottom-- - } - - private requireMulligan(playerId: string): MulliganState { - if (this.status !== 'mulligan') throw new GameError('The game is not in its mulligan step') - const player = this.getPlayer(playerId) - if (player.lost) throw new GameError('You have left the game') - const mulligan = this.mulligans.get(playerId) - if (!mulligan) throw new GameError(`Unknown player: ${playerId}`) - return mulligan - } - - private beginGame(): void { - // Leyline-style "begin the game with it on the battlefield" cards. - for (const player of this.players) { - if (player.lost) continue - for (const id of [...player.hand]) { - const object = this.getObject(id) - const beginsOnBattlefield = (object.definition.abilities ?? []).some(ability => - ability.kind === 'static' && ability.effects.some(effect => - effect.op === 'restriction' && effect.rule === 'begin_on_battlefield')) - if (beginsOnBattlefield) this.moveToZone(object, 'battlefield', { controller: player.id, silent: true }) - } - } - - this.status = 'active' - this.turn = 1 - this.activePlayer = this.firstPlayer - this.beginTurn() - } - - /** - * Adds a card directly to a zone. Intended for setup, tests, and future - * deck-building flows; by default no enter/leave triggers fire. - */ - addCard( - playerId: string, - definition: CardDefinition, - zone: Zone, - options: { controller?: string; tapped?: boolean; silent?: boolean } = {}, - ): GameObject { - const object = this.createObject(definition, playerId) - this.moveToZone(object, zone, { ...options, silent: options.silent ?? true }) - return object - } - - /** Purely cosmetic board layout: normalized center within the controller's mat. */ - movePermanent(playerId: string, cardId: string, x: number, y: number): void { - const object = this.getObject(cardId) - if (object.zone !== 'battlefield') throw new GameError('That card is not on the battlefield') - if (object.controller !== playerId) throw new GameError('You do not control that permanent') - if (!Number.isFinite(x) || !Number.isFinite(y)) throw new GameError('Invalid position') - object.position = { - x: Math.min(1, Math.max(0, x)), - y: Math.min(1, Math.max(0, y)), - } - } - - /** Moves an object to a zone, firing leave/enter triggers unless silenced. */ - moveToZone( - objectOrId: GameObject | string, - zone: Zone, - options: { controller?: string; tapped?: boolean; silent?: boolean; toTop?: boolean } = {}, - ): GameObject { - const object = typeof objectOrId === 'string' ? this.getObject(objectOrId) : objectOrId - // A commander may go to the command zone instead of the graveyard, exile, - // hand, or library. This engine always takes that replacement. - let destination: Zone = object.isCommander && zone !== 'battlefield' && zone !== 'stack' && zone !== 'command' - ? 'command' - : zone - if (destination === 'graveyard' && this.exilesInsteadOfGraveyard(object)) destination = 'exile' - const from = object.zone - this.removeFromZone(object) - object.zone = destination - if (destination !== 'exile') object.faceDown = undefined - - if (destination === 'battlefield') { - object.controller = options.controller ?? object.owner - object.tapped = options.tapped ?? false - object.damage = 0 - object.deathtouched = false - object.attacking = undefined - object.blockedBy = [] - object.blocking = undefined - object.activations = {} - object.chosenCreatureType = undefined - object.enteredTurn = this.turn - this.getPlayer(object.controller).battlefield.push(object.id) - if (from !== 'battlefield') { - if (this.turn > 0 && !this.isLand(object)) { - this.getPlayer(object.controller).nonlandPermanentsEnteredThisTurn++ - } - if (!options.silent) { - this.applyEntersReplacements(object) - this.queueEnterChoices(object) - this.dispatchEvent({ kind: 'enters', player: object.controller, subject: object }) - } - } - } else { - object.position = undefined - object.controller = object.owner - object.chosenCreatureType = undefined - const owner = this.getPlayer(object.owner) - if (destination === 'hand') owner.hand.push(object.id) - else if (destination === 'graveyard') owner.graveyard.push(object.id) - else if (destination === 'exile') owner.exile.push(object.id) - else if (destination === 'command') { - object.tapped = false - owner.command.push(object.id) - } else if (destination === 'library') { - if (options.toTop) owner.library.unshift(object.id) - else owner.library.push(object.id) - } - } - - if (from === 'battlefield' && destination !== 'battlefield') { - this.handleLeavesBattlefield(object, destination) - } - - if (object.isToken && from === 'battlefield' && destination !== 'battlefield') { - this.objects.delete(object.id) - } - - return object - } - - getPower(objectOrId: GameObject | string): number { - const object = typeof objectOrId === 'string' ? this.getObject(objectOrId) : objectOrId - const base = object.definition.power ?? 0 - if (this.statDepth > 0) return base - this.statDepth++ - try { - let power = base - let toughness = object.definition.toughness ?? 0 - - for (const staticSource of this.staticAbilities()) { - for (const effect of staticSource.ability.effects) { - if (effect.op !== 'set_pt') continue - if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue - if (effect.power) power = this.value(effect.power, this.staticContext(staticSource.source)) - if (effect.toughness) toughness = this.value(effect.toughness, this.staticContext(staticSource.source)) - } - } - for (const continuous of this.continuousEffects) { - if (continuous.effect.op !== 'set_pt' || !continuous.affectedIds.includes(object.id)) continue - const context = this.continuousContext(continuous) - if (continuous.effect.power) power = this.value(continuous.effect.power, context) - if (continuous.effect.toughness) toughness = this.value(continuous.effect.toughness, context) - } - - const counterPower = this.counterStat(object.counters, 'power') - const counterToughness = this.counterStat(object.counters, 'toughness') - power += counterPower - toughness += counterToughness - - for (const staticSource of this.staticAbilities()) { - for (const effect of staticSource.ability.effects) { - if (effect.op !== 'pump') continue - if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue - const context = this.staticContext(staticSource.source) - power += this.value(effect.power, context) - toughness += this.value(effect.toughness, context) - } - } - for (const continuous of this.continuousEffects) { - if (continuous.effect.op !== 'pump' || !continuous.affectedIds.includes(object.id)) continue - const context = this.continuousContext(continuous) - power += this.value(continuous.effect.power, context) - toughness += this.value(continuous.effect.toughness, context) - } - return power - } finally { - this.statDepth-- - } - } - - getToughness(objectOrId: GameObject | string): number { - const object = typeof objectOrId === 'string' ? this.getObject(objectOrId) : objectOrId - const base = object.definition.toughness ?? 0 - if (this.statDepth > 0) return base - this.statDepth++ - try { - let power = base - let toughness = object.definition.toughness ?? 0 - - for (const staticSource of this.staticAbilities()) { - for (const effect of staticSource.ability.effects) { - if (effect.op !== 'set_pt') continue - if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue - if (effect.power) power = this.value(effect.power, this.staticContext(staticSource.source)) - if (effect.toughness) toughness = this.value(effect.toughness, this.staticContext(staticSource.source)) - } - } - for (const continuous of this.continuousEffects) { - if (continuous.effect.op !== 'set_pt' || !continuous.affectedIds.includes(object.id)) continue - const context = this.continuousContext(continuous) - if (continuous.effect.power) power = this.value(continuous.effect.power, context) - if (continuous.effect.toughness) toughness = this.value(continuous.effect.toughness, context) - } - - toughness += this.counterStat(object.counters, 'toughness') - - for (const staticSource of this.staticAbilities()) { - for (const effect of staticSource.ability.effects) { - if (effect.op !== 'pump') continue - if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue - toughness += this.value(effect.toughness, this.staticContext(staticSource.source)) - } - } - for (const continuous of this.continuousEffects) { - if (continuous.effect.op !== 'pump' || !continuous.affectedIds.includes(object.id)) continue - toughness += this.value(continuous.effect.toughness, this.continuousContext(continuous)) - } - return toughness - } finally { - this.statDepth-- - } - } - - hasKeyword(objectOrId: GameObject | string, keyword: string): boolean { - const object = typeof objectOrId === 'string' ? this.getObject(objectOrId) : objectOrId - const wanted = keyword.toLowerCase() - if (this.keywordDepth > 0) { - for (const ability of object.definition.abilities ?? []) { - if (ability.kind === 'keyword' && ability.keyword.toLowerCase() === wanted) return true - } - return false - } - this.keywordDepth++ - try { - for (const ability of object.definition.abilities ?? []) { - if (ability.kind === 'keyword' && ability.keyword.toLowerCase() === wanted) return true - if (ability.kind === 'keywords' && ability.keywords.some(entry => entry.keyword.toLowerCase() === wanted)) { - return true - } - } - for (const staticSource of this.staticAbilities()) { - for (const effect of staticSource.ability.effects) { - if (effect.op !== 'grant' || effect.keyword.toLowerCase() !== wanted) continue - if (this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) return true - } - } - for (const continuous of this.continuousEffects) { - if (continuous.effect.op !== 'grant' || continuous.effect.keyword.toLowerCase() !== wanted) continue - if (continuous.affectedIds.includes(object.id)) return true - } - return false - } finally { - this.keywordDepth-- - } - } - - playLand(playerId: string, cardId: string): GameObject { - this.requirePriority(playerId) - const player = this.getPlayer(playerId) - if (this.activePlayer !== playerId) throw new GameError('Only the active player may play a land') - if (this.phase !== 'precombat_main' && this.phase !== 'postcombat_main') { - throw new GameError('Lands can only be played during a main phase') - } - if (this.stack.length) throw new GameError('Cannot play a land while the stack is not empty') - if (player.landPlayedThisTurn) throw new GameError('Already played a land this turn') - const object = this.getObject(cardId) - if (!player.hand.includes(cardId) && !this.playableFromExile(playerId, object)) { - throw new GameError('Card is not in hand') - } - if (!this.isLand(object)) throw new GameError('That card is not a land') - - player.landPlayedThisTurn = true - this.moveToZone(object, 'battlefield', { controller: playerId, silent: false }) - this.passesInRow = 0 - this.logMessage(`${player.name} plays ${object.definition.name}`) - this.runStateBasedActions() - return object - } - - castSpell(playerId: string, cardId: string, options: ActionOptions = {}): StackItem { - this.requirePriority(playerId) - if (this.status !== 'active') throw new GameError('Game is not active') - const player = this.getPlayer(playerId) - const fromCommand = player.command.includes(cardId) - const object = this.getObject(cardId) - if (!fromCommand && !player.hand.includes(cardId) && !this.playableFromExile(playerId, object)) { - throw new GameError('Card is not in hand') - } - if (fromCommand && !object.isCommander) throw new GameError('That card cannot be cast from the command zone') - if (this.isLand(object)) throw new GameError('Land cards are played, not cast') - if (!this.canCastAtThisTime(playerId, object)) { - throw new GameError('That spell cannot be cast right now') - } - - const abilities = object.definition.abilities ?? [] - const overload = abilities.find((ability): ability is Extract => ability.kind === 'overload') - if (options.overload && !overload) throw new GameError('That spell has no overload') - const baseEffects = abilities.filter((ability): ability is Extract => ability.kind === 'spell') - .flatMap(ability => ability.effects) - const effects = options.overload ? this.overloadEffects(baseEffects) : baseEffects - const targets = this.selectTargets(effects, object, playerId, options.targets ?? [], options.mode ?? 0) - const tax = fromCommand ? (player.commanderCasts[object.id] ?? 0) * 2 : 0 - const taxSymbols = '{2}'.repeat(tax / 2) - const extra = this.spellCostIncrease(object) - const alternative = this.alternativeCostFor(object) - if (options.overload && overload) { - this.payMana(playerId, `${this.reducedSpellCost(object, overload.cost)}${taxSymbols}${extra ? `{${extra}}` : ''}`, options.x ?? 0) - } else if (alternative) { - this.payAlternativeCost(alternative, playerId, object) - if (extra) this.payMana(playerId, `{${extra}}`, 0) - } else { - const cost = this.reducedSpellCost(object, object.definition.manaCost ?? '') - this.payMana(playerId, `${cost}${taxSymbols}${extra ? `{${extra}}` : ''}`, options.x ?? 0) - } - - this.moveToZone(object, 'stack', { controller: playerId, silent: true }) - if (fromCommand) player.commanderCasts[object.id] = (player.commanderCasts[object.id] ?? 0) + 1 - const item: StackItem = { - id: this.generateId('stack'), - kind: 'spell', - source: object, - controller: playerId, - label: object.definition.name, - effects, - targets, - x: options.x ?? 0, - mode: options.mode ?? 0, - } - this.stack.push(item) - player.spellsCastThisTurn++ - this.passesInRow = 0 - this.priority = this.nextAlivePlayer(playerId) - this.dispatchEvent({ kind: 'cast', player: playerId, subject: object, spell: object, spellItem: item }) - this.logMessage(`${player.name} casts ${object.definition.name}`) - return item - } - - private alternativeCostFor(object: GameObject): Extract | undefined { - return (object.definition.abilities ?? []).find(ability => - ability.kind === 'alternative_cost' - && (!ability.condition || this.checkCondition(ability.condition, object))) as - | Extract - | undefined - } - - private payAlternativeCost( - ability: Extract, - playerId: string, - source: GameObject, - ): void { - if (!ability.costs.length) return - this.payCosts(ability.costs, playerId, source, this.contextFor(source, playerId, [], 0, 0)) - } - - private spellCostIncrease(object: GameObject): number { - let extra = 0 - for (const { source, ability } of this.staticAbilities()) { - for (const effect of ability.effects) { - if (effect.op !== 'cost_increase') continue - if (effect.spellType === 'noncreature' && this.isCreature(object)) continue - if (effect.spellType === 'creature' && !this.isCreature(object)) continue - extra += this.value(effect.amount, this.staticContext(source)) - } - } - return extra - } - - // shortcut: only static reducers on the battlefield; a card's own "this spell - // costs less" text is not applied yet. Upgrade when self-cost cards matter. - private spellCostReduction(object: GameObject): CostReduction { - const reduction: CostReduction = { generic: 0, colored: [] } - for (const { source, ability } of this.staticAbilities()) { - for (const effect of ability.effects) { - if (effect.op !== 'cost_reduction' || effect.target.kind !== 'object') continue - if (!this.matchesSelector(object, effect.target.selector, source, object.zone)) continue - if (effect.amount) reduction.generic += this.value(effect.amount, this.staticContext(source)) - if (effect.symbols) { - const cost = parseManaCost(effect.symbols) - reduction.generic += cost.generic - reduction.colored.push(...cost.colored) - } - } - } - return reduction - } - - private reducedSpellCost(object: GameObject, symbols: string): string { - return reduceManaSymbols(symbols, this.spellCostReduction(object)) - } - - // shortcut: overload only widens top-level targets; modal/conditional nested - // effects keep their original targets. Upgrade when an overload card nests them. - private overloadEffects(effects: Effect[]): Effect[] { - return effects.map(effect => ('target' in effect && effect.target - ? { ...effect, target: this.overloadTarget(effect.target) } - : effect)) - } - - private overloadTarget(target: Target): Target { - if (target.kind === 'object' || target.kind === 'player' || target.kind === 'spell') { - return { ...target, mode: 'each' } - } - return target - } - - activateAbility(playerId: string, sourceId: string, abilityIndex: number, options: ActionOptions = {}): StackItem | undefined { - this.requirePriority(playerId) - const source = this.getObject(sourceId) - if (source.zone !== 'battlefield') throw new GameError('Ability source is not on the battlefield') - if (source.controller !== playerId) throw new GameError('You do not control that permanent') - if (this.hasRestriction(source, 'cant_activate')) throw new GameError('That permanent cannot activate abilities') - const ability = (source.definition.abilities ?? [])[abilityIndex] - if (!ability || ability.kind !== 'activated') throw new GameError('That is not an activated ability') - if (ability.condition && !this.checkCondition(ability.condition, source)) throw new GameError('Ability condition is not met') - if (ability.timing === 'sorcery' && !this.isMainPhaseWithEmptyStack(playerId)) { - throw new GameError('Activate only as a sorcery') - } - if (ability.costs.some(cost => cost.kind === 'tap') && this.isCreature(source) - && source.enteredTurn >= this.turn && !this.hasKeyword(source, 'Haste')) { - throw new GameError('That creature has summoning sickness') - } - const activations = source.activations[abilityIndex] ?? 0 - if (ability.activationsPerTurn !== undefined && activations >= ability.activationsPerTurn) { - throw new GameError('Ability activation limit reached') - } - if (options.manaColor && !this.manaColorChoices(source, abilityIndex)?.includes(options.manaColor)) { - throw new GameError('That ability cannot produce that mana') - } - - const targets = this.selectTargets(ability.effects, source, playerId, options.targets ?? [], options.mode ?? 0) - const context = this.contextFor(source, playerId, targets, options.x ?? 0, options.mode ?? 0) - context.manaColor = options.manaColor - this.payCosts(ability.costs, playerId, source, context) - source.activations[abilityIndex] = activations + 1 - - // Mana abilities bypass the stack, which also makes auto-payment possible. - if (ability.effects.length && ability.effects.every(effect => effect.op === 'add_mana')) { - this.applyEffects(context, ability.effects) - this.passesInRow = 0 - this.logMessage(`${this.getPlayer(playerId).name} activates ${source.definition.name}`) - return undefined - } - - const item: StackItem = { - id: this.generateId('stack'), - kind: 'ability', - source, - controller: playerId, - label: ability.text, - effects: ability.effects, - targets, - x: options.x ?? 0, - mode: options.mode ?? 0, - } - this.stack.push(item) - this.passesInRow = 0 - this.priority = this.nextAlivePlayer(playerId) - this.logMessage(`${this.getPlayer(playerId).name} activates ${source.definition.name}`) - return item - } - - /** Declares attackers, beginning combat first if necessary. */ - declareAttackers(playerId: string, attacks: CombatAttack[]): void { - this.requirePriority(playerId) - if (this.stack.length) throw new GameError('Cannot declare attackers while the stack is not empty') - if (this.activePlayer !== playerId) throw new GameError('Only the active player can attack') - if (this.phase === 'precombat_main') { - this.phase = 'combat' - this.step = 'declare_attackers' - this.dispatchEvent({ kind: 'begin_combat', player: playerId }) - } - if (this.phase !== 'combat' || this.step !== 'declare_attackers') { - throw new GameError('Not in the declare attackers step') - } - - const seen = new Set() - for (const attack of attacks) { - if (seen.has(attack.attackerId)) throw new GameError('A creature can only attack once') - seen.add(attack.attackerId) - const attacker = this.getObject(attack.attackerId) - this.requireCanAttack(attacker, playerId) - const defender = this.getPlayer(attack.defenderId) - if (defender.id === playerId) throw new GameError('A player cannot attack themselves') - attacker.attacking = attack.defenderId - if (!this.hasKeyword(attacker, 'Vigilance')) attacker.tapped = true - this.getPlayer(playerId).attackedThisTurn = true - this.getPlayer(playerId).creaturesAttackedThisTurn++ - this.dispatchEvent({ kind: 'attacks', player: playerId, subject: attacker }) - } - - this.step = attacks.length ? 'declare_blockers' : 'end_combat' - this.blockersDeclared.clear() - this.passesInRow = 0 - this.priority = this.nextAlivePlayer(playerId) - this.logMessage(`${this.getPlayer(playerId).name} attacks with ${attacks.length} creature(s)`) - } - - /** Marks a player as having forfeited. */ - concede(playerId: string): void { - if (this.status !== 'active' && this.status !== 'mulligan') throw new GameError('Game is not active') - this.losePlayer(playerId) - if (this.priority === playerId) this.priority = this.nextAlivePlayer(playerId) - } - - /** Declares blockers for the current combat. */ - declareBlockers(playerId: string, blocks: CombatBlock[]): void { - if (this.phase !== 'combat' || this.step !== 'declare_blockers') throw new GameError('Not in the declare blockers step') - if (this.stack.length) throw new GameError('Cannot declare blockers while the stack is not empty') - if (this.pendingSearch) throw new GameError('Choose a card from your library first') - if (this.pendingChoice) throw new GameError('Resolve the pending choice first') - if (this.priority !== playerId) throw new GameError('You do not have priority') - - const seen = new Set() - for (const block of blocks) { - if (seen.has(block.blockerId)) throw new GameError('A creature can only block once') - seen.add(block.blockerId) - const blocker = this.getObject(block.blockerId) - const attacker = this.getObject(block.attackerId) - if (blocker.controller !== playerId) throw new GameError('You do not control that blocker') - if (blocker.zone !== 'battlefield' || attacker.zone !== 'battlefield') throw new GameError('Object is not on the battlefield') - if (!this.isCreature(blocker)) throw new GameError('Only creatures can block') - if (blocker.tapped) throw new GameError('Tapped creatures cannot block') - if (blocker.blocking) throw new GameError('Creature is already blocking') - if (attacker.attacking !== playerId) throw new GameError('That creature is not attacking you') - if (this.hasRestriction(blocker, 'cant_block')) throw new GameError('That creature cannot block') - if (this.hasKeyword(attacker, 'Flying') && !this.hasKeyword(blocker, 'Flying') && !this.hasKeyword(blocker, 'Reach')) { - throw new GameError('That creature cannot block a flyer') - } - blocker.blocking = attacker.id - attacker.blockedBy.push(blocker.id) - this.dispatchEvent({ kind: 'blocks', player: playerId, subject: blocker }) - } - - this.blockersDeclared.add(playerId) - this.logMessage(`${this.getPlayer(playerId).name} declares ${blocks.length} blocker(s)`) - if ([...this.defendingPlayers()].every(id => this.blockersDeclared.has(id))) { - this.finishBlocking() - } else { - this.passesInRow = 0 - this.priority = this.nextAlivePlayer(playerId) - } - } - - private defendingPlayers(): Set { - return new Set(this.battlefieldObjects() - .filter(object => object.attacking) - .map(object => object.attacking as string)) - } - - private finishBlocking(): void { - this.step = 'combat_damage' - this.combatDamageDone = false - this.passesInRow = 0 - this.priority = this.activePlayer - } - - /** Resolves the combat damage step. Also runs automatically when both players pass. */ - resolveCombatDamage(): void { - if (this.phase !== 'combat' || this.step !== 'combat_damage') throw new GameError('Not in the combat damage step') - if (this.combatDamageDone) throw new GameError('Combat damage has already been dealt') - this.combatDamageDone = true - this.dealCombatDamage() - this.runStateBasedActions() - } - - /** Passes priority. When all players pass, the top of the stack resolves or the phase advances. */ - pass(playerId?: string): void { - if (this.status !== 'active') throw new GameError('Game is not active') - if (this.pendingSearch) throw new GameError('Choose a card from your library first') - if (this.pendingChoice) throw new GameError('Resolve the pending choice first') - const actual = playerId ?? this.priority - if (this.priority !== actual) throw new GameError('You do not have priority') - const alive = this.alivePlayers().length - this.passesInRow++ - - if (!this.stack.length && this.phase === 'combat' && this.step === 'declare_blockers') { - const defenders = this.defendingPlayers() - if (defenders.has(actual)) this.blockersDeclared.add(actual) - if ([...defenders].every(id => this.blockersDeclared.has(id))) { - this.finishBlocking() - } else { - this.priority = this.nextAlivePlayer(actual) - } - return - } - - if (this.stack.length) { - if (this.passesInRow >= alive) { - this.passesInRow = 0 - this.resolveTop() - this.priority = this.getPlayer(this.activePlayer).lost ? this.nextAlivePlayer(this.activePlayer) : this.activePlayer - } else { - this.priority = this.nextAlivePlayer(actual) - } - return - } - - if (this.passesInRow >= alive) { - this.passesInRow = 0 - this.advancePhase() - } else { - this.priority = this.nextAlivePlayer(actual) - } - } - - /** Convenience for tests and scripted games: resolve the stack without advancing phases. */ - resolveStack(): void { - let guard = 0 - while (this.stack.length && this.status === 'active' && !this.pendingSearch && !this.pendingChoice - && guard++ < 1000) { - this.pass(this.priority) - } - } - - /** Ends the active player's turn, skipping any remaining combat. */ - endTurn(playerId: string): void { - this.requirePriority(playerId) - if (playerId !== this.activePlayer) throw new GameError('Only the active player can end the turn') - if (this.stack.length) throw new GameError('Cannot end the turn while the stack is not empty') - this.clearCombat() - this.phase = 'ending' - this.step = 'end_step' - this.dispatchEvent({ kind: 'end_step', player: playerId }) - this.resolveStack() - if (this.status !== 'active' || this.pendingSearch || this.pendingChoice) return - this.finishTurn() - } - - /** - * Whether the player could legally play a card from hand or the command zone - * right now. Used for the client's playable state and for auto-passing. - */ - canPlayCard(playerId: string, cardId: string): boolean { - if (this.status !== 'active' || this.priority !== playerId || this.pendingSearch || this.pendingChoice) return false - const player = this.getPlayer(playerId) - const fromCommand = player.command.includes(cardId) - const object = this.getObject(cardId) - if (!fromCommand && !player.hand.includes(cardId) && !this.playableFromExile(playerId, object)) return false - if (fromCommand && !object.isCommander) return false - - if (this.isLand(object)) { - return this.activePlayer === playerId - && (this.phase === 'precombat_main' || this.phase === 'postcombat_main') - && !this.stack.length - && !player.landPlayedThisTurn - } - - if (!this.canCastAtThisTime(playerId, object)) return false - const tax = fromCommand ? (player.commanderCasts[cardId] ?? 0) * 2 : 0 - const extra = this.spellCostIncrease(object) - const alternative = this.alternativeCostFor(object) - if (alternative) { - for (const cost of alternative.costs) { - if (cost.kind !== 'mana' || !this.canAffordMana(playerId, cost.symbols, 0)) return false - } - } else if (!this.canAffordMana( - playerId, - `${this.reducedSpellCost(object, object.definition.manaCost ?? '')}${'{2}'.repeat(tax / 2)}${extra ? `{${extra}}` : ''}`, - 0, - )) { - return false - } - if (alternative && extra && !this.canAffordMana(playerId, `{${extra}}`, 0)) return false - return this.hasLegalTargets(object, playerId) - } - - /** Junk and other impulse effects grant a one-turn play permission from exile. */ - private playableFromExile(playerId: string, object: GameObject): boolean { - return object.zone === 'exile' - && object.owner === playerId - && object.playableFromExileTurn === this.turn - } - - /** - * Finishes one pick of a paused library search. Searches pause when several - * cards match so the player chooses instead of taking the first one. - */ - chooseSearchCard(playerId: string, cardId: string): void { - const pending = this.pendingSearch - if (!pending) throw new GameError('No search is waiting for a choice') - if (this.pendingChoice) throw new GameError('Resolve the pending choice first') - if (pending.playerId !== playerId) throw new GameError('You are not searching your library') - const object = this.searchCandidates(playerId).find(candidate => candidate.id === cardId) - if (!object) throw new GameError('That card is not a legal choice') - - this.moveSearchedCard(object, playerId, pending.destination, pending.tapped) - pending.remaining-- - if (pending.remaining > 0 && pending.split) { - pending.destination = pending.split.destination - pending.tapped = pending.split.tapped - pending.split = undefined - } - if (pending.remaining <= 0 || !this.searchCandidates(playerId).length) { - this.pendingSearch = undefined - if (pending.shuffle) this.shuffleLibrary(this.getPlayer(playerId)) - this.priority = this.getPlayer(this.activePlayer).lost - ? this.nextAlivePlayer(this.activePlayer) - : this.activePlayer - } - this.runStateBasedActions() - } - - /** Cards the pending search may pick, in library order. Empty for other players. */ - searchCandidates(playerId: string): GameObject[] { - const pending = this.pendingSearch - if (!pending || pending.playerId !== playerId) return [] - return this.findSearchCandidates(playerId, pending.selector, pending.zones) - } - - /** - * Every card in the zones a pending search can look at, in search order. This - * is what the chooser sees while deciding; others get an empty list. - */ - searchPool(playerId: string): GameObject[] { - const pending = this.pendingSearch - if (!pending || pending.playerId !== playerId) return [] - return this.searchableObjects(playerId, pending.zones) - } - - /** - * Answers the hideaway look: exiles the chosen card linked to the source and - * puts the rest on the bottom of the library in a random order. - */ - chooseHideawayCard(playerId: string, cardId: string): void { - const pending = this.pendingChoice - if (!pending || pending.what !== 'hideaway') throw new GameError('No hideaway choice is waiting') - if (pending.playerId !== playerId) throw new GameError('You are not choosing this hideaway card') - const looked = (pending.cardIds ?? []).map(id => this.getObject(id)) - const hidden = looked.find(object => object.id === cardId && object.zone === 'library') - if (!hidden) throw new GameError('That card is not a legal choice') - - this.pendingChoices.shift() - this.moveToZone(hidden, 'exile', { silent: true }) - const source = this.objects.get(pending.sourceId) - if (hidden.zone === 'exile') { - hidden.faceDown = true - if (source) source.linkedExile = [...(source.linkedExile ?? []), hidden.id] - } - - const rest = looked.filter(object => object.id !== hidden.id) - for (let index = rest.length - 1; index > 0; index--) { - const swap = Math.floor(this.rng() * (index + 1)) - const temp = rest[index] - rest[index] = rest[swap] - rest[swap] = temp - } - for (const object of rest) this.moveToZone(object, 'library', { silent: true }) - this.logMessage(`${this.getPlayer(playerId).name} hides away a card`) - } - - /** - * Answers an "as this enters, choose a creature type" prompt. The match API - * uses the `choose_type` action. - */ - chooseCreatureType(playerId: string, type: string): void { - const pending = this.pendingChoice - if (!pending || pending.what !== 'creature_type') throw new GameError('No choice is waiting') - if (pending.playerId !== playerId) throw new GameError('You are not choosing this permanent\'s type') - const chosen = CREATURE_TYPES.find(entry => entry.toLowerCase() === type.trim().toLowerCase()) - if (!chosen) throw new GameError('Choose a creature type') - const object = this.objects.get(pending.sourceId) - if (!object || object.zone !== 'battlefield') throw new GameError('That permanent is no longer on the battlefield') - object.chosenCreatureType = chosen - this.pendingChoices.shift() - this.logMessage(`${this.getPlayer(playerId).name} chooses ${chosen} for ${object.definition.name}`) - } - - /** - * Answers an "as this enters, you may pay a cost; otherwise it enters tapped" - * replacement. The match API uses the `choose_cost` action. - */ - chooseCostPayment(playerId: string, pay: boolean): void { - const pending = this.pendingChoice - if (!pending || pending.what !== 'pay_cost' || !pending.cost) throw new GameError('No cost payment is waiting') - if (pending.playerId !== playerId) throw new GameError('You are not choosing this payment') - const object = this.objects.get(pending.sourceId) - if (object && object.zone === 'battlefield') { - if (pay) { - const context = this.contextFor(object, playerId, [], 0, 0) - if (!this.tryPayUnless(pending.cost, playerId, object, context)) throw new GameError('Cannot pay the cost') - this.pendingChoices.shift() - const detail = pending.amount === undefined ? 'the cost' : `${pending.amount} life` - this.logMessage(`${this.getPlayer(playerId).name} pays ${detail} for ${object.definition.name}`) - return - } - this.pendingChoices.shift() - object.tapped = true - this.logMessage(`${object.definition.name} enters tapped`) - return - } - this.pendingChoices.shift() - } - - /** - * Passes priority for players who cannot do anything meaningful. Stops at the - * first player who can act, or when the turn ends, so turns never run on. - */ - autoAdvance(): void { - if (this.status !== 'active' || this.pendingSearch || this.pendingChoice || this.autoAdvanceDepth > 0) return - this.autoAdvanceDepth++ - const turn = this.turn - try { - let guard = 0 - while (this.status === 'active' && !this.pendingSearch && !this.pendingChoice - && this.turn === turn && guard++ < 100) { - const actor = this.priority - if (!actor || this.hasMeaningfulAction(actor)) break - this.pass(actor) - } - } finally { - this.autoAdvanceDepth-- - } - } - - // --------------------------------------------------------------------------- - // Turn structure - // --------------------------------------------------------------------------- - - private beginTurn(): void { - const player = this.getPlayer(this.activePlayer) - this.phase = 'beginning' - this.step = 'untap' - this.passesInRow = 0 - this.priority = player.id - player.landPlayedThisTurn = false - player.cardsDrawnThisTurn = 0 - player.lifeGainedThisTurn = 0 - player.spellsCastThisTurn = 0 - player.creaturesDiedThisTurn = 0 - player.nonlandPermanentsEnteredThisTurn = 0 - player.attackedThisTurn = false - player.creaturesAttackedThisTurn = 0 - player.damageTakenThisTurn = 0 - player.manaPool = emptyPool() - - this.removeExpiringEffects(player.id) - for (const id of [...player.battlefield]) { - const object = this.objects.get(id) - if (!object || object.zone !== 'battlefield') continue - if (!this.hasRestriction(object, 'doesnt_untap')) object.tapped = false - } - - this.step = 'upkeep' - this.dispatchEvent({ kind: 'upkeep', player: player.id }) - if (this.status !== 'active') return - - this.step = 'draw' - this.drawCard(player.id, false) - if (this.status !== 'active') return - - this.phase = 'precombat_main' - this.step = 'main' - this.priority = player.id - this.passesInRow = 0 - } - - private finishTurn(): void { - const player = this.getPlayer(this.activePlayer) - while (player.hand.length > 7) { - const cardId = player.hand[player.hand.length - 1] - this.moveToZone(cardId, 'graveyard', { silent: true }) - } - for (const object of this.objects.values()) { - if (object.zone === 'battlefield') { - object.damage = 0 - object.deathtouched = false - } - } - this.removeEffectsByDuration('until_end_of_turn') - this.removeEndOfNextTurnEffects(player.id) - this.clearCombat() - for (const entry of this.players) entry.manaPool = emptyPool() - - if (this.status !== 'active') return - this.turn++ - this.activePlayer = this.nextAlivePlayer(this.activePlayer) - this.beginTurn() - } - - private advancePhase(): void { - if (this.status !== 'active') return - if (this.stack.length) return - this.emptyManaPools() - - if (this.step === 'main' && this.phase === 'precombat_main') { - this.phase = 'combat' - this.step = 'begin_combat' - this.dispatchEvent({ kind: 'begin_combat', player: this.activePlayer }) - this.step = 'declare_attackers' - this.priority = this.activePlayer - this.passesInRow = 0 - return - } - if (this.step === 'declare_attackers') { - this.step = 'end_combat' - this.passesInRow = 0 - this.priority = this.activePlayer - return - } - if (this.step === 'declare_blockers') { - this.step = 'combat_damage' - this.combatDamageDone = false - this.passesInRow = 0 - this.priority = this.activePlayer - return - } - if (this.step === 'combat_damage') { - this.combatDamageDone = true - this.dealCombatDamage() - this.runStateBasedActions() - this.passesInRow = 0 - this.priority = this.activePlayer - return - } - if (this.step === 'end_combat') { - this.clearCombat() - this.removeEffectsByDuration('until_end_of_combat') - this.phase = 'postcombat_main' - this.step = 'main' - this.passesInRow = 0 - this.priority = this.activePlayer - return - } - if (this.step === 'main' && this.phase === 'postcombat_main') { - this.phase = 'ending' - this.step = 'end_step' - this.dispatchEvent({ kind: 'end_step', player: this.activePlayer }) - this.passesInRow = 0 - this.priority = this.activePlayer - return - } - if (this.step === 'end_step') { - this.finishTurn() - } - } - - private clearCombat(): void { - this.blockersDeclared.clear() - for (const object of this.objects.values()) { - if (object.zone !== 'battlefield') continue - object.attacking = undefined - object.blockedBy = [] - object.blocking = undefined - } - this.combatDamageDone = false - } - - // --------------------------------------------------------------------------- - // Stack - // --------------------------------------------------------------------------- - - private resolveTop(): void { - const item = this.stack.pop() - if (!item) return - if (item.kind === 'spell' && item.source.zone !== 'stack') return - - const context = this.contextFor( - item.source, - item.controller, - item.targets, - item.x, - item.mode, - item.triggerSubject, - item.eventPlayer, - item.eventAmount, - ) - - if (item.kind === 'spell') { - if (this.isPermanent(item.source)) { - if (item.source.zone === 'stack') { - this.moveToZone(item.source, 'battlefield', { controller: item.controller, silent: false }) - } - this.applyEffects(context, item.effects) - } else { - this.applyEffects(context, item.effects) - if (item.source.zone === 'stack') this.moveToZone(item.source, 'graveyard', { silent: true }) - } - } else { - this.applyEffects(context, item.effects) - } - - this.logMessage(`Resolved ${item.label}`) - this.runStateBasedActions() - } - - private counterStackItem(item: StackItem): void { - const index = this.stack.indexOf(item) - if (index >= 0) this.stack.splice(index, 1) - if (item.kind === 'spell' && item.source.zone === 'stack') { - this.moveToZone(item.source, 'graveyard', { silent: true }) - } - this.logMessage(`Countered ${item.label}`) - } - - // --------------------------------------------------------------------------- - // Casting, mana, and costs - // --------------------------------------------------------------------------- - - private canCastAtThisTime(playerId: string, object: GameObject): boolean { - const instant = this.isInstant(object) - const flash = this.hasKeywordForDefinition(object.definition, 'Flash') - if (instant || flash) return true - return this.isMainPhaseWithEmptyStack(playerId) - } - - private isMainPhaseWithEmptyStack(playerId: string): boolean { - return this.activePlayer === playerId - && (this.phase === 'precombat_main' || this.phase === 'postcombat_main') - && this.step === 'main' - && this.stack.length === 0 - } - - private payMana(playerId: string, symbols: string, x: number): void { - if (!symbols) return - const player = this.getPlayer(playerId) - const cost = parseManaCost(symbols, x) - const pool = { ...player.manaPool } - const tapped = player.battlefield - .map(id => this.objects.get(id)) - .filter((object): object is GameObject => Boolean(object?.tapped)) - .map(object => object.id) - this.autoTapForMana(player, cost) - if (!this.canPayMana(player, cost)) { - player.manaPool = pool - for (const id of player.battlefield) { - const object = this.objects.get(id) - if (object) object.tapped = tapped.includes(id) - } - throw new GameError('Not enough mana') - } - this.deductMana(player, cost) - } - - private canPayMana(player: PlayerState, cost: ManaCost): boolean { - const pool = { ...player.manaPool } - const payColor = (color: ManaColor): boolean => { - if (pool[color] <= 0) return false - pool[color]-- - return true - } - for (const color of cost.colored) { - if (!payColor(color)) return false - } - for (const hybrid of cost.hybrid) { - const color = hybrid.colors.find(entry => pool[entry] > 0) - if (color) pool[color]-- - else if (!(hybrid.life > 0 && player.life >= hybrid.life)) return false - } - const remaining = MANA_COLORS.reduce((total, color) => total + pool[color], 0) - return remaining >= cost.generic - } - - private deductMana(player: PlayerState, cost: ManaCost): void { - for (const color of cost.colored) player.manaPool[color]-- - for (const hybrid of cost.hybrid) { - const color = hybrid.colors.find(entry => player.manaPool[entry] > 0) - if (color) player.manaPool[color]-- - else if (hybrid.life > 0) this.loseLife(player.id, hybrid.life) - else throw new GameError('Not enough mana') - } - let generic = cost.generic - for (const color of MANA_COLORS) { - const used = Math.min(player.manaPool[color], generic) - player.manaPool[color] -= used - generic -= used - } - if (generic > 0) throw new GameError('Not enough mana') - } - - private autoTapForMana(player: PlayerState, cost: ManaCost): void { - if (this.autoManaDepth > 0) return - let guard = 0 - while (!this.canPayMana(player, cost) && guard++ < 25) { - const source = this.players - .flatMap(entry => entry.battlefield) - .map(id => this.objects.get(id)) - .map(object => { - if (!object || object.zone !== 'battlefield' || object.controller !== player.id || object.tapped) return undefined - const found = this.findFreeManaAbility(object) - if (!found) return undefined - return { object, allowed: this.manaAbilityAllowedColors(object, found.ability) } - }) - .filter((entry): entry is { object: GameObject; allowed: Set | undefined } => Boolean(entry)) - .filter(entry => this.neededColor(player, cost, entry.allowed) !== undefined) - .sort((a, b) => (a.allowed?.size ?? Number.MAX_SAFE_INTEGER) - (b.allowed?.size ?? Number.MAX_SAFE_INTEGER))[0]?.object - if (!source) break - this.autoManaDepth++ - try { - this.activateManaSource(source, cost) - } finally { - this.autoManaDepth-- - } - } - } - - private findFreeManaAbility(source: GameObject): { index: number; ability: Extract } | undefined { - const abilities = source.definition.abilities ?? [] - for (let index = 0; index < abilities.length; index++) { - const ability = abilities[index] - if (ability.kind !== 'activated') continue - if (!ability.effects.length || !ability.effects.every(effect => effect.op === 'add_mana')) continue - if (ability.costs.length !== 1 || ability.costs[0].kind !== 'tap') continue - if (source.tapped) continue - if (this.isCreature(source) && source.enteredTurn >= this.turn && !this.hasKeyword(source, 'Haste')) continue - return { index, ability } - } - return undefined - } - - private activateManaSource(source: GameObject, cost: ManaCost): void { - const found = this.findFreeManaAbility(source) - if (!found) return - const player = this.getPlayer(source.controller) - const color = this.manaAbilityColor(source, found.ability, player, cost) - if (!color) return - for (const entry of found.ability.costs) { - if (entry.kind === 'tap') source.tapped = true - } - for (const effect of found.ability.effects) { - if (effect.op === 'add_mana') this.addMana(source.controller, effect.mana, color) - } - } - - private manaAbilityColor( - source: GameObject, - ability: Extract, - player: PlayerState, - cost: ManaCost, - ): ManaColor | undefined { - return this.neededColor(player, cost, this.manaAbilityAllowedColors(source, ability)) - } - - /** - * Colors a mana ability lets its controller choose between. Undefined when - * the ability has no choice, such as fixed or single-color mana. - */ - manaColorChoices(source: GameObject, abilityIndex: number): ManaColor[] | undefined { - const ability = (source.definition.abilities ?? [])[abilityIndex] - if (!ability || ability.kind !== 'activated') return undefined - let colors: ManaColor[] | undefined - for (const effect of ability.effects) { - if (effect.op !== 'add_mana') continue - if (effect.mana.kind === 'symbols' && effect.mana.oneOf) { - colors = [...new Set(effect.mana.symbols.map(colorOfSymbol))] - } else if (effect.mana.kind === 'any_color') { - const allowed = this.anyColorRestrictionColors(effect.mana, source.controller) - colors = allowed - ? MANA_COLORS.filter(color => color !== 'C' && allowed.has(color)) - : ['W', 'U', 'B', 'R', 'G'] - } - } - return colors && colors.length > 1 ? colors : undefined - } - - private manaAbilityAllowedColors( - source: GameObject, - ability: Extract, - ): Set | undefined { - for (const effect of ability.effects) { - if (effect.op !== 'add_mana') continue - if (effect.mana.kind === 'symbols' && effect.mana.oneOf) { - return new Set(effect.mana.symbols.map(colorOfSymbol)) - } - return this.anyColorRestrictionColors(effect.mana, source.controller) - } - return undefined - } - - private neededColor(player: PlayerState, cost: ManaCost, allowed?: Set): ManaColor | undefined { - for (const color of cost.colored) { - if (player.manaPool[color] > 0) continue - return allowed && !allowed.has(color) ? undefined : color - } - for (const hybrid of cost.hybrid) { - if (hybrid.colors.some(color => player.manaPool[color] > 0)) continue - return hybrid.colors.find(color => !allowed || allowed.has(color)) - } - if (allowed) return MANA_COLORS.find(color => allowed.has(color)) - return 'W' - } - - private addMana(playerId: string, mana: ManaSpec, preferred?: ManaColor): void { - const player = this.getPlayer(playerId) - if (mana.kind === 'symbols') { - if (mana.oneOf) { - const colors = mana.symbols.map(colorOfSymbol) - const color = preferred && colors.includes(preferred) ? preferred : colors[0] - if (color) player.manaPool[color]++ - return - } - for (const symbol of mana.symbols) player.manaPool[colorOfSymbol(symbol)]++ - return - } - const amount = this.value(mana.amount, { - source: this.playerSource(playerId), - controller: playerId, - targets: [], - x: 0, - mode: 0, - }) - const allowed = this.anyColorRestrictionColors(mana, playerId) - if (allowed?.size === 0) return - let color: ManaColor = preferred ?? 'W' - if (allowed && !allowed.has(color)) { - color = MANA_COLORS.find(entry => allowed.has(entry)) ?? 'W' - } - for (let i = 0; i < amount; i++) player.manaPool[color]++ - } - - /** - * Colors a land could produce for an "any color that a land ... could - * produce" restriction. Colorless and snow are not colors. - */ - private landManaColors(playerId: string, opponentsOnly: boolean, seen = new Set()): Set { - const colors = new Set() - const opponents = this.opponentsOf(playerId) - for (const object of this.battlefieldObjects()) { - if (!this.isLand(object) || seen.has(object.id)) continue - if (opponentsOnly ? !opponents.includes(object.controller) : object.controller !== playerId) continue - seen.add(object.id) - for (const ability of object.definition.abilities ?? []) { - if (ability.kind !== 'activated') continue - for (const effect of ability.effects) { - if (effect.op !== 'add_mana') continue - if (effect.mana.kind === 'symbols') { - for (const symbol of effect.mana.symbols) { - for (const letter of symbol.match(/[WUBRG]/gi) ?? []) colors.add(letter.toUpperCase() as ManaColor) - } - } else { - const nested = this.anyColorRestrictionColors(effect.mana, object.controller, seen) - if (nested) { - for (const color of nested) colors.add(color) - } else { - for (const color of MANA_COLORS) if (color !== 'C') colors.add(color) - } - } - } - } - seen.delete(object.id) - } - return colors - } - - /** The colors an any-color mana source may produce, when the restriction is known. */ - private anyColorRestrictionColors( - mana: ManaSpec, - playerId: string, - seen?: Set, - ): Set | undefined { - if (mana.kind !== 'any_color') return undefined - if (mana.restriction === 'a land an opponent controls could produce') { - return this.landManaColors(playerId, true, seen) - } - if (mana.restriction === 'a land you control could produce') { - return this.landManaColors(playerId, false, seen) - } - if (mana.restriction === "commander's color identity") { - const commander = this.objects.get(this.getPlayer(playerId).commanderId ?? '') - const identity = commander?.definition.colorIdentity ?? [] - return new Set(identity.filter((color): color is ManaColor => /^[WUBRG]$/.test(color))) - } - return undefined - } - - private payCosts(costs: Cost[], playerId: string, source: GameObject, context: EffectContext): void { - for (const cost of costs) { - if (cost.kind !== 'mana' && !this.canPayNonManaCost(cost, playerId, source)) { - throw new GameError('Cannot pay ability cost') - } - } - for (const cost of costs) { - if (cost.kind === 'mana') this.payMana(playerId, cost.symbols, context.x) - else this.payNonManaCost(cost, playerId, source, context) - } - } - - private canPayNonManaCost(cost: Cost, playerId: string, source: GameObject): boolean { - const player = this.getPlayer(playerId) - switch (cost.kind) { - case 'tap': - return !source.tapped - case 'untap': - return source.tapped - case 'tap_other': - return this.objectsMatching(cost.selector, source).some(object => !object.tapped) - case 'energy': - return player.energy >= cost.amount - case 'pay_life': - return player.life >= this.value(cost.amount, this.staticContext(source)) - case 'discard': - return player.hand.length >= this.value(cost.amount, this.staticContext(source)) - case 'sacrifice': - return this.objectsMatching(cost.selector, source).length > 0 - case 'sacrifice_self': - return source.zone === 'battlefield' - case 'exile_self': - return source.zone === 'graveyard' - case 'exile_from_graveyard': - return this.objectsMatching(cost.selector, source).length > 0 - case 'return_to_hand': - return this.objectsMatching(cost.selector, source).length > 0 - case 'put_counter': - return this.objectsMatching(cost.selector, source).length > 0 - case 'remove_counters': { - const amount = this.value(cost.amount, this.staticContext(source)) - const objects = cost.selector ? this.objectsMatching(cost.selector, source) : [source] - return objects.some(object => (object.counters[cost.counter] ?? 0) >= amount) - } - case 'mill': - return player.library.length >= (cost.amount.kind === 'number' ? cost.amount.value : 0) - case 'choice': - return cost.options.some(option => option.every(entry => entry.kind === 'mana' || this.canPayNonManaCost(entry, playerId, source))) - case 'waterbend': - return this.canPayMana(player, parseManaCost('{0}', 0)) - case 'reveal': - case 'behold': - case 'choose': - return true - default: - return false - } - } - - private payNonManaCost(cost: Cost, playerId: string, source: GameObject, context: EffectContext): void { - const player = this.getPlayer(playerId) - switch (cost.kind) { - case 'tap': - source.tapped = true - return - case 'untap': - source.tapped = false - return - case 'tap_other': { - const target = this.objectsMatching(cost.selector, source).find(object => !object.tapped) - if (!target) throw new GameError('No permanent to tap') - target.tapped = true - return - } - case 'energy': - player.energy -= cost.amount - return - case 'loyalty': - this.addCounters(source, 'loyalty', cost.amount, true) - return - case 'pay_life': - this.loseLife(playerId, this.value(cost.amount, context)) - return - case 'discard': { - const amount = this.value(cost.amount, context) - this.discardCards(playerId, amount, cost.random, context) - return - } - case 'sacrifice': { - const target = this.objectsMatching(cost.selector, source)[0] - if (!target) throw new GameError('No permanent to sacrifice') - this.moveToZone(target, 'graveyard', { silent: false }) - return - } - case 'sacrifice_self': - this.moveToZone(source, 'graveyard', { silent: false }) - return - case 'exile_self': - this.moveToZone(source, 'exile', { silent: false }) - return - case 'exile_from_graveyard': { - const target = this.objectsMatching(cost.selector, source)[0] - if (!target) throw new GameError('No card to exile') - this.moveToZone(target, 'exile', { silent: false }) - return - } - case 'return_to_hand': { - const target = this.objectsMatching(cost.selector, source)[0] - if (!target) throw new GameError('No permanent to return') - this.moveToZone(target, 'hand', { silent: false }) - return - } - case 'put_counter': { - const target = this.objectsMatching(cost.selector, source)[0] - if (!target) throw new GameError('No permanent for counter') - this.addCounters(target, cost.counter, 1) - return - } - case 'remove_counters': { - const amount = this.value(cost.amount, context) - const objects = cost.selector ? this.objectsMatching(cost.selector, source) : [source] - const target = objects.find(object => (object.counters[cost.counter] ?? 0) >= amount) - if (!target) throw new GameError('No counters to remove') - target.counters[cost.counter] = Math.max(0, (target.counters[cost.counter] ?? 0) - amount) - return - } - case 'mill': - this.millCards(playerId, this.value(cost.amount, context)) - return - case 'reveal': - case 'behold': - case 'choose': - return - case 'choice': { - const option = cost.options.find(entries => entries.every(entry => entry.kind === 'mana' || this.canPayNonManaCost(entry, playerId, source))) - if (!option) throw new GameError('No payable cost choice') - this.payCosts(option, playerId, source, context) - return - } - case 'waterbend': - case 'blight': - case 'forage': - case 'collect_evidence': - throw new GameError(`Unsupported cost: ${cost.kind}`) - default: - throw new GameError(`Unsupported cost: ${(cost as { kind: string }).kind}`) - } - } - - // --------------------------------------------------------------------------- - // Targeting - // --------------------------------------------------------------------------- - - private selectTargets( - effects: Effect[], - source: GameObject, - controller: string, - provided: TargetChoice[], - mode: number, - ): TargetChoice[] { - const selected: TargetChoice[] = [] - const queue = [...provided] - - const take = (target: Target, playerOnly: 'opponent' | 'any' | undefined): void => { - if (target.kind === 'self' || target.kind === 'trigger_subject' || target.kind === 'previous_target') return - if (target.kind === 'object' && target.mode === 'each') return - if (target.kind === 'player' && target.mode === 'each') return - const count = target.kind === 'object' ? target.count ?? 1 : 1 - const upTo = target.kind === 'object' && Boolean(target.upTo) - for (let i = 0; i < count; i++) { - const explicit = queue.shift() - if (explicit) { - if (!this.targetChoiceMatches(explicit, target, source, playerOnly)) throw new GameError('Invalid target') - selected.push(explicit) - continue - } - const legal = this.legalTargets(target, source, controller, playerOnly) - if (!legal.length) { - if (upTo) break - throw new GameError('No legal target') - } - selected.push(legal[0]) - } - } - - const walk = (list: Effect[]): void => { - for (const effect of list) { - if (effect.op === 'conditional') { - walk(effect.effects) - continue - } - if (effect.op === 'modal') { - const chosen = effect.modes[mode] ?? effect.modes[0] ?? [] - walk(chosen) - continue - } - if ('player' in effect && (effect.player === 'target_player' || effect.player === 'opponent')) { - const who = effect.player === 'opponent' ? 'opponent' : 'any' - take({ kind: 'player', who: effect.player, mode: 'target' }, who) - } - if ('target' in effect && effect.target) take(effect.target, undefined) - if (effect.op === 'create_token') { - if (effect.copyOf) take(effect.copyOf, undefined) - if (effect.attachTo) take(effect.attachTo, undefined) - } - if (effect.op === 'fight') { - take(effect.a, undefined) - take(effect.b, undefined) - } - if (effect.op === 'damage_divided') take(effect.target, undefined) - } - } - walk(effects) - return selected - } - - /** Legal choices for a card's targets, so the UI can offer only real targets. */ - legalTargetsForCard(playerId: string, cardId: string): TargetChoice[] { - const source = this.objects.get(cardId) - if (!source) return [] - const effects = (source.definition.abilities ?? []) - .filter((ability): ability is Extract => ability.kind === 'spell') - .flatMap(ability => ability.effects) - return this.collectTargets(effects, source, playerId, 0) - } - - /** Legal choices for an activated ability's targets. */ - legalTargetsForAbility(playerId: string, sourceId: string, abilityIndex: number): TargetChoice[] { - const source = this.objects.get(sourceId) - const ability = source?.definition.abilities?.[abilityIndex] - if (!source || !ability || ability.kind !== 'activated') return [] - return this.collectTargets(ability.effects, source, playerId, 0) - } - - private collectTargets( - effects: Effect[], - source: GameObject, - controller: string, - mode: number, - ): TargetChoice[] { - const choices = new Map() - const add = (target: Target, playerOnly?: 'opponent' | 'any'): void => { - if (target.kind === 'self' || target.kind === 'trigger_subject' || target.kind === 'previous_target') return - if ((target.kind === 'object' || target.kind === 'player') && target.mode === 'each') return - for (const choice of this.legalTargets(target, source, controller, playerOnly)) { - choices.set(`${choice.kind}:${choice.id}`, choice) - } - } - const walk = (list: Effect[]): void => { - for (const effect of list) { - if (effect.op === 'conditional') { - walk(effect.effects) - continue - } - if (effect.op === 'modal') { - walk(effect.modes[mode] ?? effect.modes[0] ?? []) - continue - } - if ('player' in effect && (effect.player === 'target_player' || effect.player === 'opponent')) { - add( - { kind: 'player', who: effect.player, mode: 'target' }, - effect.player === 'opponent' ? 'opponent' : 'any', - ) - } - if ('target' in effect && effect.target) add(effect.target) - if (effect.op === 'create_token') { - if (effect.copyOf) add(effect.copyOf) - if (effect.attachTo) add(effect.attachTo) - } - if (effect.op === 'fight') { - add(effect.a) - add(effect.b) - } - if (effect.op === 'damage_divided') add(effect.target) - } - } - walk(effects) - return [...choices.values()] - } - - private legalTargets( - target: Target, - source: GameObject, - controller: string, - playerOnly: 'opponent' | 'any' | undefined, - ): TargetChoice[] { - switch (target.kind) { - case 'object': { - return this.objectsMatching(target.selector, source) - .map(object => ({ kind: 'object' as const, id: object.id })) - } - case 'player': { - const players = playerOnly === 'opponent' ? this.opponentsOf(controller) : this.alivePlayers().map(player => player.id) - return players.map(id => ({ kind: 'player' as const, id })) - } - case 'player_or_planeswalker': { - const choices: TargetChoice[] = this.opponentsOf(controller).map(id => ({ kind: 'player' as const, id })) - for (const object of this.battlefieldObjects()) { - if (this.hasType(object, 'planeswalker')) choices.push({ kind: 'object', id: object.id }) - } - return choices - } - case 'any': { - const choices: TargetChoice[] = this.opponentsOf(controller).map(id => ({ kind: 'player' as const, id })) - for (const object of this.battlefieldObjects()) choices.push({ kind: 'object', id: object.id }) - return choices - } - case 'spell': - return [...this.stack].reverse() - .filter(item => item.kind === 'spell' && this.matchesSelector(item.source, target.selector, source, 'stack')) - .map(item => ({ kind: 'spell' as const, id: item.id })) - case 'ability': - return [...this.stack].reverse() - .filter(item => item.kind === 'ability') - .map(item => ({ kind: 'spell' as const, id: item.id })) - case 'divided': - return this.opponentsOf(controller).map(id => ({ kind: 'player' as const, id })) - default: - return [] - } - } - - private targetChoiceMatches( - choice: TargetChoice, - target: Target, - source: GameObject, - playerOnly: 'opponent' | 'any' | undefined, - ): boolean { - const isOpponent = (id: string): boolean => this.opponentsOf(source.controller).includes(id) - if (choice.kind === 'player') { - if (target.kind === 'any' || target.kind === 'player' || target.kind === 'player_or_planeswalker') { - return playerOnly !== 'opponent' || isOpponent(choice.id) - } - return false - } - if (choice.kind === 'object') { - const object = this.objects.get(choice.id) - if (!object) return false - if (target.kind === 'any' || target.kind === 'player_or_planeswalker') { - return target.kind === 'any' ? object.zone === 'battlefield' : this.hasType(object, 'planeswalker') - } - if (target.kind !== 'object') return false - return this.matchesSelector(object, target.selector, source) - } - if (choice.kind === 'spell') { - const item = this.findStackItem(choice.id) - if (!item) return false - if (target.kind === 'spell') { - return item.kind === 'spell' && this.matchesSelector(item.source, target.selector, source, 'stack') - } - return target.kind === 'ability' && item.kind === 'ability' - } - return false - } - - private resolveTargets(context: EffectContext, target: Target): ResolvedTarget[] { - let result: ResolvedTarget[] = [] - switch (target.kind) { - case 'self': - result = [{ kind: 'object', object: context.source }] - break - case 'trigger_subject': - if (context.triggerSubject) result = [{ kind: 'object', object: context.triggerSubject }] - break - case 'previous_target': - if (context.lastTarget) result = [context.lastTarget] - break - case 'object': - if (target.mode === 'each') { - result = this.objectsMatching(target.selector, context.source) - .map(object => ({ kind: 'object' as const, object })) - } else { - const count = target.count ?? 1 - for (let i = 0; i < count; i++) { - const choice = context.targets.shift() - if (!choice) break - if (choice.kind === 'object') { - const object = this.objects.get(choice.id) - if (object) result.push({ kind: 'object', object }) - } - } - } - break - case 'player': - if (target.mode === 'each') { - result = this.playersForEffect(target.who, context).map(id => ({ kind: 'player' as const, id })) - } else { - const choice = context.targets.shift() - if (choice?.kind === 'player') result = [{ kind: 'player', id: choice.id }] - else { - const id = this.playersForEffect(target.who, context)[0] - if (id) result = [{ kind: 'player', id }] - } - } - break - case 'player_or_planeswalker': - case 'any': { - const choice = context.targets.shift() - if (choice?.kind === 'player') result = [{ kind: 'player', id: choice.id }] - else if (choice?.kind === 'object') { - const object = this.objects.get(choice.id) - if (object) result = [{ kind: 'object', object }] - } - break - } - case 'spell': - case 'ability': { - const choice = context.targets.shift() - if (choice?.kind === 'spell') { - const item = this.findStackItem(choice.id) - if (item) result = [{ kind: 'stack', item }] - } - break - } - case 'divided': { - const choice = context.targets.shift() - if (choice?.kind === 'player') result = [{ kind: 'player', id: choice.id }] - else if (choice?.kind === 'object') { - const object = this.objects.get(choice.id) - if (object) result = [{ kind: 'object', object }] - } - break - } - } - if (result.length) context.lastTarget = result[0] - return result - } - - private playersForEffect(ref: PlayerRef, context: EffectContext): string[] { - const controller = context.source.controller - switch (ref) { - case 'you': - return [controller] - case 'opponent': { - const choice = context.targets.shift() - if (choice?.kind === 'player') return [choice.id] - return [this.opponentsOf(controller)[0]].filter(Boolean) - } - case 'each_opponent': - return this.opponentsOf(controller) - case 'each_player': - return this.alivePlayers().map(player => player.id) - case 'target_player': { - const choice = context.targets.shift() - return [choice?.kind === 'player' ? choice.id : undefined].filter((id): id is string => Boolean(id)) - } - case 'that_player': - return [context.eventPlayer ?? this.opponentsOf(controller)[0]].filter(Boolean) - case 'its_controller': - return context.lastTarget?.kind === 'object' ? [context.lastTarget.object.controller] : [] - case 'its_owner': - return context.lastTarget?.kind === 'object' ? [context.lastTarget.object.owner] : [] - } - } - - private playersForValue(ref: PlayerRef, context: EffectContext): string[] { - const controller = context.source.controller - switch (ref) { - case 'you': - return [controller] - case 'opponent': - return [this.opponentsOf(controller)[0]].filter(Boolean) - case 'each_opponent': - return this.opponentsOf(controller) - case 'each_player': - return this.alivePlayers().map(player => player.id) - case 'target_player': - return [context.lastTarget?.kind === 'player' ? context.lastTarget.id : this.opponentsOf(controller)[0]].filter(Boolean) - case 'that_player': - return [context.eventPlayer ?? this.opponentsOf(controller)[0]].filter(Boolean) - case 'its_controller': - return context.lastTarget?.kind === 'object' ? [context.lastTarget.object.controller] : [] - case 'its_owner': - return context.lastTarget?.kind === 'object' ? [context.lastTarget.object.owner] : [] - } - } - - // --------------------------------------------------------------------------- - // Effects - // --------------------------------------------------------------------------- - - private applyEffects(context: EffectContext, effects: Effect[]): void { - for (const effect of effects) { - if (this.status === 'finished') return - switch (effect.op) { - case 'damage': { - const targets = this.resolveTargets(context, effect.target) - const amount = Math.max(0, this.value(effect.amount, context)) - let source = context.source - if (effect.source) { - const sourceTarget = this.resolveTargets(context, effect.source)[0] - if (sourceTarget?.kind === 'object') source = sourceTarget.object - } - for (const target of targets) this.damageTarget(target, amount, source, false) - break - } - case 'draw': { - const amount = this.value(effect.amount, context) - for (const playerId of this.playersForEffect(effect.player, context)) this.drawCards(playerId, amount) - break - } - case 'discard': { - const amount = this.value(effect.amount, context) - for (const playerId of this.playersForEffect(effect.player, context)) { - this.discardCards(playerId, amount, effect.random, context) - } - break - } - case 'mill': { - const amount = this.value(effect.amount, context) - for (const playerId of this.playersForEffect(effect.player, context)) this.millCards(playerId, amount) - break - } - case 'life': { - const amount = this.value(effect.amount, context) - for (const playerId of this.playersForEffect(effect.player, context)) { - if (effect.mode === 'gain') this.gainLife(playerId, amount) - else this.loseLife(playerId, amount) - } - break - } - case 'pump': { - const targets = this.resolveTargets(context, effect.target) - const ids = targets.filter((target): target is Extract => target.kind === 'object') - .map(target => target.object.id) - this.addContinuousEffect(context.source, context.controller, effect, ids, effect.duration) - break - } - case 'set_pt': { - const targets = this.resolveTargets(context, effect.target) - const ids = targets.filter((target): target is Extract => target.kind === 'object') - .map(target => target.object.id) - this.addContinuousEffect(context.source, context.controller, effect, ids, effect.duration) - break - } - case 'grant': { - const targets = this.resolveTargets(context, effect.target) - const ids = targets.filter((target): target is Extract => target.kind === 'object') - .map(target => target.object.id) - this.addContinuousEffect(context.source, context.controller, effect, ids, effect.duration) - break - } - case 'put_counters': { - const amount = this.value(effect.amount, context) - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind === 'object') this.addCounters(target.object, effect.counter, amount) - } - break - } - case 'remove_counters': { - const amount = this.value(effect.amount, context) - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind !== 'object') continue - target.object.counters[effect.counter] = Math.max(0, (target.object.counters[effect.counter] ?? 0) - amount) - } - break - } - case 'proliferate': { - for (const object of this.battlefieldObjects()) { - for (const counter of Object.keys(object.counters)) { - if (object.counters[counter] > 0) object.counters[counter]++ - } - } - break - } - case 'create_token': { - const amount = Math.max(0, this.value(effect.amount, context)) - const players = this.playersForEffect(effect.player, context) - const created: GameObject[] = [] - for (const playerId of players) { - const source = effect.copyOf - ? this.resolveTargets(context, effect.copyOf).find(target => target.kind === 'object') - : undefined - const creatureToken = source?.kind === 'object' - ? this.isCreature(source.object) - : effect.token.types.includes('creature') - const count = amount * this.tokenMultiplier(playerId, creatureToken) - for (let i = 0; i < count; i++) { - if (effect.copyOf) { - if (source?.kind === 'object') created.push(this.createTokenCopy(playerId, source.object, effect.notLegendary)) - } else { - created.push(this.createToken(playerId, effect.token, context)) - } - } - } - if (effect.attachTo) { - const target = this.resolveTargets(context, effect.attachTo)[0] - if (target?.kind === 'object') { - for (const token of created) this.attach(token, target.object) - } - } - break - } - case 'destroy': { - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind === 'object') this.destroyPermanent(target.object) - } - break - } - case 'exile': { - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind === 'object') this.moveToZone(target.object, 'exile', { silent: false }) - } - break - } - case 'exile_graveyards': { - for (const player of this.players) { - for (const id of [...player.graveyard]) this.moveToZone(id, 'exile', { silent: false }) - } - break - } - case 'sacrifice': { - const players = this.playersForEffect(effect.player, context) - if (effect.unless && this.tryPayUnless(effect.unless, players[0], context.source, context)) break - const targets = this.resolveTargets(context, effect.target) - for (const target of targets) { - if (target.kind === 'object' && players.includes(target.object.controller)) { - this.moveToZone(target.object, 'graveyard', { silent: false }) - } - } - break - } - case 'counter': { - if (effect.unless && this.tryPayUnless(effect.unless, context.controller, context.source, context)) break - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind === 'stack') this.counterStackItem(target.item) - } - break - } - case 'return_to_hand': { - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind === 'object') this.moveToZone(target.object, 'hand', { silent: false }) - } - break - } - case 'return_to_battlefield': { - const targets = this.resolveTargets(context, effect.target) - for (const target of targets) { - if (target.kind !== 'object') continue - this.moveToZone(target.object, 'battlefield', { - controller: context.controller, - tapped: effect.tapped, - silent: false, - }) - if (effect.counters) { - this.addCounters(target.object, effect.counters.counter, this.value(effect.counters.amount, context)) - } - } - break - } - case 'put_on_top': { - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind === 'object') this.moveToZone(target.object, 'library', { toTop: true, silent: false }) - } - break - } - case 'tap': { - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind === 'object') target.object.tapped = true - } - break - } - case 'untap': { - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind === 'object') target.object.tapped = false - } - break - } - case 'scry': - case 'surveil': - break - case 'search': { - const amount = Math.max(0, this.value(effect.amount, context)) - for (const playerId of this.playersForEffect(effect.player, context)) { - this.searchLibrary(playerId, effect.selector, amount, effect.destination, effect.tapped, effect.shuffle, effect.zones, effect.split) - } - break - } - case 'shuffle': { - for (const playerId of this.playersForEffect(effect.player, context)) this.shuffleLibrary(this.getPlayer(playerId)) - break - } - case 'add_mana': { - for (const playerId of this.playersForEffect(effect.player, context)) this.addMana(playerId, effect.mana, context.manaColor) - break - } - case 'fight': { - const a = this.resolveTargets(context, effect.a)[0] - const b = this.resolveTargets(context, effect.b)[0] - if (a?.kind === 'object' && b?.kind === 'object') { - const aPower = this.getPower(a.object) - const bPower = this.getPower(b.object) - this.damageTarget({ kind: 'object', object: a.object }, bPower, b.object, false) - this.damageTarget({ kind: 'object', object: b.object }, aPower, a.object, false) - } - break - } - case 'regenerate': { - for (const target of this.resolveTargets(context, effect.target)) { - if (target.kind === 'object') target.object.regenerationShields++ - } - break - } - case 'energy': { - const amount = this.value(effect.amount, context) - for (const playerId of this.playersForEffect(effect.player, context)) this.getPlayer(playerId).energy += amount - break - } - case 'attach': { - const target = this.resolveTargets(context, effect.target)[0] - if (target?.kind === 'object') this.attach(context.source, target.object) - break - } - case 'restriction': { - const targets = this.resolveTargets(context, effect.target) - const ids = targets.filter((target): target is Extract => target.kind === 'object') - .map(target => target.object.id) - this.addContinuousEffect(context.source, context.controller, effect, ids, effect.duration) - break - } - case 'keyword_action': - if (effect.action === 'explore') this.explore(context, effect) - else if (effect.action === 'incubate') this.incubate(context, effect.amount) - else if (effect.action === 'impulse') this.impulse(context) - break - case 'prevent_damage': - case 'gain_control': - case 'emblem': - case 'schedule': - case 'level_up': - case 'put_from_among': - case 'look_top': - break - case 'transform': { - const target = this.resolveTargets(context, effect.target)[0] - if (target?.kind === 'object' && target.object.backFace) { - const front = target.object.definition - target.object.definition = target.object.backFace - target.object.backFace = front - this.logMessage(`${target.object.definition.name} transforms`) - } - break - } - case 'pay': - try { - this.payCosts(effect.costs, context.controller, context.source, context) - } catch { - // "You may pay" — doing nothing is the legal choice when it is not payable. - } - break - case 'conditional': - if (this.checkCondition(effect.condition, context.source)) this.applyEffects(context, effect.effects) - break - case 'modal': { - const chosen = effect.modes[context.mode] ?? effect.modes[0] - if (chosen) this.applyEffects(context, chosen) - break - } - case 'dig': - this.dig(context, effect) - break - case 'damage_divided': { - const targets = this.resolveTargets(context, effect.target) - const amount = this.value(effect.amount, context) - if (targets.length) { - const each = Math.floor(amount / targets.length) - for (const target of targets) this.damageTarget(target, each, context.source, false) - } - break - } - case 'hideaway': - this.hideaway(context, effect) - break - case 'play_exiled': { - const playerId = this.playersForEffect(effect.player, context)[0] - const cardId = context.source.linkedExile?.find(id => this.getObject(id).zone === 'exile') - if (!playerId || !cardId) break - const object = this.getObject(cardId) - if (this.playExiledCard(playerId, object, effect.free)) { - context.source.linkedExile = context.source.linkedExile?.filter(id => id !== cardId) - } - break - } - } - } - } - - private hideaway(context: EffectContext, effect: Extract): void { - // The exiled card stays face down and is linked to the source until played. - const player = this.getPlayer(context.controller) - const amount = this.value(effect.amount, context) - const looked = player.library.slice(0, amount).map(id => this.getObject(id)) - if (!looked.length) return - if (looked.length === 1) { - this.moveToZone(looked[0], 'exile', { silent: true }) - if (looked[0].zone === 'exile') { - looked[0].faceDown = true - context.source.linkedExile = [...(context.source.linkedExile ?? []), looked[0].id] - } - this.logMessage(`${player.name} hides away a card`) - return - } - - this.pendingChoices.push({ - playerId: context.controller, - sourceId: context.source.id, - what: 'hideaway', - cardIds: looked.map(object => object.id), - }) - this.logMessage(`${player.name} looks at the top ${looked.length} cards of their library`) - } - - private playExiledCard(playerId: string, object: GameObject, free: boolean | undefined): boolean { - if (!free) return false - if (this.isLand(object)) { - const player = this.getPlayer(playerId) - if (player.landPlayedThisTurn || !this.isMainPhaseWithEmptyStack(playerId)) return false - player.landPlayedThisTurn = true - this.moveToZone(object, 'battlefield', { controller: playerId, silent: false }) - this.logMessage(`${this.getPlayer(playerId).name} plays ${object.definition.name} from exile`) - return true - } - if (!this.canCastAtThisTime(playerId, object)) return false - - const effects = (object.definition.abilities ?? []) - .filter((ability): ability is Extract => ability.kind === 'spell') - .flatMap(ability => ability.effects) - let targets: TargetChoice[] - try { - targets = this.selectTargets(effects, object, playerId, [], 0) - } catch { - return false - } - - this.moveToZone(object, 'stack', { controller: playerId, silent: true }) - const item: StackItem = { - id: this.generateId('stack'), - kind: 'spell', - source: object, - controller: playerId, - label: object.definition.name, - effects, - targets, - x: 0, - mode: 0, - } - this.stack.push(item) - this.getPlayer(playerId).spellsCastThisTurn++ - this.passesInRow = 0 - this.priority = this.nextAlivePlayer(playerId) - this.dispatchEvent({ kind: 'cast', player: playerId, subject: object, spell: object, spellItem: item }) - this.logMessage(`${this.getPlayer(playerId).name} casts ${object.definition.name} from exile`) - return true - } - - private explore(context: EffectContext, effect: Extract): void { - const target = effect.target ? this.resolveTargets(context, effect.target)[0] : undefined - if (target?.kind !== 'object') return - const player = this.getPlayer(context.controller) - const cardId = player.library[0] - if (!cardId) return - const card = this.getObject(cardId) - if (this.isLand(card)) { - this.moveToZone(card, 'hand', { silent: false }) - this.logMessage(`${player.name} explores and puts ${card.definition.name} into their hand`) - return - } - this.addCounters(target.object, '+1/+1', 1) - // shortcut: the explored card always goes to the graveyard instead of - // asking whether to put it on top. Upgrade when the choice matters. - this.moveToZone(card, 'graveyard', { silent: false }) - this.logMessage(`${player.name} explores with ${target.object.definition.name}`) - } - - private incubate(context: EffectContext, amount: Value | undefined): void { - const counters = amount ? Math.max(0, this.value(amount, context)) : 0 - const count = this.tokenMultiplier(context.controller, false) - for (let i = 0; i < count; i++) { - const token = this.createToken(context.controller, { - types: ['artifact'], - subtypes: ['incubator'], - colors: [], - }, context) - this.addCounters(token, '+1/+1', counters) - } - } - - private impulse(context: EffectContext): void { - const player = this.getPlayer(context.controller) - const cardId = player.library[0] - if (!cardId) return - const card = this.getObject(cardId) - this.moveToZone(card, 'exile', { silent: false }) - card.playableFromExileTurn = this.turn - this.logMessage(`${player.name} exiles ${card.definition.name} and may play it this turn`) - } - - private dig( - context: EffectContext, - effect: Extract, - ): void { - const player = this.getPlayer(context.controller) - const amount = this.value(effect.amount, context) - const top = player.library.slice(0, amount).map(id => this.getObject(id)) - const pickCount = this.value(effect.pick, context) - const picked = top.filter(object => !effect.pickSelector || this.matchesSelector(object, effect.pickSelector, context.source, 'library')) - .slice(0, pickCount) - for (const object of picked) { - if (effect.to === 'battlefield') { - this.moveToZone(object, 'battlefield', { controller: context.controller, tapped: effect.tapped, silent: false }) - } else { - this.moveToZone(object, 'hand', { silent: false }) - } - } - for (const object of top) { - if (picked.includes(object)) continue - if (effect.rest === 'graveyard') this.moveToZone(object, 'graveyard', { silent: false }) - else if (effect.rest === 'bottom') this.moveToZone(object, 'library', { silent: true }) - else this.moveToZone(object, 'library', { toTop: true, silent: true }) - } - } - - private tryPayUnless(cost: Cost, playerId: string | undefined, source: GameObject, context: EffectContext): boolean { - if (!playerId) return false - try { - if (cost.kind === 'mana') { - this.payMana(playerId, cost.symbols, context.x) - } else { - if (!this.canPayNonManaCost(cost, playerId, source)) return false - this.payNonManaCost(cost, playerId, source, context) - } - return true - } catch { - return false - } - } - - private addContinuousEffect( - source: GameObject, - controller: string, - effect: Extract, - affectedIds: string[], - duration: Duration, - ): void { - this.continuousEffects.push({ - id: this.generateId('effect'), - sourceId: source.id, - controller, - effect, - affectedIds, - duration, - createdTurn: this.turn, - }) - } - - private continuousContext(effect: ContinuousEffect): EffectContext { - const source = this.objects.get(effect.sourceId) ?? this.playerSource(effect.controller) - return this.contextFor(source, effect.controller, [], 0, 0) - } - - private staticContext(source: GameObject): EffectContext { - return this.contextFor(source, source.controller, [], 0, 0) - } - - private contextFor( - source: GameObject, - controller: string, - targets: TargetChoice[], - x: number, - mode: number, - triggerSubject?: GameObject, - eventPlayer?: string, - eventAmount?: number, - ): EffectContext { - return { source, controller, targets: [...targets], x, mode, triggerSubject, eventPlayer, eventAmount } - } - - private value(value: Value, context: EffectContext): number { - switch (value.kind) { - case 'number': - return value.value - case 'x': - return context.x - case 'count': - return this.objectsMatching(value.selector, context.source).length - case 'source_power': - return this.getPower(context.source) - case 'source_toughness': - return this.getToughness(context.source) - case 'cards_in_hand': { - const playerId = this.playersForValue(value.player, context)[0] - return playerId ? this.getPlayer(playerId).hand.length : 0 - } - case 'max_cards_in_hand': - return Math.max(...this.alivePlayers().map(player => player.hand.length), 0) - case 'max_opponent_count': - return Math.max(...this.opponentsOf(context.source.controller).map(playerId => this.objectsMatching(value.selector, context.source) - .filter(object => object.controller === playerId).length), 0) - case 'total_mana_value': - return this.objectsMatching(value.selector, context.source) - .reduce((total, object) => total + manaValueOf(object.definition), 0) - case 'total_power': - return this.objectsMatching(value.selector, context.source) - .reduce((total, object) => total + this.getPower(object), 0) - case 'any_number': - return 0 - case 'event_amount': - return context.eventAmount ?? 0 - } - } - - private damageTarget( - target: ResolvedTarget, - amount: number, - source: GameObject, - combat: boolean, - ): void { - if (amount <= 0) return - if (target.kind === 'player') { - if (combat && source.isCommander) { - const defender = this.getPlayer(target.id) - defender.commanderDamage[source.id] = (defender.commanderDamage[source.id] ?? 0) + amount - } - this.getPlayer(target.id).damageTakenThisTurn += amount - this.loseLife(target.id, amount) - this.dispatchEvent({ kind: 'deals_damage', player: source.controller, subject: source, recipient: 'player', amount, combat }) - } else if (target.kind === 'object') { - const object = target.object - if (object.zone !== 'battlefield') return - object.damage += amount - if (this.hasKeyword(source, 'Deathtouch')) object.deathtouched = true - this.dispatchEvent({ - kind: 'deals_damage', - player: source.controller, - subject: source, - recipient: this.isCreature(object) ? 'creature' : 'permanent', - amount, - combat, - }) - } - if (this.hasKeyword(source, 'Lifelink')) this.gainLife(source.controller, amount) - } - - private destroyPermanent(object: GameObject): void { - if (object.zone !== 'battlefield') return - if (this.hasKeyword(object, 'Indestructible')) return - if (object.regenerationShields > 0) { - object.regenerationShields-- - object.tapped = true - object.damage = 0 - object.deathtouched = false - object.attacking = undefined - object.blockedBy = [] - object.blocking = undefined - return - } - this.moveToZone(object, 'graveyard', { silent: false }) - } - - private createToken(playerId: string, spec: TokenSpec, context: EffectContext): GameObject { - const card = tokenCard({ - ...spec, - power: spec.power ? this.value(spec.power, context) : undefined, - toughness: spec.toughness ? this.value(spec.toughness, context) : undefined, - }) - const player = this.getPlayer(playerId) - const object: GameObject = { - id: this.generateId('token'), - definition: card.definition, - backFace: card.backFace, - owner: playerId, - controller: playerId, - zone: 'battlefield', - tapped: false, - damage: 0, - deathtouched: false, - counters: {}, - isToken: true, - token: spec, - enteredTurn: this.turn, - blockedBy: [], - attachments: [], - regenerationShields: 0, - activations: {}, - } - this.objects.set(object.id, object) - this.moveToZone(object, 'battlefield', { controller: playerId, tapped: spec.tapped ?? false, silent: false }) - return object - } - - private createTokenCopy(playerId: string, source: GameObject, notLegendary = false): GameObject { - const definition = notLegendary - ? { ...source.definition, typeLine: source.definition.typeLine.replace(/\bLegendary\s+/i, '') } - : source.definition - const object: GameObject = { - id: this.generateId('token'), - definition, - backFace: source.backFace, - owner: playerId, - controller: playerId, - zone: 'battlefield', - tapped: false, - damage: 0, - deathtouched: false, - counters: {}, - isToken: true, - token: source.token, - enteredTurn: this.turn, - blockedBy: [], - attachments: [], - regenerationShields: 0, - activations: {}, - } - this.objects.set(object.id, object) - this.moveToZone(object, 'battlefield', { controller: playerId, tapped: false, silent: false }) - return object - } - - private attach(source: GameObject, target: GameObject): void { - if (source.attachedTo) { - const previous = this.objects.get(source.attachedTo) - if (previous) previous.attachments = previous.attachments.filter(id => id !== source.id) - } - source.attachedTo = target.id - if (!target.attachments.includes(source.id)) target.attachments.push(source.id) - } - - private addCounters(object: GameObject, counter: string, amount: number, silent = false): void { - if (amount === 0) return - object.counters[counter] = Math.max(0, (object.counters[counter] ?? 0) + amount) - if (!silent) this.dispatchEvent({ kind: 'counter_placed', player: object.controller, subject: object, amount, counter }) - } - - // --------------------------------------------------------------------------- - // Triggers, statics, and conditions - // --------------------------------------------------------------------------- - - private dispatchEvent(event: EventContext): void { - if (this.status !== 'active') return - const sources = this.battlefieldObjects() - if (event.subject && event.subject.zone !== 'battlefield' && !sources.includes(event.subject)) { - sources.push(event.subject) - } - sources.sort((a, b) => { - const aFirst = a.controller === this.activePlayer ? 0 : 1 - const bFirst = b.controller === this.activePlayer ? 0 : 1 - return aFirst - bFirst - }) - - let added = 0 - for (const source of sources) { - for (const ability of source.definition.abilities ?? []) { - if (ability.kind !== 'triggered') continue - if (ability.condition) { - if (ability.condition.kind === 'event_subject_toughness_at_most') { - if (!event.subject || this.getToughness(event.subject) > ability.condition.amount) continue - } else if (!this.checkCondition(ability.condition, source)) continue - } - if (!this.matchesTrigger(event, ability.event, source)) continue - let targets: TargetChoice[] - try { - targets = this.selectTargets(ability.effects, source, source.controller, [], 0) - } catch { - continue - } - this.stack.push({ - id: this.generateId('stack'), - kind: 'ability', - source, - controller: source.controller, - label: ability.text, - effects: ability.effects, - targets, - x: 0, - mode: 0, - triggerSubject: event.subject, - eventPlayer: event.player, - eventAmount: event.amount, - }) - added++ - } - } - if (added) { - this.passesInRow = 0 - this.priority = this.activePlayer - } - } - - private matchesTrigger(event: EventContext, trigger: TriggerEvent, source: GameObject): boolean { - switch (trigger.kind) { - case 'enters': - case 'dies': - case 'attacks': - case 'blocks': - case 'leaves_battlefield': - return event.kind === trigger.kind && this.subjectMatches(trigger.subject, source, event) - case 'enters_or_attacks': - return (event.kind === 'enters' || event.kind === 'attacks') - && this.subjectMatches(trigger.subject, source, event) - case 'enters_or_dies': - return (event.kind === 'enters' || event.kind === 'dies') - && this.subjectMatches(trigger.subject, source, event) - case 'attacks_or_blocks': - return (event.kind === 'attacks' || event.kind === 'blocks') - && this.subjectMatches(trigger.subject, source, event) - case 'counter_placed': - return event.kind === 'counter_placed' - && this.subjectMatches(trigger.subject, source, event) - && (!trigger.counter || trigger.counter === event.counter) - case 'upkeep': - case 'end_step': - case 'begin_combat': - return event.kind === trigger.kind && this.whoMatches(trigger.who, source, event.player) - case 'main_phase': - return event.kind === 'main_phase' && this.whoMatches(trigger.who, source, event.player) - case 'cast': - if (event.kind !== 'cast' || !event.spell) return false - if (!this.whoMatches(trigger.who, source, event.player)) return false - if (!this.matchesSelector(event.spell, trigger.spell, source, 'stack')) return false - if (trigger.targetsSelf && !(event.spellItem?.targets.some(choice => choice.kind === 'object' && choice.id === source.id))) { - return false - } - return true - case 'draw': - if (event.kind !== 'draw' || !this.whoMatches(trigger.who, source, event.player)) return false - return !trigger.ordinal || trigger.ordinal === event.ordinal - case 'life': - if (event.kind !== 'life' || !this.whoMatches(trigger.who, source, event.player)) return false - return trigger.mode === event.mode - case 'deals_damage': - if (event.kind !== 'deals_damage' || !this.subjectMatches(trigger.subject, source, event)) return false - if (trigger.combat && !event.combat) return false - return trigger.recipient === 'any' || trigger.recipient === event.recipient - case 'becomes_target': - case 'becomes_level': - return false - } - } - - private subjectMatches(target: Target, source: GameObject, event: EventContext): boolean { - if (!event.subject) return false - if (target.kind === 'self' || target.kind === 'trigger_subject') return event.subject.id === source.id - if (target.kind !== 'object') return false - if (target.selector.other && event.subject.id === source.id && !target.includeSelf) return false - return this.matchesSelector(event.subject, target.selector, source, event.subject.zone) - } - - private whoMatches(who: 'you' | 'opponent' | 'each_player', source: GameObject, eventPlayer: string | undefined): boolean { - if (who === 'each_player') return true - if (!eventPlayer) return false - return who === 'you' ? source.controller === eventPlayer : source.controller !== eventPlayer - } - - private staticAbilities(): { source: GameObject; ability: Extract }[] { - const result: { source: GameObject; ability: Extract }[] = [] - for (const source of this.battlefieldObjects()) { - for (const ability of source.definition.abilities ?? []) { - if (ability.kind !== 'static') continue - if (ability.condition && !this.checkCondition(ability.condition, source)) continue - result.push({ source, ability }) - } - } - return result - } - - private staticTargets(source: GameObject, target: Target): GameObject[] { - if (target.kind === 'self') return [source] - if (target.kind !== 'object') return [] - return this.objectsMatching(target.selector, source) - } - - /** Product of every token-doubling replacement that applies to this creation. */ - private tokenMultiplier(playerId: string, creatureToken: boolean): number { - let multiplier = 1 - for (const { source, ability } of this.staticAbilities()) { - for (const effect of ability.effects) { - if (effect.op !== 'token_multiplier') continue - if (effect.who === 'you' && source.controller !== playerId) continue - if (effect.creatureOnly && !creatureToken) continue - multiplier *= effect.multiplier - } - } - return multiplier - } - - private exilesInsteadOfGraveyard(object: GameObject): boolean { - for (const { source, ability } of this.staticAbilities()) { - for (const effect of ability.effects) { - if (effect.op !== 'exile_instead_of_graveyard') continue - if (effect.owner === 'opponent' && object.owner === source.controller) continue - if (effect.owner === 'you' && object.owner !== source.controller) continue - return true - } - } - return false - } - - private applyEntersReplacements(object: GameObject): void { - for (const staticSource of this.staticAbilities()) { - for (const effect of staticSource.ability.effects) { - if (effect.op === 'enters_tapped') { - if (effect.unless && this.checkCondition(effect.unless, staticSource.source)) continue - if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue - if (effect.unlessCost && !object.tapped) { - const context = this.staticContext(staticSource.source) - this.pendingChoices.push({ - playerId: object.controller, - sourceId: object.id, - what: 'pay_cost', - cost: effect.unlessCost, - amount: effect.unlessCost.kind === 'pay_life' ? this.value(effect.unlessCost.amount, context) : undefined, - }) - continue - } - object.tapped = true - } else if (effect.op === 'enters_with_counters') { - if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue - const amount = this.value(effect.amount, this.staticContext(staticSource.source)) - this.addCounters(object, effect.counter, amount, true) - } - } - } - } - - /** Queues the "as this enters, choose a creature type" prompt for a new permanent. */ - private queueEnterChoices(object: GameObject): void { - for (const ability of object.definition.abilities ?? []) { - if (ability.kind !== 'static') continue - if (!ability.effects.some(effect => effect.op === 'choose' && effect.what === 'creature_type')) continue - this.pendingChoices.push({ playerId: object.controller, sourceId: object.id, what: 'creature_type' }) - return - } - } - - private hasRestriction(object: GameObject, rule: string): boolean { - for (const staticSource of this.staticAbilities()) { - for (const effect of staticSource.ability.effects) { - if (effect.op !== 'restriction' || (effect.rule !== rule && !effect.rule.startsWith(`${rule}_`))) continue - if (this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) return true - } - } - for (const continuous of this.continuousEffects) { - if (continuous.effect.op !== 'restriction' || continuous.effect.rule !== rule) continue - if (continuous.affectedIds.includes(object.id)) return true - } - return false - } - - private checkCondition(condition: Condition, source: GameObject): boolean { - const controller = source.controller - switch (condition.kind) { - case 'you_control': - return this.objectsMatching(condition.selector, source).filter(object => object.controller === controller).length - >= (condition.atLeast ?? 1) - case 'opponent_controls': - return this.opponentsOf(controller).some(playerId => this.objectsMatching(condition.selector, source) - .some(object => object.controller === playerId)) - case 'your_turn': - return this.activePlayer === controller - case 'not_your_turn': - return this.activePlayer !== controller - case 'source_tapped': - return source.tapped - case 'source_untapped': - return !source.tapped - case 'source_attacking': - return Boolean(source.attacking) - case 'life_at_least': - return this.playersForValue(condition.player, this.staticContext(source)) - .some(playerId => this.getPlayer(playerId).life >= condition.amount) - case 'life_at_most': - return this.playersForValue(condition.player, this.staticContext(source)) - .some(playerId => this.getPlayer(playerId).life <= condition.amount) - case 'cards_in_graveyard': - return this.playersForValue(condition.player, this.staticContext(source)) - .some(playerId => this.getPlayer(playerId).graveyard.length >= condition.atLeast) - case 'hand_empty': - return this.playersForValue(condition.player, this.staticContext(source)) - .some(playerId => this.getPlayer(playerId).hand.length === 0) - case 'creature_died_this_turn': - return this.getPlayer(controller).creaturesDiedThisTurn > 0 - case 'you_gained_life_this_turn': - return this.getPlayer(controller).lifeGainedThisTurn >= (condition.atLeast ?? 1) - case 'you_drew_cards_this_turn': - return this.getPlayer(controller).cardsDrawnThisTurn >= (condition.atLeast ?? 1) - case 'attacked_this_turn': - return this.getPlayer(controller).attackedThisTurn - case 'you_attacked_this_turn': - return this.getPlayer(controller).attackedThisTurn - case 'attacked_with_creatures': - return this.getPlayer(controller).creaturesAttackedThisTurn >= condition.atLeast - case 'opponent_damaged_this_turn': - return this.opponentsOf(controller) - .some(playerId => this.getPlayer(playerId).damageTakenThisTurn >= condition.atLeast) - case 'library_at_most': - return this.alivePlayers().some(player => player.library.length <= condition.atMost) - case 'no_objects': - return this.objectsMatching(condition.selector, source).length === 0 - case 'cards_in_hand_at_most': { - const players = this.playersForValue(condition.who, this.staticContext(source)) - const check = (playerId: string): boolean => this.getPlayer(playerId).hand.length <= condition.atMost - return condition.who === 'each_player' || condition.who === 'each_opponent' - ? players.every(check) - : players.some(check) - } - case 'on_battlefield': - return source.zone === 'battlefield' - case 'in_graveyard': - return source.zone === 'graveyard' - case 'not_token': - return !source.isToken - case 'full_party': - return false - case 'you_control_commander': - return this.battlefieldObjects().some(object => object.controller === controller && object.isCommander) - case 'distinct_names': - return new Set(this.objectsMatching(condition.selector, source) - .filter(object => object.controller === controller) - .map(object => object.definition.name.toLowerCase())).size >= condition.atLeast - case 'total_power': - return this.battlefieldObjects() - .filter(object => object.controller === controller && this.isCreature(object)) - .reduce((total, object) => total + this.getPower(object), 0) >= condition.atLeast - case 'event_subject_toughness_at_most': - return false - default: - return false - } - } - - // --------------------------------------------------------------------------- - // Combat damage - // --------------------------------------------------------------------------- - - private dealCombatDamage(): void { - const attackers = this.battlefieldObjects().filter(object => object.attacking) - const anyFirstStrike = attackers.some(object => this.hasKeyword(object, 'First strike') || this.hasKeyword(object, 'Double strike')) - || attackers.some(object => object.blockedBy - .map(id => this.objects.get(id)) - .some(blocker => blocker && (this.hasKeyword(blocker, 'First strike') || this.hasKeyword(blocker, 'Double strike')))) - - if (anyFirstStrike) this.dealCombatDamageRound(true) - this.dealCombatDamageRound(false) - this.step = 'end_combat' - this.passesInRow = 0 - this.priority = this.activePlayer - } - - private dealCombatDamageRound(firstStrike: boolean): void { - for (const attacker of this.battlefieldObjects()) { - if (attacker.zone !== 'battlefield' || !attacker.attacking) continue - const doubleStrike = this.hasKeyword(attacker, 'Double strike') - const first = this.hasKeyword(attacker, 'First strike') - if (firstStrike ? (!first && !doubleStrike) : (first && !doubleStrike)) continue - - let power = this.getPower(attacker) - const blockers = attacker.blockedBy - .map(id => this.objects.get(id)) - .filter((object): object is GameObject => Boolean(object && object.zone === 'battlefield' && object.blocking === attacker.id)) - const deathtouch = this.hasKeyword(attacker, 'Deathtouch') - const trample = this.hasKeyword(attacker, 'Trample') - - if (!blockers.length) { - this.damageDefender(attacker, power) - } else { - let remaining = power - for (let index = 0; index < blockers.length && remaining > 0; index++) { - const blocker = blockers[index] - const lethal = deathtouch ? 1 : Math.max(0, this.getToughness(blocker) - blocker.damage) - const assign = index === blockers.length - 1 && !trample - ? remaining - : Math.min(remaining, Math.max(lethal, 1)) - if (assign <= 0) continue - this.damageTarget({ kind: 'object', object: blocker }, assign, attacker, true) - remaining -= assign - } - if (trample && remaining > 0) this.damageDefender(attacker, remaining) - - for (const blocker of blockers) { - if (blocker.zone !== 'battlefield' || blocker.blocking !== attacker.id) continue - const blockerDouble = this.hasKeyword(blocker, 'Double strike') - const blockerFirst = this.hasKeyword(blocker, 'First strike') - if (firstStrike ? (!blockerFirst && !blockerDouble) : (blockerFirst && !blockerDouble)) continue - this.damageTarget({ kind: 'object', object: attacker }, this.getPower(blocker), blocker, true) - } - } - } - this.runStateBasedActions() - } - - private damageDefender(attacker: GameObject, amount: number): void { - const defenderId = attacker.attacking - if (!defenderId) return - const player = this.players.find(entry => entry.id === defenderId) - if (player) { - this.damageTarget({ kind: 'player', id: player.id }, amount, attacker, true) - return - } - const permanent = this.objects.get(defenderId) - if (permanent?.zone === 'battlefield') { - this.damageTarget({ kind: 'object', object: permanent }, amount, attacker, true) - } - } - - private requireCanAttack(attacker: GameObject, playerId: string): void { - if (attacker.zone !== 'battlefield') throw new GameError('Attacker is not on the battlefield') - if (attacker.controller !== playerId) throw new GameError('You do not control that creature') - if (!this.isCreature(attacker)) throw new GameError('Only creatures can attack') - if (attacker.tapped) throw new GameError('Tapped creatures cannot attack') - if (attacker.enteredTurn >= this.turn && !this.hasKeyword(attacker, 'Haste')) { - throw new GameError('That creature has summoning sickness') - } - if (this.hasRestriction(attacker, 'cant_attack')) throw new GameError('That creature cannot attack') - } - - private hasMeaningfulAction(playerId: string): boolean { - if (this.status !== 'active' || this.priority !== playerId || this.pendingChoice) return false - const player = this.getPlayer(playerId) - if (player.lost) return false - - if (this.phase === 'combat' && this.step === 'declare_attackers' && !this.stack.length - && this.activePlayer === playerId && this.canAttackWithAny(playerId)) { - return true - } - if (this.phase === 'combat' && this.step === 'declare_blockers' && !this.stack.length - && this.canBlockWithAny(playerId)) { - return true - } - - if ([...player.hand, ...player.command, ...player.exile].some(id => this.canPlayCard(playerId, id))) return true - - for (const id of player.battlefield) { - const object = this.objects.get(id) - if (!object) continue - const abilities = object.definition.abilities ?? [] - for (let index = 0; index < abilities.length; index++) { - const ability = abilities[index] - if (ability.kind !== 'activated') continue - // Mana abilities alone do not advance the game; counting them would - // stop auto-pass on every untapped land. - if (ability.effects.length && ability.effects.every(effect => effect.op === 'add_mana')) continue - if (this.isActivatedAbilityPlayable(playerId, object, index, ability)) return true - } - } - return false - } - - private isActivatedAbilityPlayable( - playerId: string, - source: GameObject, - index: number, - ability: Extract, - ): boolean { - if (source.zone !== 'battlefield' || source.controller !== playerId) return false - if (this.hasRestriction(source, 'cant_activate')) return false - if (ability.condition && !this.checkCondition(ability.condition, source)) return false - if (ability.timing === 'sorcery' && !this.isMainPhaseWithEmptyStack(playerId)) return false - if (ability.costs.some(cost => cost.kind === 'tap') && this.isCreature(source) - && source.enteredTurn >= this.turn && !this.hasKeyword(source, 'Haste')) { - return false - } - if (ability.activationsPerTurn !== undefined - && (source.activations[index] ?? 0) >= ability.activationsPerTurn) { - return false - } - for (const cost of ability.costs) { - if (cost.kind === 'mana') { - if (!this.canAffordMana(playerId, cost.symbols, 0)) return false - } else if (!this.canPayNonManaCost(cost, playerId, source)) { - return false - } - } - return this.hasLegalTargets(source, playerId, ability.effects) - } - - private hasLegalTargets(source: GameObject, playerId: string, effects?: Effect[]): boolean { - const list = effects ?? (source.definition.abilities ?? []) - .filter((ability): ability is Extract => ability.kind === 'spell') - .flatMap(ability => ability.effects) - try { - this.selectTargets(list, source, playerId, [], 0) - return true - } catch (error) { - if (error instanceof GameError) return false - throw error - } - } - - /** - * Affordability check that mirrors auto-tapping without changing the game. - * shortcut: only land-based any_color restrictions are modelled; mana - * restricted by a commander identity or a spell type is still flexible. - */ - private canAffordMana(playerId: string, symbols: string, x: number): boolean { - if (!symbols) return true - const player = this.getPlayer(playerId) - const cost = parseManaCost(symbols, x) - const pool = { ...player.manaPool } - let flexible = 0 - const restricted: { colors: Set; amount: number }[] = [] - for (const object of this.battlefieldObjects()) { - if (object.controller !== playerId) continue - const found = this.findFreeManaAbility(object) - if (!found) continue - for (const effect of found.ability.effects) { - if (effect.op !== 'add_mana') continue - if (effect.mana.kind === 'symbols') { - for (const symbol of effect.mana.symbols) pool[colorOfSymbol(symbol)]++ - } else { - const amount = this.value(effect.mana.amount, { - source: object, - controller: playerId, - targets: [], - x: 0, - mode: 0, - }) - const allowed = this.anyColorRestrictionColors(effect.mana, playerId) - if (!allowed) flexible += amount - else if (allowed.size) restricted.push({ colors: allowed, amount }) - } - } - } - - let life = player.life - restricted.sort((a, b) => a.colors.size - b.colors.size) - const take = (color: ManaColor): boolean => { - if (pool[color] > 0) { - pool[color]-- - return true - } - const source = restricted.find(entry => entry.amount > 0 && entry.colors.has(color)) - if (source) { - source.amount-- - return true - } - if (flexible > 0) { - flexible-- - return true - } - return false - } - - for (const color of cost.colored) { - if (!take(color)) return false - } - for (const hybrid of cost.hybrid) { - if (hybrid.colors.some(take)) continue - if (!(hybrid.life > 0 && life >= hybrid.life)) return false - life -= hybrid.life - } - const remaining = MANA_COLORS.reduce((total, color) => total + pool[color], 0) - + flexible - + restricted.reduce((total, entry) => total + entry.amount, 0) - return remaining >= cost.generic - } - - private canAttackWithAny(playerId: string): boolean { - return this.battlefieldObjects().some(object => { - try { - this.requireCanAttack(object, playerId) - return true - } catch (error) { - if (error instanceof GameError) return false - throw error - } - }) - } - - private canBlockWithAny(playerId: string): boolean { - const attackers = this.battlefieldObjects().filter(object => object.attacking === playerId) - if (!attackers.length) return false - return this.battlefieldObjects().some(blocker => { - if (blocker.controller !== playerId) return false - if (!this.isCreature(blocker) || blocker.tapped || blocker.blocking) return false - if (this.hasRestriction(blocker, 'cant_block')) return false - return attackers.some(attacker => !this.hasKeyword(attacker, 'Flying') - || this.hasKeyword(blocker, 'Flying') - || this.hasKeyword(blocker, 'Reach')) - }) - } - - // --------------------------------------------------------------------------- - // Zones, state-based actions, and utilities - // --------------------------------------------------------------------------- - - private handleLeavesBattlefield(object: GameObject, destination: Zone): void { - if (object.attachedTo) { - const attached = this.objects.get(object.attachedTo) - if (attached) attached.attachments = attached.attachments.filter(id => id !== object.id) - object.attachedTo = undefined - } - for (const attachmentId of [...object.attachments]) { - const attachment = this.objects.get(attachmentId) - if (attachment) attachment.attachedTo = undefined - } - object.attachments = [] - object.attacking = undefined - object.blockedBy = [] - object.blocking = undefined - object.linkedExile = undefined - - for (let index = this.continuousEffects.length - 1; index >= 0; index--) { - const effect = this.continuousEffects[index] - if (effect.sourceId !== object.id) continue - if (effect.duration === 'permanent' || effect.duration === 'while_source_on_battlefield') { - this.continuousEffects.splice(index, 1) - } - } - - if (destination === 'graveyard' && this.isCreature(object)) { - this.getPlayer(object.controller).creaturesDiedThisTurn++ - this.dispatchEvent({ kind: 'dies', player: object.controller, subject: object }) - } - this.dispatchEvent({ kind: 'leaves_battlefield', player: object.controller, subject: object }) - } - - private runStateBasedActions(): void { - if (this.status !== 'active') return - let changed = true - let guard = 0 - while (changed && guard++ < 50 && this.status === 'active') { - changed = false - for (const player of this.players) { - if (!player.lost && (player.life <= 0 || player.poison >= 10 - || Object.values(player.commanderDamage).some(damage => damage >= 21))) { - this.losePlayer(player.id) - changed = true - } - } - if (this.status !== 'active') return - for (const id of [...this.battlefieldObjects().map(object => object.id)]) { - const object = this.objects.get(id) - if (!object || object.zone !== 'battlefield' || !this.isCreature(object)) continue - const lethal = this.getToughness(object) <= 0 - || object.damage >= this.getToughness(object) - || (object.deathtouched && object.damage > 0) - if (!lethal) continue - if (this.hasKeyword(object, 'Indestructible')) continue - if (object.regenerationShields > 0) { - object.regenerationShields-- - object.tapped = true - object.damage = 0 - object.deathtouched = false - object.attacking = undefined - object.blockedBy = [] - object.blocking = undefined - } else { - this.moveToZone(object, 'graveyard', { silent: false }) - } - changed = true - } - for (const player of this.alivePlayers()) { - const legends = new Map() - for (const object of this.battlefieldObjects()) { - if (object.controller !== player.id || !/\blegendary\b/i.test(object.definition.typeLine)) continue - const name = object.definition.name.toLowerCase() - legends.set(name, [...(legends.get(name) ?? []), object]) - } - for (const copies of legends.values()) { - // shortcut: keeps the first copy found, not the player's choice; ask when the API can pause for it - for (const extra of copies.slice(1)) { - this.moveToZone(extra, 'graveyard', { silent: false }) - changed = true - } - } - } - } - } - - private losePlayer(playerId: string): void { - const player = this.getPlayer(playerId) - if (player.lost) return - player.lost = true - this.logMessage(`${player.name} loses the game`) - const alive = this.alivePlayers() - if (alive.length <= 1) { - this.status = 'finished' - this.winner = alive[0]?.id - if (this.winner) this.logMessage(`${this.getPlayer(this.winner).name} wins`) - } - } - - private gainLife(playerId: string, amount: number): void { - if (amount <= 0) return - const player = this.getPlayer(playerId) - if (player.lost) return - player.life += amount - player.lifeGainedThisTurn += amount - this.dispatchEvent({ kind: 'life', player: playerId, amount, mode: 'gain' }) - } - - private loseLife(playerId: string, amount: number): void { - if (amount <= 0) return - const player = this.getPlayer(playerId) - if (player.lost) return - player.life -= amount - this.dispatchEvent({ kind: 'life', player: playerId, amount, mode: 'lose' }) - this.runStateBasedActions() - } - - private drawCard(playerId: string, silent: boolean): void { - const player = this.getPlayer(playerId) - if (player.lost) return - if (!player.library.length) { - this.losePlayer(playerId) - return - } - const id = player.library.shift() - if (!id) return - player.hand.push(id) - const object = this.getObject(id) - object.zone = 'hand' - object.controller = playerId - player.cardsDrawnThisTurn++ - if (!silent) { - this.dispatchEvent({ kind: 'draw', player: playerId, amount: 1, ordinal: player.cardsDrawnThisTurn }) - } - } - - private drawCards(playerId: string, amount: number): void { - for (let i = 0; i < amount; i++) this.drawCard(playerId, false) - } - - private discardCards(playerId: string, amount: number, random: boolean | undefined, context: EffectContext): void { - const player = this.getPlayer(playerId) - for (let i = 0; i < amount && player.hand.length; i++) { - const index = random ? Math.floor(this.rng() * player.hand.length) : 0 - const id = player.hand[index] - this.moveToZone(id, 'graveyard', { silent: false }) - } - void context - } - - private millCards(playerId: string, amount: number): void { - const player = this.getPlayer(playerId) - for (let i = 0; i < amount && player.library.length; i++) { - const id = player.library[0] - this.moveToZone(id, 'graveyard', { silent: true }) - } - } - - private searchLibrary( - playerId: string, - selector: ObjectSelector, - amount: number, - destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom', - tapped: boolean, - shuffle: boolean, - zones?: ('library' | 'graveyard')[], - split?: { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean }, - ): void { - // shortcut: a search only pauses itself; later effects in the same ability - // still run before the pick, and a second search in that ability is skipped. - // Most search lines are a single effect. - if (this.pendingSearch) return - const player = this.getPlayer(playerId) - // Searching then shuffling is the same as shuffling first when the picked - // cards go on top, and it keeps the shuffle from burying them again. - if (shuffle && (destination === 'top' || split?.destination === 'top')) { - this.shuffleLibrary(player) - shuffle = false - } - let remaining = amount - let first = true - while (remaining > 0) { - const pickDestination = first ? destination : (split?.destination ?? destination) - const pickTapped = first ? tapped : (split?.tapped ?? tapped) - const candidates = this.findSearchCandidates(playerId, selector, zones) - if (!candidates.length) break - if (candidates.length > 1) { - this.pendingSearch = { - playerId, - selector, - remaining, - destination: pickDestination, - tapped: pickTapped, - shuffle, - zones, - ...(first && split && remaining > 1 ? { split } : {}), - } - return - } - this.moveSearchedCard(candidates[0], playerId, pickDestination, pickTapped) - remaining-- - first = false - } - if (shuffle) this.shuffleLibrary(player) - } - - private findSearchCandidates( - playerId: string, - selector: ObjectSelector, - zones?: ('library' | 'graveyard')[], - ): GameObject[] { - const source = this.playerSource(playerId) - return this.searchableObjects(playerId, zones) - .filter(object => this.matchesSelector(object, selector, source, object.zone)) - } - - private searchableObjects(playerId: string, zones?: ('library' | 'graveyard')[]): GameObject[] { - const player = this.getPlayer(playerId) - const allowed = zones ?? ['library'] - const libraryLimit = this.searchLibraryLimit(playerId) - const ids = allowed.includes('library') - ? player.library.slice(0, libraryLimit ?? player.library.length) - : [] - if (allowed.includes('graveyard')) ids.push(...player.graveyard) - return ids.map(id => this.getObject(id)).filter(object => object.owner === playerId) - } - - private moveSearchedCard( - object: GameObject, - playerId: string, - destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom', - tapped: boolean, - ): void { - if (destination === 'battlefield') { - this.moveToZone(object, 'battlefield', { controller: playerId, tapped, silent: false }) - } else if (destination === 'hand') { - this.moveToZone(object, 'hand', { silent: false }) - } else if (destination === 'graveyard') { - this.moveToZone(object, 'graveyard', { silent: false }) - } else if (destination === 'top') { - this.moveToZone(object, 'library', { toTop: true, silent: false }) - } else { - this.moveToZone(object, 'library', { silent: false }) - } - } - - // shortcut: the limit is recomputed after each pick, so a multi-card search - // can see one new card per pick. Upgrade when a card searches for several - // cards while Aven Mindcensor is out. - private searchLibraryLimit(playerId: string): number | undefined { - let limit: number | undefined - for (const { source, ability } of this.staticAbilities()) { - for (const effect of ability.effects) { - if (effect.op !== 'search_restriction') continue - const applies = effect.who === 'you' ? playerId === source.controller : playerId !== source.controller - if (!applies) continue - const amount = this.value(effect.amount, this.staticContext(source)) - limit = limit === undefined ? amount : Math.min(limit, amount) - } - } - return limit - } - - private shuffleLibrary(player: PlayerState): void { - for (let index = player.library.length - 1; index > 0; index--) { - const swap = Math.floor(this.rng() * (index + 1)) - const temp = player.library[index] - player.library[index] = player.library[swap] - player.library[swap] = temp - } - } - - private removeFromZone(object: GameObject): void { - const owner = this.getPlayer(object.owner) - if (object.zone === 'battlefield') { - const controller = this.getPlayer(object.controller) - controller.battlefield = controller.battlefield.filter(id => id !== object.id) - } else if (object.zone === 'hand') owner.hand = owner.hand.filter(id => id !== object.id) - else if (object.zone === 'graveyard') owner.graveyard = owner.graveyard.filter(id => id !== object.id) - else if (object.zone === 'exile') owner.exile = owner.exile.filter(id => id !== object.id) - else if (object.zone === 'command') owner.command = owner.command.filter(id => id !== object.id) - else if (object.zone === 'library') owner.library = owner.library.filter(id => id !== object.id) - } - - private objectsMatching(selector: ObjectSelector, source: GameObject, zoneOverride?: Zone): GameObject[] { - const zone = zoneOverride ?? selector.zone ?? 'battlefield' - return [...this.objects.values()].filter(object => this.matchesSelector(object, selector, source, zone)) - } - - private matchesSelector(object: GameObject, selector: ObjectSelector, source: GameObject, zoneOverride?: Zone): boolean { - const zone = zoneOverride ?? selector.zone ?? 'battlefield' - if (object.zone !== zone) return false - if (selector.other && object.id === source.id) return false - - const typeLine = object.definition.typeLine.toLowerCase() - const words = new Set(typeLine.split(/[\s—–\-/,()]+/).filter(Boolean)) - const matchesWords = (values: string[]): boolean => { - const matches = values.map(value => words.has(value.toLowerCase())) - return selector.match === 'any' ? matches.some(Boolean) : matches.every(Boolean) - } - // "Permanent" is a zone property, not a word on the type line. - const types = selector.types?.filter(type => type.toLowerCase() !== 'permanent') - if (types?.length && !matchesWords(types)) return false - if (selector.excludeTypes?.some(type => words.has(type.toLowerCase()))) return false - if (selector.supertypes?.length && !matchesWords(selector.supertypes)) return false - if (selector.subtypes?.length && !matchesWords(selector.subtypes)) return false - - if (selector.controller === 'you' && object.controller !== source.controller) return false - if (selector.controller === 'opponent' && object.controller === source.controller) return false - if (selector.owner === 'you' && object.owner !== source.controller) return false - if (selector.owner === 'opponent' && object.owner === source.controller) return false - - const colors = object.definition.colors ?? [] - if (selector.colors?.length) { - const matches = selector.colors.map(color => colors.includes(color)) - if (selector.match === 'any' ? !matches.some(Boolean) : !matches.every(Boolean)) return false - } - if (selector.excludeColors?.some(color => color === 'C' ? colors.length === 0 : colors.includes(color))) return false - if (selector.tapped !== undefined && object.tapped !== selector.tapped) return false - if (selector.attacking !== undefined && Boolean(object.attacking) !== selector.attacking) return false - if (selector.token !== undefined && object.isToken !== selector.token) return false - if (selector.name && object.definition.name.toLowerCase() !== selector.name.toLowerCase()) return false - if (selector.counters) { - const count = object.counters[selector.counters.counter] ?? 0 - if (count < selector.counters.atLeast) return false - } - if (selector.power) { - const power = this.getPower(object) - if (selector.power.atLeast !== undefined && power < selector.power.atLeast) return false - if (selector.power.atMost !== undefined && power > selector.power.atMost) return false - } - if (selector.toughness) { - const toughness = this.getToughness(object) - if (selector.toughness.atLeast !== undefined && toughness < selector.toughness.atLeast) return false - if (selector.toughness.atMost !== undefined && toughness > selector.toughness.atMost) return false - } - if (selector.manaValue) { - const value = manaValueOf(object.definition) - if (selector.manaValue.atLeast !== undefined && value < selector.manaValue.atLeast) return false - if (selector.manaValue.atMost !== undefined && value > selector.manaValue.atMost) return false - } - if (selector.keywords?.some(keyword => !this.hasKeyword(object, keyword))) return false - if (selector.excludeKeywords?.some(keyword => this.hasKeyword(object, keyword))) return false - if (selector.attached) { - const attached = [...this.objects.values()].some(attachment => attachment.attachedTo === object.id - && (selector.attached === 'equipped' ? this.hasType(attachment, 'equipment') : this.hasType(attachment, 'aura'))) - if (!attached) return false - } - return true - } - - // --------------------------------------------------------------------------- - // Rules helpers - // --------------------------------------------------------------------------- - - private isCreature(object: GameObject): boolean { - return this.hasType(object, 'creature') - } - - private isLand(object: GameObject): boolean { - return this.hasType(object, 'land') - } - - private isInstant(object: GameObject): boolean { - return this.hasType(object, 'instant') - } - - private isInstantOrSorcery(object: GameObject): boolean { - return this.hasType(object, 'instant') || this.hasType(object, 'sorcery') - } - - private isPermanent(object: GameObject): boolean { - if (this.isInstantOrSorcery(object)) return false - return ['creature', 'artifact', 'enchantment', 'planeswalker', 'battle', 'land'] - .some(type => this.hasType(object, type)) - } - - private hasType(object: GameObject, type: string): boolean { - const words = object.definition.typeLine.toLowerCase().split(/[\s—–\-/,()]+/) - return words.includes(type.toLowerCase()) - } - - private hasKeywordForDefinition(definition: CardDefinition, keyword: string): boolean { - const wanted = keyword.toLowerCase() - for (const ability of definition.abilities ?? []) { - if (ability.kind === 'keyword' && ability.keyword.toLowerCase() === wanted) return true - if (ability.kind === 'keywords' && ability.keywords.some(entry => entry.keyword.toLowerCase() === wanted)) return true - } - return false - } - - private battlefieldObjects(): GameObject[] { - return [...this.objects.values()].filter(object => object.zone === 'battlefield') - } - - private alivePlayers(): PlayerState[] { - return this.players.filter(player => !player.lost) - } - - private opponentsOf(playerId: string): string[] { - return this.alivePlayers().filter(player => player.id !== playerId).map(player => player.id) - } - - private nextAlivePlayer(playerId: string): string { - const start = this.players.findIndex(player => player.id === playerId) - for (let offset = 1; offset <= this.players.length; offset++) { - const player = this.players[(start + offset) % this.players.length] - if (!player.lost) return player.id - } - return playerId - } - - private requirePriority(playerId: string): void { - if (this.status !== 'active') throw new GameError('Game is not active') - if (this.pendingSearch) throw new GameError('Choose a card from your library first') - if (this.pendingChoice) throw new GameError('Resolve the pending choice first') - if (this.priority !== playerId) throw new GameError('You do not have priority') - } - - private emptyManaPools(): void { - for (const player of this.players) player.manaPool = emptyPool() - } - - private removeExpiringEffects(playerId: string): void { - for (let index = this.continuousEffects.length - 1; index >= 0; index--) { - const effect = this.continuousEffects[index] - if ((effect.duration === 'until_your_next_turn' || effect.duration === 'until_controllers_next_untap_step') - && effect.controller === playerId) { - this.continuousEffects.splice(index, 1) - } - } - } - - /** "Until the end of your next turn" skips the turn the effect was created in. */ - private removeEndOfNextTurnEffects(playerId: string): void { - for (let index = this.continuousEffects.length - 1; index >= 0; index--) { - const effect = this.continuousEffects[index] - if (effect.duration === 'until_end_of_your_next_turn' && effect.controller === playerId - && effect.createdTurn !== this.turn) { - this.continuousEffects.splice(index, 1) - } - } - } - - private removeEffectsByDuration(duration: Duration): void { - for (let index = this.continuousEffects.length - 1; index >= 0; index--) { - if (this.continuousEffects[index].duration === duration) this.continuousEffects.splice(index, 1) - } - } - - private counterStat(counters: Record, stat: 'power' | 'toughness'): number { - let total = 0 - for (const [counter, count] of Object.entries(counters)) { - const match = counter.match(/^([+-])(\d+)\/([+-])(\d+)$/) - if (!match) continue - const value = stat === 'power' ? `${match[1]}${match[2]}` : `${match[3]}${match[4]}` - total += Number(value) * count - } - return total - } - - private findStackItem(id: string): StackItem | undefined { - return this.stack.find(item => item.id === id) ?? this.stack.find(item => item.source.id === id) - } - - private playerSource(playerId: string): GameObject { - return { - id: `player:${playerId}`, - definition: { oracleId: `player:${playerId}`, name: this.getPlayer(playerId).name, typeLine: '' }, - owner: playerId, - controller: playerId, - zone: 'battlefield', - tapped: false, - damage: 0, - deathtouched: false, - counters: {}, - isToken: false, - enteredTurn: 0, - blockedBy: [], - attachments: [], - regenerationShields: 0, - activations: {}, - } - } - - private createObject(definition: CardDefinition, owner: string): GameObject { - const object: GameObject = { - id: this.generateId('card'), - definition, - owner, - controller: owner, - zone: 'library', - tapped: false, - damage: 0, - deathtouched: false, - counters: {}, - isToken: false, - enteredTurn: 0, - blockedBy: [], - attachments: [], - regenerationShields: 0, - activations: {}, - } - this.objects.set(object.id, object) - return object - } - - private generateId(prefix: string): string { - this.nextId++ - return `${prefix}_${this.nextId}` - } - - private logMessage(message: string): void { - this.log.push(message) - } -} - -function mulberry32(seed: number): () => number { - let state = seed >>> 0 - return () => { - state = (state + 0x6d2b79f5) >>> 0 - let value = state - value = Math.imul(value ^ (value >>> 15), value | 1) - value ^= value + Math.imul(value ^ (value >>> 7), value | 61) - return ((value ^ (value >>> 14)) >>> 0) / 4294967296 - } -} +export class Game extends GameTurn {} diff --git a/backend/src/game/rooms.ts b/backend/src/game/rooms.ts index ff5e312..011a448 100644 --- a/backend/src/game/rooms.ts +++ b/backend/src/game/rooms.ts @@ -31,6 +31,8 @@ export interface ActionPayload { /** Mana color picked when activating a mana ability that can make several. */ color?: string pay?: boolean + /** Answer to a "you may ..." prompt. */ + accept?: boolean position?: { x?: unknown; y?: unknown } attackers?: { attackerId: string; defenderId: string }[] blocks?: { blockerId: string; attackerId: string }[] @@ -142,6 +144,8 @@ export interface MatchView { sourceName: string /** Life total to display for a `pay_life` cost. */ amount?: number + /** Ability name shown when asking about a "you may" effect. */ + label?: string /** Choices to offer, populated only for the chooser. */ options: string[] /** Cards to choose from for hideaway, populated only for the chooser. */ @@ -475,6 +479,14 @@ export function performAction(matchId: string, token: string | undefined, action if (typeof action.choice !== 'string') throw new MatchError('Missing type choice') game.chooseCreatureType(seat.playerId, action.choice) break + case 'choose_color': + if (typeof action.choice !== 'string') throw new MatchError('Missing color choice') + game.chooseColor(seat.playerId, action.choice) + break + case 'choose_optional': + if (typeof action.accept !== 'boolean') throw new MatchError('Missing optional choice') + game.chooseOptional(seat.playerId, action.accept) + break case 'choose_cost': if (typeof action.pay !== 'boolean') throw new MatchError('Missing cost payment choice') game.chooseCostPayment(seat.playerId, action.pay) @@ -695,7 +707,12 @@ function serialize(match: Match, viewerId: string): MatchView { sourceId: choice.sourceId, sourceName: game.objects.get(choice.sourceId)?.definition.name ?? 'Permanent', amount: choice.amount, - options: choice.playerId === viewerId && choice.what === 'creature_type' ? [...CREATURE_TYPES] : [], + label: choice.label, + options: choice.playerId === viewerId + ? choice.what === 'creature_type' + ? [...CREATURE_TYPES] + : choice.what === 'color' ? ['White', 'Blue', 'Black', 'Red', 'Green'] : [] + : [], cards: choice.playerId === viewerId && choice.what === 'hideaway' ? (choice.cardIds ?? []).map(id => cardView(game, game.getObject(id), false)) : undefined, diff --git a/backend/src/game/types.ts b/backend/src/game/types.ts index b2043c7..6ea6755 100644 --- a/backend/src/game/types.ts +++ b/backend/src/game/types.ts @@ -96,6 +96,8 @@ export interface GameObject { token?: TokenSpec /** Back face of a double-faced token (Incubator); transform swaps it in. */ backFace?: CardDefinition + /** Set when a card would be exiled instead of dying this turn. */ + exileOnDeathTurn?: number /** Set by impulse effects; the card may be played from exile this turn. */ playableFromExileTurn?: number isCommander?: boolean @@ -113,6 +115,8 @@ export interface GameObject { faceDown?: boolean /** Creature type chosen as this permanent entered (Cavern of Souls). */ chosenCreatureType?: string + /** Color chosen as this permanent entered (mana of the chosen color). */ + chosenColor?: ManaColor regenerationShields: number activations: Record } @@ -135,6 +139,10 @@ export interface StackItem { triggerSubject?: GameObject eventPlayer?: string eventAmount?: number + /** "You may ..." — ask the controller before resolving. */ + optional?: boolean + /** Undefined until the controller answers; false skips the main effects. */ + optionalAccepted?: boolean } export interface ActionOptions { @@ -163,9 +171,11 @@ export interface PendingSearch { export interface PendingChoice { playerId: string sourceId: string - what: 'creature_type' | 'pay_cost' | 'hideaway' + what: 'creature_type' | 'color' | 'pay_cost' | 'hideaway' | 'optional' /** Cost to pay to avoid entering tapped. */ cost?: Cost + /** Ability or spell name shown for an optional choice. */ + label?: string /** Life total to display for a `pay_life` cost. */ amount?: number /** Cards to choose from for `hideaway`. */ diff --git a/backend/test/effects.test.ts b/backend/test/effects.test.ts index aa0ae89..d5b6900 100644 --- a/backend/test/effects.test.ts +++ b/backend/test/effects.test.ts @@ -29,6 +29,58 @@ test('enters trigger with a draw effect', () => { assert.equal(ability.effects[0].op, 'draw') }) +test('compound effects resolve "it" through the previous target', () => { + const [ability] = creature('When this enters, tap target creature an opponent controls and put a stun counter on it.') + assert.equal(ability.kind, 'triggered') + if (ability.kind !== 'triggered') return + assert.deepEqual(ability.effects[1], { + op: 'put_counters', + target: { kind: 'previous_target' }, + counter: 'stun', + amount: { kind: 'number', value: 1 }, + }) +}) + +test('compound effects share an explicit player subject', () => { + const [ability] = spell('Target player draws two cards and loses 2 life.') + assert.equal(ability.kind, 'spell') + if (ability.kind !== 'spell') return + assert.deepEqual(ability.effects[1], { + op: 'life', + player: 'target_player', + amount: { kind: 'number', value: 2 }, + mode: 'lose', + }) +}) + +test('damage triggers without a recipient use the event amount', () => { + const [ability] = creature('Whenever this deals damage, you gain that much life.') + assert.equal(ability.kind, 'triggered') + if (ability.kind !== 'triggered') return + assert.equal(ability.event.kind, 'deals_damage') + assert.deepEqual(ability.effects[0], { + op: 'life', + player: 'you', + amount: { kind: 'event_amount' }, + mode: 'gain', + }) +}) + +test('a later sentence can refer to a token created by an earlier one', () => { + const [ability] = creature( + 'When this enters, create a 0/0 green and blue Fractal creature token. Put three +1/+1 counters on it.', + ) + assert.equal(ability.kind, 'triggered') + if (ability.kind !== 'triggered') return + assert.equal(ability.effects[0].op, 'create_token') + assert.deepEqual(ability.effects[1], { + op: 'put_counters', + target: { kind: 'previous_target' }, + counter: '+1/+1', + amount: { kind: 'number', value: 3 }, + }) +}) + test('activated mana ability', () => { const [ability] = creature('{T}: Add {G}.') assert.equal(ability.kind, 'activated') @@ -149,11 +201,16 @@ test('"it" refers to the triggering object when unambiguous', () => { assert.deepEqual(effect.target, { kind: 'trigger_subject' }) }) -test('ambiguous "it" is left unsupported instead of guessed', () => { +test('a target introduced in one clause is the "it" of the next', () => { const [ability] = creature( 'When this creature enters, tap target creature an opponent controls and put a stun counter on it.', ) - assert.equal(ability.kind, 'unsupported') + assert.equal(ability.kind, 'triggered') + if (ability.kind !== 'triggered') return + const effect = ability.effects[1] + assert.equal(effect.op, 'put_counters') + if (effect.op !== 'put_counters') return + assert.deepEqual(effect.target, { kind: 'previous_target' }) }) test('modal text is unsupported', () => { @@ -275,7 +332,7 @@ test('token-doubling replacement lines compile and round-trip', () => { const [ability] = creature(text) assert.equal(ability.kind, 'static') if (ability.kind !== 'static') return - assert.deepEqual(ability.effects[0], expected) + assert.deepEqual(JSON.parse(JSON.stringify(ability.effects[0])), expected) const source = formatAbility(ability) assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source) @@ -354,6 +411,172 @@ test('"When " triggers and bare "gain life" effects parse', () => { }) }) +test('"This ability triggers only once" marks the trigger', () => { + const [ability] = creature('At the beginning of your second main phase, if this is tapped, put a flying counter on it. This ability triggers only once.') + assert.equal(ability.kind, 'triggered') + if (ability.kind !== 'triggered') return + assert.deepEqual(ability.event, { kind: 'main_phase', who: 'you', phase: 'postcombat' }) + assert.equal(ability.oncePerTurn, true) + assert.deepEqual(ability.effects[0], { + op: 'put_counters', + target: { kind: 'self' }, + counter: 'flying', + amount: { kind: 'number', value: 1 }, + }) +}) + +test('impulse exiles the top cards and grants play permission', () => { + const [ability] = spell('Exile the top three cards of your library. Until end of turn, you may play those cards.') + assert.equal(ability.kind, 'spell') + if (ability.kind !== 'spell') return + assert.deepEqual(ability.effects[0], { + op: 'impulse', + player: 'you', + amount: { kind: 'number', value: 3 }, + faceDown: false, + }) +}) + +test('a mana ability can produce the chosen color', () => { + const [ability] = creature('{T}: Add one mana of the chosen color.') + assert.equal(ability.kind, 'activated') + if (ability.kind !== 'activated') return + assert.deepEqual(ability.effects[0], { + op: 'add_mana', + player: 'you', + mana: { + kind: 'any_color', + amount: { kind: 'number', value: 1 }, + oneColor: true, + restriction: 'chosen color', + }, + }) +}) + +test('doubling counters compiles to its own effect', () => { + const [ability] = spell('Double the number of +1/+1 counters on target creature.') + assert.equal(ability.kind, 'spell') + if (ability.kind !== 'spell') return + assert.deepEqual(ability.effects[0], { + op: 'double_counters', + target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }, + counter: '+1/+1', + }) +}) + +test('damage prevention compiles with its shield and scope', () => { + const [shield] = spell('Prevent the next 3 damage that would be dealt to target creature this turn.') + assert.equal(shield.kind, 'spell') + if (shield.kind !== 'spell') return + assert.equal(shield.effects[0].op, 'prevent_damage') + const first = shield.effects[0] + if (first.op !== 'prevent_damage') return + assert.deepEqual(first.target, { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }) + assert.deepEqual(first.amount, { kind: 'number', value: 3 }) + assert.equal(first.duration, 'until_end_of_turn') + assert.equal(first.global, undefined) + + const [global] = spell('Prevent all combat damage that would be dealt this turn.') + assert.equal(global.kind, 'spell') + if (global.kind !== 'spell') return + const second = global.effects[0] + if (second.op !== 'prevent_damage') return + assert.equal(second.amount, 'all') + assert.equal(second.combatOnly, true) + assert.equal(second.global, true) +}) + +test('counter and energy replacement lines compile', () => { + const [counters] = creature('If one or more +1/+1 counters would be put on a creature you control, twice that many +1/+1 counters are put on that creature instead.') + assert.equal(counters.kind, 'static') + if (counters.kind !== 'static') return + assert.equal(counters.effects[0].op, 'counter_multiplier') + if (counters.effects[0].op !== 'counter_multiplier') return + assert.equal(counters.effects[0].counter, '+1/+1') + assert.equal(counters.effects[0].multiplier, 2) + + const [energy] = creature('If you would get one or more {E}, you get twice that many {E} instead.') + assert.equal(energy.kind, 'static') + if (energy.kind !== 'static') return + assert.deepEqual(energy.effects[0], { op: 'replacement_amount', what: 'energy', multiplier: 2 }) +}) + +test('static source-filtered prevention compiles', () => { + const [ability] = creature('Prevent all damage that would be dealt to this by artifact creatures.') + assert.equal(ability.kind, 'static') + if (ability.kind !== 'static') return + assert.deepEqual(ability.effects[0], { + op: 'prevent_damage', + target: { kind: 'self' }, + amount: 'all', + combatOnly: undefined, + duration: 'permanent', + sourceSelector: { types: ['artifact', 'creature'] }, + }) +}) + +test('source-scoped prevention compiles with its chosen source', () => { + const [ability] = spell('Prevent all damage a red source of your choice would deal this turn.') + assert.equal(ability.kind, 'spell') + if (ability.kind !== 'spell') return + const shield = ability.effects[0] + assert.equal(shield.op, 'prevent_damage') + if (shield.op !== 'prevent_damage') return + assert.deepEqual(shield.source, { kind: 'object', selector: { colors: ['R'] }, mode: 'target' }) + assert.equal(shield.global, true) +}) + +test('a prevention follow-up compiles into the shield', () => { + const [ability] = spell('Prevent the next 3 damage that would be dealt to target creature this turn. If damage is prevented this way, this deals that much damage to any target.') + assert.equal(ability.kind, 'spell') + if (ability.kind !== 'spell') return + const shield = ability.effects[0] + assert.equal(shield.op, 'prevent_damage') + if (shield.op !== 'prevent_damage') return + assert.deepEqual(shield.then, [{ + op: 'damage', + target: { kind: 'any' }, + amount: { kind: 'event_amount' }, + }]) +}) + +test('replacement amount lines compile', () => { + const [life] = creature('If you would gain life, you gain twice that much life instead.') + assert.equal(life.kind, 'static') + if (life.kind !== 'static') return + assert.deepEqual(life.effects[0], { op: 'replacement_amount', what: 'life_gain', multiplier: 2 }) + + const [plus] = creature('If you would gain life, you gain that much life plus 1 instead.') + assert.equal(plus.kind, 'static') + if (plus.kind !== 'static') return + assert.deepEqual(plus.effects[0], { op: 'replacement_amount', what: 'life_gain', multiplier: 1, add: 1 }) + + const [draw] = creature('If you would draw a card, draw two cards instead.') + assert.equal(draw.kind, 'static') + if (draw.kind !== 'static') return + assert.deepEqual(draw.effects[0], { op: 'replacement_amount', what: 'draw', multiplier: 2 }) +}) + +test('"skip your draw step" and attack-or-block restrictions compile', () => { + const [skip] = creature('Skip your draw step.') + assert.equal(skip.kind, 'static') + if (skip.kind !== 'static') return + assert.deepEqual(skip.effects[0], { + op: 'restriction', + target: { kind: 'player', who: 'you', mode: 'target' }, + rule: 'skip_draw_step', + }) + + const [lock] = creature('Enchanted creature cannot attack or block, and its activated abilities cannot be activated.') + assert.equal(lock.kind, 'static') + if (lock.kind !== 'static') return + assert.deepEqual(lock.effects.map(effect => effect.op === 'restriction' ? effect.rule : effect.op), [ + 'cant_attack', + 'cant_block', + 'cant_activate', + ]) +}) + test('a trailing condition becomes a static condition', () => { const [ability] = creature('This creature cannot attack if defending player controls an untapped land.') assert.equal(ability.kind, 'static') @@ -646,3 +869,51 @@ test('Role token creation compiles with the attachment target', () => { assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source) } }) + +test('token-creation replacement lines compile and round-trip', () => { + const cases: Array<[string, object]> = [ + [ + 'If you would create a Food token, instead create a Food token and a Treasure token.', + { op: 'token_replacement', from: ['food'], tokens: [{ types: ['artifact'], subtypes: ['food'], colors: [] }, { types: ['artifact'], subtypes: ['treasure'], colors: [] }], who: 'you' }, + ], + [ + 'If you would create a Clue, Food, or Treasure token, instead create one of each.', + { op: 'token_replacement', from: ['clue', 'food', 'treasure'], tokens: [{ name: 'Clue', types: ['artifact'], subtypes: ['clue'], colors: [] }, { name: 'Food', types: ['artifact'], subtypes: ['food'], colors: [] }, { name: 'Treasure', types: ['artifact'], subtypes: ['treasure'], colors: [] }], who: 'you' }, + ], + ] + for (const [text, expected] of cases) { + const [ability] = creature(text) + assert.equal(ability.kind, 'static') + if (ability.kind !== 'static') return + assert.deepEqual(JSON.parse(JSON.stringify(ability.effects[0])), expected) + + const source = formatAbility(ability) + assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source) + } +}) + +test('exile-instead-of-dying clauses compile', () => { + const [damaged] = spell('This deals 3 damage to any target. If a creature dealt damage this way would die this turn, exile it instead.') + assert.equal(damaged.kind, 'spell') + if (damaged.kind !== 'spell') return + assert.deepEqual(damaged.effects[1], { op: 'exile_instead_of_dying', target: { kind: 'damaged' } }) + + const [that] = spell('This deals 3 damage to target creature. If that creature would die this turn, exile it instead.') + assert.equal(that.kind, 'spell') + if (that.kind !== 'spell') return + assert.deepEqual(that.effects[1], { op: 'exile_instead_of_dying', target: { kind: 'previous_target' } }) +}) + +test('equipped and enchanted conditions gate static abilities', () => { + const [equipped] = creature('As long as this is equipped, it gets +2/+0 and has menace.') + assert.equal(equipped.kind, 'static') + if (equipped.kind !== 'static') return + assert.equal(equipped.condition?.kind, 'source_equipped') + assert.equal(equipped.effects[0].op, 'pump') + assert.equal(equipped.effects[1].op, 'grant') + + const [enchanted] = creature('As long as this is enchanted, it has flying.') + assert.equal(enchanted.kind, 'static') + if (enchanted.kind !== 'static') return + assert.equal(enchanted.condition?.kind, 'source_enchanted') +}) diff --git a/backend/test/game-core.test.ts b/backend/test/game-core.test.ts new file mode 100644 index 0000000..5d7afa6 --- /dev/null +++ b/backend/test/game-core.test.ts @@ -0,0 +1,283 @@ +import assert from 'node:assert/strict' +import test from 'node:test' +import { Game, GameError } from '../src/game/game.js' +import { compileText } from '../src/effects/compile.js' +import type { Ability, Effect, TokenSpec } from '../src/effects/types.js' +import type { CardDefinition, GameObject } from '../src/game/types.js' +import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js' + +test('turns start at the first main phase, draw opening hands, and pass to the next player', () => { + const forest = land('Forest', 'G') + const game = new Game({ + seed: 1, + startingHandSize: 7, + players: [ + { id: 'p1', deck: Array.from({ length: 10 }, () => forest) }, + { id: 'p2', deck: Array.from({ length: 10 }, () => forest) }, + ], + }) + game.start() + + assert.equal(game.turn, 1) + assert.equal(game.activePlayer, 'p1') + assert.equal(game.phase, 'precombat_main') + assert.equal(game.step, 'main') + assert.equal(game.priority, 'p1') + assert.equal(game.getPlayer('p1').life, 40) + assert.equal(game.getPlayer('p1').hand.length, 8) + assert.equal(game.getPlayer('p1').library.length, 2) + + game.endTurn('p1') + + assert.equal(game.turn, 2) + assert.equal(game.activePlayer, 'p2') + assert.equal(game.getPlayer('p2').hand.length, 8) + assert.equal(game.getPlayer('p1').hand.length, 7) +}) + +test('mulligans draw a new seven and bottom one more card each time', () => { + const game = new Game({ + seed: 3, + startingHandSize: 7, + mulligans: true, + players: [ + { id: 'p1', deck: Array.from({ length: 40 }, (_, index) => card(`P1 Card ${index}`)) }, + { id: 'p2', deck: Array.from({ length: 40 }, (_, index) => card(`P2 Card ${index}`)) }, + ], + }) + game.start() + + assert.equal(game.status, 'mulligan') + assert.equal(game.getPlayer('p1').hand.length, 7) + game.keepHand('p2') + + game.mulligan('p1') + assert.equal(game.getPlayer('p1').hand.length, 7) + assert.equal(game.mulligans.get('p1')?.count, 1) + assert.equal(game.mulligans.get('p1')?.bottom, 0) + + game.mulligan('p1') + assert.equal(game.mulligans.get('p1')?.count, 2) + assert.equal(game.mulligans.get('p1')?.bottom, 1) + assert.throws(() => game.keepHand('p1'), /bottom/) + + const bottomCard = game.getPlayer('p1').hand[0] + game.putOnBottom('p1', bottomCard) + assert.equal(game.getPlayer('p1').hand.length, 6) + assert.equal(game.getPlayer('p1').library.at(-1), bottomCard) + assert.equal(game.mulligans.get('p1')?.bottom, 0) + + game.mulligan('p1') + assert.equal(game.mulligans.get('p1')?.count, 3) + assert.equal(game.mulligans.get('p1')?.bottom, 2) + for (const cardId of [...game.getPlayer('p1').hand.slice(0, 2)]) game.putOnBottom('p1', cardId) + assert.equal(game.getPlayer('p1').hand.length, 5) + + game.keepHand('p1') + assert.equal(game.status, 'active') + assert.equal(game.turn, 1) + assert.equal(game.step, 'main') + assert.equal(game.getPlayer('p1').hand.length, 6) +}) + +test('passing priority twice advances from the main phase into combat', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + + game.pass('p1') + assert.equal(game.priority, 'p2') + game.pass('p2') + + assert.equal(game.phase, 'combat') + assert.equal(game.step, 'declare_attackers') + assert.equal(game.priority, 'p1') +}) + +test('a spell goes on the stack, auto-taps mana, and resolves its compiled effect', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const mountain = game.addCard('p1', land('Mountain', 'R'), 'battlefield') + const bolt = game.addCard('p1', spell('Lightning Bolt', [ + { op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } }, + ], '{R}'), 'hand') + + game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] }) + + assert.equal(game.stack.length, 1) + assert.equal(mountain.tapped, true) + assert.equal(game.priority, 'p2') + + game.resolveStack() + + assert.equal(game.stack.length, 0) + assert.equal(game.getPlayer('p2').life, 37) + assert.ok(game.getPlayer('p1').graveyard.includes(bolt.id)) +}) + +test('permanents can be repositioned by their controller and positions are cleared on zone changes', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield') + + game.movePermanent('p1', bear.id, 0.25, 0.75) + assert.deepEqual(bear.position, { x: 0.25, y: 0.75 }) + + game.movePermanent('p1', bear.id, -1, 2) + assert.deepEqual(bear.position, { x: 0, y: 1 }) + assert.throws(() => game.movePermanent('p2', bear.id, 0.5, 0.5), /control/) + + game.moveToZone(bear, 'graveyard') + assert.equal(bear.position, undefined) +}) + +test('doubling counters doubles each kind on the target', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const target = game.addCard('p1', creature('Counter Bear', 2, 3), 'battlefield') + target.counters['+1/+1'] = 2 + target.counters['charge'] = 1 + const doubler = spell('Doubler', [{ + op: 'double_counters', + target: { kind: 'object', selector: { types: ['creature'] } }, + }]) + const cardInHand = game.addCard('p1', doubler, 'hand') + game.castSpell('p1', cardInHand.id, { targets: [{ kind: 'object', id: target.id }] }) + game.resolveStack() + assert.equal(target.counters['+1/+1'], 4) + assert.equal(target.counters.charge, 2) +}) + +test('damage prevention shields absorb the next damage', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const bear = creature('Bear', 2, 3) + const target = game.addCard('p1', bear, 'battlefield') + const bolt = spell('Bolt', [{ op: 'damage', target: { kind: 'object', selector: { types: ['creature'] } }, amount: { kind: 'number', value: 5 } }]) + const shield = spell('Shield', [{ + op: 'prevent_damage', + target: { kind: 'object', selector: { types: ['creature'] } }, + amount: { kind: 'number', value: 3 }, + duration: 'until_end_of_turn', + }]) + + const shieldCard = game.addCard('p1', shield, 'hand') + game.castSpell('p1', shieldCard.id, { targets: [{ kind: 'object', id: target.id }] }) + game.resolveStack() + const boltCard = game.addCard('p1', bolt, 'hand') + game.castSpell('p1', boltCard.id, { targets: [{ kind: 'object', id: target.id }] }) + game.resolveStack() + assert.equal(target.damage, 2) + assert.equal(target.zone, 'battlefield') +}) + +test('a "you may" spell asks its controller and honors the choice', () => { + const optionalSpell = card('Optional Test', { + typeLine: 'Instant', + abilities: [{ + kind: 'spell', + effects: [{ op: 'life', player: 'you', amount: { kind: 'number', value: 3 }, mode: 'gain' }], + optional: true, + text: 'You may gain 3 life.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + + const accept = game.addCard('p1', optionalSpell, 'hand') + game.castSpell('p1', accept.id) + game.resolveStack() + assert.equal(game.pendingChoice?.what, 'optional') + const before = game.getPlayer('p1').life + game.chooseOptional('p1', true) + assert.equal(game.getPlayer('p1').life, before + 3) + + const decline = game.addCard('p1', optionalSpell, 'hand') + game.castSpell('p1', decline.id) + game.resolveStack() + assert.equal(game.pendingChoice?.what, 'optional') + const after = game.getPlayer('p1').life + game.chooseOptional('p1', false) + assert.equal(game.getPlayer('p1').life, after) + assert.equal(decline.zone, 'graveyard') +}) + +test('declining a "you may" runs the "if you don\'t" branch', () => { + const optionalSpell = card('Optional Branch', { + typeLine: 'Instant', + abilities: [{ + kind: 'spell', + effects: [ + { op: 'life', player: 'you', amount: { kind: 'number', value: 2 }, mode: 'gain' }, + { + op: 'conditional', + condition: { kind: 'if_you_dont' }, + effects: [{ op: 'life', player: 'you', amount: { kind: 'number', value: 1 }, mode: 'lose' }], + }, + ], + optional: true, + text: 'You may gain 2 life. If you don\'t, you lose 1 life.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const spellCard = game.addCard('p1', optionalSpell, 'hand') + game.castSpell('p1', spellCard.id) + game.resolveStack() + const before = game.getPlayer('p1').life + game.chooseOptional('p1', false) + assert.equal(game.getPlayer('p1').life, before - 1) +}) + +test('a compiled "you may" enters trigger asks and applies the choice', () => { + const abilities = compileText( + 'When this creature enters, you may gain 2 life.', + 'Optional Bear', + [], + 'Creature — Bear', + ) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const bear = game.addCard('p1', creature('Optional Bear', 2, 2, abilities), 'hand') + + game.castSpell('p1', bear.id) + game.resolveStack() + assert.equal(game.pendingChoice?.what, 'optional') + const before = game.getPlayer('p1').life + game.chooseOptional('p1', true) + assert.equal(game.getPlayer('p1').life, before + 2) +}) + +test('a land that chooses a color produces that color', () => { + const landDef = card('Chosen Color Land', { + typeLine: 'Land', + abilities: [ + { + kind: 'static', + effects: [{ op: 'choose', what: 'color' }], + text: 'As this enters, choose a color.', + }, + { + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ + op: 'add_mana', + player: 'you', + mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: true, restriction: 'chosen color' }, + }], + optional: false, + text: '{T}: Add one mana of the chosen color.', + }, + ], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const land = game.addCard('p1', landDef, 'hand') + + game.playLand('p1', land.id) + assert.equal(game.pendingChoice?.what, 'color') + game.chooseColor('p1', 'Blue') + + game.activateAbility('p1', land.id, 1) + game.resolveStack() + assert.equal(game.getPlayer('p1').manaPool.U, 1) +}) diff --git a/backend/test/game-effects.test.ts b/backend/test/game-effects.test.ts new file mode 100644 index 0000000..ae904d4 --- /dev/null +++ b/backend/test/game-effects.test.ts @@ -0,0 +1,343 @@ +import assert from 'node:assert/strict' +import test from 'node:test' +import { Game, GameError } from '../src/game/game.js' +import { compileText } from '../src/effects/compile.js' +import type { Ability, Effect, TokenSpec } from '../src/effects/types.js' +import type { CardDefinition, GameObject } from '../src/game/types.js' +import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js' + +test('impulse exiles the top cards and lets the player cast them this turn', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const impulseSpell = game.addCard('p1', spell('Impulse Test', [ + { op: 'impulse', player: 'you', amount: { kind: 'number', value: 2 } }, + ]), 'hand') + const top = game.addCard('p1', spell('Top Card', []), 'library') + const second = game.addCard('p1', spell('Second Card', []), 'library') + + game.castSpell('p1', impulseSpell.id) + game.resolveStack() + + assert.equal(top.zone, 'exile') + assert.equal(second.zone, 'exile') + assert.equal(top.playableFromExileTurn, game.turn) + assert.equal(second.playableFromExileTurn, game.turn) + assert.doesNotThrow(() => game.castSpell('p1', top.id)) +}) + +test('hideaway exiles a card and its linked ability plays it for free once the condition is met', () => { + const hideawayLand = card('Hideaway Test', { + typeLine: 'Land', + abilities: [ + { + kind: 'triggered', + event: { kind: 'enters', subject: { kind: 'self' } }, + effects: [{ op: 'hideaway', amount: { kind: 'number', value: 4 } }], + optional: false, + text: 'Hideaway 4', + }, + { + kind: 'activated', + costs: [], + effects: [{ + op: 'conditional', + condition: { kind: 'total_power', controller: 'you', atLeast: 10 }, + effects: [{ op: 'play_exiled', player: 'you', free: true }], + }], + optional: false, + text: 'Play the exiled card without paying its mana cost if creatures you control have total power 10 or greater.', + }, + ], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const hidden = game.addCard('p1', creature('Hidden Bear', 2, 2), 'library') + for (const name of ['Filler One', 'Filler Two', 'Filler Three']) { + game.addCard('p1', creature(name, 1, 1), 'library') + } + const library = game.getPlayer('p1').library + library.splice(library.indexOf(hidden.id), 1) + library.unshift(hidden.id) + const land = game.addCard('p1', hideawayLand, 'hand') + + game.playLand('p1', land.id) + game.resolveStack() + + assert.equal(game.pendingChoice?.what, 'hideaway') + assert.equal(game.pendingChoice?.playerId, 'p1') + assert.equal(game.pendingChoice?.cardIds?.length, 4) + assert.ok(game.pendingChoice?.cardIds?.includes(hidden.id)) + assert.throws(() => game.chooseHideawayCard('p2', hidden.id), GameError) + const looked = [...game.getPlayer('p1').library.slice(0, 4)] + game.chooseHideawayCard('p1', hidden.id) + assert.equal(game.pendingChoice, undefined) + + assert.equal(hidden.zone, 'exile') + assert.equal(hidden.faceDown, true) + assert.deepEqual(land.linkedExile, [hidden.id]) + assert.deepEqual( + game.getPlayer('p1').library.slice(-3).sort(), + looked.filter(id => id !== hidden.id).sort(), + ) + + game.activateAbility('p1', land.id, 1) + game.resolveStack() + assert.equal(hidden.zone, 'exile') + + game.addCard('p1', creature('Big Bear', 10, 10), 'battlefield') + game.activateAbility('p1', land.id, 1) + game.resolveStack() + + assert.equal(hidden.zone, 'battlefield') + assert.equal(hidden.faceDown, undefined) + assert.ok(game.getPlayer('p1').battlefield.includes(hidden.id)) +}) + +test('playing a card hidden by hideaway uses the land drop', () => { + const hideawayLand = card('Hideaway Land', { + typeLine: 'Land', + abilities: [ + { + kind: 'triggered', + event: { kind: 'enters', subject: { kind: 'self' } }, + effects: [{ op: 'hideaway', amount: { kind: 'number', value: 1 } }], + optional: false, + text: 'Hideaway 1', + }, + { + kind: 'activated', + costs: [], + effects: [{ + op: 'conditional', + condition: { kind: 'total_power', controller: 'you', atLeast: 0 }, + effects: [{ op: 'play_exiled', player: 'you', free: true }], + }], + optional: false, + text: 'Play the exiled card without paying its mana cost.', + }, + ], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const hidden = game.addCard('p1', land('Island', 'U'), 'library') + const library = game.getPlayer('p1').library + library.splice(library.indexOf(hidden.id), 1) + library.unshift(hidden.id) + const source = game.addCard('p1', hideawayLand, 'hand') + + game.playLand('p1', source.id) + game.resolveStack() + assert.equal(hidden.zone, 'exile') + assert.equal(hidden.faceDown, true) + + game.getPlayer('p1').landPlayedThisTurn = true + game.activateAbility('p1', source.id, 1) + game.resolveStack() + assert.equal(hidden.zone, 'exile') + + game.getPlayer('p1').landPlayedThisTurn = false + game.activateAbility('p1', source.id, 1) + game.resolveStack() + assert.equal(hidden.zone, 'battlefield') + assert.equal(game.getPlayer('p1').landPlayedThisTurn, true) +}) + +test('enters triggers from compiled card code fire and resolve through the stack', () => { + const soulWarden = card('Soul Warden', { + typeLine: 'Creature — Human Cleric', + power: 1, + toughness: 1, + colors: ['W'], + abilities: [{ + kind: 'triggered', + event: { + kind: 'enters', + subject: { kind: 'object', selector: { other: true, types: ['creature'] }, mode: 'each' }, + }, + effects: [{ op: 'life', player: 'you', amount: { kind: 'number', value: 1 }, mode: 'gain' }], + optional: false, + text: 'Whenever another creature enters, you gain 1 life.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', soulWarden, 'battlefield') + const elves = game.addCard('p1', creature('Llanowar Elves', 1, 1), 'hand') + + game.castSpell('p1', elves.id) + game.resolveStack() + + assert.equal(game.getPlayer('p1').life, 41) + assert.ok(game.getPlayer('p1').battlefield.includes(elves.id)) +}) + +test('activated mana abilities produce mana and creatures have summoning sickness', () => { + const solRing = card('Sol Ring', { + typeLine: 'Artifact', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{C}', '{C}'] } }], + optional: false, + text: '{T}: Add {C}{C}.', + }], + }) + const game = setup([{ id: 'p1', deck: Array.from({ length: 5 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 5 }, () => card('Filler')) }]) + game.start() + const ring = game.addCard('p1', solRing, 'battlefield') + const elves = game.addCard('p1', creature('Llanowar Elves', 1, 1, [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{G}'] } }], + optional: false, + text: '{T}: Add {G}.', + }]), 'battlefield') + + game.activateAbility('p1', ring.id, 0) + assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 2 }) + assert.equal(ring.tapped, true) + assert.throws(() => game.activateAbility('p1', elves.id, 0), GameError) + + game.endTurn('p1') + game.endTurn('p2') + assert.equal(elves.tapped, false) + game.activateAbility('p1', elves.id, 0) + assert.equal(game.getPlayer('p1').manaPool.G, 1) +}) + +test('a player who runs out of cards loses and the last player wins', () => { + const game = new Game({ + seed: 3, + startingHandSize: 0, + players: [ + { id: 'p1', deck: [card('Filler')] }, + { id: 'p2', deck: [] }, + ], + }) + game.start() + game.endTurn('p1') + + assert.equal(game.status, 'finished') + assert.equal(game.winner, 'p1') + assert.equal(game.getPlayer('p2').lost, true) +}) + +test('lethal damage to a player ends the game', () => { + const game = setup([{ id: 'p1' }, { id: 'p2', life: 3 }]) + game.start() + game.addCard('p1', land('Mountain', 'R'), 'battlefield') + const bolt = game.addCard('p1', spell('Lightning Bolt', [ + { op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } }, + ], '{R}'), 'hand') + + game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] }) + game.resolveStack() + + assert.equal(game.status, 'finished') + assert.equal(game.winner, 'p1') + assert.equal(game.getPlayer('p2').life, 0) +}) + +test('the legend rule leaves one legendary permanent per name under one controller', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const legend = card('Kiora, the Rising Tide', { + typeLine: 'Legendary Creature — Merfolk Wizard', + power: 1, + toughness: 1, + }) + const first = game.addCard('p1', legend, 'battlefield') + const second = game.addCard('p1', legend, 'battlefield') + const forest = game.addCard('p1', land('Forest', 'G'), 'hand') + + game.playLand('p1', forest.id) + + assert.equal(first.zone, 'battlefield') + assert.equal(second.zone, 'graveyard') + assert.ok(game.getPlayer('p1').graveyard.includes(second.id)) +}) + +test('the legend rule does not apply across controllers', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const legend = card('Kiora, the Rising Tide', { + typeLine: 'Legendary Creature — Merfolk Wizard', + power: 1, + toughness: 1, + }) + const mine = game.addCard('p1', legend, 'battlefield') + const theirs = game.addCard('p2', legend, 'battlefield') + const forest = game.addCard('p1', land('Forest', 'G'), 'hand') + + game.playLand('p1', forest.id) + + assert.equal(mine.zone, 'battlefield') + assert.equal(theirs.zone, 'battlefield') +}) + +test('a failed mana payment leaves mana sources untapped and the pool unchanged', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const mountain = game.addCard('p1', land('Mountain', 'R'), 'battlefield') + const expensive = game.addCard('p1', spell('Expensive Spell', [], '{R}{R}'), 'hand') + + assert.throws(() => game.castSpell('p1', expensive.id), GameError) + assert.equal(mountain.tapped, false) + assert.equal(game.getPlayer('p1').manaPool.R, 0) + assert.ok(game.getPlayer('p1').hand.includes(expensive.id)) +}) + +test('phyrexian mana can be paid with exactly enough life', () => { + const game = setup([{ id: 'p1', life: 2 }, { id: 'p2' }]) + game.start() + const spellCard = game.addCard('p1', spell('Gitaxian Probe', [], '{W/P}'), 'hand') + + assert.doesNotThrow(() => game.castSpell('p1', spellCard.id)) + assert.equal(game.getPlayer('p1').life, 0) + assert.equal(game.status, 'finished') + assert.equal(game.winner, 'p2') +}) + +test('an unless cost auto-taps the mana sources of the payer', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const bear = game.addCard('p2', creature('Grizzly Bears', 2, 2), 'battlefield') + const forests = [ + game.addCard('p2', land('Forest', 'G'), 'battlefield'), + game.addCard('p2', land('Forest', 'G'), 'battlefield'), + ] + const edict = game.addCard('p1', spell('Edict', [{ + op: 'sacrifice', + player: 'opponent', + target: { kind: 'object', selector: { types: ['creature'] } }, + unless: { kind: 'mana', symbols: '{2}' }, + }]), 'hand') + + game.castSpell('p1', edict.id, { + targets: [{ kind: 'player', id: 'p2' }, { kind: 'object', id: bear.id }], + }) + game.resolveStack() + + assert.equal(bear.zone, 'battlefield') + assert.ok(forests.every(forest => forest.tapped)) + assert.equal(game.getPlayer('p2').manaPool.G, 0) +}) + +test('damage followed by exile-instead-of-dying sends the damaged creature to exile', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const bear = game.addCard('p2', creature('Doomed Bear', 2, 2), 'battlefield') + const burn = game.addCard('p1', spell('Exiling Burn', [ + { op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } }, + { op: 'exile_instead_of_dying', target: { kind: 'damaged' } }, + ]), 'hand') + + game.castSpell('p1', burn.id, { targets: [{ kind: 'object', id: bear.id }] }) + game.resolveStack() + + assert.equal(bear.zone, 'exile') + assert.ok(game.getPlayer('p2').exile.includes(bear.id)) + assert.ok(!game.getPlayer('p2').graveyard.includes(bear.id)) +}) diff --git a/backend/test/game-mana.test.ts b/backend/test/game-mana.test.ts new file mode 100644 index 0000000..9ac3c28 --- /dev/null +++ b/backend/test/game-mana.test.ts @@ -0,0 +1,155 @@ +import assert from 'node:assert/strict' +import test from 'node:test' +import { Game, GameError } from '../src/game/game.js' +import { compileText } from '../src/effects/compile.js' +import type { Ability, Effect, TokenSpec } from '../src/effects/types.js' +import type { CardDefinition, GameObject } from '../src/game/types.js' +import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js' + +test('Exotic Orchard is limited to colors an opponent land could produce', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const orchard = game.addCard('p1', exoticOrchard(), 'battlefield') + game.addCard('p2', land('Forest', 'G'), 'battlefield') + const green = game.addCard('p1', spell('Green Spell', [], '{G}'), 'hand') + const blue = game.addCard('p1', spell('Blue Spell', [], '{U}'), 'hand') + + assert.equal(game.canPlayCard('p1', green.id), true) + assert.equal(game.canPlayCard('p1', blue.id), false) + assert.throws(() => game.castSpell('p1', blue.id), GameError) + assert.equal(orchard.tapped, false) + assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 }) + + game.castSpell('p1', green.id) + assert.equal(orchard.tapped, true) + assert.equal(game.getPlayer('p1').manaPool.G, 0) +}) + +test('Exotic Orchard adds an opponent land color when activated manually', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const orchard = game.addCard('p1', exoticOrchard(), 'battlefield') + game.addCard('p2', land('Island', 'U'), 'battlefield') + + game.activateAbility('p1', orchard.id, 0) + assert.equal(game.getPlayer('p1').manaPool.U, 1) + assert.equal(game.getPlayer('p1').manaPool.W, 0) +}) + +test('Exotic Orchard produces nothing without an opponent land', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const orchard = game.addCard('p1', exoticOrchard(), 'battlefield') + + game.activateAbility('p1', orchard.id, 0) + assert.equal(orchard.tapped, true) + assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 }) +}) + +test('a mana ability that makes one of several colors uses the chosen color', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const dual = game.addCard('p1', card('Dual Land', { + typeLine: 'Land', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{W}', '{U}'], oneOf: true } }], + optional: false, + text: '{T}: Add {W} or {U}.', + }], + }), 'battlefield') + + assert.deepEqual(game.manaColorChoices(dual, 0), ['W', 'U']) + game.activateAbility('p1', dual.id, 0, { manaColor: 'U' }) + assert.equal(game.getPlayer('p1').manaPool.U, 1) + assert.equal(game.getPlayer('p1').manaPool.W, 0) +}) + +test('a mana color the ability cannot make is rejected before tapping', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const mono = game.addCard('p1', land('Mono Land', 'W'), 'battlefield') + + assert.throws(() => game.activateAbility('p1', mono.id, 0, { manaColor: 'G' }), GameError) + assert.equal(mono.tapped, false) + assert.equal(game.getPlayer('p1').manaPool.G, 0) +}) + +test('an any-color mana source produces the chosen color and offers all five', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const rainbow = game.addCard('p1', card('Rainbow Land', { + typeLine: 'Land', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: false } }], + optional: false, + text: '{T}: Add one mana of any color.', + }], + }), 'battlefield') + + assert.deepEqual(game.manaColorChoices(rainbow, 0), ['W', 'U', 'B', 'R', 'G']) + game.activateAbility('p1', rainbow.id, 0, { manaColor: 'R' }) + assert.equal(game.getPlayer('p1').manaPool.R, 1) +}) + +test('a restricted mana source is used before an unrestricted one', () => { + const rainbow = card('Rainbow Land', { + typeLine: 'Land', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: false } }], + optional: false, + text: '{T}: Add one mana of any color.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const rainbowLand = game.addCard('p1', rainbow, 'battlefield') + const orchard = game.addCard('p1', exoticOrchard(), 'battlefield') + game.addCard('p2', land('Forest', 'G'), 'battlefield') + const gold = game.addCard('p1', spell('Gold Spell', [], '{G}{U}'), 'hand') + + assert.equal(game.canPlayCard('p1', gold.id), true) + game.castSpell('p1', gold.id) + assert.equal(orchard.tapped, true) + assert.equal(rainbowLand.tapped, true) + assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 }) +}) + +test('static pump effects apply to matching creatures only', () => { + const anthem = card('Glorious Anthem', { + typeLine: 'Enchantment', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'static', + effects: [{ + op: 'pump', + target: { kind: 'object', selector: { controller: 'you', types: ['creature'] }, mode: 'each' }, + power: { kind: 'number', value: 1 }, + toughness: { kind: 'number', value: 1 }, + }], + text: 'Creatures you control get +1/+1.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const anthemObject = game.addCard('p1', anthem, 'battlefield') + const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield') + const enemy = game.addCard('p2', creature('Enemy Bear', 2, 2), 'battlefield') + + assert.equal(game.getPower(bear), 3) + assert.equal(game.getToughness(bear), 3) + assert.equal(game.getPower(enemy), 2) + assert.equal(game.getPower(anthemObject), 0) +}) diff --git a/backend/test/game-rules.test.ts b/backend/test/game-rules.test.ts new file mode 100644 index 0000000..be08497 --- /dev/null +++ b/backend/test/game-rules.test.ts @@ -0,0 +1,663 @@ +import assert from 'node:assert/strict' +import test from 'node:test' +import { Game, GameError } from '../src/game/game.js' +import { compileText } from '../src/effects/compile.js' +import type { Ability, Effect, TokenSpec } from '../src/effects/types.js' +import type { CardDefinition, GameObject } from '../src/game/types.js' +import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js' + +test('canPlayCard reports legal lands and spells for the player with priority', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const forest = game.addCard('p1', land('Forest', 'G'), 'hand') + const bear = game.addCard('p1', card('Grizzly Bears', { + typeLine: 'Creature — Bear', + power: 2, + toughness: 2, + manaCost: '{G}', + }), 'hand') + + assert.equal(game.canPlayCard('p1', forest.id), true) + assert.equal(game.canPlayCard('p1', bear.id), false) + assert.equal(game.canPlayCard('p2', forest.id), false) + + game.playLand('p1', forest.id) + assert.equal(game.canPlayCard('p1', bear.id), true) +}) + +test('autoAdvance skips empty phases and stops when someone can act', () => { + const expensive = card('Expensive', { manaCost: '{5}' }) + const game = new Game({ + seed: 3, + startingHandSize: 0, + players: [ + { id: 'p1', deck: [expensive] }, + { id: 'p2', deck: [expensive] }, + ], + }) + game.start() + game.addCard('p1', land('Forest', 'G'), 'battlefield') + + // The only action is a mana ability, which should not hold the phase open. + game.autoAdvance() + assert.equal(game.turn, 2) + assert.equal(game.activePlayer, 'p2') + assert.equal(game.phase, 'precombat_main') + assert.equal(game.priority, 'p2') + + const hasty = creature('Hasty', 2, 2, [{ kind: 'keyword', keyword: 'Haste' }]) + game.addCard('p2', hasty, 'battlefield') + game.autoAdvance() + assert.equal(game.turn, 2) + assert.equal(game.phase, 'combat') + assert.equal(game.step, 'declare_attackers') + assert.equal(game.priority, 'p2') +}) + +test('every defending player declares blocks before combat damage in multiplayer', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }, { id: 'p3' }]) + game.start() + const first = game.addCard('p1', creature('First Attacker', 2, 2), 'battlefield') + const second = game.addCard('p1', creature('Second Attacker', 3, 3), 'battlefield') + first.enteredTurn = 0 + second.enteredTurn = 0 + + game.declareAttackers('p1', [ + { attackerId: first.id, defenderId: 'p2' }, + { attackerId: second.id, defenderId: 'p3' }, + ]) + assert.equal(game.step, 'declare_blockers') + + game.declareBlockers('p2', []) + assert.equal(game.step, 'declare_blockers') + assert.equal(game.priority, 'p3') + + game.declareBlockers('p3', []) + assert.equal(game.step, 'combat_damage') + + game.resolveCombatDamage() + assert.equal(game.getPlayer('p2').life, 38) + assert.equal(game.getPlayer('p3').life, 37) +}) + +test('counter-removal costs are paid and fail when counters run out', () => { + const vessel = card('Spore Vessel', { + typeLine: 'Artifact', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'activated', + costs: [{ kind: 'remove_counters', counter: 'spore', amount: { kind: 'number', value: 2 } }], + effects: [{ op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }], + optional: false, + text: 'Remove two spore counters from this: Draw a card.', + }], + }) + const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2' }]) + game.start() + const source = game.addCard('p1', vessel, 'battlefield') + source.counters.spore = 3 + + game.activateAbility('p1', source.id, 0) + game.resolveStack() + assert.equal(source.counters.spore, 1) + assert.equal(game.getPlayer('p1').hand.length, 2) + + assert.throws(() => game.activateAbility('p1', source.id, 0), GameError) + assert.equal(source.counters.spore, 1) +}) + +test('a free alternative cost needs a commander and skips the mana cost', () => { + const maneuver = card('Flawless Maneuver', { + typeLine: 'Instant', + manaCost: '{2}{W}', + manaValue: 3, + abilities: [ + { + kind: 'alternative_cost', + costs: [], + condition: { kind: 'you_control_commander' }, + text: 'If you control a commander, you may cast this spell without paying its mana cost.', + }, + { + kind: 'spell', + effects: [{ + op: 'grant', + target: { kind: 'object', selector: { controller: 'you', types: ['creature'] }, mode: 'each' }, + keyword: 'Indestructible', + duration: 'until_end_of_turn', + }], + optional: false, + text: 'Creatures you control gain indestructible until end of turn.', + }, + ], + }) + const game = new Game({ + seed: 1, + startingHandSize: 0, + commander: true, + players: [ + { id: 'p1', deck: [card('Filler')], commander: creature('Test Commander', 2, 2) }, + { id: 'p2', deck: [card('Filler')], commander: creature('Other Commander', 2, 2) }, + ], + }) + game.start() + const spell = game.addCard('p1', maneuver, 'hand') + + assert.equal(game.canPlayCard('p1', spell.id), false) + assert.throws(() => game.castSpell('p1', spell.id), GameError) + + game.moveToZone(game.getPlayer('p1').commanderId!, 'battlefield', { silent: true }) + + assert.equal(game.canPlayCard('p1', spell.id), true) + game.castSpell('p1', spell.id) + assert.equal(game.stack.length, 1) + assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 }) +}) + +test('overload pays the overload cost and widens the spell target', () => { + const rift = card('Cyclonic Rift', { + typeLine: 'Instant', + manaCost: '{U}', + manaValue: 1, + abilities: [ + { + kind: 'spell', + effects: [{ + op: 'return_to_hand', + target: { + kind: 'object', + selector: { controller: 'opponent', types: ['permanent'], excludeTypes: ['land'] }, + mode: 'target', + }, + }], + optional: false, + text: "Return target nonland permanent you don't control to its owner's hand.", + }, + { kind: 'overload', cost: '{1}{U}', text: 'Overload {1}{U}' }, + ], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const island = game.addCard('p1', land('Island', 'U'), 'battlefield') + const wastes = game.addCard('p1', land('Wastes', 'C'), 'battlefield') + const ownCreature = game.addCard('p1', creature('Own Bear', 2, 2), 'battlefield') + const theirCreature = game.addCard('p2', creature('Their Bear', 2, 2), 'battlefield') + const theirArtifact = game.addCard('p2', card('Their Rock', { + typeLine: 'Artifact', + power: undefined, + toughness: undefined, + }), 'battlefield') + const theirLand = game.addCard('p2', land('Forest', 'G'), 'battlefield') + const spell = game.addCard('p1', rift, 'hand') + + game.castSpell('p1', spell.id, { overload: true }) + + assert.equal(island.tapped, true) + assert.equal(wastes.tapped, true) + game.resolveStack() + + assert.ok(game.getPlayer('p2').hand.includes(theirCreature.id)) + assert.ok(game.getPlayer('p2').hand.includes(theirArtifact.id)) + assert.ok(game.getPlayer('p2').battlefield.includes(theirLand.id)) + assert.ok(game.getPlayer('p1').battlefield.includes(ownCreature.id)) +}) + +test('a noncreature cost increase taxes spells but not creatures', () => { + const thalia = card('Thalia, Guardian of Thraben', { + typeLine: 'Legendary Creature — Human Soldier', + power: 2, + toughness: 1, + abilities: [{ + kind: 'static', + effects: [{ op: 'cost_increase', amount: { kind: 'number', value: 1 }, spellType: 'noncreature' }], + text: 'Noncreature spells cost {1} more to cast.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', thalia, 'battlefield') + const first = game.addCard('p1', land('Wastes', 'C'), 'battlefield') + const instant = game.addCard('p1', spell('Ponder', [ + { op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }, + ], '{1}'), 'hand') + const bears = game.addCard('p1', card('Grizzly Bears', { + typeLine: 'Creature — Bear', + power: 2, + toughness: 2, + manaCost: '{1}', + }), 'hand') + + assert.equal(game.canPlayCard('p1', instant.id), false) + assert.equal(game.canPlayCard('p1', bears.id), true) + + game.addCard('p1', land('Wastes', 'C'), 'battlefield') + assert.equal(game.canPlayCard('p1', instant.id), true) + game.castSpell('p1', instant.id) + assert.equal(first.tapped, true) +}) + +test('spell cost reductions match the spell type and controller', () => { + const baral = card('Baral, Chief of Compliance', { + typeLine: 'Legendary Creature — Human Wizard', + power: 1, + toughness: 3, + abilities: [{ + kind: 'static', + effects: [{ + op: 'cost_reduction', + target: { kind: 'object', selector: { controller: 'you', types: ['instant', 'sorcery'], match: 'any' }, mode: 'each' }, + amount: { kind: 'number', value: 1 }, + }], + text: 'Instant and sorcery spells you cast cost {1} less to cast.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', baral, 'battlefield') + const wastes = game.addCard('p1', land('Wastes', 'C'), 'battlefield') + const sorcery = game.addCard('p1', card('Divination', { + typeLine: 'Sorcery', + manaCost: '{2}', + abilities: [{ kind: 'spell', effects: [{ op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }], optional: false, text: 'Draw a card.' }], + }), 'hand') + const bears = game.addCard('p1', card('Grizzly Bears', { + typeLine: 'Creature — Bear', + power: 2, + toughness: 2, + manaCost: '{2}', + }), 'hand') + + assert.equal(game.canPlayCard('p1', sorcery.id), true) + assert.equal(game.canPlayCard('p1', bears.id), false) + + game.castSpell('p1', sorcery.id) + assert.equal(wastes.tapped, true) +}) + +test('a colored cost reduction removes matching pips and nothing else', () => { + const edgewalker = card('Edgewalker', { + typeLine: 'Creature — Human Cleric', + power: 2, + toughness: 2, + abilities: [{ + kind: 'static', + effects: [{ + op: 'cost_reduction', + target: { kind: 'object', selector: { controller: 'you', types: ['creature'], match: 'any', subtypes: ['cleric', 'soldier'] }, mode: 'each' }, + symbols: '{W}{B}', + }], + text: 'Cleric spells you cast cost {W}{B} less to cast.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', edgewalker, 'battlefield') + game.addCard('p1', land('Plains', 'W'), 'battlefield') + game.addCard('p1', land('Swamp', 'B'), 'battlefield') + const cleric = game.addCard('p1', card('Cleric Test', { + typeLine: 'Creature — Human Cleric', + power: 2, + toughness: 2, + colors: ['W', 'B'], + manaCost: '{1}{W}{B}', + manaValue: 3, + }), 'hand') + const soldier = game.addCard('p1', card('Soldier Test', { + typeLine: 'Creature — Human Soldier', + power: 2, + toughness: 2, + colors: ['W', 'B'], + manaCost: '{1}{W}{B}', + manaValue: 3, + }), 'hand') + const bear = game.addCard('p1', card('Bear Test', { + typeLine: 'Creature — Bear', + power: 2, + toughness: 2, + colors: ['W', 'B'], + manaCost: '{1}{W}{B}', + manaValue: 3, + }), 'hand') + + assert.equal(game.canPlayCard('p1', cleric.id), true) + assert.equal(game.canPlayCard('p1', soldier.id), true) + assert.equal(game.canPlayCard('p1', bear.id), false) + game.castSpell('p1', cleric.id) +}) + +test('Linvala stops only opponents from activating creature abilities', () => { + const linvala = card('Linvala, Keeper of Silence', { + typeLine: 'Legendary Creature — Angel', + power: 3, + toughness: 4, + abilities: [{ + kind: 'static', + effects: [{ + op: 'restriction', + target: { kind: 'object', selector: { controller: 'opponent', types: ['creature'] }, mode: 'each' }, + rule: 'cant_activate', + }], + text: "Activated abilities of creatures your opponents control can't be activated.", + }], + }) + const drawAbility = { + kind: 'activated' as const, + costs: [], + effects: [{ op: 'draw' as const, player: 'you' as const, amount: { kind: 'number' as const, value: 1 } }], + optional: false, + text: 'Draw a card.', + } + const game = setup([{ id: 'p1', deck: [card('Filler'), card('Filler')] }, { id: 'p2' }]) + game.start() + game.addCard('p1', linvala, 'battlefield') + const own = game.addCard('p1', creature('Own Cleric', 1, 1, [drawAbility]), 'battlefield') + const theirs = game.addCard('p2', creature('Their Cleric', 1, 1, [drawAbility]), 'battlefield') + + game.activateAbility('p1', own.id, 0) + assert.equal(game.stack.length, 1) + + game.resolveStack() + game.pass('p1') + assert.throws(() => game.activateAbility('p2', theirs.id, 0), /cannot activate/) +}) + +test('Aven Mindcensor limits an opponent search to the top four cards', () => { + const aven = card('Aven Mindcensor', { + typeLine: 'Creature — Bird Wizard', + power: 2, + toughness: 1, + abilities: [{ + kind: 'static', + effects: [{ op: 'search_restriction', who: 'opponent', amount: { kind: 'number', value: 4 } }], + text: 'If an opponent would search a library, that player searches the top four cards of that library instead.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2', deck: [] }]) + game.start() + game.addCard('p1', aven, 'battlefield') + for (const name of ['Forest', 'Island', 'Mountain', 'Plains', 'Swamp', 'Wastes']) { + game.addCard('p2', land(name, 'C'), 'library') + } + const topFour = game.getPlayer('p2').library.slice(0, 4) + const growth = game.addCard('p2', spell('Rampant Growth', [{ + op: 'search', + player: 'you', + selector: { types: ['land'] }, + amount: { kind: 'number', value: 1 }, + destination: 'battlefield', + shuffle: true, + }]), 'hand') + + game.pass('p1') + game.castSpell('p2', growth.id) + game.resolveStack() + + assert.deepEqual( + game.searchCandidates('p2').map(object => object.id).sort(), + [...topFour].sort(), + ) +}) + +test('Rest in Peace exiles all graveyards and replaces later graveyard moves', () => { + const rest = card('Rest in Peace', { + typeLine: 'Enchantment', + power: undefined, + toughness: undefined, + abilities: [ + { + kind: 'triggered', + event: { kind: 'enters', subject: { kind: 'self' } }, + effects: [{ op: 'exile_graveyards' }], + optional: false, + text: 'When this enchantment enters, exile all graveyards.', + }, + { + kind: 'static', + effects: [{ op: 'exile_instead_of_graveyard' }], + text: 'If a card or token would be put into a graveyard from anywhere, exile it instead.', + }, + ], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const oldSpell = game.addCard('p1', spell('Old Spell', []), 'graveyard') + const oldCreature = game.addCard('p2', creature('Old Bear', 2, 2), 'graveyard') + const doomed = game.addCard('p1', creature('Doomed Bear', 2, 2), 'battlefield') + + game.addCard('p1', rest, 'battlefield', { silent: false }) + game.resolveStack() + + assert.ok(game.getPlayer('p1').exile.includes(oldSpell.id)) + assert.ok(game.getPlayer('p2').exile.includes(oldCreature.id)) + assert.deepEqual(game.getPlayer('p1').graveyard, []) + assert.deepEqual(game.getPlayer('p2').graveyard, []) + + game.moveToZone(doomed, 'graveyard') + + assert.equal(doomed.zone, 'exile') + assert.ok(game.getPlayer('p1').exile.includes(doomed.id)) +}) + +test("Leyline of the Void exiles only opponents' cards and starts on the battlefield", () => { + const leyline = card('Leyline of the Void', { + typeLine: 'Enchantment', + power: undefined, + toughness: undefined, + abilities: [ + { + kind: 'static', + effects: [{ op: 'restriction', target: { kind: 'self' }, rule: 'begin_on_battlefield' }], + text: 'If this card is in your opening hand, you may begin the game with it on the battlefield.', + }, + { + kind: 'static', + effects: [{ op: 'exile_instead_of_graveyard', owner: 'opponent' }], + text: "If a card would be put into an opponent's graveyard from anywhere, exile it instead.", + }, + ], + }) + const game = new Game({ + seed: 3, + startingHandSize: 0, + players: [{ id: 'p1', deck: [card('Filler')] }, { id: 'p2', deck: [card('Filler')] }], + }) + const leylineObject = game.addCard('p1', leyline, 'hand') + game.start() + + assert.ok(game.getPlayer('p1').battlefield.includes(leylineObject.id)) + assert.ok(!game.getPlayer('p1').hand.includes(leylineObject.id)) + + const theirs = game.addCard('p2', creature('Their Bear', 2, 2), 'battlefield') + const own = game.addCard('p1', creature('Own Bear', 2, 2), 'battlefield') + game.moveToZone(theirs, 'graveyard') + game.moveToZone(own, 'graveyard') + + assert.equal(theirs.zone, 'exile') + assert.equal(own.zone, 'graveyard') +}) + +test('Field of the Dead makes a Zombie at seven differently named lands', () => { + const field = card('Field of the Dead', { + typeLine: 'Land', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'triggered', + event: { + kind: 'enters', + subject: { + kind: 'object', + selector: { other: true, controller: 'you', types: ['land'] }, + mode: 'each', + includeSelf: true, + }, + }, + condition: { kind: 'distinct_names', selector: { types: ['land'] }, atLeast: 7 }, + effects: [{ + op: 'create_token', + player: 'you', + amount: { kind: 'number', value: 1 }, + token: { + types: ['creature'], + subtypes: ['zombie'], + colors: ['B'], + power: { kind: 'number', value: 2 }, + toughness: { kind: 'number', value: 2 }, + }, + }], + optional: false, + text: 'Whenever this or another land you control enters, if you control seven or more lands with different names, create a 2/2 black Zombie creature token.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', field, 'battlefield') + for (const name of ['Forest', 'Island', 'Mountain', 'Plains']) { + game.addCard('p1', land(name, 'C'), 'battlefield') + } + + game.addCard('p1', land('Swamp', 'C'), 'battlefield', { silent: false }) + game.resolveStack() + assert.equal(game.getPlayer('p1').battlefield + .map(id => game.getObject(id)).filter(object => object.isToken).length, 0) + + game.addCard('p1', land('Wastes', 'C'), 'battlefield', { silent: false }) + game.resolveStack() + + const tokens = game.getPlayer('p1').battlefield + .map(id => game.getObject(id)).filter(object => object.isToken) + assert.equal(tokens.length, 1) + assert.equal(tokens[0].definition.typeLine.toLowerCase().includes('zombie'), true) +}) + +test('predefined Treasure, Gold, Powerstone, Heartwood, and Vibranium tokens produce mana', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + + const treasure = makeToken(game, { types: ['artifact'], subtypes: ['treasure'], colors: [] }) + assert.equal(treasure.definition.name, 'Treasure') + game.activateAbility('p1', treasure.id, 0, { manaColor: 'G' }) + assert.equal(game.getPlayer('p1').manaPool.G, 1) + assert.equal(treasure.zone, 'graveyard') + + const gold = makeToken(game, { types: ['artifact'], subtypes: ['gold'], colors: [] }) + game.activateAbility('p1', gold.id, 0, { manaColor: 'R' }) + assert.equal(game.getPlayer('p1').manaPool.R, 1) + + const powerstone = makeToken(game, { types: ['artifact'], subtypes: ['powerstone'], colors: [] }) + game.activateAbility('p1', powerstone.id, 0) + assert.equal(game.getPlayer('p1').manaPool.C, 1) + + const heartwood = makeToken(game, { types: ['artifact'], subtypes: ['heartwood'], colors: [] }) + game.activateAbility('p1', heartwood.id, 0, { manaColor: 'G' }) + assert.equal(game.getPlayer('p1').manaPool.G, 2) + + const vibranium = makeToken(game, { types: ['artifact'], subtypes: ['vibranium'], colors: [] }) + assert.equal(game.hasKeyword(vibranium, 'Indestructible'), true) + game.activateAbility('p1', vibranium.id, 0) + assert.equal(game.getPlayer('p1').manaPool.C, 2) +}) + +test('predefined Food, Clue, Blood, and Shard tokens sacrifice for their effects', () => { + const game = setup([{ + id: 'p1', + deck: Array.from({ length: 6 }, (_, index) => card(`Filler ${index}`)), + }, { id: 'p2' }]) + game.start() + + const food = makeToken(game, { types: ['artifact'], subtypes: ['food'], colors: [] }) + addMana(game, 'G', 'G') + game.activateAbility('p1', food.id, 0) + game.resolveStack() + assert.equal(game.getPlayer('p1').life, 43) + assert.equal(food.zone, 'graveyard') + + game.addCard('p1', card('Discard Fodder'), 'hand') + const discard = game.getObject(game.getPlayer('p1').hand[0]) + const handAfterFood = game.getPlayer('p1').hand.length + const blood = makeToken(game, { types: ['artifact'], subtypes: ['blood'], colors: [] }) + addMana(game, 'G') + game.activateAbility('p1', blood.id, 0) + game.resolveStack() + assert.equal(discard.zone, 'graveyard') + assert.equal(game.getPlayer('p1').hand.length, handAfterFood) + + const clue = makeToken(game, { types: ['artifact'], subtypes: ['clue'], colors: [] }) + addMana(game, 'G', 'G') + game.activateAbility('p1', clue.id, 0) + game.resolveStack() + assert.equal(game.getPlayer('p1').hand.length, handAfterFood + 1) + + const shard = makeToken(game, { types: ['enchantment'], subtypes: ['shard'], colors: [] }) + addMana(game, 'G', 'G') + game.activateAbility('p1', shard.id, 0) + game.resolveStack() + assert.equal(game.getPlayer('p1').hand.length, handAfterFood + 2) +}) + +test('Walker and Incubator tokens use their predefined characteristics', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + + const walker = makeToken(game, { types: ['artifact'], subtypes: ['walker'], colors: [] }) + assert.equal(walker.definition.name, 'Walker') + assert.equal(game.getPower(walker), 2) + assert.equal(game.getToughness(walker), 2) + assert.deepEqual(walker.definition.colors, ['B']) + + const maker = game.addCard('p1', card('Incubator Maker', { + typeLine: 'Artifact', + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'keyword_action', action: 'incubate', amount: { kind: 'number', value: 2 } }], + optional: false, + text: '{T}: Incubate 2.', + }], + }), 'battlefield') + game.activateAbility('p1', maker.id, 0) + game.resolveStack() + + const incubator = game.getPlayer('p1').battlefield + .map(id => game.getObject(id)) + .find(object => object.isToken && object.definition.name === 'Incubator') + assert.ok(incubator) + assert.equal(incubator.counters['+1/+1'], 2) + + addMana(game, 'G', 'G') + game.activateAbility('p1', incubator.id, 0) + game.resolveStack() + assert.equal(incubator.definition.name, 'Phyrexian') + assert.equal(game.getPower(incubator), 2) + assert.equal(game.getToughness(incubator), 2) +}) + +test('predefined Map, Lander, and Mutagen tokens use their activated abilities', () => { + const mapGame = setup([{ id: 'p1', deck: [card('Filler')] }, { id: 'p2' }]) + mapGame.start() + const topCard = mapGame.addCard('p1', card('Top Card'), 'library') + const bear = mapGame.addCard('p1', creature('Bear', 2, 2), 'battlefield') + addMana(mapGame, 'G') + const map = makeToken(mapGame, { types: ['artifact'], subtypes: ['map'], colors: [] }) + mapGame.activateAbility('p1', map.id, 0, { targets: [{ kind: 'object', id: bear.id }] }) + mapGame.resolveStack() + assert.equal(bear.counters['+1/+1'], 1) + assert.equal(topCard.zone, 'graveyard') + + addMana(mapGame, 'G') + const mutagen = makeToken(mapGame, { types: ['artifact'], subtypes: ['mutagen'], colors: [] }) + mapGame.activateAbility('p1', mutagen.id, 0, { targets: [{ kind: 'object', id: bear.id }] }) + mapGame.resolveStack() + assert.equal(bear.counters['+1/+1'], 2) + + const landGame = setup([{ id: 'p1', deck: [card('Filler')] }, { id: 'p2' }]) + landGame.start() + const forest = landGame.addCard('p1', land('Forest', 'G'), 'library') + addMana(landGame, 'G', 'G') + const lander = makeToken(landGame, { types: ['artifact'], subtypes: ['lander'], colors: [] }) + landGame.activateAbility('p1', lander.id, 0) + landGame.resolveStack() + assert.equal(forest.zone, 'battlefield') + assert.equal(forest.tapped, true) +}) diff --git a/backend/test/game-search.test.ts b/backend/test/game-search.test.ts new file mode 100644 index 0000000..7119467 --- /dev/null +++ b/backend/test/game-search.test.ts @@ -0,0 +1,204 @@ +import assert from 'node:assert/strict' +import test from 'node:test' +import { Game, GameError } from '../src/game/game.js' +import { compileText } from '../src/effects/compile.js' +import type { Ability, Effect, TokenSpec } from '../src/effects/types.js' +import type { CardDefinition, GameObject } from '../src/game/types.js' +import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js' + +test('a search that shuffles and puts the chosen card on top leaves it on top', () => { + const bear = creature('Bear', 2, 2) + const elf = creature('Elf', 1, 1) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const bearObject = game.addCard('p1', bear, 'library') + const elfObject = game.addCard('p1', elf, 'library') + const worldlyTutor = game.addCard('p1', spell('Worldly Tutor', [{ + op: 'search', + player: 'you', + selector: { types: ['creature'] }, + amount: { kind: 'number', value: 1 }, + destination: 'top', + tapped: false, + shuffle: true, + }]), 'hand') + + game.castSpell('p1', worldlyTutor.id) + game.resolveStack() + assert.equal(game.pendingSearch?.playerId, 'p1') + + game.chooseSearchCard('p1', elfObject.id) + + assert.equal(game.getPlayer('p1').library[0], elfObject.id) + assert.ok(game.getPlayer('p1').library.includes(bearObject.id)) +}) + +test('as-enters creature type choices pause until the controller picks', () => { + const cavern = card('Cavern of Souls', { + typeLine: 'Land', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'static', + effects: [{ op: 'choose', what: 'creature_type' }], + text: 'As this enters, choose a creature type.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const object = game.addCard('p1', cavern, 'hand') + game.playLand('p1', object.id) + + assert.equal(game.pendingChoice?.sourceId, object.id) + assert.equal(game.pendingChoice?.playerId, 'p1') + assert.throws(() => game.pass('p1'), GameError) + assert.throws(() => game.chooseCreatureType('p2', 'Elf'), GameError) + assert.throws(() => game.chooseCreatureType('p1', 'Not A Type'), GameError) + + game.chooseCreatureType('p1', 'elf') + assert.equal(object.chosenCreatureType, 'Elf') + assert.equal(game.pendingChoice, undefined) + + game.moveToZone(object, 'graveyard') + assert.equal(object.chosenCreatureType, undefined) + game.moveToZone(object, 'battlefield', { silent: false }) + assert.equal(game.pendingChoice?.sourceId, object.id) +}) + +test('a split search sends the first pick to the battlefield and the next to hand', () => { + const forest = land('Forest', 'G') + const island = land('Island', 'U') + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const forestObject = game.addCard('p1', forest, 'library') + const islandObject = game.addCard('p1', island, 'library') + const cultivate = game.addCard('p1', spell('Cultivate', [{ + op: 'search', + player: 'you', + selector: { types: ['land'], supertypes: ['basic'] }, + amount: { kind: 'number', value: 2 }, + destination: 'battlefield', + tapped: true, + shuffle: true, + split: { destination: 'hand', tapped: false }, + }]), 'hand') + + game.castSpell('p1', cultivate.id) + game.resolveStack() + + game.chooseSearchCard('p1', islandObject.id) + assert.equal(game.pendingSearch?.destination, 'hand') + game.chooseSearchCard('p1', forestObject.id) + + assert.equal(game.pendingSearch, undefined) + assert.ok(game.getPlayer('p1').battlefield.includes(islandObject.id)) + assert.equal(islandObject.tapped, true) + assert.ok(game.getPlayer('p1').hand.includes(forestObject.id)) +}) + +test('autoAdvance stops instead of passing while a search needs a pick', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', land('Forest', 'G'), 'library') + game.addCard('p1', land('Island', 'U'), 'library') + const rampantGrowth = game.addCard('p1', spell('Rampant Growth', [{ + op: 'search', + player: 'you', + selector: { types: ['land'], supertypes: ['basic'] }, + amount: { kind: 'number', value: 1 }, + destination: 'battlefield', + tapped: true, + shuffle: true, + }]), 'hand') + + game.castSpell('p1', rampantGrowth.id) + game.autoAdvance() + + assert.equal(game.pendingSearch?.playerId, 'p1') + assert.equal(game.priority, 'p1') +}) + +test('static replacement effects make permanents enter tapped with counters', () => { + const slow = creature('Slow Bear', 2, 2, [{ + kind: 'static', + effects: [{ op: 'enters_tapped', target: { kind: 'self' } }], + text: 'This enters tapped.', + }, { + kind: 'static', + effects: [{ + op: 'enters_with_counters', + target: { kind: 'self' }, + counter: '+1/+1', + amount: { kind: 'number', value: 1 }, + }], + text: 'This enters with a +1/+1 counter.', + }]) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const bear = game.addCard('p1', slow, 'hand') + + game.castSpell('p1', bear.id) + game.resolveStack() + + assert.equal(bear.tapped, true) + assert.equal(bear.counters['+1/+1'], 1) + assert.equal(game.getPower(bear), 3) + assert.equal(game.getToughness(bear), 3) +}) + +function shockLand(): CardDefinition { + return card('Steam Vents', { + typeLine: 'Land — Island Mountain', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'static', + effects: [{ op: 'enters_tapped', target: { kind: 'self' }, unlessCost: { kind: 'pay_life', amount: { kind: 'number', value: 2 } } }], + text: "As this land enters, you may pay 2 life. If you don't, it enters tapped.", + }, { + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{U}', '{R}'], oneOf: true } }], + optional: false, + text: '{T}: Add {U} or {R}.', + }], + }) +} + +test('a land can pay life to enter untapped or enter tapped', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const vents = game.addCard('p1', shockLand(), 'hand') + game.playLand('p1', vents.id) + + assert.equal(vents.tapped, false) + assert.equal(game.pendingChoice?.what, 'pay_cost') + assert.equal(game.pendingChoice?.amount, 2) + assert.throws(() => game.chooseCostPayment('p2', true), GameError) + + game.chooseCostPayment('p1', true) + assert.equal(game.getPlayer('p1').life, 38) + assert.equal(vents.tapped, false) + assert.equal(game.pendingChoice, undefined) + + const second = game.addCard('p1', shockLand(), 'hand') + game.moveToZone(second, 'battlefield', { controller: 'p1', silent: false }) + assert.equal(game.pendingChoice?.what, 'pay_cost') + + game.chooseCostPayment('p1', false) + assert.equal(second.tapped, true) + assert.equal(game.getPlayer('p1').life, 38) +}) + +test('a choice mana ability adds only the color the spell needs', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const vents = game.addCard('p1', shockLand(), 'battlefield') + const red = game.addCard('p1', spell('Red Spell', [], '{R}'), 'hand') + + game.castSpell('p1', red.id) + + assert.equal(vents.tapped, true) + assert.equal(game.getPlayer('p1').manaPool.R, 0) + assert.equal(game.getPlayer('p1').manaPool.U, 0) +}) diff --git a/backend/test/game-targets.test.ts b/backend/test/game-targets.test.ts new file mode 100644 index 0000000..cf7bb81 --- /dev/null +++ b/backend/test/game-targets.test.ts @@ -0,0 +1,520 @@ +import assert from 'node:assert/strict' +import test from 'node:test' +import { Game, GameError } from '../src/game/game.js' +import { compileText } from '../src/effects/compile.js' +import type { Ability, Effect, TokenSpec } from '../src/effects/types.js' +import type { CardDefinition, GameObject } from '../src/game/types.js' +import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js' + +test('temporary pump effects expire at end of turn', () => { + const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) + game.start() + const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield') + const growth = game.addCard('p1', spell('Giant Growth', [{ + op: 'pump', + target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }, + power: { kind: 'number', value: 3 }, + toughness: { kind: 'number', value: 3 }, + duration: 'until_end_of_turn', + }]), 'hand') + + game.castSpell('p1', growth.id, { targets: [{ kind: 'object', id: bear.id }] }) + game.resolveStack() + assert.equal(game.getPower(bear), 5) + assert.equal(game.getToughness(bear), 5) + + game.endTurn('p1') + assert.equal(game.getPower(bear), 2) +}) + +test('the engine exposes legal creature targets for a card', () => { + const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) + game.start() + const bear = game.addCard('p2', creature('Grizzly Bears', 2, 2), 'battlefield') + const growth = game.addCard('p1', spell('Giant Growth', [{ + op: 'pump', + target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }, + power: { kind: 'number', value: 3 }, + toughness: { kind: 'number', value: 3 }, + duration: 'until_end_of_turn', + }]), 'hand') + + assert.deepEqual(game.legalTargetsForCard('p1', growth.id), [{ kind: 'object', id: bear.id }]) +}) + +test('excluded colors filter legal targets', () => { + const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) + game.start() + game.addCard('p2', card('Black Bear', { typeLine: 'Creature — Bear', colors: ['B'], power: 2, toughness: 2 }), 'battlefield') + const green = game.addCard('p2', card('Green Bear', { typeLine: 'Creature — Bear', colors: ['G'], power: 2, toughness: 2 }), 'battlefield') + const doomBlade = game.addCard('p1', spell('Doom Blade', [{ + op: 'destroy', + target: { kind: 'object', selector: { types: ['creature'], excludeColors: ['B'] }, mode: 'target' }, + }]), 'hand') + + assert.deepEqual(game.legalTargetsForCard('p1', doomBlade.id), [{ kind: 'object', id: green.id }]) +}) + +test('the engine exposes legal targets for an activated ability', () => { + const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) + game.start() + const bear = game.addCard('p2', creature('Grizzly Bears', 2, 2), 'battlefield') + const pinger = game.addCard('p1', card('Pinger', { + typeLine: 'Creature — Test', + power: 1, + toughness: 1, + abilities: [{ + kind: 'activated', + costs: [], + optional: false, + text: '{T}: This creature deals 1 damage to target creature an opponent controls.', + effects: [{ + op: 'damage', + target: { kind: 'object', selector: { controller: 'opponent', types: ['creature'] }, mode: 'target' }, + amount: { kind: 'number', value: 1 }, + }], + }], + }), 'battlefield') + + assert.deepEqual(game.legalTargetsForAbility('p1', pinger.id, 0), [{ kind: 'object', id: bear.id }]) +}) + +test('"until the end of your next turn" lasts through the controller next turn', () => { + const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) + game.start() + const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield') + const growth = game.addCard('p1', spell('Growth', [{ + op: 'pump', + target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }, + power: { kind: 'number', value: 3 }, + toughness: { kind: 'number', value: 3 }, + duration: 'until_end_of_your_next_turn', + }]), 'hand') + + game.castSpell('p1', growth.id, { targets: [{ kind: 'object', id: bear.id }] }) + game.resolveStack() + assert.equal(game.getPower(bear), 5) + + game.endTurn('p1') + assert.equal(game.getPower(bear), 5) + + game.endTurn('p2') + assert.equal(game.getPower(bear), 5) + + game.endTurn('p1') + assert.equal(game.getPower(bear), 2) +}) + +test('counter replacement doubles counters put on matching creatures', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.addCard('p1', card('Hardened Scales Test', { + typeLine: 'Enchantment', + abilities: [{ + kind: 'static', + effects: [{ + op: 'counter_multiplier', + target: { kind: 'object', selector: { types: ['creature'], controller: 'you' }, mode: 'each' }, + counter: '+1/+1', + multiplier: 2, + }], + text: 'If one or more +1/+1 counters would be put on a creature you control, twice that many are put on it instead.', + }], + }), 'battlefield') + game.start() + const bear = game.addCard('p1', creature('Counter Bear', 2, 2), 'battlefield') + const growth = game.addCard('p1', spell('Growth', [{ + op: 'put_counters', + target: { kind: 'object', selector: { types: ['creature'] } }, + counter: '+1/+1', + amount: { kind: 'number', value: 2 }, + }]), 'hand') + + game.castSpell('p1', growth.id, { targets: [{ kind: 'object', id: bear.id }] }) + game.resolveStack() + assert.equal(bear.counters['+1/+1'], 4) +}) + +test('energy replacement doubles energy gained', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.addCard('p1', card('Energy Doubler', { + typeLine: 'Enchantment', + abilities: [{ + kind: 'static', + effects: [{ op: 'replacement_amount', what: 'energy', multiplier: 2 }], + text: 'If you would get one or more {E}, you get twice that many {E} instead.', + }], + }), 'battlefield') + game.start() + const spark = game.addCard('p1', spell('Spark', [ + { op: 'energy', player: 'you', amount: { kind: 'number', value: 2 } }, + ]), 'hand') + + game.castSpell('p1', spark.id) + game.resolveStack() + assert.equal(game.getPlayer('p1').energy, 4) +}) + +test('a static source-filtered prevention stops only matching damage', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + const protectedCreature = game.addCard('p1', card('Ward Golem', { + typeLine: 'Artifact Creature — Golem', + power: 2, + toughness: 5, + abilities: [{ + kind: 'static', + effects: [{ + op: 'prevent_damage', + target: { kind: 'self' }, + amount: 'all', + duration: 'permanent', + sourceSelector: { types: ['creature'] }, + }], + text: 'Prevent all damage that would be dealt to this by creatures.', + }], + }), 'battlefield') + const plain = game.addCard('p1', creature('Plain Bear', 2, 5), 'battlefield') + const pinger = game.addCard('p2', card('Pinger', { + typeLine: 'Creature — Test', + power: 1, + toughness: 1, + abilities: [{ + kind: 'activated', + costs: [], + effects: [{ + op: 'damage', + target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }, + amount: { kind: 'number', value: 3 }, + }], + optional: false, + text: '{0}: Deal 3 damage to target creature.', + }], + }), 'battlefield') + game.start() + + while (game.priority !== 'p2') game.pass(game.priority) + game.activateAbility('p2', pinger.id, 0, { targets: [{ kind: 'object', id: protectedCreature.id }] }) + game.resolveStack() + assert.equal(protectedCreature.damage, 0) + + while (game.priority !== 'p2') game.pass(game.priority) + game.activateAbility('p2', pinger.id, 0, { targets: [{ kind: 'object', id: plain.id }] }) + game.resolveStack() + assert.equal(plain.damage, 3) +}) + +test('a source-scoped shield only stops the chosen source', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + const pinger = (name: string) => card(name, { + typeLine: 'Creature — Test', + power: 1, + toughness: 1, + abilities: [{ + kind: 'activated', + costs: [], + effects: [{ + op: 'damage', + target: { kind: 'player', who: 'opponent', mode: 'target' }, + amount: { kind: 'number', value: 3 }, + }], + optional: false, + text: '{0}: Deal 3 damage to target opponent.', + }], + }) + const chosen = game.addCard('p2', pinger('Chosen Pinger'), 'battlefield') + const other = game.addCard('p2', pinger('Other Pinger'), 'battlefield') + game.start() + + const shield = spell('Source Shield', [{ + op: 'prevent_damage', + target: { kind: 'any' }, + amount: 'all', + duration: 'until_end_of_turn', + global: true, + source: { kind: 'object', selector: {}, mode: 'target' }, + }]) + const shieldCard = game.addCard('p1', shield, 'hand') + game.castSpell('p1', shieldCard.id, { targets: [{ kind: 'object', id: chosen.id }] }) + game.resolveStack() + + while (game.priority !== 'p2') game.pass(game.priority) + game.activateAbility('p2', chosen.id, 0, { targets: [{ kind: 'player', id: 'p1' }] }) + game.resolveStack() + assert.equal(game.getPlayer('p1').life, 40) + + while (game.priority !== 'p2') game.pass(game.priority) + game.activateAbility('p2', other.id, 0, { targets: [{ kind: 'player', id: 'p1' }] }) + game.resolveStack() + assert.equal(game.getPlayer('p1').life, 37) +}) + +test('a prevention follow-up runs with the prevented amount', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const target = game.addCard('p1', creature('Shielded Bear', 2, 5), 'battlefield') + const shield = spell('Shield', [{ + op: 'prevent_damage', + target: { kind: 'object', selector: { types: ['creature'] } }, + amount: { kind: 'number', value: 3 }, + duration: 'until_end_of_turn', + then: [{ + op: 'damage', + target: { kind: 'player', who: 'opponent', mode: 'target' }, + amount: { kind: 'event_amount' }, + }], + }]) + const bolt = spell('Bolt', [{ + op: 'damage', + target: { kind: 'object', selector: { types: ['creature'] } }, + amount: { kind: 'number', value: 5 }, + }]) + + const shieldCard = game.addCard('p1', shield, 'hand') + game.castSpell('p1', shieldCard.id, { + targets: [{ kind: 'object', id: target.id }, { kind: 'player', id: 'p2' }], + }) + game.resolveStack() + const boltCard = game.addCard('p1', bolt, 'hand') + game.castSpell('p1', boltCard.id, { targets: [{ kind: 'object', id: target.id }] }) + game.resolveStack() + + assert.equal(target.damage, 2) + assert.equal(game.getPlayer('p2').life, 37) +}) + +test('color-specific damage replacement only boosts matching sources', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.addCard('p1', card('Red Enhancer', { + typeLine: 'Enchantment', + abilities: [{ + kind: 'static', + effects: [{ op: 'replacement_amount', what: 'damage', multiplier: 1, add: 1, sourceColor: 'R' }], + text: 'If a red source would deal damage, it deals that much damage plus 1 instead.', + }], + }), 'battlefield') + game.start() + const redBolt = game.addCard('p1', card('Red Bolt', { + typeLine: 'Instant', + colors: ['R'], + abilities: [{ + kind: 'spell', + effects: [{ op: 'damage', target: { kind: 'player', who: 'opponent', mode: 'target' }, amount: { kind: 'number', value: 3 } }], + optional: false, + text: 'Deal 3 damage.', + }], + }), 'hand') + + game.castSpell('p1', redBolt.id, { targets: [{ kind: 'player', id: 'p2' }] }) + game.resolveStack() + assert.equal(game.getPlayer('p2').life, 36) +}) + +test('life-gain replacement doubles the life gained', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.addCard('p1', card('Life Doubler', { + typeLine: 'Enchantment', + abilities: [{ + kind: 'static', + effects: [{ op: 'replacement_amount', what: 'life_gain', multiplier: 2 }], + text: 'If you would gain life, you gain twice that much life instead.', + }], + }), 'battlefield') + game.start() + const heal = game.addCard('p1', spell('Heal', [ + { op: 'life', player: 'you', amount: { kind: 'number', value: 3 }, mode: 'gain' }, + ]), 'hand') + + game.castSpell('p1', heal.id) + game.resolveStack() + assert.equal(game.getPlayer('p1').life, 46) +}) + +test('damage replacement doubles damage from sources you control', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.addCard('p1', card('Furnace', { + typeLine: 'Enchantment', + abilities: [{ + kind: 'static', + effects: [{ op: 'replacement_amount', what: 'damage', multiplier: 2 }], + text: 'If a source you control would deal damage, it deals double that damage instead.', + }], + }), 'battlefield') + game.start() + const bolt = game.addCard('p1', spell('Bolt', [ + { op: 'damage', target: { kind: 'player', who: 'opponent', mode: 'target' }, amount: { kind: 'number', value: 3 } }, + ]), 'hand') + + game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] }) + game.resolveStack() + assert.equal(game.getPlayer('p2').life, 34) +}) + +test('draw replacement doubles each draw', () => { + const deck = [card('Filler One'), card('Filler Two'), card('Filler Three'), card('Filler Four')] + const game = setup([{ id: 'p1', deck }, { id: 'p2', deck }]) + game.addCard('p1', card('Draw Doubler', { + typeLine: 'Enchantment', + abilities: [{ + kind: 'static', + effects: [{ op: 'replacement_amount', what: 'draw', multiplier: 2 }], + text: 'If you would draw a card, draw two cards instead.', + }], + }), 'battlefield') + game.start() + assert.equal(game.getPlayer('p1').hand.length, 2) + assert.equal(game.getPlayer('p2').hand.length, 0) +}) + +test('"skip your draw step" stops its controller drawing', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.addCard('p1', card('Necro Test', { + typeLine: 'Enchantment', + abilities: [{ + kind: 'static', + effects: [{ op: 'restriction', target: { kind: 'player', who: 'you', mode: 'target' }, rule: 'skip_draw_step' }], + text: 'Skip your draw step.', + }], + }), 'battlefield') + game.start() + + assert.equal(game.getPlayer('p1').hand.length, 0) + assert.equal(game.getPlayer('p1').library.length, 1) + + game.endTurn('p1') + game.endTurn('p2') + assert.equal(game.activePlayer, 'p1') + assert.equal(game.getPlayer('p1').hand.length, 0) + assert.equal(game.getPlayer('p1').library.length, 1) +}) + +test('an unblockable attacker rejects declared blockers', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + const attacker = game.addCard('p1', card('Slippery Otter', { + typeLine: 'Creature — Otter', + power: 2, + toughness: 2, + abilities: [{ + kind: 'static', + effects: [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_be_blocked' }], + text: 'This creature cannot be blocked.', + }], + }), 'battlefield') + const blocker = game.addCard('p2', creature('Blocker', 2, 2), 'battlefield') + game.start() + + game.declareAttackers('p1', [{ attackerId: attacker.id, defenderId: 'p2' }]) + assert.throws( + () => game.declareBlockers('p2', [{ blockerId: blocker.id, attackerId: attacker.id }]), + /cannot be blocked/, + ) +}) + +test('a "can\'t be countered" spell survives a counterspell', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const uncounterable = card('Uncounterable', { + typeLine: 'Instant', + abilities: [ + { kind: 'spell', effects: [{ op: 'life', player: 'you', amount: { kind: 'number', value: 3 }, mode: 'gain' }], optional: false, text: 'Gain 3 life.' }, + { kind: 'static', effects: [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_be_countered' }], text: 'This spell cannot be countered.' }, + ], + }) + const counterspell = spell('Counterspell', [{ op: 'counter', what: 'spell', target: { kind: 'spell', selector: {}, mode: 'target' } }]) + const target = game.addCard('p1', uncounterable, 'hand') + const counterCard = game.addCard('p2', counterspell, 'hand') + + game.castSpell('p1', target.id) + game.castSpell('p2', counterCard.id, { targets: [{ kind: 'spell', id: game.stack[game.stack.length - 1].id }] }) + game.resolveStack() + + assert.equal(game.getPlayer('p1').life, 43) + assert.equal(target.zone, 'graveyard') +}) + +test('combat damage kills creatures and moves them to the graveyard', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + const attacker = game.addCard('p1', creature('Attacker', 2, 2), 'battlefield') + const blocker = game.addCard('p2', creature('Blocker', 2, 2), 'battlefield') + game.start() + + game.declareAttackers('p1', [{ attackerId: attacker.id, defenderId: 'p2' }]) + assert.equal(game.step, 'declare_blockers') + assert.equal(game.priority, 'p2') + assert.equal(attacker.tapped, true) + + game.declareBlockers('p2', [{ blockerId: blocker.id, attackerId: attacker.id }]) + game.resolveCombatDamage() + + assert.equal(game.getPlayer('p2').life, 40) + assert.equal(game.step, 'end_combat') + assert.ok(game.getPlayer('p1').graveyard.includes(attacker.id)) + assert.ok(game.getPlayer('p2').graveyard.includes(blocker.id)) +}) + +test('unblocked attackers deal damage to the defending player', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + const attacker = game.addCard('p1', creature('Attacker', 3, 3), 'battlefield') + game.start() + + game.declareAttackers('p1', [{ attackerId: attacker.id, defenderId: 'p2' }]) + game.declareBlockers('p2', []) + game.resolveCombatDamage() + + assert.equal(game.getPlayer('p2').life, 37) +}) + +test('counterspell counters a spell on the stack', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', land('Mountain', 'R'), 'battlefield') + game.addCard('p2', land('Island', 'U'), 'battlefield') + game.addCard('p2', land('Island', 'U'), 'battlefield') + const bolt = game.addCard('p1', spell('Lightning Bolt', [ + { op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } }, + ], '{R}'), 'hand') + const counterspell = game.addCard('p2', spell('Counterspell', [ + { op: 'counter', what: 'spell', target: { kind: 'spell', selector: { types: [] }, mode: 'target' } }, + ], '{U}{U}'), 'hand') + + game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] }) + game.castSpell('p2', counterspell.id) + assert.equal(game.stack.length, 2) + + game.resolveStack() + + assert.equal(game.getPlayer('p2').life, 40) + assert.equal(game.stack.length, 0) + assert.ok(game.getPlayer('p1').graveyard.includes(bolt.id)) + assert.ok(game.getPlayer('p2').graveyard.includes(counterspell.id)) +}) + +test('activated abilities create tokens that enter the battlefield', () => { + const maker = card('Goblin Maker', { + typeLine: 'Artifact', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ + op: 'create_token', + player: 'you', + amount: { kind: 'number', value: 1 }, + token: { name: 'Goblin', types: ['creature'], subtypes: ['goblin'], colors: ['R'], power: { kind: 'number', value: 1 }, toughness: { kind: 'number', value: 1 } }, + }], + optional: false, + text: '{T}: Create a 1/1 Goblin.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const source = game.addCard('p1', maker, 'battlefield') + + game.activateAbility('p1', source.id, 0) + assert.equal(game.stack.length, 1) + game.resolveStack() + + const tokens = game.getPlayer('p1').battlefield.map(id => game.getObject(id)).filter(object => object.isToken) + assert.equal(tokens.length, 1) + assert.equal(tokens[0].definition.name, 'Goblin') + assert.equal(game.getPower(tokens[0]), 1) +}) diff --git a/backend/test/game-tokens.test.ts b/backend/test/game-tokens.test.ts new file mode 100644 index 0000000..1def059 --- /dev/null +++ b/backend/test/game-tokens.test.ts @@ -0,0 +1,224 @@ +import assert from 'node:assert/strict' +import test from 'node:test' +import { Game, GameError } from '../src/game/game.js' +import { compileText } from '../src/effects/compile.js' +import type { Ability, Effect, TokenSpec } from '../src/effects/types.js' +import type { CardDefinition, GameObject } from '../src/game/types.js' +import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js' + +test('token doublers stack and only apply to their controller', () => { + const goblin: TokenSpec = { + types: ['creature'], + subtypes: ['goblin'], + colors: ['R'], + power: { kind: 'number', value: 1 }, + toughness: { kind: 'number', value: 1 }, + } + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const p1Maker = game.addCard('p1', tokenMaker('P1 Maker', goblin), 'battlefield') + game.addCard('p1', tokenDoubler('Parallel Lives', 2), 'battlefield') + game.addCard('p1', tokenDoubler('Anointed Procession', 2), 'battlefield') + const p2Maker = game.addCard('p2', tokenMaker('P2 Maker', goblin), 'battlefield') + game.addCard('p2', tokenDoubler('Adrix and Nev', 2), 'battlefield') + const tokensOf = (playerId: string): number => game.getPlayer(playerId).battlefield + .map(id => game.getObject(id)).filter(object => object.isToken).length + + game.activateAbility('p1', p1Maker.id, 0) + game.resolveStack() + assert.equal(tokensOf('p1'), 4) + assert.equal(tokensOf('p2'), 0) + + game.endTurn('p1') + game.activateAbility('p2', p2Maker.id, 0) + game.resolveStack() + assert.equal(tokensOf('p2'), 2) +}) + +test('Primal Vigor doubles tokens for every player', () => { + const goblin: TokenSpec = { + types: ['creature'], + subtypes: ['goblin'], + colors: ['R'], + power: { kind: 'number', value: 1 }, + toughness: { kind: 'number', value: 1 }, + } + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const p1Maker = game.addCard('p1', tokenMaker('P1 Maker', goblin), 'battlefield') + game.addCard('p1', tokenDoubler('Primal Vigor', 2, 'each_player'), 'battlefield') + const p2Maker = game.addCard('p2', tokenMaker('P2 Maker', goblin), 'battlefield') + const tokensOf = (playerId: string): number => game.getPlayer(playerId).battlefield + .map(id => game.getObject(id)).filter(object => object.isToken).length + + game.activateAbility('p1', p1Maker.id, 0) + game.resolveStack() + assert.equal(tokensOf('p1'), 2) + + game.endTurn('p1') + game.activateAbility('p2', p2Maker.id, 0) + game.resolveStack() + assert.equal(tokensOf('p2'), 2) +}) + +test('Ojer Taq triples creature tokens but not other tokens', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const creatureMaker = game.addCard('p1', tokenMaker('Creature Maker', { + types: ['creature'], + subtypes: ['goblin'], + colors: ['R'], + power: { kind: 'number', value: 1 }, + toughness: { kind: 'number', value: 1 }, + }), 'battlefield') + const treasureMaker = game.addCard('p1', tokenMaker('Treasure Maker', { + types: ['artifact'], subtypes: ['treasure'], colors: [], + }), 'battlefield') + game.addCard('p1', tokenDoubler('Ojer Taq', 3, 'you', true), 'battlefield') + + game.activateAbility('p1', creatureMaker.id, 0) + game.resolveStack() + game.activateAbility('p1', treasureMaker.id, 0) + game.resolveStack() + + const tokens = game.getPlayer('p1').battlefield.map(id => game.getObject(id)).filter(object => object.isToken) + assert.equal(tokens.filter(object => object.definition.typeLine.toLowerCase().includes('creature')).length, 3) + assert.equal(tokens.filter(object => object.definition.typeLine.toLowerCase().includes('treasure')).length, 1) +}) + +test('search effects find cards in the library and put them onto the battlefield tapped', () => { + const forest = land('Forest', 'G') + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const found = game.addCard('p1', forest, 'library') + const rampantGrowth = game.addCard('p1', spell('Rampant Growth', [{ + op: 'search', + player: 'you', + selector: { types: ['land'], supertypes: ['basic'] }, + amount: { kind: 'number', value: 1 }, + destination: 'battlefield', + tapped: true, + shuffle: true, + }]), 'hand') + + game.castSpell('p1', rampantGrowth.id) + game.resolveStack() + + assert.ok(game.getPlayer('p1').battlefield.includes(found.id)) + assert.equal(found.tapped, true) +}) + +test('search effects let the player pick among multiple matching cards', () => { + const forest = land('Forest', 'G') + const island = land('Island', 'U') + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const forestObject = game.addCard('p1', forest, 'library') + const islandObject = game.addCard('p1', island, 'library') + const rampantGrowth = game.addCard('p1', spell('Rampant Growth', [{ + op: 'search', + player: 'you', + selector: { types: ['land'], supertypes: ['basic'] }, + amount: { kind: 'number', value: 1 }, + destination: 'battlefield', + tapped: true, + shuffle: true, + }]), 'hand') + + game.castSpell('p1', rampantGrowth.id) + game.resolveStack() + + assert.equal(game.pendingSearch?.playerId, 'p1') + assert.deepEqual( + game.searchCandidates('p1').map(object => object.id).sort(), + [forestObject.id, islandObject.id].sort(), + ) + assert.equal(forestObject.zone, 'library') + assert.throws(() => game.pass('p1'), GameError) + + game.chooseSearchCard('p1', islandObject.id) + + assert.equal(game.pendingSearch, undefined) + assert.ok(game.getPlayer('p1').battlefield.includes(islandObject.id)) + assert.equal(islandObject.tapped, true) + assert.ok(game.getPlayer('p1').library.includes(forestObject.id)) +}) + +test('Junk exiles the top card and lets its controller cast it that turn', () => { + const game = setup([{ id: 'p1', deck: [card('Filler')] }, { id: 'p2' }]) + game.start() + const exiled = game.addCard('p1', spell('Top Spell', [], ''), 'library') + const junk = makeToken(game, { types: ['artifact'], subtypes: ['junk'], colors: [] }) + + game.activateAbility('p1', junk.id, 0) + game.resolveStack() + assert.equal(exiled.zone, 'exile') + assert.equal(game.canPlayCard('p1', exiled.id), true) + + game.castSpell('p1', exiled.id) + game.resolveStack() + assert.equal(exiled.zone, 'graveyard') +}) + +test('Role tokens attach to the target creature and apply their abilities', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const bear = game.addCard('p1', creature('Bear', 2, 2), 'battlefield') + const maker = game.addCard('p1', roleMaker('Monster'), 'battlefield') + + assert.deepEqual(game.legalTargetsForAbility('p1', maker.id, 0), [{ kind: 'object', id: bear.id }]) + game.activateAbility('p1', maker.id, 0, { targets: [{ kind: 'object', id: bear.id }] }) + game.resolveStack() + + const role = game.getPlayer('p1').battlefield + .map(id => game.getObject(id)) + .find(object => object.isToken) + assert.ok(role) + assert.equal(role.definition.name, 'Monster Role') + assert.match(role.definition.typeLine.toLowerCase(), /enchantment — aura role/) + assert.equal(role.attachedTo, bear.id) + assert.equal(game.getPower(bear), 3) + assert.equal(game.getToughness(bear), 3) + assert.equal(game.hasKeyword(bear, 'Trample'), true) +}) + +test('Young Hero Role triggers when the enchanted creature attacks with toughness 3 or less', () => { + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + const bear = game.addCard('p1', creature('Bear', 2, 2), 'battlefield') + game.start() + const maker = game.addCard('p1', roleMaker('Young Hero'), 'battlefield') + game.activateAbility('p1', maker.id, 0, { targets: [{ kind: 'object', id: bear.id }] }) + game.resolveStack() + + game.declareAttackers('p1', [{ attackerId: bear.id, defenderId: 'p2' }]) + game.resolveStack() + assert.equal(bear.counters['+1/+1'], 1) + assert.equal(game.getPower(bear), 3) +}) + +test('token creation replacement swaps the created token', () => { + const food: TokenSpec = { + name: 'Food', + types: ['artifact'], + subtypes: ['food'], + colors: [], + abilities: [{ kind: 'activated', costs: [{ kind: 'tap' }, { kind: 'mana', cost: '{2}' }], effects: [] }], + } + const treasure: TokenSpec = { name: 'Treasure', types: ['artifact'], subtypes: ['treasure'], colors: [] } + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const maker = game.addCard('p1', tokenMaker('Food Maker', food), 'battlefield') + game.addCard('p1', card('Token Replacer', { + typeLine: 'Enchantment', + abilities: [{ + kind: 'static', + effects: [{ op: 'token_replacement', from: ['food'], tokens: [food, treasure], who: 'you' }], + text: 'If you would create a Food token, instead create a Food token and a Treasure token.', + }], + }), 'battlefield') + + game.activateAbility('p1', maker.id, 0) + game.resolveStack() + const tokens = game.getPlayer('p1').battlefield.map(id => game.getObject(id)).filter(object => object.isToken) + assert.deepEqual(tokens.map(token => token.definition.name).sort(), ['Food', 'Treasure']) +}) diff --git a/backend/test/game.test.ts b/backend/test/game.test.ts deleted file mode 100644 index bae54a5..0000000 --- a/backend/test/game.test.ts +++ /dev/null @@ -1,1941 +0,0 @@ -import assert from 'node:assert/strict' -import test from 'node:test' -import { Game, GameError } from '../src/game/game.js' -import type { Ability, Effect, TokenSpec } from '../src/effects/types.js' -import type { CardDefinition, GameObject } from '../src/game/types.js' - -function card(name: string, overrides: Partial = {}): CardDefinition { - return { - oracleId: name.toLowerCase().replace(/[^a-z0-9]+/g, '-'), - name, - typeLine: 'Creature — Test', - manaValue: 0, - colors: [], - abilities: [], - ...overrides, - } -} - -function creature(name: string, power: number, toughness: number, abilities: Ability[] = []): CardDefinition { - return card(name, { typeLine: 'Creature — Test', power, toughness, abilities }) -} - -function spell(name: string, effects: Effect[], manaCost = ''): CardDefinition { - return card(name, { typeLine: 'Instant', manaCost, manaValue: 0, abilities: [{ kind: 'spell', effects, optional: false, text: name }] }) -} - -function land(name: string, color: string): CardDefinition { - return card(name, { - typeLine: `Basic Land — ${name}`, - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: [`{${color}}`] } }], - optional: false, - text: `{T}: Add {${color}}.`, - }], - }) -} - -function exoticOrchard(): CardDefinition { - return card('Exotic Orchard', { - typeLine: 'Land', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ - op: 'add_mana', - player: 'you', - mana: { - kind: 'any_color', - amount: { kind: 'number', value: 1 }, - oneColor: false, - restriction: 'a land an opponent controls could produce', - }, - }], - optional: false, - text: '{T}: Add one mana of any color that a land an opponent controls could produce.', - }], - }) -} - -function setup(players: { id: string; deck?: CardDefinition[]; life?: number }[]): Game { - const game = new Game({ - seed: 7, - startingHandSize: 0, - players: players.map(player => ({ id: player.id, life: player.life, deck: player.deck ?? [card('Filler')] })), - }) - return game -} - -function tokenMaker(name: string, token: TokenSpec): CardDefinition { - return card(name, { - typeLine: 'Artifact', - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ op: 'create_token', player: 'you', amount: { kind: 'number', value: 1 }, token }], - optional: false, - text: '{T}: Create a token.', - }], - }) -} - -function tokenDoubler( - name: string, - multiplier: number, - who: 'you' | 'each_player' = 'you', - creatureOnly = false, -): CardDefinition { - return card(name, { - typeLine: 'Enchantment', - abilities: [{ - kind: 'static', - effects: [{ op: 'token_multiplier', multiplier, who, ...(creatureOnly ? { creatureOnly: true } : {}) }], - text: 'Token replacement.', - }], - }) -} - -function makeToken(game: Game, token: TokenSpec, playerId = 'p1'): GameObject { - const maker = game.addCard(playerId, tokenMaker('Token Maker', token), 'battlefield') - game.activateAbility(playerId, maker.id, 0) - game.resolveStack() - const tokens = game.getPlayer(playerId).battlefield - .map(id => game.getObject(id)) - .filter(object => object.isToken) - return tokens[tokens.length - 1] -} - -function addMana(game: Game, ...symbols: string[]): void { - for (const symbol of symbols) { - const source = game.addCard('p1', land('Mana Land', symbol), 'battlefield') - game.activateAbility('p1', source.id, 0) - } -} - -function roleMaker(name: string): CardDefinition { - return card(`${name} Role Maker`, { - typeLine: 'Enchantment', - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ - op: 'create_token', - player: 'you', - amount: { kind: 'number', value: 1 }, - token: { name, types: ['enchantment'], subtypes: ['aura', 'role'], colors: [] }, - attachTo: { kind: 'object', selector: { types: ['creature'], controller: 'you' }, mode: 'target' }, - }], - optional: false, - text: `{T}: Create a ${name} Role token attached to target creature you control.`, - }], - }) -} - -test('turns start at the first main phase, draw opening hands, and pass to the next player', () => { - const forest = land('Forest', 'G') - const game = new Game({ - seed: 1, - startingHandSize: 7, - players: [ - { id: 'p1', deck: Array.from({ length: 10 }, () => forest) }, - { id: 'p2', deck: Array.from({ length: 10 }, () => forest) }, - ], - }) - game.start() - - assert.equal(game.turn, 1) - assert.equal(game.activePlayer, 'p1') - assert.equal(game.phase, 'precombat_main') - assert.equal(game.step, 'main') - assert.equal(game.priority, 'p1') - assert.equal(game.getPlayer('p1').life, 40) - assert.equal(game.getPlayer('p1').hand.length, 8) - assert.equal(game.getPlayer('p1').library.length, 2) - - game.endTurn('p1') - - assert.equal(game.turn, 2) - assert.equal(game.activePlayer, 'p2') - assert.equal(game.getPlayer('p2').hand.length, 8) - assert.equal(game.getPlayer('p1').hand.length, 7) -}) - -test('mulligans draw a new seven and bottom one more card each time', () => { - const game = new Game({ - seed: 3, - startingHandSize: 7, - mulligans: true, - players: [ - { id: 'p1', deck: Array.from({ length: 40 }, (_, index) => card(`P1 Card ${index}`)) }, - { id: 'p2', deck: Array.from({ length: 40 }, (_, index) => card(`P2 Card ${index}`)) }, - ], - }) - game.start() - - assert.equal(game.status, 'mulligan') - assert.equal(game.getPlayer('p1').hand.length, 7) - game.keepHand('p2') - - game.mulligan('p1') - assert.equal(game.getPlayer('p1').hand.length, 7) - assert.equal(game.mulligans.get('p1')?.count, 1) - assert.equal(game.mulligans.get('p1')?.bottom, 0) - - game.mulligan('p1') - assert.equal(game.mulligans.get('p1')?.count, 2) - assert.equal(game.mulligans.get('p1')?.bottom, 1) - assert.throws(() => game.keepHand('p1'), /bottom/) - - const bottomCard = game.getPlayer('p1').hand[0] - game.putOnBottom('p1', bottomCard) - assert.equal(game.getPlayer('p1').hand.length, 6) - assert.equal(game.getPlayer('p1').library.at(-1), bottomCard) - assert.equal(game.mulligans.get('p1')?.bottom, 0) - - game.mulligan('p1') - assert.equal(game.mulligans.get('p1')?.count, 3) - assert.equal(game.mulligans.get('p1')?.bottom, 2) - for (const cardId of [...game.getPlayer('p1').hand.slice(0, 2)]) game.putOnBottom('p1', cardId) - assert.equal(game.getPlayer('p1').hand.length, 5) - - game.keepHand('p1') - assert.equal(game.status, 'active') - assert.equal(game.turn, 1) - assert.equal(game.step, 'main') - assert.equal(game.getPlayer('p1').hand.length, 6) -}) - -test('passing priority twice advances from the main phase into combat', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - - game.pass('p1') - assert.equal(game.priority, 'p2') - game.pass('p2') - - assert.equal(game.phase, 'combat') - assert.equal(game.step, 'declare_attackers') - assert.equal(game.priority, 'p1') -}) - -test('a spell goes on the stack, auto-taps mana, and resolves its compiled effect', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const mountain = game.addCard('p1', land('Mountain', 'R'), 'battlefield') - const bolt = game.addCard('p1', spell('Lightning Bolt', [ - { op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } }, - ], '{R}'), 'hand') - - game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] }) - - assert.equal(game.stack.length, 1) - assert.equal(mountain.tapped, true) - assert.equal(game.priority, 'p2') - - game.resolveStack() - - assert.equal(game.stack.length, 0) - assert.equal(game.getPlayer('p2').life, 37) - assert.ok(game.getPlayer('p1').graveyard.includes(bolt.id)) -}) - -test('permanents can be repositioned by their controller and positions are cleared on zone changes', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield') - - game.movePermanent('p1', bear.id, 0.25, 0.75) - assert.deepEqual(bear.position, { x: 0.25, y: 0.75 }) - - game.movePermanent('p1', bear.id, -1, 2) - assert.deepEqual(bear.position, { x: 0, y: 1 }) - assert.throws(() => game.movePermanent('p2', bear.id, 0.5, 0.5), /control/) - - game.moveToZone(bear, 'graveyard') - assert.equal(bear.position, undefined) -}) - -test('hideaway exiles a card and its linked ability plays it for free once the condition is met', () => { - const hideawayLand = card('Hideaway Test', { - typeLine: 'Land', - abilities: [ - { - kind: 'triggered', - event: { kind: 'enters', subject: { kind: 'self' } }, - effects: [{ op: 'hideaway', amount: { kind: 'number', value: 4 } }], - optional: false, - text: 'Hideaway 4', - }, - { - kind: 'activated', - costs: [], - effects: [{ - op: 'conditional', - condition: { kind: 'total_power', controller: 'you', atLeast: 10 }, - effects: [{ op: 'play_exiled', player: 'you', free: true }], - }], - optional: false, - text: 'Play the exiled card without paying its mana cost if creatures you control have total power 10 or greater.', - }, - ], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const hidden = game.addCard('p1', creature('Hidden Bear', 2, 2), 'library') - for (const name of ['Filler One', 'Filler Two', 'Filler Three']) { - game.addCard('p1', creature(name, 1, 1), 'library') - } - const library = game.getPlayer('p1').library - library.splice(library.indexOf(hidden.id), 1) - library.unshift(hidden.id) - const land = game.addCard('p1', hideawayLand, 'hand') - - game.playLand('p1', land.id) - game.resolveStack() - - assert.equal(game.pendingChoice?.what, 'hideaway') - assert.equal(game.pendingChoice?.playerId, 'p1') - assert.equal(game.pendingChoice?.cardIds?.length, 4) - assert.ok(game.pendingChoice?.cardIds?.includes(hidden.id)) - assert.throws(() => game.chooseHideawayCard('p2', hidden.id), GameError) - const looked = [...game.getPlayer('p1').library.slice(0, 4)] - game.chooseHideawayCard('p1', hidden.id) - assert.equal(game.pendingChoice, undefined) - - assert.equal(hidden.zone, 'exile') - assert.equal(hidden.faceDown, true) - assert.deepEqual(land.linkedExile, [hidden.id]) - assert.deepEqual( - game.getPlayer('p1').library.slice(-3).sort(), - looked.filter(id => id !== hidden.id).sort(), - ) - - game.activateAbility('p1', land.id, 1) - game.resolveStack() - assert.equal(hidden.zone, 'exile') - - game.addCard('p1', creature('Big Bear', 10, 10), 'battlefield') - game.activateAbility('p1', land.id, 1) - game.resolveStack() - - assert.equal(hidden.zone, 'battlefield') - assert.equal(hidden.faceDown, undefined) - assert.ok(game.getPlayer('p1').battlefield.includes(hidden.id)) -}) - -test('playing a card hidden by hideaway uses the land drop', () => { - const hideawayLand = card('Hideaway Land', { - typeLine: 'Land', - abilities: [ - { - kind: 'triggered', - event: { kind: 'enters', subject: { kind: 'self' } }, - effects: [{ op: 'hideaway', amount: { kind: 'number', value: 1 } }], - optional: false, - text: 'Hideaway 1', - }, - { - kind: 'activated', - costs: [], - effects: [{ - op: 'conditional', - condition: { kind: 'total_power', controller: 'you', atLeast: 0 }, - effects: [{ op: 'play_exiled', player: 'you', free: true }], - }], - optional: false, - text: 'Play the exiled card without paying its mana cost.', - }, - ], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const hidden = game.addCard('p1', land('Island', 'U'), 'library') - const library = game.getPlayer('p1').library - library.splice(library.indexOf(hidden.id), 1) - library.unshift(hidden.id) - const source = game.addCard('p1', hideawayLand, 'hand') - - game.playLand('p1', source.id) - game.resolveStack() - assert.equal(hidden.zone, 'exile') - assert.equal(hidden.faceDown, true) - - game.getPlayer('p1').landPlayedThisTurn = true - game.activateAbility('p1', source.id, 1) - game.resolveStack() - assert.equal(hidden.zone, 'exile') - - game.getPlayer('p1').landPlayedThisTurn = false - game.activateAbility('p1', source.id, 1) - game.resolveStack() - assert.equal(hidden.zone, 'battlefield') - assert.equal(game.getPlayer('p1').landPlayedThisTurn, true) -}) - -test('enters triggers from compiled card code fire and resolve through the stack', () => { - const soulWarden = card('Soul Warden', { - typeLine: 'Creature — Human Cleric', - power: 1, - toughness: 1, - colors: ['W'], - abilities: [{ - kind: 'triggered', - event: { - kind: 'enters', - subject: { kind: 'object', selector: { other: true, types: ['creature'] }, mode: 'each' }, - }, - effects: [{ op: 'life', player: 'you', amount: { kind: 'number', value: 1 }, mode: 'gain' }], - optional: false, - text: 'Whenever another creature enters, you gain 1 life.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - game.addCard('p1', soulWarden, 'battlefield') - const elves = game.addCard('p1', creature('Llanowar Elves', 1, 1), 'hand') - - game.castSpell('p1', elves.id) - game.resolveStack() - - assert.equal(game.getPlayer('p1').life, 41) - assert.ok(game.getPlayer('p1').battlefield.includes(elves.id)) -}) - -test('activated mana abilities produce mana and creatures have summoning sickness', () => { - const solRing = card('Sol Ring', { - typeLine: 'Artifact', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{C}', '{C}'] } }], - optional: false, - text: '{T}: Add {C}{C}.', - }], - }) - const game = setup([{ id: 'p1', deck: Array.from({ length: 5 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 5 }, () => card('Filler')) }]) - game.start() - const ring = game.addCard('p1', solRing, 'battlefield') - const elves = game.addCard('p1', creature('Llanowar Elves', 1, 1, [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{G}'] } }], - optional: false, - text: '{T}: Add {G}.', - }]), 'battlefield') - - game.activateAbility('p1', ring.id, 0) - assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 2 }) - assert.equal(ring.tapped, true) - assert.throws(() => game.activateAbility('p1', elves.id, 0), GameError) - - game.endTurn('p1') - game.endTurn('p2') - assert.equal(elves.tapped, false) - game.activateAbility('p1', elves.id, 0) - assert.equal(game.getPlayer('p1').manaPool.G, 1) -}) - -test('Exotic Orchard is limited to colors an opponent land could produce', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const orchard = game.addCard('p1', exoticOrchard(), 'battlefield') - game.addCard('p2', land('Forest', 'G'), 'battlefield') - const green = game.addCard('p1', spell('Green Spell', [], '{G}'), 'hand') - const blue = game.addCard('p1', spell('Blue Spell', [], '{U}'), 'hand') - - assert.equal(game.canPlayCard('p1', green.id), true) - assert.equal(game.canPlayCard('p1', blue.id), false) - assert.throws(() => game.castSpell('p1', blue.id), GameError) - assert.equal(orchard.tapped, false) - assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 }) - - game.castSpell('p1', green.id) - assert.equal(orchard.tapped, true) - assert.equal(game.getPlayer('p1').manaPool.G, 0) -}) - -test('Exotic Orchard adds an opponent land color when activated manually', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const orchard = game.addCard('p1', exoticOrchard(), 'battlefield') - game.addCard('p2', land('Island', 'U'), 'battlefield') - - game.activateAbility('p1', orchard.id, 0) - assert.equal(game.getPlayer('p1').manaPool.U, 1) - assert.equal(game.getPlayer('p1').manaPool.W, 0) -}) - -test('Exotic Orchard produces nothing without an opponent land', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const orchard = game.addCard('p1', exoticOrchard(), 'battlefield') - - game.activateAbility('p1', orchard.id, 0) - assert.equal(orchard.tapped, true) - assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 }) -}) - -test('a mana ability that makes one of several colors uses the chosen color', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const dual = game.addCard('p1', card('Dual Land', { - typeLine: 'Land', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{W}', '{U}'], oneOf: true } }], - optional: false, - text: '{T}: Add {W} or {U}.', - }], - }), 'battlefield') - - assert.deepEqual(game.manaColorChoices(dual, 0), ['W', 'U']) - game.activateAbility('p1', dual.id, 0, { manaColor: 'U' }) - assert.equal(game.getPlayer('p1').manaPool.U, 1) - assert.equal(game.getPlayer('p1').manaPool.W, 0) -}) - -test('a mana color the ability cannot make is rejected before tapping', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const mono = game.addCard('p1', land('Mono Land', 'W'), 'battlefield') - - assert.throws(() => game.activateAbility('p1', mono.id, 0, { manaColor: 'G' }), GameError) - assert.equal(mono.tapped, false) - assert.equal(game.getPlayer('p1').manaPool.G, 0) -}) - -test('an any-color mana source produces the chosen color and offers all five', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const rainbow = game.addCard('p1', card('Rainbow Land', { - typeLine: 'Land', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: false } }], - optional: false, - text: '{T}: Add one mana of any color.', - }], - }), 'battlefield') - - assert.deepEqual(game.manaColorChoices(rainbow, 0), ['W', 'U', 'B', 'R', 'G']) - game.activateAbility('p1', rainbow.id, 0, { manaColor: 'R' }) - assert.equal(game.getPlayer('p1').manaPool.R, 1) -}) - -test('a restricted mana source is used before an unrestricted one', () => { - const rainbow = card('Rainbow Land', { - typeLine: 'Land', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: false } }], - optional: false, - text: '{T}: Add one mana of any color.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const rainbowLand = game.addCard('p1', rainbow, 'battlefield') - const orchard = game.addCard('p1', exoticOrchard(), 'battlefield') - game.addCard('p2', land('Forest', 'G'), 'battlefield') - const gold = game.addCard('p1', spell('Gold Spell', [], '{G}{U}'), 'hand') - - assert.equal(game.canPlayCard('p1', gold.id), true) - game.castSpell('p1', gold.id) - assert.equal(orchard.tapped, true) - assert.equal(rainbowLand.tapped, true) - assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 }) -}) - -test('static pump effects apply to matching creatures only', () => { - const anthem = card('Glorious Anthem', { - typeLine: 'Enchantment', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'static', - effects: [{ - op: 'pump', - target: { kind: 'object', selector: { controller: 'you', types: ['creature'] }, mode: 'each' }, - power: { kind: 'number', value: 1 }, - toughness: { kind: 'number', value: 1 }, - }], - text: 'Creatures you control get +1/+1.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const anthemObject = game.addCard('p1', anthem, 'battlefield') - const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield') - const enemy = game.addCard('p2', creature('Enemy Bear', 2, 2), 'battlefield') - - assert.equal(game.getPower(bear), 3) - assert.equal(game.getToughness(bear), 3) - assert.equal(game.getPower(enemy), 2) - assert.equal(game.getPower(anthemObject), 0) -}) - -test('temporary pump effects expire at end of turn', () => { - const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) - game.start() - const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield') - const growth = game.addCard('p1', spell('Giant Growth', [{ - op: 'pump', - target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }, - power: { kind: 'number', value: 3 }, - toughness: { kind: 'number', value: 3 }, - duration: 'until_end_of_turn', - }]), 'hand') - - game.castSpell('p1', growth.id, { targets: [{ kind: 'object', id: bear.id }] }) - game.resolveStack() - assert.equal(game.getPower(bear), 5) - assert.equal(game.getToughness(bear), 5) - - game.endTurn('p1') - assert.equal(game.getPower(bear), 2) -}) - -test('the engine exposes legal creature targets for a card', () => { - const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) - game.start() - const bear = game.addCard('p2', creature('Grizzly Bears', 2, 2), 'battlefield') - const growth = game.addCard('p1', spell('Giant Growth', [{ - op: 'pump', - target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }, - power: { kind: 'number', value: 3 }, - toughness: { kind: 'number', value: 3 }, - duration: 'until_end_of_turn', - }]), 'hand') - - assert.deepEqual(game.legalTargetsForCard('p1', growth.id), [{ kind: 'object', id: bear.id }]) -}) - -test('excluded colors filter legal targets', () => { - const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) - game.start() - game.addCard('p2', card('Black Bear', { typeLine: 'Creature — Bear', colors: ['B'], power: 2, toughness: 2 }), 'battlefield') - const green = game.addCard('p2', card('Green Bear', { typeLine: 'Creature — Bear', colors: ['G'], power: 2, toughness: 2 }), 'battlefield') - const doomBlade = game.addCard('p1', spell('Doom Blade', [{ - op: 'destroy', - target: { kind: 'object', selector: { types: ['creature'], excludeColors: ['B'] }, mode: 'target' }, - }]), 'hand') - - assert.deepEqual(game.legalTargetsForCard('p1', doomBlade.id), [{ kind: 'object', id: green.id }]) -}) - -test('the engine exposes legal targets for an activated ability', () => { - const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) - game.start() - const bear = game.addCard('p2', creature('Grizzly Bears', 2, 2), 'battlefield') - const pinger = game.addCard('p1', card('Pinger', { - typeLine: 'Creature — Test', - power: 1, - toughness: 1, - abilities: [{ - kind: 'activated', - costs: [], - optional: false, - text: '{T}: This creature deals 1 damage to target creature an opponent controls.', - effects: [{ - op: 'damage', - target: { kind: 'object', selector: { controller: 'opponent', types: ['creature'] }, mode: 'target' }, - amount: { kind: 'number', value: 1 }, - }], - }], - }), 'battlefield') - - assert.deepEqual(game.legalTargetsForAbility('p1', pinger.id, 0), [{ kind: 'object', id: bear.id }]) -}) - -test('"until the end of your next turn" lasts through the controller next turn', () => { - const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }]) - game.start() - const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield') - const growth = game.addCard('p1', spell('Growth', [{ - op: 'pump', - target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' }, - power: { kind: 'number', value: 3 }, - toughness: { kind: 'number', value: 3 }, - duration: 'until_end_of_your_next_turn', - }]), 'hand') - - game.castSpell('p1', growth.id, { targets: [{ kind: 'object', id: bear.id }] }) - game.resolveStack() - assert.equal(game.getPower(bear), 5) - - game.endTurn('p1') - assert.equal(game.getPower(bear), 5) - - game.endTurn('p2') - assert.equal(game.getPower(bear), 5) - - game.endTurn('p1') - assert.equal(game.getPower(bear), 2) -}) - -test('combat damage kills creatures and moves them to the graveyard', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - const attacker = game.addCard('p1', creature('Attacker', 2, 2), 'battlefield') - const blocker = game.addCard('p2', creature('Blocker', 2, 2), 'battlefield') - game.start() - - game.declareAttackers('p1', [{ attackerId: attacker.id, defenderId: 'p2' }]) - assert.equal(game.step, 'declare_blockers') - assert.equal(game.priority, 'p2') - assert.equal(attacker.tapped, true) - - game.declareBlockers('p2', [{ blockerId: blocker.id, attackerId: attacker.id }]) - game.resolveCombatDamage() - - assert.equal(game.getPlayer('p2').life, 40) - assert.equal(game.step, 'end_combat') - assert.ok(game.getPlayer('p1').graveyard.includes(attacker.id)) - assert.ok(game.getPlayer('p2').graveyard.includes(blocker.id)) -}) - -test('unblocked attackers deal damage to the defending player', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - const attacker = game.addCard('p1', creature('Attacker', 3, 3), 'battlefield') - game.start() - - game.declareAttackers('p1', [{ attackerId: attacker.id, defenderId: 'p2' }]) - game.declareBlockers('p2', []) - game.resolveCombatDamage() - - assert.equal(game.getPlayer('p2').life, 37) -}) - -test('counterspell counters a spell on the stack', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - game.addCard('p1', land('Mountain', 'R'), 'battlefield') - game.addCard('p2', land('Island', 'U'), 'battlefield') - game.addCard('p2', land('Island', 'U'), 'battlefield') - const bolt = game.addCard('p1', spell('Lightning Bolt', [ - { op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } }, - ], '{R}'), 'hand') - const counterspell = game.addCard('p2', spell('Counterspell', [ - { op: 'counter', what: 'spell', target: { kind: 'spell', selector: { types: [] }, mode: 'target' } }, - ], '{U}{U}'), 'hand') - - game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] }) - game.castSpell('p2', counterspell.id) - assert.equal(game.stack.length, 2) - - game.resolveStack() - - assert.equal(game.getPlayer('p2').life, 40) - assert.equal(game.stack.length, 0) - assert.ok(game.getPlayer('p1').graveyard.includes(bolt.id)) - assert.ok(game.getPlayer('p2').graveyard.includes(counterspell.id)) -}) - -test('activated abilities create tokens that enter the battlefield', () => { - const maker = card('Goblin Maker', { - typeLine: 'Artifact', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ - op: 'create_token', - player: 'you', - amount: { kind: 'number', value: 1 }, - token: { name: 'Goblin', types: ['creature'], subtypes: ['goblin'], colors: ['R'], power: { kind: 'number', value: 1 }, toughness: { kind: 'number', value: 1 } }, - }], - optional: false, - text: '{T}: Create a 1/1 Goblin.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const source = game.addCard('p1', maker, 'battlefield') - - game.activateAbility('p1', source.id, 0) - assert.equal(game.stack.length, 1) - game.resolveStack() - - const tokens = game.getPlayer('p1').battlefield.map(id => game.getObject(id)).filter(object => object.isToken) - assert.equal(tokens.length, 1) - assert.equal(tokens[0].definition.name, 'Goblin') - assert.equal(game.getPower(tokens[0]), 1) -}) - -test('token doublers stack and only apply to their controller', () => { - const goblin: TokenSpec = { - types: ['creature'], - subtypes: ['goblin'], - colors: ['R'], - power: { kind: 'number', value: 1 }, - toughness: { kind: 'number', value: 1 }, - } - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const p1Maker = game.addCard('p1', tokenMaker('P1 Maker', goblin), 'battlefield') - game.addCard('p1', tokenDoubler('Parallel Lives', 2), 'battlefield') - game.addCard('p1', tokenDoubler('Anointed Procession', 2), 'battlefield') - const p2Maker = game.addCard('p2', tokenMaker('P2 Maker', goblin), 'battlefield') - game.addCard('p2', tokenDoubler('Adrix and Nev', 2), 'battlefield') - const tokensOf = (playerId: string): number => game.getPlayer(playerId).battlefield - .map(id => game.getObject(id)).filter(object => object.isToken).length - - game.activateAbility('p1', p1Maker.id, 0) - game.resolveStack() - assert.equal(tokensOf('p1'), 4) - assert.equal(tokensOf('p2'), 0) - - game.endTurn('p1') - game.activateAbility('p2', p2Maker.id, 0) - game.resolveStack() - assert.equal(tokensOf('p2'), 2) -}) - -test('Primal Vigor doubles tokens for every player', () => { - const goblin: TokenSpec = { - types: ['creature'], - subtypes: ['goblin'], - colors: ['R'], - power: { kind: 'number', value: 1 }, - toughness: { kind: 'number', value: 1 }, - } - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const p1Maker = game.addCard('p1', tokenMaker('P1 Maker', goblin), 'battlefield') - game.addCard('p1', tokenDoubler('Primal Vigor', 2, 'each_player'), 'battlefield') - const p2Maker = game.addCard('p2', tokenMaker('P2 Maker', goblin), 'battlefield') - const tokensOf = (playerId: string): number => game.getPlayer(playerId).battlefield - .map(id => game.getObject(id)).filter(object => object.isToken).length - - game.activateAbility('p1', p1Maker.id, 0) - game.resolveStack() - assert.equal(tokensOf('p1'), 2) - - game.endTurn('p1') - game.activateAbility('p2', p2Maker.id, 0) - game.resolveStack() - assert.equal(tokensOf('p2'), 2) -}) - -test('Ojer Taq triples creature tokens but not other tokens', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const creatureMaker = game.addCard('p1', tokenMaker('Creature Maker', { - types: ['creature'], - subtypes: ['goblin'], - colors: ['R'], - power: { kind: 'number', value: 1 }, - toughness: { kind: 'number', value: 1 }, - }), 'battlefield') - const treasureMaker = game.addCard('p1', tokenMaker('Treasure Maker', { - types: ['artifact'], subtypes: ['treasure'], colors: [], - }), 'battlefield') - game.addCard('p1', tokenDoubler('Ojer Taq', 3, 'you', true), 'battlefield') - - game.activateAbility('p1', creatureMaker.id, 0) - game.resolveStack() - game.activateAbility('p1', treasureMaker.id, 0) - game.resolveStack() - - const tokens = game.getPlayer('p1').battlefield.map(id => game.getObject(id)).filter(object => object.isToken) - assert.equal(tokens.filter(object => object.definition.typeLine.toLowerCase().includes('creature')).length, 3) - assert.equal(tokens.filter(object => object.definition.typeLine.toLowerCase().includes('treasure')).length, 1) -}) - -test('search effects find cards in the library and put them onto the battlefield tapped', () => { - const forest = land('Forest', 'G') - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const found = game.addCard('p1', forest, 'library') - const rampantGrowth = game.addCard('p1', spell('Rampant Growth', [{ - op: 'search', - player: 'you', - selector: { types: ['land'], supertypes: ['basic'] }, - amount: { kind: 'number', value: 1 }, - destination: 'battlefield', - tapped: true, - shuffle: true, - }]), 'hand') - - game.castSpell('p1', rampantGrowth.id) - game.resolveStack() - - assert.ok(game.getPlayer('p1').battlefield.includes(found.id)) - assert.equal(found.tapped, true) -}) - -test('search effects let the player pick among multiple matching cards', () => { - const forest = land('Forest', 'G') - const island = land('Island', 'U') - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const forestObject = game.addCard('p1', forest, 'library') - const islandObject = game.addCard('p1', island, 'library') - const rampantGrowth = game.addCard('p1', spell('Rampant Growth', [{ - op: 'search', - player: 'you', - selector: { types: ['land'], supertypes: ['basic'] }, - amount: { kind: 'number', value: 1 }, - destination: 'battlefield', - tapped: true, - shuffle: true, - }]), 'hand') - - game.castSpell('p1', rampantGrowth.id) - game.resolveStack() - - assert.equal(game.pendingSearch?.playerId, 'p1') - assert.deepEqual( - game.searchCandidates('p1').map(object => object.id).sort(), - [forestObject.id, islandObject.id].sort(), - ) - assert.equal(forestObject.zone, 'library') - assert.throws(() => game.pass('p1'), GameError) - - game.chooseSearchCard('p1', islandObject.id) - - assert.equal(game.pendingSearch, undefined) - assert.ok(game.getPlayer('p1').battlefield.includes(islandObject.id)) - assert.equal(islandObject.tapped, true) - assert.ok(game.getPlayer('p1').library.includes(forestObject.id)) -}) - -test('a search that shuffles and puts the chosen card on top leaves it on top', () => { - const bear = creature('Bear', 2, 2) - const elf = creature('Elf', 1, 1) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const bearObject = game.addCard('p1', bear, 'library') - const elfObject = game.addCard('p1', elf, 'library') - const worldlyTutor = game.addCard('p1', spell('Worldly Tutor', [{ - op: 'search', - player: 'you', - selector: { types: ['creature'] }, - amount: { kind: 'number', value: 1 }, - destination: 'top', - tapped: false, - shuffle: true, - }]), 'hand') - - game.castSpell('p1', worldlyTutor.id) - game.resolveStack() - assert.equal(game.pendingSearch?.playerId, 'p1') - - game.chooseSearchCard('p1', elfObject.id) - - assert.equal(game.getPlayer('p1').library[0], elfObject.id) - assert.ok(game.getPlayer('p1').library.includes(bearObject.id)) -}) - -test('as-enters creature type choices pause until the controller picks', () => { - const cavern = card('Cavern of Souls', { - typeLine: 'Land', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'static', - effects: [{ op: 'choose', what: 'creature_type' }], - text: 'As this enters, choose a creature type.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const object = game.addCard('p1', cavern, 'hand') - game.playLand('p1', object.id) - - assert.equal(game.pendingChoice?.sourceId, object.id) - assert.equal(game.pendingChoice?.playerId, 'p1') - assert.throws(() => game.pass('p1'), GameError) - assert.throws(() => game.chooseCreatureType('p2', 'Elf'), GameError) - assert.throws(() => game.chooseCreatureType('p1', 'Not A Type'), GameError) - - game.chooseCreatureType('p1', 'elf') - assert.equal(object.chosenCreatureType, 'Elf') - assert.equal(game.pendingChoice, undefined) - - game.moveToZone(object, 'graveyard') - assert.equal(object.chosenCreatureType, undefined) - game.moveToZone(object, 'battlefield', { silent: false }) - assert.equal(game.pendingChoice?.sourceId, object.id) -}) - -test('a split search sends the first pick to the battlefield and the next to hand', () => { - const forest = land('Forest', 'G') - const island = land('Island', 'U') - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const forestObject = game.addCard('p1', forest, 'library') - const islandObject = game.addCard('p1', island, 'library') - const cultivate = game.addCard('p1', spell('Cultivate', [{ - op: 'search', - player: 'you', - selector: { types: ['land'], supertypes: ['basic'] }, - amount: { kind: 'number', value: 2 }, - destination: 'battlefield', - tapped: true, - shuffle: true, - split: { destination: 'hand', tapped: false }, - }]), 'hand') - - game.castSpell('p1', cultivate.id) - game.resolveStack() - - game.chooseSearchCard('p1', islandObject.id) - assert.equal(game.pendingSearch?.destination, 'hand') - game.chooseSearchCard('p1', forestObject.id) - - assert.equal(game.pendingSearch, undefined) - assert.ok(game.getPlayer('p1').battlefield.includes(islandObject.id)) - assert.equal(islandObject.tapped, true) - assert.ok(game.getPlayer('p1').hand.includes(forestObject.id)) -}) - -test('autoAdvance stops instead of passing while a search needs a pick', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - game.addCard('p1', land('Forest', 'G'), 'library') - game.addCard('p1', land('Island', 'U'), 'library') - const rampantGrowth = game.addCard('p1', spell('Rampant Growth', [{ - op: 'search', - player: 'you', - selector: { types: ['land'], supertypes: ['basic'] }, - amount: { kind: 'number', value: 1 }, - destination: 'battlefield', - tapped: true, - shuffle: true, - }]), 'hand') - - game.castSpell('p1', rampantGrowth.id) - game.autoAdvance() - - assert.equal(game.pendingSearch?.playerId, 'p1') - assert.equal(game.priority, 'p1') -}) - -test('static replacement effects make permanents enter tapped with counters', () => { - const slow = creature('Slow Bear', 2, 2, [{ - kind: 'static', - effects: [{ op: 'enters_tapped', target: { kind: 'self' } }], - text: 'This enters tapped.', - }, { - kind: 'static', - effects: [{ - op: 'enters_with_counters', - target: { kind: 'self' }, - counter: '+1/+1', - amount: { kind: 'number', value: 1 }, - }], - text: 'This enters with a +1/+1 counter.', - }]) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const bear = game.addCard('p1', slow, 'hand') - - game.castSpell('p1', bear.id) - game.resolveStack() - - assert.equal(bear.tapped, true) - assert.equal(bear.counters['+1/+1'], 1) - assert.equal(game.getPower(bear), 3) - assert.equal(game.getToughness(bear), 3) -}) - -function shockLand(): CardDefinition { - return card('Steam Vents', { - typeLine: 'Land — Island Mountain', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'static', - effects: [{ op: 'enters_tapped', target: { kind: 'self' }, unlessCost: { kind: 'pay_life', amount: { kind: 'number', value: 2 } } }], - text: "As this land enters, you may pay 2 life. If you don't, it enters tapped.", - }, { - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{U}', '{R}'], oneOf: true } }], - optional: false, - text: '{T}: Add {U} or {R}.', - }], - }) -} - -test('a land can pay life to enter untapped or enter tapped', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const vents = game.addCard('p1', shockLand(), 'hand') - game.playLand('p1', vents.id) - - assert.equal(vents.tapped, false) - assert.equal(game.pendingChoice?.what, 'pay_cost') - assert.equal(game.pendingChoice?.amount, 2) - assert.throws(() => game.chooseCostPayment('p2', true), GameError) - - game.chooseCostPayment('p1', true) - assert.equal(game.getPlayer('p1').life, 38) - assert.equal(vents.tapped, false) - assert.equal(game.pendingChoice, undefined) - - const second = game.addCard('p1', shockLand(), 'hand') - game.moveToZone(second, 'battlefield', { controller: 'p1', silent: false }) - assert.equal(game.pendingChoice?.what, 'pay_cost') - - game.chooseCostPayment('p1', false) - assert.equal(second.tapped, true) - assert.equal(game.getPlayer('p1').life, 38) -}) - -test('a choice mana ability adds only the color the spell needs', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const vents = game.addCard('p1', shockLand(), 'battlefield') - const red = game.addCard('p1', spell('Red Spell', [], '{R}'), 'hand') - - game.castSpell('p1', red.id) - - assert.equal(vents.tapped, true) - assert.equal(game.getPlayer('p1').manaPool.R, 0) - assert.equal(game.getPlayer('p1').manaPool.U, 0) -}) - -test('a player who runs out of cards loses and the last player wins', () => { - const game = new Game({ - seed: 3, - startingHandSize: 0, - players: [ - { id: 'p1', deck: [card('Filler')] }, - { id: 'p2', deck: [] }, - ], - }) - game.start() - game.endTurn('p1') - - assert.equal(game.status, 'finished') - assert.equal(game.winner, 'p1') - assert.equal(game.getPlayer('p2').lost, true) -}) - -test('lethal damage to a player ends the game', () => { - const game = setup([{ id: 'p1' }, { id: 'p2', life: 3 }]) - game.start() - game.addCard('p1', land('Mountain', 'R'), 'battlefield') - const bolt = game.addCard('p1', spell('Lightning Bolt', [ - { op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } }, - ], '{R}'), 'hand') - - game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] }) - game.resolveStack() - - assert.equal(game.status, 'finished') - assert.equal(game.winner, 'p1') - assert.equal(game.getPlayer('p2').life, 0) -}) - -test('the legend rule leaves one legendary permanent per name under one controller', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const legend = card('Kiora, the Rising Tide', { - typeLine: 'Legendary Creature — Merfolk Wizard', - power: 1, - toughness: 1, - }) - const first = game.addCard('p1', legend, 'battlefield') - const second = game.addCard('p1', legend, 'battlefield') - const forest = game.addCard('p1', land('Forest', 'G'), 'hand') - - game.playLand('p1', forest.id) - - assert.equal(first.zone, 'battlefield') - assert.equal(second.zone, 'graveyard') - assert.ok(game.getPlayer('p1').graveyard.includes(second.id)) -}) - -test('the legend rule does not apply across controllers', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const legend = card('Kiora, the Rising Tide', { - typeLine: 'Legendary Creature — Merfolk Wizard', - power: 1, - toughness: 1, - }) - const mine = game.addCard('p1', legend, 'battlefield') - const theirs = game.addCard('p2', legend, 'battlefield') - const forest = game.addCard('p1', land('Forest', 'G'), 'hand') - - game.playLand('p1', forest.id) - - assert.equal(mine.zone, 'battlefield') - assert.equal(theirs.zone, 'battlefield') -}) - -test('a failed mana payment leaves mana sources untapped and the pool unchanged', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const mountain = game.addCard('p1', land('Mountain', 'R'), 'battlefield') - const expensive = game.addCard('p1', spell('Expensive Spell', [], '{R}{R}'), 'hand') - - assert.throws(() => game.castSpell('p1', expensive.id), GameError) - assert.equal(mountain.tapped, false) - assert.equal(game.getPlayer('p1').manaPool.R, 0) - assert.ok(game.getPlayer('p1').hand.includes(expensive.id)) -}) - -test('phyrexian mana can be paid with exactly enough life', () => { - const game = setup([{ id: 'p1', life: 2 }, { id: 'p2' }]) - game.start() - const spellCard = game.addCard('p1', spell('Gitaxian Probe', [], '{W/P}'), 'hand') - - assert.doesNotThrow(() => game.castSpell('p1', spellCard.id)) - assert.equal(game.getPlayer('p1').life, 0) - assert.equal(game.status, 'finished') - assert.equal(game.winner, 'p2') -}) - -test('an unless cost auto-taps the mana sources of the payer', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const bear = game.addCard('p2', creature('Grizzly Bears', 2, 2), 'battlefield') - const forests = [ - game.addCard('p2', land('Forest', 'G'), 'battlefield'), - game.addCard('p2', land('Forest', 'G'), 'battlefield'), - ] - const edict = game.addCard('p1', spell('Edict', [{ - op: 'sacrifice', - player: 'opponent', - target: { kind: 'object', selector: { types: ['creature'] } }, - unless: { kind: 'mana', symbols: '{2}' }, - }]), 'hand') - - game.castSpell('p1', edict.id, { - targets: [{ kind: 'player', id: 'p2' }, { kind: 'object', id: bear.id }], - }) - game.resolveStack() - - assert.equal(bear.zone, 'battlefield') - assert.ok(forests.every(forest => forest.tapped)) - assert.equal(game.getPlayer('p2').manaPool.G, 0) -}) - -test('canPlayCard reports legal lands and spells for the player with priority', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const forest = game.addCard('p1', land('Forest', 'G'), 'hand') - const bear = game.addCard('p1', card('Grizzly Bears', { - typeLine: 'Creature — Bear', - power: 2, - toughness: 2, - manaCost: '{G}', - }), 'hand') - - assert.equal(game.canPlayCard('p1', forest.id), true) - assert.equal(game.canPlayCard('p1', bear.id), false) - assert.equal(game.canPlayCard('p2', forest.id), false) - - game.playLand('p1', forest.id) - assert.equal(game.canPlayCard('p1', bear.id), true) -}) - -test('autoAdvance skips empty phases and stops when someone can act', () => { - const expensive = card('Expensive', { manaCost: '{5}' }) - const game = new Game({ - seed: 3, - startingHandSize: 0, - players: [ - { id: 'p1', deck: [expensive] }, - { id: 'p2', deck: [expensive] }, - ], - }) - game.start() - game.addCard('p1', land('Forest', 'G'), 'battlefield') - - // The only action is a mana ability, which should not hold the phase open. - game.autoAdvance() - assert.equal(game.turn, 2) - assert.equal(game.activePlayer, 'p2') - assert.equal(game.phase, 'precombat_main') - assert.equal(game.priority, 'p2') - - const hasty = creature('Hasty', 2, 2, [{ kind: 'keyword', keyword: 'Haste' }]) - game.addCard('p2', hasty, 'battlefield') - game.autoAdvance() - assert.equal(game.turn, 2) - assert.equal(game.phase, 'combat') - assert.equal(game.step, 'declare_attackers') - assert.equal(game.priority, 'p2') -}) - -test('every defending player declares blocks before combat damage in multiplayer', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }, { id: 'p3' }]) - game.start() - const first = game.addCard('p1', creature('First Attacker', 2, 2), 'battlefield') - const second = game.addCard('p1', creature('Second Attacker', 3, 3), 'battlefield') - first.enteredTurn = 0 - second.enteredTurn = 0 - - game.declareAttackers('p1', [ - { attackerId: first.id, defenderId: 'p2' }, - { attackerId: second.id, defenderId: 'p3' }, - ]) - assert.equal(game.step, 'declare_blockers') - - game.declareBlockers('p2', []) - assert.equal(game.step, 'declare_blockers') - assert.equal(game.priority, 'p3') - - game.declareBlockers('p3', []) - assert.equal(game.step, 'combat_damage') - - game.resolveCombatDamage() - assert.equal(game.getPlayer('p2').life, 38) - assert.equal(game.getPlayer('p3').life, 37) -}) - -test('counter-removal costs are paid and fail when counters run out', () => { - const vessel = card('Spore Vessel', { - typeLine: 'Artifact', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'activated', - costs: [{ kind: 'remove_counters', counter: 'spore', amount: { kind: 'number', value: 2 } }], - effects: [{ op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }], - optional: false, - text: 'Remove two spore counters from this: Draw a card.', - }], - }) - const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2' }]) - game.start() - const source = game.addCard('p1', vessel, 'battlefield') - source.counters.spore = 3 - - game.activateAbility('p1', source.id, 0) - game.resolveStack() - assert.equal(source.counters.spore, 1) - assert.equal(game.getPlayer('p1').hand.length, 2) - - assert.throws(() => game.activateAbility('p1', source.id, 0), GameError) - assert.equal(source.counters.spore, 1) -}) - -test('a free alternative cost needs a commander and skips the mana cost', () => { - const maneuver = card('Flawless Maneuver', { - typeLine: 'Instant', - manaCost: '{2}{W}', - manaValue: 3, - abilities: [ - { - kind: 'alternative_cost', - costs: [], - condition: { kind: 'you_control_commander' }, - text: 'If you control a commander, you may cast this spell without paying its mana cost.', - }, - { - kind: 'spell', - effects: [{ - op: 'grant', - target: { kind: 'object', selector: { controller: 'you', types: ['creature'] }, mode: 'each' }, - keyword: 'Indestructible', - duration: 'until_end_of_turn', - }], - optional: false, - text: 'Creatures you control gain indestructible until end of turn.', - }, - ], - }) - const game = new Game({ - seed: 1, - startingHandSize: 0, - commander: true, - players: [ - { id: 'p1', deck: [card('Filler')], commander: creature('Test Commander', 2, 2) }, - { id: 'p2', deck: [card('Filler')], commander: creature('Other Commander', 2, 2) }, - ], - }) - game.start() - const spell = game.addCard('p1', maneuver, 'hand') - - assert.equal(game.canPlayCard('p1', spell.id), false) - assert.throws(() => game.castSpell('p1', spell.id), GameError) - - game.moveToZone(game.getPlayer('p1').commanderId!, 'battlefield', { silent: true }) - - assert.equal(game.canPlayCard('p1', spell.id), true) - game.castSpell('p1', spell.id) - assert.equal(game.stack.length, 1) - assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 }) -}) - -test('overload pays the overload cost and widens the spell target', () => { - const rift = card('Cyclonic Rift', { - typeLine: 'Instant', - manaCost: '{U}', - manaValue: 1, - abilities: [ - { - kind: 'spell', - effects: [{ - op: 'return_to_hand', - target: { - kind: 'object', - selector: { controller: 'opponent', types: ['permanent'], excludeTypes: ['land'] }, - mode: 'target', - }, - }], - optional: false, - text: "Return target nonland permanent you don't control to its owner's hand.", - }, - { kind: 'overload', cost: '{1}{U}', text: 'Overload {1}{U}' }, - ], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const island = game.addCard('p1', land('Island', 'U'), 'battlefield') - const wastes = game.addCard('p1', land('Wastes', 'C'), 'battlefield') - const ownCreature = game.addCard('p1', creature('Own Bear', 2, 2), 'battlefield') - const theirCreature = game.addCard('p2', creature('Their Bear', 2, 2), 'battlefield') - const theirArtifact = game.addCard('p2', card('Their Rock', { - typeLine: 'Artifact', - power: undefined, - toughness: undefined, - }), 'battlefield') - const theirLand = game.addCard('p2', land('Forest', 'G'), 'battlefield') - const spell = game.addCard('p1', rift, 'hand') - - game.castSpell('p1', spell.id, { overload: true }) - - assert.equal(island.tapped, true) - assert.equal(wastes.tapped, true) - game.resolveStack() - - assert.ok(game.getPlayer('p2').hand.includes(theirCreature.id)) - assert.ok(game.getPlayer('p2').hand.includes(theirArtifact.id)) - assert.ok(game.getPlayer('p2').battlefield.includes(theirLand.id)) - assert.ok(game.getPlayer('p1').battlefield.includes(ownCreature.id)) -}) - -test('a noncreature cost increase taxes spells but not creatures', () => { - const thalia = card('Thalia, Guardian of Thraben', { - typeLine: 'Legendary Creature — Human Soldier', - power: 2, - toughness: 1, - abilities: [{ - kind: 'static', - effects: [{ op: 'cost_increase', amount: { kind: 'number', value: 1 }, spellType: 'noncreature' }], - text: 'Noncreature spells cost {1} more to cast.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - game.addCard('p1', thalia, 'battlefield') - const first = game.addCard('p1', land('Wastes', 'C'), 'battlefield') - const instant = game.addCard('p1', spell('Ponder', [ - { op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }, - ], '{1}'), 'hand') - const bears = game.addCard('p1', card('Grizzly Bears', { - typeLine: 'Creature — Bear', - power: 2, - toughness: 2, - manaCost: '{1}', - }), 'hand') - - assert.equal(game.canPlayCard('p1', instant.id), false) - assert.equal(game.canPlayCard('p1', bears.id), true) - - game.addCard('p1', land('Wastes', 'C'), 'battlefield') - assert.equal(game.canPlayCard('p1', instant.id), true) - game.castSpell('p1', instant.id) - assert.equal(first.tapped, true) -}) - -test('spell cost reductions match the spell type and controller', () => { - const baral = card('Baral, Chief of Compliance', { - typeLine: 'Legendary Creature — Human Wizard', - power: 1, - toughness: 3, - abilities: [{ - kind: 'static', - effects: [{ - op: 'cost_reduction', - target: { kind: 'object', selector: { controller: 'you', types: ['instant', 'sorcery'], match: 'any' }, mode: 'each' }, - amount: { kind: 'number', value: 1 }, - }], - text: 'Instant and sorcery spells you cast cost {1} less to cast.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - game.addCard('p1', baral, 'battlefield') - const wastes = game.addCard('p1', land('Wastes', 'C'), 'battlefield') - const sorcery = game.addCard('p1', card('Divination', { - typeLine: 'Sorcery', - manaCost: '{2}', - abilities: [{ kind: 'spell', effects: [{ op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }], optional: false, text: 'Draw a card.' }], - }), 'hand') - const bears = game.addCard('p1', card('Grizzly Bears', { - typeLine: 'Creature — Bear', - power: 2, - toughness: 2, - manaCost: '{2}', - }), 'hand') - - assert.equal(game.canPlayCard('p1', sorcery.id), true) - assert.equal(game.canPlayCard('p1', bears.id), false) - - game.castSpell('p1', sorcery.id) - assert.equal(wastes.tapped, true) -}) - -test('a colored cost reduction removes matching pips and nothing else', () => { - const edgewalker = card('Edgewalker', { - typeLine: 'Creature — Human Cleric', - power: 2, - toughness: 2, - abilities: [{ - kind: 'static', - effects: [{ - op: 'cost_reduction', - target: { kind: 'object', selector: { controller: 'you', types: ['creature'], match: 'any', subtypes: ['cleric', 'soldier'] }, mode: 'each' }, - symbols: '{W}{B}', - }], - text: 'Cleric spells you cast cost {W}{B} less to cast.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - game.addCard('p1', edgewalker, 'battlefield') - game.addCard('p1', land('Plains', 'W'), 'battlefield') - game.addCard('p1', land('Swamp', 'B'), 'battlefield') - const cleric = game.addCard('p1', card('Cleric Test', { - typeLine: 'Creature — Human Cleric', - power: 2, - toughness: 2, - colors: ['W', 'B'], - manaCost: '{1}{W}{B}', - manaValue: 3, - }), 'hand') - const soldier = game.addCard('p1', card('Soldier Test', { - typeLine: 'Creature — Human Soldier', - power: 2, - toughness: 2, - colors: ['W', 'B'], - manaCost: '{1}{W}{B}', - manaValue: 3, - }), 'hand') - const bear = game.addCard('p1', card('Bear Test', { - typeLine: 'Creature — Bear', - power: 2, - toughness: 2, - colors: ['W', 'B'], - manaCost: '{1}{W}{B}', - manaValue: 3, - }), 'hand') - - assert.equal(game.canPlayCard('p1', cleric.id), true) - assert.equal(game.canPlayCard('p1', soldier.id), true) - assert.equal(game.canPlayCard('p1', bear.id), false) - game.castSpell('p1', cleric.id) -}) - -test('Linvala stops only opponents from activating creature abilities', () => { - const linvala = card('Linvala, Keeper of Silence', { - typeLine: 'Legendary Creature — Angel', - power: 3, - toughness: 4, - abilities: [{ - kind: 'static', - effects: [{ - op: 'restriction', - target: { kind: 'object', selector: { controller: 'opponent', types: ['creature'] }, mode: 'each' }, - rule: 'cant_activate', - }], - text: "Activated abilities of creatures your opponents control can't be activated.", - }], - }) - const drawAbility = { - kind: 'activated' as const, - costs: [], - effects: [{ op: 'draw' as const, player: 'you' as const, amount: { kind: 'number' as const, value: 1 } }], - optional: false, - text: 'Draw a card.', - } - const game = setup([{ id: 'p1', deck: [card('Filler'), card('Filler')] }, { id: 'p2' }]) - game.start() - game.addCard('p1', linvala, 'battlefield') - const own = game.addCard('p1', creature('Own Cleric', 1, 1, [drawAbility]), 'battlefield') - const theirs = game.addCard('p2', creature('Their Cleric', 1, 1, [drawAbility]), 'battlefield') - - game.activateAbility('p1', own.id, 0) - assert.equal(game.stack.length, 1) - - game.resolveStack() - game.pass('p1') - assert.throws(() => game.activateAbility('p2', theirs.id, 0), /cannot activate/) -}) - -test('Aven Mindcensor limits an opponent search to the top four cards', () => { - const aven = card('Aven Mindcensor', { - typeLine: 'Creature — Bird Wizard', - power: 2, - toughness: 1, - abilities: [{ - kind: 'static', - effects: [{ op: 'search_restriction', who: 'opponent', amount: { kind: 'number', value: 4 } }], - text: 'If an opponent would search a library, that player searches the top four cards of that library instead.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2', deck: [] }]) - game.start() - game.addCard('p1', aven, 'battlefield') - for (const name of ['Forest', 'Island', 'Mountain', 'Plains', 'Swamp', 'Wastes']) { - game.addCard('p2', land(name, 'C'), 'library') - } - const topFour = game.getPlayer('p2').library.slice(0, 4) - const growth = game.addCard('p2', spell('Rampant Growth', [{ - op: 'search', - player: 'you', - selector: { types: ['land'] }, - amount: { kind: 'number', value: 1 }, - destination: 'battlefield', - shuffle: true, - }]), 'hand') - - game.pass('p1') - game.castSpell('p2', growth.id) - game.resolveStack() - - assert.deepEqual( - game.searchCandidates('p2').map(object => object.id).sort(), - [...topFour].sort(), - ) -}) - -test('Rest in Peace exiles all graveyards and replaces later graveyard moves', () => { - const rest = card('Rest in Peace', { - typeLine: 'Enchantment', - power: undefined, - toughness: undefined, - abilities: [ - { - kind: 'triggered', - event: { kind: 'enters', subject: { kind: 'self' } }, - effects: [{ op: 'exile_graveyards' }], - optional: false, - text: 'When this enchantment enters, exile all graveyards.', - }, - { - kind: 'static', - effects: [{ op: 'exile_instead_of_graveyard' }], - text: 'If a card or token would be put into a graveyard from anywhere, exile it instead.', - }, - ], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const oldSpell = game.addCard('p1', spell('Old Spell', []), 'graveyard') - const oldCreature = game.addCard('p2', creature('Old Bear', 2, 2), 'graveyard') - const doomed = game.addCard('p1', creature('Doomed Bear', 2, 2), 'battlefield') - - game.addCard('p1', rest, 'battlefield', { silent: false }) - game.resolveStack() - - assert.ok(game.getPlayer('p1').exile.includes(oldSpell.id)) - assert.ok(game.getPlayer('p2').exile.includes(oldCreature.id)) - assert.deepEqual(game.getPlayer('p1').graveyard, []) - assert.deepEqual(game.getPlayer('p2').graveyard, []) - - game.moveToZone(doomed, 'graveyard') - - assert.equal(doomed.zone, 'exile') - assert.ok(game.getPlayer('p1').exile.includes(doomed.id)) -}) - -test("Leyline of the Void exiles only opponents' cards and starts on the battlefield", () => { - const leyline = card('Leyline of the Void', { - typeLine: 'Enchantment', - power: undefined, - toughness: undefined, - abilities: [ - { - kind: 'static', - effects: [{ op: 'restriction', target: { kind: 'self' }, rule: 'begin_on_battlefield' }], - text: 'If this card is in your opening hand, you may begin the game with it on the battlefield.', - }, - { - kind: 'static', - effects: [{ op: 'exile_instead_of_graveyard', owner: 'opponent' }], - text: "If a card would be put into an opponent's graveyard from anywhere, exile it instead.", - }, - ], - }) - const game = new Game({ - seed: 3, - startingHandSize: 0, - players: [{ id: 'p1', deck: [card('Filler')] }, { id: 'p2', deck: [card('Filler')] }], - }) - const leylineObject = game.addCard('p1', leyline, 'hand') - game.start() - - assert.ok(game.getPlayer('p1').battlefield.includes(leylineObject.id)) - assert.ok(!game.getPlayer('p1').hand.includes(leylineObject.id)) - - const theirs = game.addCard('p2', creature('Their Bear', 2, 2), 'battlefield') - const own = game.addCard('p1', creature('Own Bear', 2, 2), 'battlefield') - game.moveToZone(theirs, 'graveyard') - game.moveToZone(own, 'graveyard') - - assert.equal(theirs.zone, 'exile') - assert.equal(own.zone, 'graveyard') -}) - -test('Field of the Dead makes a Zombie at seven differently named lands', () => { - const field = card('Field of the Dead', { - typeLine: 'Land', - power: undefined, - toughness: undefined, - abilities: [{ - kind: 'triggered', - event: { - kind: 'enters', - subject: { - kind: 'object', - selector: { other: true, controller: 'you', types: ['land'] }, - mode: 'each', - includeSelf: true, - }, - }, - condition: { kind: 'distinct_names', selector: { types: ['land'] }, atLeast: 7 }, - effects: [{ - op: 'create_token', - player: 'you', - amount: { kind: 'number', value: 1 }, - token: { - types: ['creature'], - subtypes: ['zombie'], - colors: ['B'], - power: { kind: 'number', value: 2 }, - toughness: { kind: 'number', value: 2 }, - }, - }], - optional: false, - text: 'Whenever this or another land you control enters, if you control seven or more lands with different names, create a 2/2 black Zombie creature token.', - }], - }) - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - game.addCard('p1', field, 'battlefield') - for (const name of ['Forest', 'Island', 'Mountain', 'Plains']) { - game.addCard('p1', land(name, 'C'), 'battlefield') - } - - game.addCard('p1', land('Swamp', 'C'), 'battlefield', { silent: false }) - game.resolveStack() - assert.equal(game.getPlayer('p1').battlefield - .map(id => game.getObject(id)).filter(object => object.isToken).length, 0) - - game.addCard('p1', land('Wastes', 'C'), 'battlefield', { silent: false }) - game.resolveStack() - - const tokens = game.getPlayer('p1').battlefield - .map(id => game.getObject(id)).filter(object => object.isToken) - assert.equal(tokens.length, 1) - assert.equal(tokens[0].definition.typeLine.toLowerCase().includes('zombie'), true) -}) - -test('predefined Treasure, Gold, Powerstone, Heartwood, and Vibranium tokens produce mana', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - - const treasure = makeToken(game, { types: ['artifact'], subtypes: ['treasure'], colors: [] }) - assert.equal(treasure.definition.name, 'Treasure') - game.activateAbility('p1', treasure.id, 0, { manaColor: 'G' }) - assert.equal(game.getPlayer('p1').manaPool.G, 1) - assert.equal(treasure.zone, 'graveyard') - - const gold = makeToken(game, { types: ['artifact'], subtypes: ['gold'], colors: [] }) - game.activateAbility('p1', gold.id, 0, { manaColor: 'R' }) - assert.equal(game.getPlayer('p1').manaPool.R, 1) - - const powerstone = makeToken(game, { types: ['artifact'], subtypes: ['powerstone'], colors: [] }) - game.activateAbility('p1', powerstone.id, 0) - assert.equal(game.getPlayer('p1').manaPool.C, 1) - - const heartwood = makeToken(game, { types: ['artifact'], subtypes: ['heartwood'], colors: [] }) - game.activateAbility('p1', heartwood.id, 0, { manaColor: 'G' }) - assert.equal(game.getPlayer('p1').manaPool.G, 2) - - const vibranium = makeToken(game, { types: ['artifact'], subtypes: ['vibranium'], colors: [] }) - assert.equal(game.hasKeyword(vibranium, 'Indestructible'), true) - game.activateAbility('p1', vibranium.id, 0) - assert.equal(game.getPlayer('p1').manaPool.C, 2) -}) - -test('predefined Food, Clue, Blood, and Shard tokens sacrifice for their effects', () => { - const game = setup([{ - id: 'p1', - deck: Array.from({ length: 6 }, (_, index) => card(`Filler ${index}`)), - }, { id: 'p2' }]) - game.start() - - const food = makeToken(game, { types: ['artifact'], subtypes: ['food'], colors: [] }) - addMana(game, 'G', 'G') - game.activateAbility('p1', food.id, 0) - game.resolveStack() - assert.equal(game.getPlayer('p1').life, 43) - assert.equal(food.zone, 'graveyard') - - game.addCard('p1', card('Discard Fodder'), 'hand') - const discard = game.getObject(game.getPlayer('p1').hand[0]) - const handAfterFood = game.getPlayer('p1').hand.length - const blood = makeToken(game, { types: ['artifact'], subtypes: ['blood'], colors: [] }) - addMana(game, 'G') - game.activateAbility('p1', blood.id, 0) - game.resolveStack() - assert.equal(discard.zone, 'graveyard') - assert.equal(game.getPlayer('p1').hand.length, handAfterFood) - - const clue = makeToken(game, { types: ['artifact'], subtypes: ['clue'], colors: [] }) - addMana(game, 'G', 'G') - game.activateAbility('p1', clue.id, 0) - game.resolveStack() - assert.equal(game.getPlayer('p1').hand.length, handAfterFood + 1) - - const shard = makeToken(game, { types: ['enchantment'], subtypes: ['shard'], colors: [] }) - addMana(game, 'G', 'G') - game.activateAbility('p1', shard.id, 0) - game.resolveStack() - assert.equal(game.getPlayer('p1').hand.length, handAfterFood + 2) -}) - -test('Walker and Incubator tokens use their predefined characteristics', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - - const walker = makeToken(game, { types: ['artifact'], subtypes: ['walker'], colors: [] }) - assert.equal(walker.definition.name, 'Walker') - assert.equal(game.getPower(walker), 2) - assert.equal(game.getToughness(walker), 2) - assert.deepEqual(walker.definition.colors, ['B']) - - const maker = game.addCard('p1', card('Incubator Maker', { - typeLine: 'Artifact', - abilities: [{ - kind: 'activated', - costs: [{ kind: 'tap' }], - effects: [{ op: 'keyword_action', action: 'incubate', amount: { kind: 'number', value: 2 } }], - optional: false, - text: '{T}: Incubate 2.', - }], - }), 'battlefield') - game.activateAbility('p1', maker.id, 0) - game.resolveStack() - - const incubator = game.getPlayer('p1').battlefield - .map(id => game.getObject(id)) - .find(object => object.isToken && object.definition.name === 'Incubator') - assert.ok(incubator) - assert.equal(incubator.counters['+1/+1'], 2) - - addMana(game, 'G', 'G') - game.activateAbility('p1', incubator.id, 0) - game.resolveStack() - assert.equal(incubator.definition.name, 'Phyrexian') - assert.equal(game.getPower(incubator), 2) - assert.equal(game.getToughness(incubator), 2) -}) - -test('predefined Map, Lander, and Mutagen tokens use their activated abilities', () => { - const mapGame = setup([{ id: 'p1', deck: [card('Filler')] }, { id: 'p2' }]) - mapGame.start() - const topCard = mapGame.addCard('p1', card('Top Card'), 'library') - const bear = mapGame.addCard('p1', creature('Bear', 2, 2), 'battlefield') - addMana(mapGame, 'G') - const map = makeToken(mapGame, { types: ['artifact'], subtypes: ['map'], colors: [] }) - mapGame.activateAbility('p1', map.id, 0, { targets: [{ kind: 'object', id: bear.id }] }) - mapGame.resolveStack() - assert.equal(bear.counters['+1/+1'], 1) - assert.equal(topCard.zone, 'graveyard') - - addMana(mapGame, 'G') - const mutagen = makeToken(mapGame, { types: ['artifact'], subtypes: ['mutagen'], colors: [] }) - mapGame.activateAbility('p1', mutagen.id, 0, { targets: [{ kind: 'object', id: bear.id }] }) - mapGame.resolveStack() - assert.equal(bear.counters['+1/+1'], 2) - - const landGame = setup([{ id: 'p1', deck: [card('Filler')] }, { id: 'p2' }]) - landGame.start() - const forest = landGame.addCard('p1', land('Forest', 'G'), 'library') - addMana(landGame, 'G', 'G') - const lander = makeToken(landGame, { types: ['artifact'], subtypes: ['lander'], colors: [] }) - landGame.activateAbility('p1', lander.id, 0) - landGame.resolveStack() - assert.equal(forest.zone, 'battlefield') - assert.equal(forest.tapped, true) -}) - -test('Junk exiles the top card and lets its controller cast it that turn', () => { - const game = setup([{ id: 'p1', deck: [card('Filler')] }, { id: 'p2' }]) - game.start() - const exiled = game.addCard('p1', spell('Top Spell', [], ''), 'library') - const junk = makeToken(game, { types: ['artifact'], subtypes: ['junk'], colors: [] }) - - game.activateAbility('p1', junk.id, 0) - game.resolveStack() - assert.equal(exiled.zone, 'exile') - assert.equal(game.canPlayCard('p1', exiled.id), true) - - game.castSpell('p1', exiled.id) - game.resolveStack() - assert.equal(exiled.zone, 'graveyard') -}) - -test('Role tokens attach to the target creature and apply their abilities', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - game.start() - const bear = game.addCard('p1', creature('Bear', 2, 2), 'battlefield') - const maker = game.addCard('p1', roleMaker('Monster'), 'battlefield') - - assert.deepEqual(game.legalTargetsForAbility('p1', maker.id, 0), [{ kind: 'object', id: bear.id }]) - game.activateAbility('p1', maker.id, 0, { targets: [{ kind: 'object', id: bear.id }] }) - game.resolveStack() - - const role = game.getPlayer('p1').battlefield - .map(id => game.getObject(id)) - .find(object => object.isToken) - assert.ok(role) - assert.equal(role.definition.name, 'Monster Role') - assert.match(role.definition.typeLine.toLowerCase(), /enchantment — aura role/) - assert.equal(role.attachedTo, bear.id) - assert.equal(game.getPower(bear), 3) - assert.equal(game.getToughness(bear), 3) - assert.equal(game.hasKeyword(bear, 'Trample'), true) -}) - -test('Young Hero Role triggers when the enchanted creature attacks with toughness 3 or less', () => { - const game = setup([{ id: 'p1' }, { id: 'p2' }]) - const bear = game.addCard('p1', creature('Bear', 2, 2), 'battlefield') - game.start() - const maker = game.addCard('p1', roleMaker('Young Hero'), 'battlefield') - game.activateAbility('p1', maker.id, 0, { targets: [{ kind: 'object', id: bear.id }] }) - game.resolveStack() - - game.declareAttackers('p1', [{ attackerId: bear.id, defenderId: 'p2' }]) - game.resolveStack() - assert.equal(bear.counters['+1/+1'], 1) - assert.equal(game.getPower(bear), 3) -}) diff --git a/backend/test/helpers.ts b/backend/test/helpers.ts new file mode 100644 index 0000000..dc00d4b --- /dev/null +++ b/backend/test/helpers.ts @@ -0,0 +1,159 @@ +import assert from 'node:assert/strict' +import test from 'node:test' +import { Game, GameError } from '../src/game/game.js' +import { compileText } from '../src/effects/compile.js' +import type { Ability, Effect, TokenSpec } from '../src/effects/types.js' +import type { CardDefinition, GameObject } from '../src/game/types.js' + +export function card(name: string, overrides: Partial = {}): CardDefinition { + return { + oracleId: name.toLowerCase().replace(/[^a-z0-9]+/g, '-'), + name, + typeLine: 'Creature — Test', + manaValue: 0, + colors: [], + abilities: [], + ...overrides, + } +} + +export function creature(name: string, power: number, toughness: number, abilities: Ability[] = []): CardDefinition { + return card(name, { typeLine: 'Creature — Test', power, toughness, abilities }) +} + +export function spell(name: string, effects: Effect[], manaCost = ''): CardDefinition { + return card(name, { typeLine: 'Instant', manaCost, manaValue: 0, abilities: [{ kind: 'spell', effects, optional: false, text: name }] }) +} + +export function land(name: string, color: string): CardDefinition { + return card(name, { + typeLine: `Basic Land — ${name}`, + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: [`{${color}}`] } }], + optional: false, + text: `{T}: Add {${color}}.`, + }], + }) +} + +export function exoticOrchard(): CardDefinition { + return card('Exotic Orchard', { + typeLine: 'Land', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ + op: 'add_mana', + player: 'you', + mana: { + kind: 'any_color', + amount: { kind: 'number', value: 1 }, + oneColor: false, + restriction: 'a land an opponent controls could produce', + }, + }], + optional: false, + text: '{T}: Add one mana of any color that a land an opponent controls could produce.', + }], + }) +} + +export function setup(players: { id: string; deck?: CardDefinition[]; life?: number }[]): Game { + const game = new Game({ + seed: 7, + startingHandSize: 0, + players: players.map(player => ({ id: player.id, life: player.life, deck: player.deck ?? [card('Filler')] })), + }) + return game +} + +export function tokenMaker(name: string, token: TokenSpec): CardDefinition { + return card(name, { + typeLine: 'Artifact', + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'create_token', player: 'you', amount: { kind: 'number', value: 1 }, token }], + optional: false, + text: '{T}: Create a token.', + }], + }) +} + +export function tokenDoubler( + name: string, + multiplier: number, + who: 'you' | 'each_player' = 'you', + creatureOnly = false, +): CardDefinition { + return card(name, { + typeLine: 'Enchantment', + abilities: [{ + kind: 'static', + effects: [{ op: 'token_multiplier', multiplier, who, ...(creatureOnly ? { creatureOnly: true } : {}) }], + text: 'Token replacement.', + }], + }) +} + +export function makeToken(game: Game, token: TokenSpec, playerId = 'p1'): GameObject { + const maker = game.addCard(playerId, tokenMaker('Token Maker', token), 'battlefield') + game.activateAbility(playerId, maker.id, 0) + game.resolveStack() + const tokens = game.getPlayer(playerId).battlefield + .map(id => game.getObject(id)) + .filter(object => object.isToken) + return tokens[tokens.length - 1] +} + +export function addMana(game: Game, ...symbols: string[]): void { + for (const symbol of symbols) { + const source = game.addCard('p1', land('Mana Land', symbol), 'battlefield') + game.activateAbility('p1', source.id, 0) + } +} + +export function roleMaker(name: string): CardDefinition { + return card(`${name} Role Maker`, { + typeLine: 'Enchantment', + abilities: [{ + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ + op: 'create_token', + player: 'you', + amount: { kind: 'number', value: 1 }, + token: { name, types: ['enchantment'], subtypes: ['aura', 'role'], colors: [] }, + attachTo: { kind: 'object', selector: { types: ['creature'], controller: 'you' }, mode: 'target' }, + }], + optional: false, + text: `{T}: Create a ${name} Role token attached to target creature you control.`, + }], + }) +} + + +export function shockLand(): CardDefinition { + return card('Steam Vents', { + typeLine: 'Land — Island Mountain', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'static', + effects: [{ op: 'enters_tapped', target: { kind: 'self' }, unlessCost: { kind: 'pay_life', amount: { kind: 'number', value: 2 } } }], + text: "As this land enters, you may pay 2 life. If you don't, it enters tapped.", + }, { + kind: 'activated', + costs: [{ kind: 'tap' }], + effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{U}', '{R}'], oneOf: true } }], + optional: false, + text: '{T}: Add {U} or {R}.', + }], + }) +} diff --git a/frontend/app/pages/games/[id].vue b/frontend/app/pages/games/[id].vue index 9523a70..6702591 100644 --- a/frontend/app/pages/games/[id].vue +++ b/frontend/app/pages/games/[id].vue @@ -98,6 +98,7 @@ interface MatchView { sourceId: string sourceName: string amount?: number + label?: string options: string[] cards?: CardView[] } @@ -1172,6 +1173,16 @@ async function chooseCreatureType(type: string) { await act({ type: 'choose_type', choice: type }) } +async function chooseColor(color: string) { + if (busy.value) return + await act({ type: 'choose_color', choice: color }) +} + +async function chooseOptional(accept: boolean) { + if (busy.value) return + await act({ type: 'choose_optional', accept }) +} + async function chooseCost(pay: boolean) { if (busy.value) return await act({ type: 'choose_cost', pay }) @@ -1901,14 +1912,18 @@ onUnmounted(() => {
-

{{ pendingChoice.what === 'pay_cost' ? 'Pay a cost' : pendingChoice.what === 'hideaway' ? 'Hideaway' : 'Choose a type' }}

+

{{ pendingChoice.what === 'pay_cost' ? 'Pay a cost' : pendingChoice.what === 'hideaway' ? 'Hideaway' : pendingChoice.what === 'color' ? 'Choose a color' : pendingChoice.what === 'optional' ? 'Optional effect' : 'Choose a type' }}

{{ playerName(pendingChoice.player) }} {{ pendingChoice.what === 'pay_cost' ? `is deciding whether to pay ${pendingCostLabel} for ${pendingChoice.sourceName}.` : pendingChoice.what === 'hideaway' ? 'is looking at the top cards of their library.' - : `is choosing a creature type for ${pendingChoice.sourceName}.` }} + : pendingChoice.what === 'color' + ? `is choosing a color for ${pendingChoice.sourceName}.` + : pendingChoice.what === 'optional' + ? `is deciding whether to use ${pendingChoice.label ?? pendingChoice.sourceName}.` + : `is choosing a creature type for ${pendingChoice.sourceName}.` }}

@@ -2049,10 +2064,12 @@ onUnmounted(() => {

{{ pendingChoice.what === 'pay_cost' ? `Pay ${pendingCostLabel}?` - : pendingChoice.what === 'hideaway' ? 'Hideaway' : 'Choose a creature type' }}

+ : pendingChoice.what === 'hideaway' ? 'Hideaway' : pendingChoice.what === 'color' ? 'Choose a color' : pendingChoice.what === 'optional' ? 'Use this effect?' : 'Choose a creature type' }}

{{ pendingChoice.what === 'hideaway' ? 'Look at the top cards of your library and exile one face down.' - : `${pendingChoice.sourceName} enters.` }}

+ : pendingChoice.what === 'optional' + ? pendingChoice.label ?? `${pendingChoice.sourceName} gives you a choice.` + : `${pendingChoice.sourceName} enters.` }}

{{ filteredChoiceOptions.length }} types {{ pendingChoice.cards?.length ?? 0 }} cards @@ -2093,6 +2110,34 @@ onUnmounted(() => {

The rest go to the bottom of your library in a random order.

+ +