Compare commits

1 Commits
master ... goal

Author SHA1 Message Date
c742d0cfa8 test 2026-11-04 17:10:22 +01:00
40 changed files with 12394 additions and 9414 deletions

View File

@@ -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<string, string>([
['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<string>): 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<string>): 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
}

View File

@@ -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)
}

View File

@@ -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
}

View File

@@ -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
}

File diff suppressed because it is too large Load Diff

View File

@@ -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],
])})`
}
}

View File

@@ -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' }

View File

@@ -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') }
}

View File

@@ -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<string, unknown> {
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,
})
}

View File

@@ -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
// ---------------------------------------------------------------------------

View File

@@ -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<T extends TriggerEvent>(kind: T['kind'], fields: Omit<T, 'kind'>): T {
return { kind, ...fields } as T
}
export function createWhen(): Record<string, unknown> {
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<string, unknown> = Object.create(null) as Record<string, unknown>
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<T extends Condition>(kind: T['kind'], fields: Omit<T, 'kind'> = {} as Omit<T, 'kind'>): 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') })
}

View File

@@ -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
// ---------------------------------------------------------------------------

View File

@@ -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
// ---------------------------------------------------------------------------

View File

@@ -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<PlayerRef>([
'you',
'opponent',
'each_opponent',
'each_player',
'target_player',
'that_player',
'its_controller',
'its_owner',
])
export const DURATIONS = new Set<Duration>([
'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<Zone>(['battlefield', 'hand', 'graveyard', 'library', 'exile', 'stack', 'command'])
export const SEARCH_DESTINATIONS = new Set<SearchDestination>(['hand', 'battlefield', 'graveyard', 'top', 'bottom'])
export const COLOR_CODES: Record<string, string> = {
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<string>, label: string, key = 'kind'): Record<string, unknown> {
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<string, unknown> {
return value !== null && typeof value === 'object' && !Array.isArray(value)
}
export function asRecord(value: unknown, label: string): Record<string, unknown> {
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<string, unknown> {
if (value === undefined || value === null) return Object.create(null) as Record<string, unknown>
return asRecord(value, 'options')
}
// ---------------------------------------------------------------------------
// Selectors
// ---------------------------------------------------------------------------
export class Selector {
readonly fields: ObjectSelector
constructor(fields: ObjectSelector = {}) {
this.fields = fields
}
private with(patch: Partial<ObjectSelector>): 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
// ---------------------------------------------------------------------------

View File

@@ -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<Extract<Target, { kind: 'object' }>, '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
// ---------------------------------------------------------------------------

File diff suppressed because it is too large Load Diff

View File

@@ -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
}
| {

View File

@@ -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' }> => 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' }> => 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<Ability, { kind: 'alternative_cost' }> | undefined {
return (object.definition.abilities ?? []).find(ability =>
ability.kind === 'alternative_cost'
&& (!ability.condition || this.checkCondition(ability.condition, object))) as
| Extract<Ability, { kind: 'alternative_cost' }>
| undefined
}
protected payAlternativeCost(
ability: Extract<Ability, { kind: 'alternative_cost' }>,
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' }> => 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<string, TargetChoice>()
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' }> => 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<Ability, { kind: 'activated' }>,
): 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)
}
}

View File

@@ -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<string, GameObject>()
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<string, MulliganState>()
/** 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<string>()
protected nextId = 0
protected autoManaDepth = 0
protected autoAdvanceDepth = 0
protected statDepth = 0
protected keywordDepth = 0
protected combatDamageDone = false
protected readonly triggeredThisTurn = new Set<string>()
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<Ability, { kind: 'alternative_cost' }> | undefined;
protected abstract payAlternativeCost(
ability: Extract<Ability, { kind: 'alternative_cost' }>,
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<string>;
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<Ability, { kind: 'activated' }> } | undefined;
protected abstract activateManaSource(source: GameObject, cost: ManaCost): void;
protected abstract manaAbilityColor(
source: GameObject,
ability: Extract<Ability, { kind: 'activated' }>,
player: PlayerState,
cost: ManaCost,
): ManaColor | undefined;
abstract manaColorChoices(source: GameObject, abilityIndex: number): ManaColor[] | undefined;
protected abstract manaAbilityAllowedColors(
source: GameObject,
ability: Extract<Ability, { kind: 'activated' }>,
): Set<ManaColor> | undefined;
protected abstract neededColor(player: PlayerState, cost: ManaCost, allowed?: Set<ManaColor>): ManaColor | undefined;
protected abstract addMana(playerId: string, mana: ManaSpec, preferred?: ManaColor, source?: GameObject): void;
protected abstract landManaColors(playerId: string, opponentsOnly: boolean, seen?: Set<string>): Set<ManaColor>;
protected abstract anyColorRestrictionColors(
mana: ManaSpec,
playerId: string,
seen?: Set<string>,
source?: GameObject,
): Set<ManaColor> | 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<Effect, { op: 'hideaway' }>): void;
protected abstract playExiledCard(playerId: string, object: GameObject, free: boolean | undefined): boolean;
protected abstract explore(context: EffectContext, effect: Extract<Effect, { op: 'keyword_action' }>): void;
protected abstract incubate(context: EffectContext, amount: Value | undefined): void;
protected abstract impulse(context: EffectContext): void;
protected abstract dig(
context: EffectContext,
effect: Extract<Effect, { op: 'dig' }>,
): void;
protected abstract tryPayUnless(cost: Cost, playerId: string | undefined, source: GameObject, context: EffectContext): boolean;
protected abstract addContinuousEffect(
source: GameObject,
controller: string,
effect: Extract<Effect, { op: 'pump' | 'set_pt' | 'grant' | 'restriction' }>,
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<Ability, { kind: 'static' }> }[];
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<Ability, { kind: 'activated' }>,
): 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<string, number>, stat: 'power' | 'toughness'): number;
protected abstract findStackItem(id: string): StackItem | undefined;
protected abstract playerSource(playerId: string): GameObject;
}

View File

@@ -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<string>()
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<string>()
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<string> {
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<StaticEffect, { op: 'restriction' }>[] {
const found: Extract<StaticEffect, { op: 'restriction' }>[] = []
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
// ---------------------------------------------------------------------------
}

File diff suppressed because it is too large Load Diff

View File

@@ -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<Effect, { op: 'pump' | 'set_pt' | 'grant' | 'restriction' }>
affectedIds: string[]
duration: Duration
createdTurn: number
}
export interface DamageShield {
/** Object or player ids this shield covers; empty with `global` covers everything. */
ids: Set<string>
global: boolean
/** When set, only damage dealt by these source objects is prevented. */
sourceIds?: Set<string>
/** 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<string, ManaColor> = {
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
}
}

View File

@@ -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<ManaColor> | 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<Ability, { kind: 'activated' }> } | 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<Ability, { kind: 'activated' }>,
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<Ability, { kind: 'activated' }>,
): Set<ManaColor> | 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>): 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<string>()): Set<ManaColor> {
const colors = new Set<ManaColor>()
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<string>,
source?: GameObject,
): Set<ManaColor> | 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<ManaColor>; 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()
}
}

View File

@@ -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<string, number>, 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
// ---------------------------------------------------------------------------
}

View File

@@ -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
}
}

View File

@@ -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<string, GameObject[]>()
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: {},
}
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -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,

View File

@@ -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<number, number>
}
@@ -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`. */

