This commit is contained in:
2026-11-04 17:10:22 +01:00
parent 9ec486274f
commit c742d0cfa8
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`. */