View File

@@ -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 <subject>" 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')
})

View File

@@ -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)
})

View File

@@ -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))
})

View File

@@ -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)
})

View File

@@ -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)
})

View File

@@ -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)
})

View File

@@ -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)
})

View File

@@ -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'])
})

File diff suppressed because it is too large Load Diff

159
backend/test/helpers.ts Normal file
View File

@@ -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> = {}): 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}.',
}],
})
}

View File

@@ -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,13 +1912,17 @@ onUnmounted(() => {
</section>
<section v-if="pendingChoice && pendingChoice.player !== viewerId" class="panel side search-panel">
<h2>{{ pendingChoice.what === 'pay_cost' ? 'Pay a cost' : pendingChoice.what === 'hideaway' ? 'Hideaway' : 'Choose a type' }}</h2>
<h2>{{ 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' }}</h2>
<p class="muted">
{{ 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.'
: 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}.` }}
</p>
</section>
@@ -2049,9 +2064,11 @@ onUnmounted(() => {
<div class="grow">
<h2 id="choice-title">{{ pendingChoice.what === 'pay_cost'
? `Pay ${pendingCostLabel}?`
: pendingChoice.what === 'hideaway' ? 'Hideaway' : 'Choose a creature type' }}</h2>
: pendingChoice.what === 'hideaway' ? 'Hideaway' : pendingChoice.what === 'color' ? 'Choose a color' : pendingChoice.what === 'optional' ? 'Use this effect?' : 'Choose a creature type' }}</h2>
<p class="muted">{{ pendingChoice.what === 'hideaway'
? 'Look at the top cards of your library and exile one face down.'
: pendingChoice.what === 'optional'
? pendingChoice.label ?? `${pendingChoice.sourceName} gives you a choice.`
: `${pendingChoice.sourceName} enters.` }}</p>
</div>
<span v-if="pendingChoice.what === 'creature_type'" class="tag">{{ filteredChoiceOptions.length }} types</span>
@@ -2093,6 +2110,34 @@ onUnmounted(() => {
</div>
<p class="muted small">The rest go to the bottom of your library in a random order.</p>
</template>
<template v-else-if="pendingChoice.what === 'optional'">
<div class="choice-grid">
<button
type="button"
class="choice-option"
:disabled="busy"
@click="chooseOptional(true)"
>Use it</button>
<button
type="button"
class="choice-option"
:disabled="busy"
@click="chooseOptional(false)"
>Decline</button>
</div>
</template>
<template v-else-if="pendingChoice.what === 'color'">
<div class="choice-grid">
<button
v-for="color in pendingChoice.options"
:key="color"
type="button"
class="choice-option"
:disabled="busy"
@click="chooseColor(color)"
>{{ color }}</button>
</div>
</template>
<template v-else>
<input
ref="choiceInput"