Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| c742d0cfa8 |
558
backend/src/effects/compile-primitives.ts
Normal file
558
backend/src/effects/compile-primitives.ts
Normal 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
|
||||
}
|
||||
|
||||
507
backend/src/effects/compile-sentences.ts
Normal file
507
backend/src/effects/compile-sentences.ts
Normal 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)
|
||||
}
|
||||
688
backend/src/effects/compile-static.ts
Normal file
688
backend/src/effects/compile-static.ts
Normal 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
|
||||
}
|
||||
|
||||
247
backend/src/effects/compile-triggers.ts
Normal file
247
backend/src/effects/compile-triggers.ts
Normal 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
@@ -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],
|
||||
])})`
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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' }
|
||||
|
||||
176
backend/src/effects/source-abilities.ts
Normal file
176
backend/src/effects/source-abilities.ts
Normal 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') }
|
||||
}
|
||||
|
||||
297
backend/src/effects/source-api.ts
Normal file
297
backend/src/effects/source-api.ts
Normal 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,
|
||||
})
|
||||
}
|
||||
|
||||
94
backend/src/effects/source-card.ts
Normal file
94
backend/src/effects/source-card.ts
Normal 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
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
400
backend/src/effects/source-conditions.ts
Normal file
400
backend/src/effects/source-conditions.ts
Normal 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') })
|
||||
}
|
||||
431
backend/src/effects/source-effects.ts
Normal file
431
backend/src/effects/source-effects.ts
Normal 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
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
218
backend/src/effects/source-static.ts
Normal file
218
backend/src/effects/source-static.ts
Normal 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
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
470
backend/src/effects/source-validation.ts
Normal file
470
backend/src/effects/source-validation.ts
Normal 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
|
||||
// ---------------------------------------------------------------------------
|
||||
306
backend/src/effects/source-values.ts
Normal file
306
backend/src/effects/source-values.ts
Normal 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
@@ -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
|
||||
}
|
||||
| {
|
||||
|
||||
970
backend/src/game/game-actions.ts
Normal file
970
backend/src/game/game-actions.ts
Normal 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)
|
||||
}
|
||||
}
|
||||
468
backend/src/game/game-base.ts
Normal file
468
backend/src/game/game-base.ts
Normal 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;
|
||||
}
|
||||
309
backend/src/game/game-combat.ts
Normal file
309
backend/src/game/game-combat.ts
Normal 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
|
||||
// ---------------------------------------------------------------------------
|
||||
}
|
||||
1220
backend/src/game/game-effects.ts
Normal file
1220
backend/src/game/game-effects.ts
Normal file
File diff suppressed because it is too large
Load Diff
270
backend/src/game/game-helpers.ts
Normal file
270
backend/src/game/game-helpers.ts
Normal 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
|
||||
}
|
||||
}
|
||||
|
||||
369
backend/src/game/game-mana.ts
Normal file
369
backend/src/game/game-mana.ts
Normal 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()
|
||||
}
|
||||
}
|
||||
306
backend/src/game/game-stats.ts
Normal file
306
backend/src/game/game-stats.ts
Normal 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
|
||||
// ---------------------------------------------------------------------------
|
||||
}
|
||||
485
backend/src/game/game-turn.ts
Normal file
485
backend/src/game/game-turn.ts
Normal 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
|
||||
}
|
||||
}
|
||||
479
backend/src/game/game-zones.ts
Normal file
479
backend/src/game/game-zones.ts
Normal 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
@@ -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,
|
||||
|
||||
@@ -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`. */
|
||||
|
||||
@@ -29,6 +29,58 @@ test('enters trigger with a draw effect', () => {
|
||||
assert.equal(ability.effects[0].op, 'draw')
|
||||
})
|
||||
|
||||
test('compound effects resolve "it" through the previous target', () => {
|
||||
const [ability] = creature('When this enters, tap target creature an opponent controls and put a stun counter on it.')
|
||||
assert.equal(ability.kind, 'triggered')
|
||||
if (ability.kind !== 'triggered') return
|
||||
assert.deepEqual(ability.effects[1], {
|
||||
op: 'put_counters',
|
||||
target: { kind: 'previous_target' },
|
||||
counter: 'stun',
|
||||
amount: { kind: 'number', value: 1 },
|
||||
})
|
||||
})
|
||||
|
||||
test('compound effects share an explicit player subject', () => {
|
||||
const [ability] = spell('Target player draws two cards and loses 2 life.')
|
||||
assert.equal(ability.kind, 'spell')
|
||||
if (ability.kind !== 'spell') return
|
||||
assert.deepEqual(ability.effects[1], {
|
||||
op: 'life',
|
||||
player: 'target_player',
|
||||
amount: { kind: 'number', value: 2 },
|
||||
mode: 'lose',
|
||||
})
|
||||
})
|
||||
|
||||
test('damage triggers without a recipient use the event amount', () => {
|
||||
const [ability] = creature('Whenever this deals damage, you gain that much life.')
|
||||
assert.equal(ability.kind, 'triggered')
|
||||
if (ability.kind !== 'triggered') return
|
||||
assert.equal(ability.event.kind, 'deals_damage')
|
||||
assert.deepEqual(ability.effects[0], {
|
||||
op: 'life',
|
||||
player: 'you',
|
||||
amount: { kind: 'event_amount' },
|
||||
mode: 'gain',
|
||||
})
|
||||
})
|
||||
|
||||
test('a later sentence can refer to a token created by an earlier one', () => {
|
||||
const [ability] = creature(
|
||||
'When this enters, create a 0/0 green and blue Fractal creature token. Put three +1/+1 counters on it.',
|
||||
)
|
||||
assert.equal(ability.kind, 'triggered')
|
||||
if (ability.kind !== 'triggered') return
|
||||
assert.equal(ability.effects[0].op, 'create_token')
|
||||
assert.deepEqual(ability.effects[1], {
|
||||
op: 'put_counters',
|
||||
target: { kind: 'previous_target' },
|
||||
counter: '+1/+1',
|
||||
amount: { kind: 'number', value: 3 },
|
||||
})
|
||||
})
|
||||
|
||||
test('activated mana ability', () => {
|
||||
const [ability] = creature('{T}: Add {G}.')
|
||||
assert.equal(ability.kind, 'activated')
|
||||
@@ -149,11 +201,16 @@ test('"it" refers to the triggering object when unambiguous', () => {
|
||||
assert.deepEqual(effect.target, { kind: 'trigger_subject' })
|
||||
})
|
||||
|
||||
test('ambiguous "it" is left unsupported instead of guessed', () => {
|
||||
test('a target introduced in one clause is the "it" of the next', () => {
|
||||
const [ability] = creature(
|
||||
'When this creature enters, tap target creature an opponent controls and put a stun counter on it.',
|
||||
)
|
||||
assert.equal(ability.kind, 'unsupported')
|
||||
assert.equal(ability.kind, 'triggered')
|
||||
if (ability.kind !== 'triggered') return
|
||||
const effect = ability.effects[1]
|
||||
assert.equal(effect.op, 'put_counters')
|
||||
if (effect.op !== 'put_counters') return
|
||||
assert.deepEqual(effect.target, { kind: 'previous_target' })
|
||||
})
|
||||
|
||||
test('modal text is unsupported', () => {
|
||||
@@ -275,7 +332,7 @@ test('token-doubling replacement lines compile and round-trip', () => {
|
||||
const [ability] = creature(text)
|
||||
assert.equal(ability.kind, 'static')
|
||||
if (ability.kind !== 'static') return
|
||||
assert.deepEqual(ability.effects[0], expected)
|
||||
assert.deepEqual(JSON.parse(JSON.stringify(ability.effects[0])), expected)
|
||||
|
||||
const source = formatAbility(ability)
|
||||
assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source)
|
||||
@@ -354,6 +411,172 @@ test('"When <subject>" triggers and bare "gain life" effects parse', () => {
|
||||
})
|
||||
})
|
||||
|
||||
test('"This ability triggers only once" marks the trigger', () => {
|
||||
const [ability] = creature('At the beginning of your second main phase, if this is tapped, put a flying counter on it. This ability triggers only once.')
|
||||
assert.equal(ability.kind, 'triggered')
|
||||
if (ability.kind !== 'triggered') return
|
||||
assert.deepEqual(ability.event, { kind: 'main_phase', who: 'you', phase: 'postcombat' })
|
||||
assert.equal(ability.oncePerTurn, true)
|
||||
assert.deepEqual(ability.effects[0], {
|
||||
op: 'put_counters',
|
||||
target: { kind: 'self' },
|
||||
counter: 'flying',
|
||||
amount: { kind: 'number', value: 1 },
|
||||
})
|
||||
})
|
||||
|
||||
test('impulse exiles the top cards and grants play permission', () => {
|
||||
const [ability] = spell('Exile the top three cards of your library. Until end of turn, you may play those cards.')
|
||||
assert.equal(ability.kind, 'spell')
|
||||
if (ability.kind !== 'spell') return
|
||||
assert.deepEqual(ability.effects[0], {
|
||||
op: 'impulse',
|
||||
player: 'you',
|
||||
amount: { kind: 'number', value: 3 },
|
||||
faceDown: false,
|
||||
})
|
||||
})
|
||||
|
||||
test('a mana ability can produce the chosen color', () => {
|
||||
const [ability] = creature('{T}: Add one mana of the chosen color.')
|
||||
assert.equal(ability.kind, 'activated')
|
||||
if (ability.kind !== 'activated') return
|
||||
assert.deepEqual(ability.effects[0], {
|
||||
op: 'add_mana',
|
||||
player: 'you',
|
||||
mana: {
|
||||
kind: 'any_color',
|
||||
amount: { kind: 'number', value: 1 },
|
||||
oneColor: true,
|
||||
restriction: 'chosen color',
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
test('doubling counters compiles to its own effect', () => {
|
||||
const [ability] = spell('Double the number of +1/+1 counters on target creature.')
|
||||
assert.equal(ability.kind, 'spell')
|
||||
if (ability.kind !== 'spell') return
|
||||
assert.deepEqual(ability.effects[0], {
|
||||
op: 'double_counters',
|
||||
target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' },
|
||||
counter: '+1/+1',
|
||||
})
|
||||
})
|
||||
|
||||
test('damage prevention compiles with its shield and scope', () => {
|
||||
const [shield] = spell('Prevent the next 3 damage that would be dealt to target creature this turn.')
|
||||
assert.equal(shield.kind, 'spell')
|
||||
if (shield.kind !== 'spell') return
|
||||
assert.equal(shield.effects[0].op, 'prevent_damage')
|
||||
const first = shield.effects[0]
|
||||
if (first.op !== 'prevent_damage') return
|
||||
assert.deepEqual(first.target, { kind: 'object', selector: { types: ['creature'] }, mode: 'target' })
|
||||
assert.deepEqual(first.amount, { kind: 'number', value: 3 })
|
||||
assert.equal(first.duration, 'until_end_of_turn')
|
||||
assert.equal(first.global, undefined)
|
||||
|
||||
const [global] = spell('Prevent all combat damage that would be dealt this turn.')
|
||||
assert.equal(global.kind, 'spell')
|
||||
if (global.kind !== 'spell') return
|
||||
const second = global.effects[0]
|
||||
if (second.op !== 'prevent_damage') return
|
||||
assert.equal(second.amount, 'all')
|
||||
assert.equal(second.combatOnly, true)
|
||||
assert.equal(second.global, true)
|
||||
})
|
||||
|
||||
test('counter and energy replacement lines compile', () => {
|
||||
const [counters] = creature('If one or more +1/+1 counters would be put on a creature you control, twice that many +1/+1 counters are put on that creature instead.')
|
||||
assert.equal(counters.kind, 'static')
|
||||
if (counters.kind !== 'static') return
|
||||
assert.equal(counters.effects[0].op, 'counter_multiplier')
|
||||
if (counters.effects[0].op !== 'counter_multiplier') return
|
||||
assert.equal(counters.effects[0].counter, '+1/+1')
|
||||
assert.equal(counters.effects[0].multiplier, 2)
|
||||
|
||||
const [energy] = creature('If you would get one or more {E}, you get twice that many {E} instead.')
|
||||
assert.equal(energy.kind, 'static')
|
||||
if (energy.kind !== 'static') return
|
||||
assert.deepEqual(energy.effects[0], { op: 'replacement_amount', what: 'energy', multiplier: 2 })
|
||||
})
|
||||
|
||||
test('static source-filtered prevention compiles', () => {
|
||||
const [ability] = creature('Prevent all damage that would be dealt to this by artifact creatures.')
|
||||
assert.equal(ability.kind, 'static')
|
||||
if (ability.kind !== 'static') return
|
||||
assert.deepEqual(ability.effects[0], {
|
||||
op: 'prevent_damage',
|
||||
target: { kind: 'self' },
|
||||
amount: 'all',
|
||||
combatOnly: undefined,
|
||||
duration: 'permanent',
|
||||
sourceSelector: { types: ['artifact', 'creature'] },
|
||||
})
|
||||
})
|
||||
|
||||
test('source-scoped prevention compiles with its chosen source', () => {
|
||||
const [ability] = spell('Prevent all damage a red source of your choice would deal this turn.')
|
||||
assert.equal(ability.kind, 'spell')
|
||||
if (ability.kind !== 'spell') return
|
||||
const shield = ability.effects[0]
|
||||
assert.equal(shield.op, 'prevent_damage')
|
||||
if (shield.op !== 'prevent_damage') return
|
||||
assert.deepEqual(shield.source, { kind: 'object', selector: { colors: ['R'] }, mode: 'target' })
|
||||
assert.equal(shield.global, true)
|
||||
})
|
||||
|
||||
test('a prevention follow-up compiles into the shield', () => {
|
||||
const [ability] = spell('Prevent the next 3 damage that would be dealt to target creature this turn. If damage is prevented this way, this deals that much damage to any target.')
|
||||
assert.equal(ability.kind, 'spell')
|
||||
if (ability.kind !== 'spell') return
|
||||
const shield = ability.effects[0]
|
||||
assert.equal(shield.op, 'prevent_damage')
|
||||
if (shield.op !== 'prevent_damage') return
|
||||
assert.deepEqual(shield.then, [{
|
||||
op: 'damage',
|
||||
target: { kind: 'any' },
|
||||
amount: { kind: 'event_amount' },
|
||||
}])
|
||||
})
|
||||
|
||||
test('replacement amount lines compile', () => {
|
||||
const [life] = creature('If you would gain life, you gain twice that much life instead.')
|
||||
assert.equal(life.kind, 'static')
|
||||
if (life.kind !== 'static') return
|
||||
assert.deepEqual(life.effects[0], { op: 'replacement_amount', what: 'life_gain', multiplier: 2 })
|
||||
|
||||
const [plus] = creature('If you would gain life, you gain that much life plus 1 instead.')
|
||||
assert.equal(plus.kind, 'static')
|
||||
if (plus.kind !== 'static') return
|
||||
assert.deepEqual(plus.effects[0], { op: 'replacement_amount', what: 'life_gain', multiplier: 1, add: 1 })
|
||||
|
||||
const [draw] = creature('If you would draw a card, draw two cards instead.')
|
||||
assert.equal(draw.kind, 'static')
|
||||
if (draw.kind !== 'static') return
|
||||
assert.deepEqual(draw.effects[0], { op: 'replacement_amount', what: 'draw', multiplier: 2 })
|
||||
})
|
||||
|
||||
test('"skip your draw step" and attack-or-block restrictions compile', () => {
|
||||
const [skip] = creature('Skip your draw step.')
|
||||
assert.equal(skip.kind, 'static')
|
||||
if (skip.kind !== 'static') return
|
||||
assert.deepEqual(skip.effects[0], {
|
||||
op: 'restriction',
|
||||
target: { kind: 'player', who: 'you', mode: 'target' },
|
||||
rule: 'skip_draw_step',
|
||||
})
|
||||
|
||||
const [lock] = creature('Enchanted creature cannot attack or block, and its activated abilities cannot be activated.')
|
||||
assert.equal(lock.kind, 'static')
|
||||
if (lock.kind !== 'static') return
|
||||
assert.deepEqual(lock.effects.map(effect => effect.op === 'restriction' ? effect.rule : effect.op), [
|
||||
'cant_attack',
|
||||
'cant_block',
|
||||
'cant_activate',
|
||||
])
|
||||
})
|
||||
|
||||
test('a trailing condition becomes a static condition', () => {
|
||||
const [ability] = creature('This creature cannot attack if defending player controls an untapped land.')
|
||||
assert.equal(ability.kind, 'static')
|
||||
@@ -646,3 +869,51 @@ test('Role token creation compiles with the attachment target', () => {
|
||||
assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source)
|
||||
}
|
||||
})
|
||||
|
||||
test('token-creation replacement lines compile and round-trip', () => {
|
||||
const cases: Array<[string, object]> = [
|
||||
[
|
||||
'If you would create a Food token, instead create a Food token and a Treasure token.',
|
||||
{ op: 'token_replacement', from: ['food'], tokens: [{ types: ['artifact'], subtypes: ['food'], colors: [] }, { types: ['artifact'], subtypes: ['treasure'], colors: [] }], who: 'you' },
|
||||
],
|
||||
[
|
||||
'If you would create a Clue, Food, or Treasure token, instead create one of each.',
|
||||
{ op: 'token_replacement', from: ['clue', 'food', 'treasure'], tokens: [{ name: 'Clue', types: ['artifact'], subtypes: ['clue'], colors: [] }, { name: 'Food', types: ['artifact'], subtypes: ['food'], colors: [] }, { name: 'Treasure', types: ['artifact'], subtypes: ['treasure'], colors: [] }], who: 'you' },
|
||||
],
|
||||
]
|
||||
for (const [text, expected] of cases) {
|
||||
const [ability] = creature(text)
|
||||
assert.equal(ability.kind, 'static')
|
||||
if (ability.kind !== 'static') return
|
||||
assert.deepEqual(JSON.parse(JSON.stringify(ability.effects[0])), expected)
|
||||
|
||||
const source = formatAbility(ability)
|
||||
assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source)
|
||||
}
|
||||
})
|
||||
|
||||
test('exile-instead-of-dying clauses compile', () => {
|
||||
const [damaged] = spell('This deals 3 damage to any target. If a creature dealt damage this way would die this turn, exile it instead.')
|
||||
assert.equal(damaged.kind, 'spell')
|
||||
if (damaged.kind !== 'spell') return
|
||||
assert.deepEqual(damaged.effects[1], { op: 'exile_instead_of_dying', target: { kind: 'damaged' } })
|
||||
|
||||
const [that] = spell('This deals 3 damage to target creature. If that creature would die this turn, exile it instead.')
|
||||
assert.equal(that.kind, 'spell')
|
||||
if (that.kind !== 'spell') return
|
||||
assert.deepEqual(that.effects[1], { op: 'exile_instead_of_dying', target: { kind: 'previous_target' } })
|
||||
})
|
||||
|
||||
test('equipped and enchanted conditions gate static abilities', () => {
|
||||
const [equipped] = creature('As long as this is equipped, it gets +2/+0 and has menace.')
|
||||
assert.equal(equipped.kind, 'static')
|
||||
if (equipped.kind !== 'static') return
|
||||
assert.equal(equipped.condition?.kind, 'source_equipped')
|
||||
assert.equal(equipped.effects[0].op, 'pump')
|
||||
assert.equal(equipped.effects[1].op, 'grant')
|
||||
|
||||
const [enchanted] = creature('As long as this is enchanted, it has flying.')
|
||||
assert.equal(enchanted.kind, 'static')
|
||||
if (enchanted.kind !== 'static') return
|
||||
assert.equal(enchanted.condition?.kind, 'source_enchanted')
|
||||
})
|
||||
|
||||
283
backend/test/game-core.test.ts
Normal file
283
backend/test/game-core.test.ts
Normal file
@@ -0,0 +1,283 @@
|
||||
import assert from 'node:assert/strict'
|
||||
import test from 'node:test'
|
||||
import { Game, GameError } from '../src/game/game.js'
|
||||
import { compileText } from '../src/effects/compile.js'
|
||||
import type { Ability, Effect, TokenSpec } from '../src/effects/types.js'
|
||||
import type { CardDefinition, GameObject } from '../src/game/types.js'
|
||||
import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js'
|
||||
|
||||
test('turns start at the first main phase, draw opening hands, and pass to the next player', () => {
|
||||
const forest = land('Forest', 'G')
|
||||
const game = new Game({
|
||||
seed: 1,
|
||||
startingHandSize: 7,
|
||||
players: [
|
||||
{ id: 'p1', deck: Array.from({ length: 10 }, () => forest) },
|
||||
{ id: 'p2', deck: Array.from({ length: 10 }, () => forest) },
|
||||
],
|
||||
})
|
||||
game.start()
|
||||
|
||||
assert.equal(game.turn, 1)
|
||||
assert.equal(game.activePlayer, 'p1')
|
||||
assert.equal(game.phase, 'precombat_main')
|
||||
assert.equal(game.step, 'main')
|
||||
assert.equal(game.priority, 'p1')
|
||||
assert.equal(game.getPlayer('p1').life, 40)
|
||||
assert.equal(game.getPlayer('p1').hand.length, 8)
|
||||
assert.equal(game.getPlayer('p1').library.length, 2)
|
||||
|
||||
game.endTurn('p1')
|
||||
|
||||
assert.equal(game.turn, 2)
|
||||
assert.equal(game.activePlayer, 'p2')
|
||||
assert.equal(game.getPlayer('p2').hand.length, 8)
|
||||
assert.equal(game.getPlayer('p1').hand.length, 7)
|
||||
})
|
||||
|
||||
test('mulligans draw a new seven and bottom one more card each time', () => {
|
||||
const game = new Game({
|
||||
seed: 3,
|
||||
startingHandSize: 7,
|
||||
mulligans: true,
|
||||
players: [
|
||||
{ id: 'p1', deck: Array.from({ length: 40 }, (_, index) => card(`P1 Card ${index}`)) },
|
||||
{ id: 'p2', deck: Array.from({ length: 40 }, (_, index) => card(`P2 Card ${index}`)) },
|
||||
],
|
||||
})
|
||||
game.start()
|
||||
|
||||
assert.equal(game.status, 'mulligan')
|
||||
assert.equal(game.getPlayer('p1').hand.length, 7)
|
||||
game.keepHand('p2')
|
||||
|
||||
game.mulligan('p1')
|
||||
assert.equal(game.getPlayer('p1').hand.length, 7)
|
||||
assert.equal(game.mulligans.get('p1')?.count, 1)
|
||||
assert.equal(game.mulligans.get('p1')?.bottom, 0)
|
||||
|
||||
game.mulligan('p1')
|
||||
assert.equal(game.mulligans.get('p1')?.count, 2)
|
||||
assert.equal(game.mulligans.get('p1')?.bottom, 1)
|
||||
assert.throws(() => game.keepHand('p1'), /bottom/)
|
||||
|
||||
const bottomCard = game.getPlayer('p1').hand[0]
|
||||
game.putOnBottom('p1', bottomCard)
|
||||
assert.equal(game.getPlayer('p1').hand.length, 6)
|
||||
assert.equal(game.getPlayer('p1').library.at(-1), bottomCard)
|
||||
assert.equal(game.mulligans.get('p1')?.bottom, 0)
|
||||
|
||||
game.mulligan('p1')
|
||||
assert.equal(game.mulligans.get('p1')?.count, 3)
|
||||
assert.equal(game.mulligans.get('p1')?.bottom, 2)
|
||||
for (const cardId of [...game.getPlayer('p1').hand.slice(0, 2)]) game.putOnBottom('p1', cardId)
|
||||
assert.equal(game.getPlayer('p1').hand.length, 5)
|
||||
|
||||
game.keepHand('p1')
|
||||
assert.equal(game.status, 'active')
|
||||
assert.equal(game.turn, 1)
|
||||
assert.equal(game.step, 'main')
|
||||
assert.equal(game.getPlayer('p1').hand.length, 6)
|
||||
})
|
||||
|
||||
test('passing priority twice advances from the main phase into combat', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
|
||||
game.pass('p1')
|
||||
assert.equal(game.priority, 'p2')
|
||||
game.pass('p2')
|
||||
|
||||
assert.equal(game.phase, 'combat')
|
||||
assert.equal(game.step, 'declare_attackers')
|
||||
assert.equal(game.priority, 'p1')
|
||||
})
|
||||
|
||||
test('a spell goes on the stack, auto-taps mana, and resolves its compiled effect', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const mountain = game.addCard('p1', land('Mountain', 'R'), 'battlefield')
|
||||
const bolt = game.addCard('p1', spell('Lightning Bolt', [
|
||||
{ op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } },
|
||||
], '{R}'), 'hand')
|
||||
|
||||
game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] })
|
||||
|
||||
assert.equal(game.stack.length, 1)
|
||||
assert.equal(mountain.tapped, true)
|
||||
assert.equal(game.priority, 'p2')
|
||||
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(game.stack.length, 0)
|
||||
assert.equal(game.getPlayer('p2').life, 37)
|
||||
assert.ok(game.getPlayer('p1').graveyard.includes(bolt.id))
|
||||
})
|
||||
|
||||
test('permanents can be repositioned by their controller and positions are cleared on zone changes', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield')
|
||||
|
||||
game.movePermanent('p1', bear.id, 0.25, 0.75)
|
||||
assert.deepEqual(bear.position, { x: 0.25, y: 0.75 })
|
||||
|
||||
game.movePermanent('p1', bear.id, -1, 2)
|
||||
assert.deepEqual(bear.position, { x: 0, y: 1 })
|
||||
assert.throws(() => game.movePermanent('p2', bear.id, 0.5, 0.5), /control/)
|
||||
|
||||
game.moveToZone(bear, 'graveyard')
|
||||
assert.equal(bear.position, undefined)
|
||||
})
|
||||
|
||||
test('doubling counters doubles each kind on the target', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const target = game.addCard('p1', creature('Counter Bear', 2, 3), 'battlefield')
|
||||
target.counters['+1/+1'] = 2
|
||||
target.counters['charge'] = 1
|
||||
const doubler = spell('Doubler', [{
|
||||
op: 'double_counters',
|
||||
target: { kind: 'object', selector: { types: ['creature'] } },
|
||||
}])
|
||||
const cardInHand = game.addCard('p1', doubler, 'hand')
|
||||
game.castSpell('p1', cardInHand.id, { targets: [{ kind: 'object', id: target.id }] })
|
||||
game.resolveStack()
|
||||
assert.equal(target.counters['+1/+1'], 4)
|
||||
assert.equal(target.counters.charge, 2)
|
||||
})
|
||||
|
||||
test('damage prevention shields absorb the next damage', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const bear = creature('Bear', 2, 3)
|
||||
const target = game.addCard('p1', bear, 'battlefield')
|
||||
const bolt = spell('Bolt', [{ op: 'damage', target: { kind: 'object', selector: { types: ['creature'] } }, amount: { kind: 'number', value: 5 } }])
|
||||
const shield = spell('Shield', [{
|
||||
op: 'prevent_damage',
|
||||
target: { kind: 'object', selector: { types: ['creature'] } },
|
||||
amount: { kind: 'number', value: 3 },
|
||||
duration: 'until_end_of_turn',
|
||||
}])
|
||||
|
||||
const shieldCard = game.addCard('p1', shield, 'hand')
|
||||
game.castSpell('p1', shieldCard.id, { targets: [{ kind: 'object', id: target.id }] })
|
||||
game.resolveStack()
|
||||
const boltCard = game.addCard('p1', bolt, 'hand')
|
||||
game.castSpell('p1', boltCard.id, { targets: [{ kind: 'object', id: target.id }] })
|
||||
game.resolveStack()
|
||||
assert.equal(target.damage, 2)
|
||||
assert.equal(target.zone, 'battlefield')
|
||||
})
|
||||
|
||||
test('a "you may" spell asks its controller and honors the choice', () => {
|
||||
const optionalSpell = card('Optional Test', {
|
||||
typeLine: 'Instant',
|
||||
abilities: [{
|
||||
kind: 'spell',
|
||||
effects: [{ op: 'life', player: 'you', amount: { kind: 'number', value: 3 }, mode: 'gain' }],
|
||||
optional: true,
|
||||
text: 'You may gain 3 life.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
|
||||
const accept = game.addCard('p1', optionalSpell, 'hand')
|
||||
game.castSpell('p1', accept.id)
|
||||
game.resolveStack()
|
||||
assert.equal(game.pendingChoice?.what, 'optional')
|
||||
const before = game.getPlayer('p1').life
|
||||
game.chooseOptional('p1', true)
|
||||
assert.equal(game.getPlayer('p1').life, before + 3)
|
||||
|
||||
const decline = game.addCard('p1', optionalSpell, 'hand')
|
||||
game.castSpell('p1', decline.id)
|
||||
game.resolveStack()
|
||||
assert.equal(game.pendingChoice?.what, 'optional')
|
||||
const after = game.getPlayer('p1').life
|
||||
game.chooseOptional('p1', false)
|
||||
assert.equal(game.getPlayer('p1').life, after)
|
||||
assert.equal(decline.zone, 'graveyard')
|
||||
})
|
||||
|
||||
test('declining a "you may" runs the "if you don\'t" branch', () => {
|
||||
const optionalSpell = card('Optional Branch', {
|
||||
typeLine: 'Instant',
|
||||
abilities: [{
|
||||
kind: 'spell',
|
||||
effects: [
|
||||
{ op: 'life', player: 'you', amount: { kind: 'number', value: 2 }, mode: 'gain' },
|
||||
{
|
||||
op: 'conditional',
|
||||
condition: { kind: 'if_you_dont' },
|
||||
effects: [{ op: 'life', player: 'you', amount: { kind: 'number', value: 1 }, mode: 'lose' }],
|
||||
},
|
||||
],
|
||||
optional: true,
|
||||
text: 'You may gain 2 life. If you don\'t, you lose 1 life.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const spellCard = game.addCard('p1', optionalSpell, 'hand')
|
||||
game.castSpell('p1', spellCard.id)
|
||||
game.resolveStack()
|
||||
const before = game.getPlayer('p1').life
|
||||
game.chooseOptional('p1', false)
|
||||
assert.equal(game.getPlayer('p1').life, before - 1)
|
||||
})
|
||||
|
||||
test('a compiled "you may" enters trigger asks and applies the choice', () => {
|
||||
const abilities = compileText(
|
||||
'When this creature enters, you may gain 2 life.',
|
||||
'Optional Bear',
|
||||
[],
|
||||
'Creature — Bear',
|
||||
)
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const bear = game.addCard('p1', creature('Optional Bear', 2, 2, abilities), 'hand')
|
||||
|
||||
game.castSpell('p1', bear.id)
|
||||
game.resolveStack()
|
||||
assert.equal(game.pendingChoice?.what, 'optional')
|
||||
const before = game.getPlayer('p1').life
|
||||
game.chooseOptional('p1', true)
|
||||
assert.equal(game.getPlayer('p1').life, before + 2)
|
||||
})
|
||||
|
||||
test('a land that chooses a color produces that color', () => {
|
||||
const landDef = card('Chosen Color Land', {
|
||||
typeLine: 'Land',
|
||||
abilities: [
|
||||
{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'choose', what: 'color' }],
|
||||
text: 'As this enters, choose a color.',
|
||||
},
|
||||
{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{
|
||||
op: 'add_mana',
|
||||
player: 'you',
|
||||
mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: true, restriction: 'chosen color' },
|
||||
}],
|
||||
optional: false,
|
||||
text: '{T}: Add one mana of the chosen color.',
|
||||
},
|
||||
],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const land = game.addCard('p1', landDef, 'hand')
|
||||
|
||||
game.playLand('p1', land.id)
|
||||
assert.equal(game.pendingChoice?.what, 'color')
|
||||
game.chooseColor('p1', 'Blue')
|
||||
|
||||
game.activateAbility('p1', land.id, 1)
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p1').manaPool.U, 1)
|
||||
})
|
||||
343
backend/test/game-effects.test.ts
Normal file
343
backend/test/game-effects.test.ts
Normal file
@@ -0,0 +1,343 @@
|
||||
import assert from 'node:assert/strict'
|
||||
import test from 'node:test'
|
||||
import { Game, GameError } from '../src/game/game.js'
|
||||
import { compileText } from '../src/effects/compile.js'
|
||||
import type { Ability, Effect, TokenSpec } from '../src/effects/types.js'
|
||||
import type { CardDefinition, GameObject } from '../src/game/types.js'
|
||||
import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js'
|
||||
|
||||
test('impulse exiles the top cards and lets the player cast them this turn', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const impulseSpell = game.addCard('p1', spell('Impulse Test', [
|
||||
{ op: 'impulse', player: 'you', amount: { kind: 'number', value: 2 } },
|
||||
]), 'hand')
|
||||
const top = game.addCard('p1', spell('Top Card', []), 'library')
|
||||
const second = game.addCard('p1', spell('Second Card', []), 'library')
|
||||
|
||||
game.castSpell('p1', impulseSpell.id)
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(top.zone, 'exile')
|
||||
assert.equal(second.zone, 'exile')
|
||||
assert.equal(top.playableFromExileTurn, game.turn)
|
||||
assert.equal(second.playableFromExileTurn, game.turn)
|
||||
assert.doesNotThrow(() => game.castSpell('p1', top.id))
|
||||
})
|
||||
|
||||
test('hideaway exiles a card and its linked ability plays it for free once the condition is met', () => {
|
||||
const hideawayLand = card('Hideaway Test', {
|
||||
typeLine: 'Land',
|
||||
abilities: [
|
||||
{
|
||||
kind: 'triggered',
|
||||
event: { kind: 'enters', subject: { kind: 'self' } },
|
||||
effects: [{ op: 'hideaway', amount: { kind: 'number', value: 4 } }],
|
||||
optional: false,
|
||||
text: 'Hideaway 4',
|
||||
},
|
||||
{
|
||||
kind: 'activated',
|
||||
costs: [],
|
||||
effects: [{
|
||||
op: 'conditional',
|
||||
condition: { kind: 'total_power', controller: 'you', atLeast: 10 },
|
||||
effects: [{ op: 'play_exiled', player: 'you', free: true }],
|
||||
}],
|
||||
optional: false,
|
||||
text: 'Play the exiled card without paying its mana cost if creatures you control have total power 10 or greater.',
|
||||
},
|
||||
],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const hidden = game.addCard('p1', creature('Hidden Bear', 2, 2), 'library')
|
||||
for (const name of ['Filler One', 'Filler Two', 'Filler Three']) {
|
||||
game.addCard('p1', creature(name, 1, 1), 'library')
|
||||
}
|
||||
const library = game.getPlayer('p1').library
|
||||
library.splice(library.indexOf(hidden.id), 1)
|
||||
library.unshift(hidden.id)
|
||||
const land = game.addCard('p1', hideawayLand, 'hand')
|
||||
|
||||
game.playLand('p1', land.id)
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(game.pendingChoice?.what, 'hideaway')
|
||||
assert.equal(game.pendingChoice?.playerId, 'p1')
|
||||
assert.equal(game.pendingChoice?.cardIds?.length, 4)
|
||||
assert.ok(game.pendingChoice?.cardIds?.includes(hidden.id))
|
||||
assert.throws(() => game.chooseHideawayCard('p2', hidden.id), GameError)
|
||||
const looked = [...game.getPlayer('p1').library.slice(0, 4)]
|
||||
game.chooseHideawayCard('p1', hidden.id)
|
||||
assert.equal(game.pendingChoice, undefined)
|
||||
|
||||
assert.equal(hidden.zone, 'exile')
|
||||
assert.equal(hidden.faceDown, true)
|
||||
assert.deepEqual(land.linkedExile, [hidden.id])
|
||||
assert.deepEqual(
|
||||
game.getPlayer('p1').library.slice(-3).sort(),
|
||||
looked.filter(id => id !== hidden.id).sort(),
|
||||
)
|
||||
|
||||
game.activateAbility('p1', land.id, 1)
|
||||
game.resolveStack()
|
||||
assert.equal(hidden.zone, 'exile')
|
||||
|
||||
game.addCard('p1', creature('Big Bear', 10, 10), 'battlefield')
|
||||
game.activateAbility('p1', land.id, 1)
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(hidden.zone, 'battlefield')
|
||||
assert.equal(hidden.faceDown, undefined)
|
||||
assert.ok(game.getPlayer('p1').battlefield.includes(hidden.id))
|
||||
})
|
||||
|
||||
test('playing a card hidden by hideaway uses the land drop', () => {
|
||||
const hideawayLand = card('Hideaway Land', {
|
||||
typeLine: 'Land',
|
||||
abilities: [
|
||||
{
|
||||
kind: 'triggered',
|
||||
event: { kind: 'enters', subject: { kind: 'self' } },
|
||||
effects: [{ op: 'hideaway', amount: { kind: 'number', value: 1 } }],
|
||||
optional: false,
|
||||
text: 'Hideaway 1',
|
||||
},
|
||||
{
|
||||
kind: 'activated',
|
||||
costs: [],
|
||||
effects: [{
|
||||
op: 'conditional',
|
||||
condition: { kind: 'total_power', controller: 'you', atLeast: 0 },
|
||||
effects: [{ op: 'play_exiled', player: 'you', free: true }],
|
||||
}],
|
||||
optional: false,
|
||||
text: 'Play the exiled card without paying its mana cost.',
|
||||
},
|
||||
],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const hidden = game.addCard('p1', land('Island', 'U'), 'library')
|
||||
const library = game.getPlayer('p1').library
|
||||
library.splice(library.indexOf(hidden.id), 1)
|
||||
library.unshift(hidden.id)
|
||||
const source = game.addCard('p1', hideawayLand, 'hand')
|
||||
|
||||
game.playLand('p1', source.id)
|
||||
game.resolveStack()
|
||||
assert.equal(hidden.zone, 'exile')
|
||||
assert.equal(hidden.faceDown, true)
|
||||
|
||||
game.getPlayer('p1').landPlayedThisTurn = true
|
||||
game.activateAbility('p1', source.id, 1)
|
||||
game.resolveStack()
|
||||
assert.equal(hidden.zone, 'exile')
|
||||
|
||||
game.getPlayer('p1').landPlayedThisTurn = false
|
||||
game.activateAbility('p1', source.id, 1)
|
||||
game.resolveStack()
|
||||
assert.equal(hidden.zone, 'battlefield')
|
||||
assert.equal(game.getPlayer('p1').landPlayedThisTurn, true)
|
||||
})
|
||||
|
||||
test('enters triggers from compiled card code fire and resolve through the stack', () => {
|
||||
const soulWarden = card('Soul Warden', {
|
||||
typeLine: 'Creature — Human Cleric',
|
||||
power: 1,
|
||||
toughness: 1,
|
||||
colors: ['W'],
|
||||
abilities: [{
|
||||
kind: 'triggered',
|
||||
event: {
|
||||
kind: 'enters',
|
||||
subject: { kind: 'object', selector: { other: true, types: ['creature'] }, mode: 'each' },
|
||||
},
|
||||
effects: [{ op: 'life', player: 'you', amount: { kind: 'number', value: 1 }, mode: 'gain' }],
|
||||
optional: false,
|
||||
text: 'Whenever another creature enters, you gain 1 life.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
game.addCard('p1', soulWarden, 'battlefield')
|
||||
const elves = game.addCard('p1', creature('Llanowar Elves', 1, 1), 'hand')
|
||||
|
||||
game.castSpell('p1', elves.id)
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(game.getPlayer('p1').life, 41)
|
||||
assert.ok(game.getPlayer('p1').battlefield.includes(elves.id))
|
||||
})
|
||||
|
||||
test('activated mana abilities produce mana and creatures have summoning sickness', () => {
|
||||
const solRing = card('Sol Ring', {
|
||||
typeLine: 'Artifact',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{C}', '{C}'] } }],
|
||||
optional: false,
|
||||
text: '{T}: Add {C}{C}.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1', deck: Array.from({ length: 5 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 5 }, () => card('Filler')) }])
|
||||
game.start()
|
||||
const ring = game.addCard('p1', solRing, 'battlefield')
|
||||
const elves = game.addCard('p1', creature('Llanowar Elves', 1, 1, [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{G}'] } }],
|
||||
optional: false,
|
||||
text: '{T}: Add {G}.',
|
||||
}]), 'battlefield')
|
||||
|
||||
game.activateAbility('p1', ring.id, 0)
|
||||
assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 2 })
|
||||
assert.equal(ring.tapped, true)
|
||||
assert.throws(() => game.activateAbility('p1', elves.id, 0), GameError)
|
||||
|
||||
game.endTurn('p1')
|
||||
game.endTurn('p2')
|
||||
assert.equal(elves.tapped, false)
|
||||
game.activateAbility('p1', elves.id, 0)
|
||||
assert.equal(game.getPlayer('p1').manaPool.G, 1)
|
||||
})
|
||||
|
||||
test('a player who runs out of cards loses and the last player wins', () => {
|
||||
const game = new Game({
|
||||
seed: 3,
|
||||
startingHandSize: 0,
|
||||
players: [
|
||||
{ id: 'p1', deck: [card('Filler')] },
|
||||
{ id: 'p2', deck: [] },
|
||||
],
|
||||
})
|
||||
game.start()
|
||||
game.endTurn('p1')
|
||||
|
||||
assert.equal(game.status, 'finished')
|
||||
assert.equal(game.winner, 'p1')
|
||||
assert.equal(game.getPlayer('p2').lost, true)
|
||||
})
|
||||
|
||||
test('lethal damage to a player ends the game', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2', life: 3 }])
|
||||
game.start()
|
||||
game.addCard('p1', land('Mountain', 'R'), 'battlefield')
|
||||
const bolt = game.addCard('p1', spell('Lightning Bolt', [
|
||||
{ op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } },
|
||||
], '{R}'), 'hand')
|
||||
|
||||
game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] })
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(game.status, 'finished')
|
||||
assert.equal(game.winner, 'p1')
|
||||
assert.equal(game.getPlayer('p2').life, 0)
|
||||
})
|
||||
|
||||
test('the legend rule leaves one legendary permanent per name under one controller', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const legend = card('Kiora, the Rising Tide', {
|
||||
typeLine: 'Legendary Creature — Merfolk Wizard',
|
||||
power: 1,
|
||||
toughness: 1,
|
||||
})
|
||||
const first = game.addCard('p1', legend, 'battlefield')
|
||||
const second = game.addCard('p1', legend, 'battlefield')
|
||||
const forest = game.addCard('p1', land('Forest', 'G'), 'hand')
|
||||
|
||||
game.playLand('p1', forest.id)
|
||||
|
||||
assert.equal(first.zone, 'battlefield')
|
||||
assert.equal(second.zone, 'graveyard')
|
||||
assert.ok(game.getPlayer('p1').graveyard.includes(second.id))
|
||||
})
|
||||
|
||||
test('the legend rule does not apply across controllers', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const legend = card('Kiora, the Rising Tide', {
|
||||
typeLine: 'Legendary Creature — Merfolk Wizard',
|
||||
power: 1,
|
||||
toughness: 1,
|
||||
})
|
||||
const mine = game.addCard('p1', legend, 'battlefield')
|
||||
const theirs = game.addCard('p2', legend, 'battlefield')
|
||||
const forest = game.addCard('p1', land('Forest', 'G'), 'hand')
|
||||
|
||||
game.playLand('p1', forest.id)
|
||||
|
||||
assert.equal(mine.zone, 'battlefield')
|
||||
assert.equal(theirs.zone, 'battlefield')
|
||||
})
|
||||
|
||||
test('a failed mana payment leaves mana sources untapped and the pool unchanged', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const mountain = game.addCard('p1', land('Mountain', 'R'), 'battlefield')
|
||||
const expensive = game.addCard('p1', spell('Expensive Spell', [], '{R}{R}'), 'hand')
|
||||
|
||||
assert.throws(() => game.castSpell('p1', expensive.id), GameError)
|
||||
assert.equal(mountain.tapped, false)
|
||||
assert.equal(game.getPlayer('p1').manaPool.R, 0)
|
||||
assert.ok(game.getPlayer('p1').hand.includes(expensive.id))
|
||||
})
|
||||
|
||||
test('phyrexian mana can be paid with exactly enough life', () => {
|
||||
const game = setup([{ id: 'p1', life: 2 }, { id: 'p2' }])
|
||||
game.start()
|
||||
const spellCard = game.addCard('p1', spell('Gitaxian Probe', [], '{W/P}'), 'hand')
|
||||
|
||||
assert.doesNotThrow(() => game.castSpell('p1', spellCard.id))
|
||||
assert.equal(game.getPlayer('p1').life, 0)
|
||||
assert.equal(game.status, 'finished')
|
||||
assert.equal(game.winner, 'p2')
|
||||
})
|
||||
|
||||
test('an unless cost auto-taps the mana sources of the payer', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const bear = game.addCard('p2', creature('Grizzly Bears', 2, 2), 'battlefield')
|
||||
const forests = [
|
||||
game.addCard('p2', land('Forest', 'G'), 'battlefield'),
|
||||
game.addCard('p2', land('Forest', 'G'), 'battlefield'),
|
||||
]
|
||||
const edict = game.addCard('p1', spell('Edict', [{
|
||||
op: 'sacrifice',
|
||||
player: 'opponent',
|
||||
target: { kind: 'object', selector: { types: ['creature'] } },
|
||||
unless: { kind: 'mana', symbols: '{2}' },
|
||||
}]), 'hand')
|
||||
|
||||
game.castSpell('p1', edict.id, {
|
||||
targets: [{ kind: 'player', id: 'p2' }, { kind: 'object', id: bear.id }],
|
||||
})
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(bear.zone, 'battlefield')
|
||||
assert.ok(forests.every(forest => forest.tapped))
|
||||
assert.equal(game.getPlayer('p2').manaPool.G, 0)
|
||||
})
|
||||
|
||||
test('damage followed by exile-instead-of-dying sends the damaged creature to exile', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const bear = game.addCard('p2', creature('Doomed Bear', 2, 2), 'battlefield')
|
||||
const burn = game.addCard('p1', spell('Exiling Burn', [
|
||||
{ op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } },
|
||||
{ op: 'exile_instead_of_dying', target: { kind: 'damaged' } },
|
||||
]), 'hand')
|
||||
|
||||
game.castSpell('p1', burn.id, { targets: [{ kind: 'object', id: bear.id }] })
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(bear.zone, 'exile')
|
||||
assert.ok(game.getPlayer('p2').exile.includes(bear.id))
|
||||
assert.ok(!game.getPlayer('p2').graveyard.includes(bear.id))
|
||||
})
|
||||
155
backend/test/game-mana.test.ts
Normal file
155
backend/test/game-mana.test.ts
Normal file
@@ -0,0 +1,155 @@
|
||||
import assert from 'node:assert/strict'
|
||||
import test from 'node:test'
|
||||
import { Game, GameError } from '../src/game/game.js'
|
||||
import { compileText } from '../src/effects/compile.js'
|
||||
import type { Ability, Effect, TokenSpec } from '../src/effects/types.js'
|
||||
import type { CardDefinition, GameObject } from '../src/game/types.js'
|
||||
import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js'
|
||||
|
||||
test('Exotic Orchard is limited to colors an opponent land could produce', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const orchard = game.addCard('p1', exoticOrchard(), 'battlefield')
|
||||
game.addCard('p2', land('Forest', 'G'), 'battlefield')
|
||||
const green = game.addCard('p1', spell('Green Spell', [], '{G}'), 'hand')
|
||||
const blue = game.addCard('p1', spell('Blue Spell', [], '{U}'), 'hand')
|
||||
|
||||
assert.equal(game.canPlayCard('p1', green.id), true)
|
||||
assert.equal(game.canPlayCard('p1', blue.id), false)
|
||||
assert.throws(() => game.castSpell('p1', blue.id), GameError)
|
||||
assert.equal(orchard.tapped, false)
|
||||
assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 })
|
||||
|
||||
game.castSpell('p1', green.id)
|
||||
assert.equal(orchard.tapped, true)
|
||||
assert.equal(game.getPlayer('p1').manaPool.G, 0)
|
||||
})
|
||||
|
||||
test('Exotic Orchard adds an opponent land color when activated manually', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const orchard = game.addCard('p1', exoticOrchard(), 'battlefield')
|
||||
game.addCard('p2', land('Island', 'U'), 'battlefield')
|
||||
|
||||
game.activateAbility('p1', orchard.id, 0)
|
||||
assert.equal(game.getPlayer('p1').manaPool.U, 1)
|
||||
assert.equal(game.getPlayer('p1').manaPool.W, 0)
|
||||
})
|
||||
|
||||
test('Exotic Orchard produces nothing without an opponent land', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const orchard = game.addCard('p1', exoticOrchard(), 'battlefield')
|
||||
|
||||
game.activateAbility('p1', orchard.id, 0)
|
||||
assert.equal(orchard.tapped, true)
|
||||
assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 })
|
||||
})
|
||||
|
||||
test('a mana ability that makes one of several colors uses the chosen color', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const dual = game.addCard('p1', card('Dual Land', {
|
||||
typeLine: 'Land',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{W}', '{U}'], oneOf: true } }],
|
||||
optional: false,
|
||||
text: '{T}: Add {W} or {U}.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
|
||||
assert.deepEqual(game.manaColorChoices(dual, 0), ['W', 'U'])
|
||||
game.activateAbility('p1', dual.id, 0, { manaColor: 'U' })
|
||||
assert.equal(game.getPlayer('p1').manaPool.U, 1)
|
||||
assert.equal(game.getPlayer('p1').manaPool.W, 0)
|
||||
})
|
||||
|
||||
test('a mana color the ability cannot make is rejected before tapping', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const mono = game.addCard('p1', land('Mono Land', 'W'), 'battlefield')
|
||||
|
||||
assert.throws(() => game.activateAbility('p1', mono.id, 0, { manaColor: 'G' }), GameError)
|
||||
assert.equal(mono.tapped, false)
|
||||
assert.equal(game.getPlayer('p1').manaPool.G, 0)
|
||||
})
|
||||
|
||||
test('an any-color mana source produces the chosen color and offers all five', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const rainbow = game.addCard('p1', card('Rainbow Land', {
|
||||
typeLine: 'Land',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: false } }],
|
||||
optional: false,
|
||||
text: '{T}: Add one mana of any color.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
|
||||
assert.deepEqual(game.manaColorChoices(rainbow, 0), ['W', 'U', 'B', 'R', 'G'])
|
||||
game.activateAbility('p1', rainbow.id, 0, { manaColor: 'R' })
|
||||
assert.equal(game.getPlayer('p1').manaPool.R, 1)
|
||||
})
|
||||
|
||||
test('a restricted mana source is used before an unrestricted one', () => {
|
||||
const rainbow = card('Rainbow Land', {
|
||||
typeLine: 'Land',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: false } }],
|
||||
optional: false,
|
||||
text: '{T}: Add one mana of any color.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const rainbowLand = game.addCard('p1', rainbow, 'battlefield')
|
||||
const orchard = game.addCard('p1', exoticOrchard(), 'battlefield')
|
||||
game.addCard('p2', land('Forest', 'G'), 'battlefield')
|
||||
const gold = game.addCard('p1', spell('Gold Spell', [], '{G}{U}'), 'hand')
|
||||
|
||||
assert.equal(game.canPlayCard('p1', gold.id), true)
|
||||
game.castSpell('p1', gold.id)
|
||||
assert.equal(orchard.tapped, true)
|
||||
assert.equal(rainbowLand.tapped, true)
|
||||
assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 })
|
||||
})
|
||||
|
||||
test('static pump effects apply to matching creatures only', () => {
|
||||
const anthem = card('Glorious Anthem', {
|
||||
typeLine: 'Enchantment',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{
|
||||
op: 'pump',
|
||||
target: { kind: 'object', selector: { controller: 'you', types: ['creature'] }, mode: 'each' },
|
||||
power: { kind: 'number', value: 1 },
|
||||
toughness: { kind: 'number', value: 1 },
|
||||
}],
|
||||
text: 'Creatures you control get +1/+1.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const anthemObject = game.addCard('p1', anthem, 'battlefield')
|
||||
const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield')
|
||||
const enemy = game.addCard('p2', creature('Enemy Bear', 2, 2), 'battlefield')
|
||||
|
||||
assert.equal(game.getPower(bear), 3)
|
||||
assert.equal(game.getToughness(bear), 3)
|
||||
assert.equal(game.getPower(enemy), 2)
|
||||
assert.equal(game.getPower(anthemObject), 0)
|
||||
})
|
||||
663
backend/test/game-rules.test.ts
Normal file
663
backend/test/game-rules.test.ts
Normal file
@@ -0,0 +1,663 @@
|
||||
import assert from 'node:assert/strict'
|
||||
import test from 'node:test'
|
||||
import { Game, GameError } from '../src/game/game.js'
|
||||
import { compileText } from '../src/effects/compile.js'
|
||||
import type { Ability, Effect, TokenSpec } from '../src/effects/types.js'
|
||||
import type { CardDefinition, GameObject } from '../src/game/types.js'
|
||||
import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js'
|
||||
|
||||
test('canPlayCard reports legal lands and spells for the player with priority', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const forest = game.addCard('p1', land('Forest', 'G'), 'hand')
|
||||
const bear = game.addCard('p1', card('Grizzly Bears', {
|
||||
typeLine: 'Creature — Bear',
|
||||
power: 2,
|
||||
toughness: 2,
|
||||
manaCost: '{G}',
|
||||
}), 'hand')
|
||||
|
||||
assert.equal(game.canPlayCard('p1', forest.id), true)
|
||||
assert.equal(game.canPlayCard('p1', bear.id), false)
|
||||
assert.equal(game.canPlayCard('p2', forest.id), false)
|
||||
|
||||
game.playLand('p1', forest.id)
|
||||
assert.equal(game.canPlayCard('p1', bear.id), true)
|
||||
})
|
||||
|
||||
test('autoAdvance skips empty phases and stops when someone can act', () => {
|
||||
const expensive = card('Expensive', { manaCost: '{5}' })
|
||||
const game = new Game({
|
||||
seed: 3,
|
||||
startingHandSize: 0,
|
||||
players: [
|
||||
{ id: 'p1', deck: [expensive] },
|
||||
{ id: 'p2', deck: [expensive] },
|
||||
],
|
||||
})
|
||||
game.start()
|
||||
game.addCard('p1', land('Forest', 'G'), 'battlefield')
|
||||
|
||||
// The only action is a mana ability, which should not hold the phase open.
|
||||
game.autoAdvance()
|
||||
assert.equal(game.turn, 2)
|
||||
assert.equal(game.activePlayer, 'p2')
|
||||
assert.equal(game.phase, 'precombat_main')
|
||||
assert.equal(game.priority, 'p2')
|
||||
|
||||
const hasty = creature('Hasty', 2, 2, [{ kind: 'keyword', keyword: 'Haste' }])
|
||||
game.addCard('p2', hasty, 'battlefield')
|
||||
game.autoAdvance()
|
||||
assert.equal(game.turn, 2)
|
||||
assert.equal(game.phase, 'combat')
|
||||
assert.equal(game.step, 'declare_attackers')
|
||||
assert.equal(game.priority, 'p2')
|
||||
})
|
||||
|
||||
test('every defending player declares blocks before combat damage in multiplayer', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }, { id: 'p3' }])
|
||||
game.start()
|
||||
const first = game.addCard('p1', creature('First Attacker', 2, 2), 'battlefield')
|
||||
const second = game.addCard('p1', creature('Second Attacker', 3, 3), 'battlefield')
|
||||
first.enteredTurn = 0
|
||||
second.enteredTurn = 0
|
||||
|
||||
game.declareAttackers('p1', [
|
||||
{ attackerId: first.id, defenderId: 'p2' },
|
||||
{ attackerId: second.id, defenderId: 'p3' },
|
||||
])
|
||||
assert.equal(game.step, 'declare_blockers')
|
||||
|
||||
game.declareBlockers('p2', [])
|
||||
assert.equal(game.step, 'declare_blockers')
|
||||
assert.equal(game.priority, 'p3')
|
||||
|
||||
game.declareBlockers('p3', [])
|
||||
assert.equal(game.step, 'combat_damage')
|
||||
|
||||
game.resolveCombatDamage()
|
||||
assert.equal(game.getPlayer('p2').life, 38)
|
||||
assert.equal(game.getPlayer('p3').life, 37)
|
||||
})
|
||||
|
||||
test('counter-removal costs are paid and fail when counters run out', () => {
|
||||
const vessel = card('Spore Vessel', {
|
||||
typeLine: 'Artifact',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'remove_counters', counter: 'spore', amount: { kind: 'number', value: 2 } }],
|
||||
effects: [{ op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }],
|
||||
optional: false,
|
||||
text: 'Remove two spore counters from this: Draw a card.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2' }])
|
||||
game.start()
|
||||
const source = game.addCard('p1', vessel, 'battlefield')
|
||||
source.counters.spore = 3
|
||||
|
||||
game.activateAbility('p1', source.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(source.counters.spore, 1)
|
||||
assert.equal(game.getPlayer('p1').hand.length, 2)
|
||||
|
||||
assert.throws(() => game.activateAbility('p1', source.id, 0), GameError)
|
||||
assert.equal(source.counters.spore, 1)
|
||||
})
|
||||
|
||||
test('a free alternative cost needs a commander and skips the mana cost', () => {
|
||||
const maneuver = card('Flawless Maneuver', {
|
||||
typeLine: 'Instant',
|
||||
manaCost: '{2}{W}',
|
||||
manaValue: 3,
|
||||
abilities: [
|
||||
{
|
||||
kind: 'alternative_cost',
|
||||
costs: [],
|
||||
condition: { kind: 'you_control_commander' },
|
||||
text: 'If you control a commander, you may cast this spell without paying its mana cost.',
|
||||
},
|
||||
{
|
||||
kind: 'spell',
|
||||
effects: [{
|
||||
op: 'grant',
|
||||
target: { kind: 'object', selector: { controller: 'you', types: ['creature'] }, mode: 'each' },
|
||||
keyword: 'Indestructible',
|
||||
duration: 'until_end_of_turn',
|
||||
}],
|
||||
optional: false,
|
||||
text: 'Creatures you control gain indestructible until end of turn.',
|
||||
},
|
||||
],
|
||||
})
|
||||
const game = new Game({
|
||||
seed: 1,
|
||||
startingHandSize: 0,
|
||||
commander: true,
|
||||
players: [
|
||||
{ id: 'p1', deck: [card('Filler')], commander: creature('Test Commander', 2, 2) },
|
||||
{ id: 'p2', deck: [card('Filler')], commander: creature('Other Commander', 2, 2) },
|
||||
],
|
||||
})
|
||||
game.start()
|
||||
const spell = game.addCard('p1', maneuver, 'hand')
|
||||
|
||||
assert.equal(game.canPlayCard('p1', spell.id), false)
|
||||
assert.throws(() => game.castSpell('p1', spell.id), GameError)
|
||||
|
||||
game.moveToZone(game.getPlayer('p1').commanderId!, 'battlefield', { silent: true })
|
||||
|
||||
assert.equal(game.canPlayCard('p1', spell.id), true)
|
||||
game.castSpell('p1', spell.id)
|
||||
assert.equal(game.stack.length, 1)
|
||||
assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 })
|
||||
})
|
||||
|
||||
test('overload pays the overload cost and widens the spell target', () => {
|
||||
const rift = card('Cyclonic Rift', {
|
||||
typeLine: 'Instant',
|
||||
manaCost: '{U}',
|
||||
manaValue: 1,
|
||||
abilities: [
|
||||
{
|
||||
kind: 'spell',
|
||||
effects: [{
|
||||
op: 'return_to_hand',
|
||||
target: {
|
||||
kind: 'object',
|
||||
selector: { controller: 'opponent', types: ['permanent'], excludeTypes: ['land'] },
|
||||
mode: 'target',
|
||||
},
|
||||
}],
|
||||
optional: false,
|
||||
text: "Return target nonland permanent you don't control to its owner's hand.",
|
||||
},
|
||||
{ kind: 'overload', cost: '{1}{U}', text: 'Overload {1}{U}' },
|
||||
],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const island = game.addCard('p1', land('Island', 'U'), 'battlefield')
|
||||
const wastes = game.addCard('p1', land('Wastes', 'C'), 'battlefield')
|
||||
const ownCreature = game.addCard('p1', creature('Own Bear', 2, 2), 'battlefield')
|
||||
const theirCreature = game.addCard('p2', creature('Their Bear', 2, 2), 'battlefield')
|
||||
const theirArtifact = game.addCard('p2', card('Their Rock', {
|
||||
typeLine: 'Artifact',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
}), 'battlefield')
|
||||
const theirLand = game.addCard('p2', land('Forest', 'G'), 'battlefield')
|
||||
const spell = game.addCard('p1', rift, 'hand')
|
||||
|
||||
game.castSpell('p1', spell.id, { overload: true })
|
||||
|
||||
assert.equal(island.tapped, true)
|
||||
assert.equal(wastes.tapped, true)
|
||||
game.resolveStack()
|
||||
|
||||
assert.ok(game.getPlayer('p2').hand.includes(theirCreature.id))
|
||||
assert.ok(game.getPlayer('p2').hand.includes(theirArtifact.id))
|
||||
assert.ok(game.getPlayer('p2').battlefield.includes(theirLand.id))
|
||||
assert.ok(game.getPlayer('p1').battlefield.includes(ownCreature.id))
|
||||
})
|
||||
|
||||
test('a noncreature cost increase taxes spells but not creatures', () => {
|
||||
const thalia = card('Thalia, Guardian of Thraben', {
|
||||
typeLine: 'Legendary Creature — Human Soldier',
|
||||
power: 2,
|
||||
toughness: 1,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'cost_increase', amount: { kind: 'number', value: 1 }, spellType: 'noncreature' }],
|
||||
text: 'Noncreature spells cost {1} more to cast.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
game.addCard('p1', thalia, 'battlefield')
|
||||
const first = game.addCard('p1', land('Wastes', 'C'), 'battlefield')
|
||||
const instant = game.addCard('p1', spell('Ponder', [
|
||||
{ op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } },
|
||||
], '{1}'), 'hand')
|
||||
const bears = game.addCard('p1', card('Grizzly Bears', {
|
||||
typeLine: 'Creature — Bear',
|
||||
power: 2,
|
||||
toughness: 2,
|
||||
manaCost: '{1}',
|
||||
}), 'hand')
|
||||
|
||||
assert.equal(game.canPlayCard('p1', instant.id), false)
|
||||
assert.equal(game.canPlayCard('p1', bears.id), true)
|
||||
|
||||
game.addCard('p1', land('Wastes', 'C'), 'battlefield')
|
||||
assert.equal(game.canPlayCard('p1', instant.id), true)
|
||||
game.castSpell('p1', instant.id)
|
||||
assert.equal(first.tapped, true)
|
||||
})
|
||||
|
||||
test('spell cost reductions match the spell type and controller', () => {
|
||||
const baral = card('Baral, Chief of Compliance', {
|
||||
typeLine: 'Legendary Creature — Human Wizard',
|
||||
power: 1,
|
||||
toughness: 3,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{
|
||||
op: 'cost_reduction',
|
||||
target: { kind: 'object', selector: { controller: 'you', types: ['instant', 'sorcery'], match: 'any' }, mode: 'each' },
|
||||
amount: { kind: 'number', value: 1 },
|
||||
}],
|
||||
text: 'Instant and sorcery spells you cast cost {1} less to cast.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
game.addCard('p1', baral, 'battlefield')
|
||||
const wastes = game.addCard('p1', land('Wastes', 'C'), 'battlefield')
|
||||
const sorcery = game.addCard('p1', card('Divination', {
|
||||
typeLine: 'Sorcery',
|
||||
manaCost: '{2}',
|
||||
abilities: [{ kind: 'spell', effects: [{ op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }], optional: false, text: 'Draw a card.' }],
|
||||
}), 'hand')
|
||||
const bears = game.addCard('p1', card('Grizzly Bears', {
|
||||
typeLine: 'Creature — Bear',
|
||||
power: 2,
|
||||
toughness: 2,
|
||||
manaCost: '{2}',
|
||||
}), 'hand')
|
||||
|
||||
assert.equal(game.canPlayCard('p1', sorcery.id), true)
|
||||
assert.equal(game.canPlayCard('p1', bears.id), false)
|
||||
|
||||
game.castSpell('p1', sorcery.id)
|
||||
assert.equal(wastes.tapped, true)
|
||||
})
|
||||
|
||||
test('a colored cost reduction removes matching pips and nothing else', () => {
|
||||
const edgewalker = card('Edgewalker', {
|
||||
typeLine: 'Creature — Human Cleric',
|
||||
power: 2,
|
||||
toughness: 2,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{
|
||||
op: 'cost_reduction',
|
||||
target: { kind: 'object', selector: { controller: 'you', types: ['creature'], match: 'any', subtypes: ['cleric', 'soldier'] }, mode: 'each' },
|
||||
symbols: '{W}{B}',
|
||||
}],
|
||||
text: 'Cleric spells you cast cost {W}{B} less to cast.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
game.addCard('p1', edgewalker, 'battlefield')
|
||||
game.addCard('p1', land('Plains', 'W'), 'battlefield')
|
||||
game.addCard('p1', land('Swamp', 'B'), 'battlefield')
|
||||
const cleric = game.addCard('p1', card('Cleric Test', {
|
||||
typeLine: 'Creature — Human Cleric',
|
||||
power: 2,
|
||||
toughness: 2,
|
||||
colors: ['W', 'B'],
|
||||
manaCost: '{1}{W}{B}',
|
||||
manaValue: 3,
|
||||
}), 'hand')
|
||||
const soldier = game.addCard('p1', card('Soldier Test', {
|
||||
typeLine: 'Creature — Human Soldier',
|
||||
power: 2,
|
||||
toughness: 2,
|
||||
colors: ['W', 'B'],
|
||||
manaCost: '{1}{W}{B}',
|
||||
manaValue: 3,
|
||||
}), 'hand')
|
||||
const bear = game.addCard('p1', card('Bear Test', {
|
||||
typeLine: 'Creature — Bear',
|
||||
power: 2,
|
||||
toughness: 2,
|
||||
colors: ['W', 'B'],
|
||||
manaCost: '{1}{W}{B}',
|
||||
manaValue: 3,
|
||||
}), 'hand')
|
||||
|
||||
assert.equal(game.canPlayCard('p1', cleric.id), true)
|
||||
assert.equal(game.canPlayCard('p1', soldier.id), true)
|
||||
assert.equal(game.canPlayCard('p1', bear.id), false)
|
||||
game.castSpell('p1', cleric.id)
|
||||
})
|
||||
|
||||
test('Linvala stops only opponents from activating creature abilities', () => {
|
||||
const linvala = card('Linvala, Keeper of Silence', {
|
||||
typeLine: 'Legendary Creature — Angel',
|
||||
power: 3,
|
||||
toughness: 4,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{
|
||||
op: 'restriction',
|
||||
target: { kind: 'object', selector: { controller: 'opponent', types: ['creature'] }, mode: 'each' },
|
||||
rule: 'cant_activate',
|
||||
}],
|
||||
text: "Activated abilities of creatures your opponents control can't be activated.",
|
||||
}],
|
||||
})
|
||||
const drawAbility = {
|
||||
kind: 'activated' as const,
|
||||
costs: [],
|
||||
effects: [{ op: 'draw' as const, player: 'you' as const, amount: { kind: 'number' as const, value: 1 } }],
|
||||
optional: false,
|
||||
text: 'Draw a card.',
|
||||
}
|
||||
const game = setup([{ id: 'p1', deck: [card('Filler'), card('Filler')] }, { id: 'p2' }])
|
||||
game.start()
|
||||
game.addCard('p1', linvala, 'battlefield')
|
||||
const own = game.addCard('p1', creature('Own Cleric', 1, 1, [drawAbility]), 'battlefield')
|
||||
const theirs = game.addCard('p2', creature('Their Cleric', 1, 1, [drawAbility]), 'battlefield')
|
||||
|
||||
game.activateAbility('p1', own.id, 0)
|
||||
assert.equal(game.stack.length, 1)
|
||||
|
||||
game.resolveStack()
|
||||
game.pass('p1')
|
||||
assert.throws(() => game.activateAbility('p2', theirs.id, 0), /cannot activate/)
|
||||
})
|
||||
|
||||
test('Aven Mindcensor limits an opponent search to the top four cards', () => {
|
||||
const aven = card('Aven Mindcensor', {
|
||||
typeLine: 'Creature — Bird Wizard',
|
||||
power: 2,
|
||||
toughness: 1,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'search_restriction', who: 'opponent', amount: { kind: 'number', value: 4 } }],
|
||||
text: 'If an opponent would search a library, that player searches the top four cards of that library instead.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2', deck: [] }])
|
||||
game.start()
|
||||
game.addCard('p1', aven, 'battlefield')
|
||||
for (const name of ['Forest', 'Island', 'Mountain', 'Plains', 'Swamp', 'Wastes']) {
|
||||
game.addCard('p2', land(name, 'C'), 'library')
|
||||
}
|
||||
const topFour = game.getPlayer('p2').library.slice(0, 4)
|
||||
const growth = game.addCard('p2', spell('Rampant Growth', [{
|
||||
op: 'search',
|
||||
player: 'you',
|
||||
selector: { types: ['land'] },
|
||||
amount: { kind: 'number', value: 1 },
|
||||
destination: 'battlefield',
|
||||
shuffle: true,
|
||||
}]), 'hand')
|
||||
|
||||
game.pass('p1')
|
||||
game.castSpell('p2', growth.id)
|
||||
game.resolveStack()
|
||||
|
||||
assert.deepEqual(
|
||||
game.searchCandidates('p2').map(object => object.id).sort(),
|
||||
[...topFour].sort(),
|
||||
)
|
||||
})
|
||||
|
||||
test('Rest in Peace exiles all graveyards and replaces later graveyard moves', () => {
|
||||
const rest = card('Rest in Peace', {
|
||||
typeLine: 'Enchantment',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [
|
||||
{
|
||||
kind: 'triggered',
|
||||
event: { kind: 'enters', subject: { kind: 'self' } },
|
||||
effects: [{ op: 'exile_graveyards' }],
|
||||
optional: false,
|
||||
text: 'When this enchantment enters, exile all graveyards.',
|
||||
},
|
||||
{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'exile_instead_of_graveyard' }],
|
||||
text: 'If a card or token would be put into a graveyard from anywhere, exile it instead.',
|
||||
},
|
||||
],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const oldSpell = game.addCard('p1', spell('Old Spell', []), 'graveyard')
|
||||
const oldCreature = game.addCard('p2', creature('Old Bear', 2, 2), 'graveyard')
|
||||
const doomed = game.addCard('p1', creature('Doomed Bear', 2, 2), 'battlefield')
|
||||
|
||||
game.addCard('p1', rest, 'battlefield', { silent: false })
|
||||
game.resolveStack()
|
||||
|
||||
assert.ok(game.getPlayer('p1').exile.includes(oldSpell.id))
|
||||
assert.ok(game.getPlayer('p2').exile.includes(oldCreature.id))
|
||||
assert.deepEqual(game.getPlayer('p1').graveyard, [])
|
||||
assert.deepEqual(game.getPlayer('p2').graveyard, [])
|
||||
|
||||
game.moveToZone(doomed, 'graveyard')
|
||||
|
||||
assert.equal(doomed.zone, 'exile')
|
||||
assert.ok(game.getPlayer('p1').exile.includes(doomed.id))
|
||||
})
|
||||
|
||||
test("Leyline of the Void exiles only opponents' cards and starts on the battlefield", () => {
|
||||
const leyline = card('Leyline of the Void', {
|
||||
typeLine: 'Enchantment',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [
|
||||
{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'restriction', target: { kind: 'self' }, rule: 'begin_on_battlefield' }],
|
||||
text: 'If this card is in your opening hand, you may begin the game with it on the battlefield.',
|
||||
},
|
||||
{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'exile_instead_of_graveyard', owner: 'opponent' }],
|
||||
text: "If a card would be put into an opponent's graveyard from anywhere, exile it instead.",
|
||||
},
|
||||
],
|
||||
})
|
||||
const game = new Game({
|
||||
seed: 3,
|
||||
startingHandSize: 0,
|
||||
players: [{ id: 'p1', deck: [card('Filler')] }, { id: 'p2', deck: [card('Filler')] }],
|
||||
})
|
||||
const leylineObject = game.addCard('p1', leyline, 'hand')
|
||||
game.start()
|
||||
|
||||
assert.ok(game.getPlayer('p1').battlefield.includes(leylineObject.id))
|
||||
assert.ok(!game.getPlayer('p1').hand.includes(leylineObject.id))
|
||||
|
||||
const theirs = game.addCard('p2', creature('Their Bear', 2, 2), 'battlefield')
|
||||
const own = game.addCard('p1', creature('Own Bear', 2, 2), 'battlefield')
|
||||
game.moveToZone(theirs, 'graveyard')
|
||||
game.moveToZone(own, 'graveyard')
|
||||
|
||||
assert.equal(theirs.zone, 'exile')
|
||||
assert.equal(own.zone, 'graveyard')
|
||||
})
|
||||
|
||||
test('Field of the Dead makes a Zombie at seven differently named lands', () => {
|
||||
const field = card('Field of the Dead', {
|
||||
typeLine: 'Land',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'triggered',
|
||||
event: {
|
||||
kind: 'enters',
|
||||
subject: {
|
||||
kind: 'object',
|
||||
selector: { other: true, controller: 'you', types: ['land'] },
|
||||
mode: 'each',
|
||||
includeSelf: true,
|
||||
},
|
||||
},
|
||||
condition: { kind: 'distinct_names', selector: { types: ['land'] }, atLeast: 7 },
|
||||
effects: [{
|
||||
op: 'create_token',
|
||||
player: 'you',
|
||||
amount: { kind: 'number', value: 1 },
|
||||
token: {
|
||||
types: ['creature'],
|
||||
subtypes: ['zombie'],
|
||||
colors: ['B'],
|
||||
power: { kind: 'number', value: 2 },
|
||||
toughness: { kind: 'number', value: 2 },
|
||||
},
|
||||
}],
|
||||
optional: false,
|
||||
text: 'Whenever this or another land you control enters, if you control seven or more lands with different names, create a 2/2 black Zombie creature token.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
game.addCard('p1', field, 'battlefield')
|
||||
for (const name of ['Forest', 'Island', 'Mountain', 'Plains']) {
|
||||
game.addCard('p1', land(name, 'C'), 'battlefield')
|
||||
}
|
||||
|
||||
game.addCard('p1', land('Swamp', 'C'), 'battlefield', { silent: false })
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p1').battlefield
|
||||
.map(id => game.getObject(id)).filter(object => object.isToken).length, 0)
|
||||
|
||||
game.addCard('p1', land('Wastes', 'C'), 'battlefield', { silent: false })
|
||||
game.resolveStack()
|
||||
|
||||
const tokens = game.getPlayer('p1').battlefield
|
||||
.map(id => game.getObject(id)).filter(object => object.isToken)
|
||||
assert.equal(tokens.length, 1)
|
||||
assert.equal(tokens[0].definition.typeLine.toLowerCase().includes('zombie'), true)
|
||||
})
|
||||
|
||||
test('predefined Treasure, Gold, Powerstone, Heartwood, and Vibranium tokens produce mana', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
|
||||
const treasure = makeToken(game, { types: ['artifact'], subtypes: ['treasure'], colors: [] })
|
||||
assert.equal(treasure.definition.name, 'Treasure')
|
||||
game.activateAbility('p1', treasure.id, 0, { manaColor: 'G' })
|
||||
assert.equal(game.getPlayer('p1').manaPool.G, 1)
|
||||
assert.equal(treasure.zone, 'graveyard')
|
||||
|
||||
const gold = makeToken(game, { types: ['artifact'], subtypes: ['gold'], colors: [] })
|
||||
game.activateAbility('p1', gold.id, 0, { manaColor: 'R' })
|
||||
assert.equal(game.getPlayer('p1').manaPool.R, 1)
|
||||
|
||||
const powerstone = makeToken(game, { types: ['artifact'], subtypes: ['powerstone'], colors: [] })
|
||||
game.activateAbility('p1', powerstone.id, 0)
|
||||
assert.equal(game.getPlayer('p1').manaPool.C, 1)
|
||||
|
||||
const heartwood = makeToken(game, { types: ['artifact'], subtypes: ['heartwood'], colors: [] })
|
||||
game.activateAbility('p1', heartwood.id, 0, { manaColor: 'G' })
|
||||
assert.equal(game.getPlayer('p1').manaPool.G, 2)
|
||||
|
||||
const vibranium = makeToken(game, { types: ['artifact'], subtypes: ['vibranium'], colors: [] })
|
||||
assert.equal(game.hasKeyword(vibranium, 'Indestructible'), true)
|
||||
game.activateAbility('p1', vibranium.id, 0)
|
||||
assert.equal(game.getPlayer('p1').manaPool.C, 2)
|
||||
})
|
||||
|
||||
test('predefined Food, Clue, Blood, and Shard tokens sacrifice for their effects', () => {
|
||||
const game = setup([{
|
||||
id: 'p1',
|
||||
deck: Array.from({ length: 6 }, (_, index) => card(`Filler ${index}`)),
|
||||
}, { id: 'p2' }])
|
||||
game.start()
|
||||
|
||||
const food = makeToken(game, { types: ['artifact'], subtypes: ['food'], colors: [] })
|
||||
addMana(game, 'G', 'G')
|
||||
game.activateAbility('p1', food.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p1').life, 43)
|
||||
assert.equal(food.zone, 'graveyard')
|
||||
|
||||
game.addCard('p1', card('Discard Fodder'), 'hand')
|
||||
const discard = game.getObject(game.getPlayer('p1').hand[0])
|
||||
const handAfterFood = game.getPlayer('p1').hand.length
|
||||
const blood = makeToken(game, { types: ['artifact'], subtypes: ['blood'], colors: [] })
|
||||
addMana(game, 'G')
|
||||
game.activateAbility('p1', blood.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(discard.zone, 'graveyard')
|
||||
assert.equal(game.getPlayer('p1').hand.length, handAfterFood)
|
||||
|
||||
const clue = makeToken(game, { types: ['artifact'], subtypes: ['clue'], colors: [] })
|
||||
addMana(game, 'G', 'G')
|
||||
game.activateAbility('p1', clue.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p1').hand.length, handAfterFood + 1)
|
||||
|
||||
const shard = makeToken(game, { types: ['enchantment'], subtypes: ['shard'], colors: [] })
|
||||
addMana(game, 'G', 'G')
|
||||
game.activateAbility('p1', shard.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p1').hand.length, handAfterFood + 2)
|
||||
})
|
||||
|
||||
test('Walker and Incubator tokens use their predefined characteristics', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
|
||||
const walker = makeToken(game, { types: ['artifact'], subtypes: ['walker'], colors: [] })
|
||||
assert.equal(walker.definition.name, 'Walker')
|
||||
assert.equal(game.getPower(walker), 2)
|
||||
assert.equal(game.getToughness(walker), 2)
|
||||
assert.deepEqual(walker.definition.colors, ['B'])
|
||||
|
||||
const maker = game.addCard('p1', card('Incubator Maker', {
|
||||
typeLine: 'Artifact',
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'keyword_action', action: 'incubate', amount: { kind: 'number', value: 2 } }],
|
||||
optional: false,
|
||||
text: '{T}: Incubate 2.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
game.activateAbility('p1', maker.id, 0)
|
||||
game.resolveStack()
|
||||
|
||||
const incubator = game.getPlayer('p1').battlefield
|
||||
.map(id => game.getObject(id))
|
||||
.find(object => object.isToken && object.definition.name === 'Incubator')
|
||||
assert.ok(incubator)
|
||||
assert.equal(incubator.counters['+1/+1'], 2)
|
||||
|
||||
addMana(game, 'G', 'G')
|
||||
game.activateAbility('p1', incubator.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(incubator.definition.name, 'Phyrexian')
|
||||
assert.equal(game.getPower(incubator), 2)
|
||||
assert.equal(game.getToughness(incubator), 2)
|
||||
})
|
||||
|
||||
test('predefined Map, Lander, and Mutagen tokens use their activated abilities', () => {
|
||||
const mapGame = setup([{ id: 'p1', deck: [card('Filler')] }, { id: 'p2' }])
|
||||
mapGame.start()
|
||||
const topCard = mapGame.addCard('p1', card('Top Card'), 'library')
|
||||
const bear = mapGame.addCard('p1', creature('Bear', 2, 2), 'battlefield')
|
||||
addMana(mapGame, 'G')
|
||||
const map = makeToken(mapGame, { types: ['artifact'], subtypes: ['map'], colors: [] })
|
||||
mapGame.activateAbility('p1', map.id, 0, { targets: [{ kind: 'object', id: bear.id }] })
|
||||
mapGame.resolveStack()
|
||||
assert.equal(bear.counters['+1/+1'], 1)
|
||||
assert.equal(topCard.zone, 'graveyard')
|
||||
|
||||
addMana(mapGame, 'G')
|
||||
const mutagen = makeToken(mapGame, { types: ['artifact'], subtypes: ['mutagen'], colors: [] })
|
||||
mapGame.activateAbility('p1', mutagen.id, 0, { targets: [{ kind: 'object', id: bear.id }] })
|
||||
mapGame.resolveStack()
|
||||
assert.equal(bear.counters['+1/+1'], 2)
|
||||
|
||||
const landGame = setup([{ id: 'p1', deck: [card('Filler')] }, { id: 'p2' }])
|
||||
landGame.start()
|
||||
const forest = landGame.addCard('p1', land('Forest', 'G'), 'library')
|
||||
addMana(landGame, 'G', 'G')
|
||||
const lander = makeToken(landGame, { types: ['artifact'], subtypes: ['lander'], colors: [] })
|
||||
landGame.activateAbility('p1', lander.id, 0)
|
||||
landGame.resolveStack()
|
||||
assert.equal(forest.zone, 'battlefield')
|
||||
assert.equal(forest.tapped, true)
|
||||
})
|
||||
204
backend/test/game-search.test.ts
Normal file
204
backend/test/game-search.test.ts
Normal file
@@ -0,0 +1,204 @@
|
||||
import assert from 'node:assert/strict'
|
||||
import test from 'node:test'
|
||||
import { Game, GameError } from '../src/game/game.js'
|
||||
import { compileText } from '../src/effects/compile.js'
|
||||
import type { Ability, Effect, TokenSpec } from '../src/effects/types.js'
|
||||
import type { CardDefinition, GameObject } from '../src/game/types.js'
|
||||
import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js'
|
||||
|
||||
test('a search that shuffles and puts the chosen card on top leaves it on top', () => {
|
||||
const bear = creature('Bear', 2, 2)
|
||||
const elf = creature('Elf', 1, 1)
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const bearObject = game.addCard('p1', bear, 'library')
|
||||
const elfObject = game.addCard('p1', elf, 'library')
|
||||
const worldlyTutor = game.addCard('p1', spell('Worldly Tutor', [{
|
||||
op: 'search',
|
||||
player: 'you',
|
||||
selector: { types: ['creature'] },
|
||||
amount: { kind: 'number', value: 1 },
|
||||
destination: 'top',
|
||||
tapped: false,
|
||||
shuffle: true,
|
||||
}]), 'hand')
|
||||
|
||||
game.castSpell('p1', worldlyTutor.id)
|
||||
game.resolveStack()
|
||||
assert.equal(game.pendingSearch?.playerId, 'p1')
|
||||
|
||||
game.chooseSearchCard('p1', elfObject.id)
|
||||
|
||||
assert.equal(game.getPlayer('p1').library[0], elfObject.id)
|
||||
assert.ok(game.getPlayer('p1').library.includes(bearObject.id))
|
||||
})
|
||||
|
||||
test('as-enters creature type choices pause until the controller picks', () => {
|
||||
const cavern = card('Cavern of Souls', {
|
||||
typeLine: 'Land',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'choose', what: 'creature_type' }],
|
||||
text: 'As this enters, choose a creature type.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const object = game.addCard('p1', cavern, 'hand')
|
||||
game.playLand('p1', object.id)
|
||||
|
||||
assert.equal(game.pendingChoice?.sourceId, object.id)
|
||||
assert.equal(game.pendingChoice?.playerId, 'p1')
|
||||
assert.throws(() => game.pass('p1'), GameError)
|
||||
assert.throws(() => game.chooseCreatureType('p2', 'Elf'), GameError)
|
||||
assert.throws(() => game.chooseCreatureType('p1', 'Not A Type'), GameError)
|
||||
|
||||
game.chooseCreatureType('p1', 'elf')
|
||||
assert.equal(object.chosenCreatureType, 'Elf')
|
||||
assert.equal(game.pendingChoice, undefined)
|
||||
|
||||
game.moveToZone(object, 'graveyard')
|
||||
assert.equal(object.chosenCreatureType, undefined)
|
||||
game.moveToZone(object, 'battlefield', { silent: false })
|
||||
assert.equal(game.pendingChoice?.sourceId, object.id)
|
||||
})
|
||||
|
||||
test('a split search sends the first pick to the battlefield and the next to hand', () => {
|
||||
const forest = land('Forest', 'G')
|
||||
const island = land('Island', 'U')
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const forestObject = game.addCard('p1', forest, 'library')
|
||||
const islandObject = game.addCard('p1', island, 'library')
|
||||
const cultivate = game.addCard('p1', spell('Cultivate', [{
|
||||
op: 'search',
|
||||
player: 'you',
|
||||
selector: { types: ['land'], supertypes: ['basic'] },
|
||||
amount: { kind: 'number', value: 2 },
|
||||
destination: 'battlefield',
|
||||
tapped: true,
|
||||
shuffle: true,
|
||||
split: { destination: 'hand', tapped: false },
|
||||
}]), 'hand')
|
||||
|
||||
game.castSpell('p1', cultivate.id)
|
||||
game.resolveStack()
|
||||
|
||||
game.chooseSearchCard('p1', islandObject.id)
|
||||
assert.equal(game.pendingSearch?.destination, 'hand')
|
||||
game.chooseSearchCard('p1', forestObject.id)
|
||||
|
||||
assert.equal(game.pendingSearch, undefined)
|
||||
assert.ok(game.getPlayer('p1').battlefield.includes(islandObject.id))
|
||||
assert.equal(islandObject.tapped, true)
|
||||
assert.ok(game.getPlayer('p1').hand.includes(forestObject.id))
|
||||
})
|
||||
|
||||
test('autoAdvance stops instead of passing while a search needs a pick', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
game.addCard('p1', land('Forest', 'G'), 'library')
|
||||
game.addCard('p1', land('Island', 'U'), 'library')
|
||||
const rampantGrowth = game.addCard('p1', spell('Rampant Growth', [{
|
||||
op: 'search',
|
||||
player: 'you',
|
||||
selector: { types: ['land'], supertypes: ['basic'] },
|
||||
amount: { kind: 'number', value: 1 },
|
||||
destination: 'battlefield',
|
||||
tapped: true,
|
||||
shuffle: true,
|
||||
}]), 'hand')
|
||||
|
||||
game.castSpell('p1', rampantGrowth.id)
|
||||
game.autoAdvance()
|
||||
|
||||
assert.equal(game.pendingSearch?.playerId, 'p1')
|
||||
assert.equal(game.priority, 'p1')
|
||||
})
|
||||
|
||||
test('static replacement effects make permanents enter tapped with counters', () => {
|
||||
const slow = creature('Slow Bear', 2, 2, [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'enters_tapped', target: { kind: 'self' } }],
|
||||
text: 'This enters tapped.',
|
||||
}, {
|
||||
kind: 'static',
|
||||
effects: [{
|
||||
op: 'enters_with_counters',
|
||||
target: { kind: 'self' },
|
||||
counter: '+1/+1',
|
||||
amount: { kind: 'number', value: 1 },
|
||||
}],
|
||||
text: 'This enters with a +1/+1 counter.',
|
||||
}])
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const bear = game.addCard('p1', slow, 'hand')
|
||||
|
||||
game.castSpell('p1', bear.id)
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(bear.tapped, true)
|
||||
assert.equal(bear.counters['+1/+1'], 1)
|
||||
assert.equal(game.getPower(bear), 3)
|
||||
assert.equal(game.getToughness(bear), 3)
|
||||
})
|
||||
|
||||
function shockLand(): CardDefinition {
|
||||
return card('Steam Vents', {
|
||||
typeLine: 'Land — Island Mountain',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'enters_tapped', target: { kind: 'self' }, unlessCost: { kind: 'pay_life', amount: { kind: 'number', value: 2 } } }],
|
||||
text: "As this land enters, you may pay 2 life. If you don't, it enters tapped.",
|
||||
}, {
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{U}', '{R}'], oneOf: true } }],
|
||||
optional: false,
|
||||
text: '{T}: Add {U} or {R}.',
|
||||
}],
|
||||
})
|
||||
}
|
||||
|
||||
test('a land can pay life to enter untapped or enter tapped', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const vents = game.addCard('p1', shockLand(), 'hand')
|
||||
game.playLand('p1', vents.id)
|
||||
|
||||
assert.equal(vents.tapped, false)
|
||||
assert.equal(game.pendingChoice?.what, 'pay_cost')
|
||||
assert.equal(game.pendingChoice?.amount, 2)
|
||||
assert.throws(() => game.chooseCostPayment('p2', true), GameError)
|
||||
|
||||
game.chooseCostPayment('p1', true)
|
||||
assert.equal(game.getPlayer('p1').life, 38)
|
||||
assert.equal(vents.tapped, false)
|
||||
assert.equal(game.pendingChoice, undefined)
|
||||
|
||||
const second = game.addCard('p1', shockLand(), 'hand')
|
||||
game.moveToZone(second, 'battlefield', { controller: 'p1', silent: false })
|
||||
assert.equal(game.pendingChoice?.what, 'pay_cost')
|
||||
|
||||
game.chooseCostPayment('p1', false)
|
||||
assert.equal(second.tapped, true)
|
||||
assert.equal(game.getPlayer('p1').life, 38)
|
||||
})
|
||||
|
||||
test('a choice mana ability adds only the color the spell needs', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const vents = game.addCard('p1', shockLand(), 'battlefield')
|
||||
const red = game.addCard('p1', spell('Red Spell', [], '{R}'), 'hand')
|
||||
|
||||
game.castSpell('p1', red.id)
|
||||
|
||||
assert.equal(vents.tapped, true)
|
||||
assert.equal(game.getPlayer('p1').manaPool.R, 0)
|
||||
assert.equal(game.getPlayer('p1').manaPool.U, 0)
|
||||
})
|
||||
520
backend/test/game-targets.test.ts
Normal file
520
backend/test/game-targets.test.ts
Normal file
@@ -0,0 +1,520 @@
|
||||
import assert from 'node:assert/strict'
|
||||
import test from 'node:test'
|
||||
import { Game, GameError } from '../src/game/game.js'
|
||||
import { compileText } from '../src/effects/compile.js'
|
||||
import type { Ability, Effect, TokenSpec } from '../src/effects/types.js'
|
||||
import type { CardDefinition, GameObject } from '../src/game/types.js'
|
||||
import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js'
|
||||
|
||||
test('temporary pump effects expire at end of turn', () => {
|
||||
const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }])
|
||||
game.start()
|
||||
const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield')
|
||||
const growth = game.addCard('p1', spell('Giant Growth', [{
|
||||
op: 'pump',
|
||||
target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' },
|
||||
power: { kind: 'number', value: 3 },
|
||||
toughness: { kind: 'number', value: 3 },
|
||||
duration: 'until_end_of_turn',
|
||||
}]), 'hand')
|
||||
|
||||
game.castSpell('p1', growth.id, { targets: [{ kind: 'object', id: bear.id }] })
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPower(bear), 5)
|
||||
assert.equal(game.getToughness(bear), 5)
|
||||
|
||||
game.endTurn('p1')
|
||||
assert.equal(game.getPower(bear), 2)
|
||||
})
|
||||
|
||||
test('the engine exposes legal creature targets for a card', () => {
|
||||
const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }])
|
||||
game.start()
|
||||
const bear = game.addCard('p2', creature('Grizzly Bears', 2, 2), 'battlefield')
|
||||
const growth = game.addCard('p1', spell('Giant Growth', [{
|
||||
op: 'pump',
|
||||
target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' },
|
||||
power: { kind: 'number', value: 3 },
|
||||
toughness: { kind: 'number', value: 3 },
|
||||
duration: 'until_end_of_turn',
|
||||
}]), 'hand')
|
||||
|
||||
assert.deepEqual(game.legalTargetsForCard('p1', growth.id), [{ kind: 'object', id: bear.id }])
|
||||
})
|
||||
|
||||
test('excluded colors filter legal targets', () => {
|
||||
const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }])
|
||||
game.start()
|
||||
game.addCard('p2', card('Black Bear', { typeLine: 'Creature — Bear', colors: ['B'], power: 2, toughness: 2 }), 'battlefield')
|
||||
const green = game.addCard('p2', card('Green Bear', { typeLine: 'Creature — Bear', colors: ['G'], power: 2, toughness: 2 }), 'battlefield')
|
||||
const doomBlade = game.addCard('p1', spell('Doom Blade', [{
|
||||
op: 'destroy',
|
||||
target: { kind: 'object', selector: { types: ['creature'], excludeColors: ['B'] }, mode: 'target' },
|
||||
}]), 'hand')
|
||||
|
||||
assert.deepEqual(game.legalTargetsForCard('p1', doomBlade.id), [{ kind: 'object', id: green.id }])
|
||||
})
|
||||
|
||||
test('the engine exposes legal targets for an activated ability', () => {
|
||||
const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }])
|
||||
game.start()
|
||||
const bear = game.addCard('p2', creature('Grizzly Bears', 2, 2), 'battlefield')
|
||||
const pinger = game.addCard('p1', card('Pinger', {
|
||||
typeLine: 'Creature — Test',
|
||||
power: 1,
|
||||
toughness: 1,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [],
|
||||
optional: false,
|
||||
text: '{T}: This creature deals 1 damage to target creature an opponent controls.',
|
||||
effects: [{
|
||||
op: 'damage',
|
||||
target: { kind: 'object', selector: { controller: 'opponent', types: ['creature'] }, mode: 'target' },
|
||||
amount: { kind: 'number', value: 1 },
|
||||
}],
|
||||
}],
|
||||
}), 'battlefield')
|
||||
|
||||
assert.deepEqual(game.legalTargetsForAbility('p1', pinger.id, 0), [{ kind: 'object', id: bear.id }])
|
||||
})
|
||||
|
||||
test('"until the end of your next turn" lasts through the controller next turn', () => {
|
||||
const game = setup([{ id: 'p1', deck: Array.from({ length: 3 }, () => card('Filler')) }, { id: 'p2', deck: Array.from({ length: 3 }, () => card('Filler')) }])
|
||||
game.start()
|
||||
const bear = game.addCard('p1', creature('Grizzly Bears', 2, 2), 'battlefield')
|
||||
const growth = game.addCard('p1', spell('Growth', [{
|
||||
op: 'pump',
|
||||
target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' },
|
||||
power: { kind: 'number', value: 3 },
|
||||
toughness: { kind: 'number', value: 3 },
|
||||
duration: 'until_end_of_your_next_turn',
|
||||
}]), 'hand')
|
||||
|
||||
game.castSpell('p1', growth.id, { targets: [{ kind: 'object', id: bear.id }] })
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPower(bear), 5)
|
||||
|
||||
game.endTurn('p1')
|
||||
assert.equal(game.getPower(bear), 5)
|
||||
|
||||
game.endTurn('p2')
|
||||
assert.equal(game.getPower(bear), 5)
|
||||
|
||||
game.endTurn('p1')
|
||||
assert.equal(game.getPower(bear), 2)
|
||||
})
|
||||
|
||||
test('counter replacement doubles counters put on matching creatures', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.addCard('p1', card('Hardened Scales Test', {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{
|
||||
op: 'counter_multiplier',
|
||||
target: { kind: 'object', selector: { types: ['creature'], controller: 'you' }, mode: 'each' },
|
||||
counter: '+1/+1',
|
||||
multiplier: 2,
|
||||
}],
|
||||
text: 'If one or more +1/+1 counters would be put on a creature you control, twice that many are put on it instead.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
game.start()
|
||||
const bear = game.addCard('p1', creature('Counter Bear', 2, 2), 'battlefield')
|
||||
const growth = game.addCard('p1', spell('Growth', [{
|
||||
op: 'put_counters',
|
||||
target: { kind: 'object', selector: { types: ['creature'] } },
|
||||
counter: '+1/+1',
|
||||
amount: { kind: 'number', value: 2 },
|
||||
}]), 'hand')
|
||||
|
||||
game.castSpell('p1', growth.id, { targets: [{ kind: 'object', id: bear.id }] })
|
||||
game.resolveStack()
|
||||
assert.equal(bear.counters['+1/+1'], 4)
|
||||
})
|
||||
|
||||
test('energy replacement doubles energy gained', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.addCard('p1', card('Energy Doubler', {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'replacement_amount', what: 'energy', multiplier: 2 }],
|
||||
text: 'If you would get one or more {E}, you get twice that many {E} instead.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
game.start()
|
||||
const spark = game.addCard('p1', spell('Spark', [
|
||||
{ op: 'energy', player: 'you', amount: { kind: 'number', value: 2 } },
|
||||
]), 'hand')
|
||||
|
||||
game.castSpell('p1', spark.id)
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p1').energy, 4)
|
||||
})
|
||||
|
||||
test('a static source-filtered prevention stops only matching damage', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
const protectedCreature = game.addCard('p1', card('Ward Golem', {
|
||||
typeLine: 'Artifact Creature — Golem',
|
||||
power: 2,
|
||||
toughness: 5,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{
|
||||
op: 'prevent_damage',
|
||||
target: { kind: 'self' },
|
||||
amount: 'all',
|
||||
duration: 'permanent',
|
||||
sourceSelector: { types: ['creature'] },
|
||||
}],
|
||||
text: 'Prevent all damage that would be dealt to this by creatures.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
const plain = game.addCard('p1', creature('Plain Bear', 2, 5), 'battlefield')
|
||||
const pinger = game.addCard('p2', card('Pinger', {
|
||||
typeLine: 'Creature — Test',
|
||||
power: 1,
|
||||
toughness: 1,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [],
|
||||
effects: [{
|
||||
op: 'damage',
|
||||
target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' },
|
||||
amount: { kind: 'number', value: 3 },
|
||||
}],
|
||||
optional: false,
|
||||
text: '{0}: Deal 3 damage to target creature.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
game.start()
|
||||
|
||||
while (game.priority !== 'p2') game.pass(game.priority)
|
||||
game.activateAbility('p2', pinger.id, 0, { targets: [{ kind: 'object', id: protectedCreature.id }] })
|
||||
game.resolveStack()
|
||||
assert.equal(protectedCreature.damage, 0)
|
||||
|
||||
while (game.priority !== 'p2') game.pass(game.priority)
|
||||
game.activateAbility('p2', pinger.id, 0, { targets: [{ kind: 'object', id: plain.id }] })
|
||||
game.resolveStack()
|
||||
assert.equal(plain.damage, 3)
|
||||
})
|
||||
|
||||
test('a source-scoped shield only stops the chosen source', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
const pinger = (name: string) => card(name, {
|
||||
typeLine: 'Creature — Test',
|
||||
power: 1,
|
||||
toughness: 1,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [],
|
||||
effects: [{
|
||||
op: 'damage',
|
||||
target: { kind: 'player', who: 'opponent', mode: 'target' },
|
||||
amount: { kind: 'number', value: 3 },
|
||||
}],
|
||||
optional: false,
|
||||
text: '{0}: Deal 3 damage to target opponent.',
|
||||
}],
|
||||
})
|
||||
const chosen = game.addCard('p2', pinger('Chosen Pinger'), 'battlefield')
|
||||
const other = game.addCard('p2', pinger('Other Pinger'), 'battlefield')
|
||||
game.start()
|
||||
|
||||
const shield = spell('Source Shield', [{
|
||||
op: 'prevent_damage',
|
||||
target: { kind: 'any' },
|
||||
amount: 'all',
|
||||
duration: 'until_end_of_turn',
|
||||
global: true,
|
||||
source: { kind: 'object', selector: {}, mode: 'target' },
|
||||
}])
|
||||
const shieldCard = game.addCard('p1', shield, 'hand')
|
||||
game.castSpell('p1', shieldCard.id, { targets: [{ kind: 'object', id: chosen.id }] })
|
||||
game.resolveStack()
|
||||
|
||||
while (game.priority !== 'p2') game.pass(game.priority)
|
||||
game.activateAbility('p2', chosen.id, 0, { targets: [{ kind: 'player', id: 'p1' }] })
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p1').life, 40)
|
||||
|
||||
while (game.priority !== 'p2') game.pass(game.priority)
|
||||
game.activateAbility('p2', other.id, 0, { targets: [{ kind: 'player', id: 'p1' }] })
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p1').life, 37)
|
||||
})
|
||||
|
||||
test('a prevention follow-up runs with the prevented amount', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const target = game.addCard('p1', creature('Shielded Bear', 2, 5), 'battlefield')
|
||||
const shield = spell('Shield', [{
|
||||
op: 'prevent_damage',
|
||||
target: { kind: 'object', selector: { types: ['creature'] } },
|
||||
amount: { kind: 'number', value: 3 },
|
||||
duration: 'until_end_of_turn',
|
||||
then: [{
|
||||
op: 'damage',
|
||||
target: { kind: 'player', who: 'opponent', mode: 'target' },
|
||||
amount: { kind: 'event_amount' },
|
||||
}],
|
||||
}])
|
||||
const bolt = spell('Bolt', [{
|
||||
op: 'damage',
|
||||
target: { kind: 'object', selector: { types: ['creature'] } },
|
||||
amount: { kind: 'number', value: 5 },
|
||||
}])
|
||||
|
||||
const shieldCard = game.addCard('p1', shield, 'hand')
|
||||
game.castSpell('p1', shieldCard.id, {
|
||||
targets: [{ kind: 'object', id: target.id }, { kind: 'player', id: 'p2' }],
|
||||
})
|
||||
game.resolveStack()
|
||||
const boltCard = game.addCard('p1', bolt, 'hand')
|
||||
game.castSpell('p1', boltCard.id, { targets: [{ kind: 'object', id: target.id }] })
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(target.damage, 2)
|
||||
assert.equal(game.getPlayer('p2').life, 37)
|
||||
})
|
||||
|
||||
test('color-specific damage replacement only boosts matching sources', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.addCard('p1', card('Red Enhancer', {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'replacement_amount', what: 'damage', multiplier: 1, add: 1, sourceColor: 'R' }],
|
||||
text: 'If a red source would deal damage, it deals that much damage plus 1 instead.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
game.start()
|
||||
const redBolt = game.addCard('p1', card('Red Bolt', {
|
||||
typeLine: 'Instant',
|
||||
colors: ['R'],
|
||||
abilities: [{
|
||||
kind: 'spell',
|
||||
effects: [{ op: 'damage', target: { kind: 'player', who: 'opponent', mode: 'target' }, amount: { kind: 'number', value: 3 } }],
|
||||
optional: false,
|
||||
text: 'Deal 3 damage.',
|
||||
}],
|
||||
}), 'hand')
|
||||
|
||||
game.castSpell('p1', redBolt.id, { targets: [{ kind: 'player', id: 'p2' }] })
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p2').life, 36)
|
||||
})
|
||||
|
||||
test('life-gain replacement doubles the life gained', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.addCard('p1', card('Life Doubler', {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'replacement_amount', what: 'life_gain', multiplier: 2 }],
|
||||
text: 'If you would gain life, you gain twice that much life instead.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
game.start()
|
||||
const heal = game.addCard('p1', spell('Heal', [
|
||||
{ op: 'life', player: 'you', amount: { kind: 'number', value: 3 }, mode: 'gain' },
|
||||
]), 'hand')
|
||||
|
||||
game.castSpell('p1', heal.id)
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p1').life, 46)
|
||||
})
|
||||
|
||||
test('damage replacement doubles damage from sources you control', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.addCard('p1', card('Furnace', {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'replacement_amount', what: 'damage', multiplier: 2 }],
|
||||
text: 'If a source you control would deal damage, it deals double that damage instead.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
game.start()
|
||||
const bolt = game.addCard('p1', spell('Bolt', [
|
||||
{ op: 'damage', target: { kind: 'player', who: 'opponent', mode: 'target' }, amount: { kind: 'number', value: 3 } },
|
||||
]), 'hand')
|
||||
|
||||
game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] })
|
||||
game.resolveStack()
|
||||
assert.equal(game.getPlayer('p2').life, 34)
|
||||
})
|
||||
|
||||
test('draw replacement doubles each draw', () => {
|
||||
const deck = [card('Filler One'), card('Filler Two'), card('Filler Three'), card('Filler Four')]
|
||||
const game = setup([{ id: 'p1', deck }, { id: 'p2', deck }])
|
||||
game.addCard('p1', card('Draw Doubler', {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'replacement_amount', what: 'draw', multiplier: 2 }],
|
||||
text: 'If you would draw a card, draw two cards instead.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
game.start()
|
||||
assert.equal(game.getPlayer('p1').hand.length, 2)
|
||||
assert.equal(game.getPlayer('p2').hand.length, 0)
|
||||
})
|
||||
|
||||
test('"skip your draw step" stops its controller drawing', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.addCard('p1', card('Necro Test', {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'restriction', target: { kind: 'player', who: 'you', mode: 'target' }, rule: 'skip_draw_step' }],
|
||||
text: 'Skip your draw step.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
game.start()
|
||||
|
||||
assert.equal(game.getPlayer('p1').hand.length, 0)
|
||||
assert.equal(game.getPlayer('p1').library.length, 1)
|
||||
|
||||
game.endTurn('p1')
|
||||
game.endTurn('p2')
|
||||
assert.equal(game.activePlayer, 'p1')
|
||||
assert.equal(game.getPlayer('p1').hand.length, 0)
|
||||
assert.equal(game.getPlayer('p1').library.length, 1)
|
||||
})
|
||||
|
||||
test('an unblockable attacker rejects declared blockers', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
const attacker = game.addCard('p1', card('Slippery Otter', {
|
||||
typeLine: 'Creature — Otter',
|
||||
power: 2,
|
||||
toughness: 2,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_be_blocked' }],
|
||||
text: 'This creature cannot be blocked.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
const blocker = game.addCard('p2', creature('Blocker', 2, 2), 'battlefield')
|
||||
game.start()
|
||||
|
||||
game.declareAttackers('p1', [{ attackerId: attacker.id, defenderId: 'p2' }])
|
||||
assert.throws(
|
||||
() => game.declareBlockers('p2', [{ blockerId: blocker.id, attackerId: attacker.id }]),
|
||||
/cannot be blocked/,
|
||||
)
|
||||
})
|
||||
|
||||
test('a "can\'t be countered" spell survives a counterspell', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const uncounterable = card('Uncounterable', {
|
||||
typeLine: 'Instant',
|
||||
abilities: [
|
||||
{ kind: 'spell', effects: [{ op: 'life', player: 'you', amount: { kind: 'number', value: 3 }, mode: 'gain' }], optional: false, text: 'Gain 3 life.' },
|
||||
{ kind: 'static', effects: [{ op: 'restriction', target: { kind: 'self' }, rule: 'cant_be_countered' }], text: 'This spell cannot be countered.' },
|
||||
],
|
||||
})
|
||||
const counterspell = spell('Counterspell', [{ op: 'counter', what: 'spell', target: { kind: 'spell', selector: {}, mode: 'target' } }])
|
||||
const target = game.addCard('p1', uncounterable, 'hand')
|
||||
const counterCard = game.addCard('p2', counterspell, 'hand')
|
||||
|
||||
game.castSpell('p1', target.id)
|
||||
game.castSpell('p2', counterCard.id, { targets: [{ kind: 'spell', id: game.stack[game.stack.length - 1].id }] })
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(game.getPlayer('p1').life, 43)
|
||||
assert.equal(target.zone, 'graveyard')
|
||||
})
|
||||
|
||||
test('combat damage kills creatures and moves them to the graveyard', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
const attacker = game.addCard('p1', creature('Attacker', 2, 2), 'battlefield')
|
||||
const blocker = game.addCard('p2', creature('Blocker', 2, 2), 'battlefield')
|
||||
game.start()
|
||||
|
||||
game.declareAttackers('p1', [{ attackerId: attacker.id, defenderId: 'p2' }])
|
||||
assert.equal(game.step, 'declare_blockers')
|
||||
assert.equal(game.priority, 'p2')
|
||||
assert.equal(attacker.tapped, true)
|
||||
|
||||
game.declareBlockers('p2', [{ blockerId: blocker.id, attackerId: attacker.id }])
|
||||
game.resolveCombatDamage()
|
||||
|
||||
assert.equal(game.getPlayer('p2').life, 40)
|
||||
assert.equal(game.step, 'end_combat')
|
||||
assert.ok(game.getPlayer('p1').graveyard.includes(attacker.id))
|
||||
assert.ok(game.getPlayer('p2').graveyard.includes(blocker.id))
|
||||
})
|
||||
|
||||
test('unblocked attackers deal damage to the defending player', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
const attacker = game.addCard('p1', creature('Attacker', 3, 3), 'battlefield')
|
||||
game.start()
|
||||
|
||||
game.declareAttackers('p1', [{ attackerId: attacker.id, defenderId: 'p2' }])
|
||||
game.declareBlockers('p2', [])
|
||||
game.resolveCombatDamage()
|
||||
|
||||
assert.equal(game.getPlayer('p2').life, 37)
|
||||
})
|
||||
|
||||
test('counterspell counters a spell on the stack', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
game.addCard('p1', land('Mountain', 'R'), 'battlefield')
|
||||
game.addCard('p2', land('Island', 'U'), 'battlefield')
|
||||
game.addCard('p2', land('Island', 'U'), 'battlefield')
|
||||
const bolt = game.addCard('p1', spell('Lightning Bolt', [
|
||||
{ op: 'damage', target: { kind: 'any' }, amount: { kind: 'number', value: 3 } },
|
||||
], '{R}'), 'hand')
|
||||
const counterspell = game.addCard('p2', spell('Counterspell', [
|
||||
{ op: 'counter', what: 'spell', target: { kind: 'spell', selector: { types: [] }, mode: 'target' } },
|
||||
], '{U}{U}'), 'hand')
|
||||
|
||||
game.castSpell('p1', bolt.id, { targets: [{ kind: 'player', id: 'p2' }] })
|
||||
game.castSpell('p2', counterspell.id)
|
||||
assert.equal(game.stack.length, 2)
|
||||
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(game.getPlayer('p2').life, 40)
|
||||
assert.equal(game.stack.length, 0)
|
||||
assert.ok(game.getPlayer('p1').graveyard.includes(bolt.id))
|
||||
assert.ok(game.getPlayer('p2').graveyard.includes(counterspell.id))
|
||||
})
|
||||
|
||||
test('activated abilities create tokens that enter the battlefield', () => {
|
||||
const maker = card('Goblin Maker', {
|
||||
typeLine: 'Artifact',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{
|
||||
op: 'create_token',
|
||||
player: 'you',
|
||||
amount: { kind: 'number', value: 1 },
|
||||
token: { name: 'Goblin', types: ['creature'], subtypes: ['goblin'], colors: ['R'], power: { kind: 'number', value: 1 }, toughness: { kind: 'number', value: 1 } },
|
||||
}],
|
||||
optional: false,
|
||||
text: '{T}: Create a 1/1 Goblin.',
|
||||
}],
|
||||
})
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const source = game.addCard('p1', maker, 'battlefield')
|
||||
|
||||
game.activateAbility('p1', source.id, 0)
|
||||
assert.equal(game.stack.length, 1)
|
||||
game.resolveStack()
|
||||
|
||||
const tokens = game.getPlayer('p1').battlefield.map(id => game.getObject(id)).filter(object => object.isToken)
|
||||
assert.equal(tokens.length, 1)
|
||||
assert.equal(tokens[0].definition.name, 'Goblin')
|
||||
assert.equal(game.getPower(tokens[0]), 1)
|
||||
})
|
||||
224
backend/test/game-tokens.test.ts
Normal file
224
backend/test/game-tokens.test.ts
Normal file
@@ -0,0 +1,224 @@
|
||||
import assert from 'node:assert/strict'
|
||||
import test from 'node:test'
|
||||
import { Game, GameError } from '../src/game/game.js'
|
||||
import { compileText } from '../src/effects/compile.js'
|
||||
import type { Ability, Effect, TokenSpec } from '../src/effects/types.js'
|
||||
import type { CardDefinition, GameObject } from '../src/game/types.js'
|
||||
import { card, creature, spell, land, exoticOrchard, setup, tokenMaker, tokenDoubler, makeToken, addMana, roleMaker, shockLand } from './helpers.js'
|
||||
|
||||
test('token doublers stack and only apply to their controller', () => {
|
||||
const goblin: TokenSpec = {
|
||||
types: ['creature'],
|
||||
subtypes: ['goblin'],
|
||||
colors: ['R'],
|
||||
power: { kind: 'number', value: 1 },
|
||||
toughness: { kind: 'number', value: 1 },
|
||||
}
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const p1Maker = game.addCard('p1', tokenMaker('P1 Maker', goblin), 'battlefield')
|
||||
game.addCard('p1', tokenDoubler('Parallel Lives', 2), 'battlefield')
|
||||
game.addCard('p1', tokenDoubler('Anointed Procession', 2), 'battlefield')
|
||||
const p2Maker = game.addCard('p2', tokenMaker('P2 Maker', goblin), 'battlefield')
|
||||
game.addCard('p2', tokenDoubler('Adrix and Nev', 2), 'battlefield')
|
||||
const tokensOf = (playerId: string): number => game.getPlayer(playerId).battlefield
|
||||
.map(id => game.getObject(id)).filter(object => object.isToken).length
|
||||
|
||||
game.activateAbility('p1', p1Maker.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(tokensOf('p1'), 4)
|
||||
assert.equal(tokensOf('p2'), 0)
|
||||
|
||||
game.endTurn('p1')
|
||||
game.activateAbility('p2', p2Maker.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(tokensOf('p2'), 2)
|
||||
})
|
||||
|
||||
test('Primal Vigor doubles tokens for every player', () => {
|
||||
const goblin: TokenSpec = {
|
||||
types: ['creature'],
|
||||
subtypes: ['goblin'],
|
||||
colors: ['R'],
|
||||
power: { kind: 'number', value: 1 },
|
||||
toughness: { kind: 'number', value: 1 },
|
||||
}
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const p1Maker = game.addCard('p1', tokenMaker('P1 Maker', goblin), 'battlefield')
|
||||
game.addCard('p1', tokenDoubler('Primal Vigor', 2, 'each_player'), 'battlefield')
|
||||
const p2Maker = game.addCard('p2', tokenMaker('P2 Maker', goblin), 'battlefield')
|
||||
const tokensOf = (playerId: string): number => game.getPlayer(playerId).battlefield
|
||||
.map(id => game.getObject(id)).filter(object => object.isToken).length
|
||||
|
||||
game.activateAbility('p1', p1Maker.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(tokensOf('p1'), 2)
|
||||
|
||||
game.endTurn('p1')
|
||||
game.activateAbility('p2', p2Maker.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(tokensOf('p2'), 2)
|
||||
})
|
||||
|
||||
test('Ojer Taq triples creature tokens but not other tokens', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const creatureMaker = game.addCard('p1', tokenMaker('Creature Maker', {
|
||||
types: ['creature'],
|
||||
subtypes: ['goblin'],
|
||||
colors: ['R'],
|
||||
power: { kind: 'number', value: 1 },
|
||||
toughness: { kind: 'number', value: 1 },
|
||||
}), 'battlefield')
|
||||
const treasureMaker = game.addCard('p1', tokenMaker('Treasure Maker', {
|
||||
types: ['artifact'], subtypes: ['treasure'], colors: [],
|
||||
}), 'battlefield')
|
||||
game.addCard('p1', tokenDoubler('Ojer Taq', 3, 'you', true), 'battlefield')
|
||||
|
||||
game.activateAbility('p1', creatureMaker.id, 0)
|
||||
game.resolveStack()
|
||||
game.activateAbility('p1', treasureMaker.id, 0)
|
||||
game.resolveStack()
|
||||
|
||||
const tokens = game.getPlayer('p1').battlefield.map(id => game.getObject(id)).filter(object => object.isToken)
|
||||
assert.equal(tokens.filter(object => object.definition.typeLine.toLowerCase().includes('creature')).length, 3)
|
||||
assert.equal(tokens.filter(object => object.definition.typeLine.toLowerCase().includes('treasure')).length, 1)
|
||||
})
|
||||
|
||||
test('search effects find cards in the library and put them onto the battlefield tapped', () => {
|
||||
const forest = land('Forest', 'G')
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const found = game.addCard('p1', forest, 'library')
|
||||
const rampantGrowth = game.addCard('p1', spell('Rampant Growth', [{
|
||||
op: 'search',
|
||||
player: 'you',
|
||||
selector: { types: ['land'], supertypes: ['basic'] },
|
||||
amount: { kind: 'number', value: 1 },
|
||||
destination: 'battlefield',
|
||||
tapped: true,
|
||||
shuffle: true,
|
||||
}]), 'hand')
|
||||
|
||||
game.castSpell('p1', rampantGrowth.id)
|
||||
game.resolveStack()
|
||||
|
||||
assert.ok(game.getPlayer('p1').battlefield.includes(found.id))
|
||||
assert.equal(found.tapped, true)
|
||||
})
|
||||
|
||||
test('search effects let the player pick among multiple matching cards', () => {
|
||||
const forest = land('Forest', 'G')
|
||||
const island = land('Island', 'U')
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const forestObject = game.addCard('p1', forest, 'library')
|
||||
const islandObject = game.addCard('p1', island, 'library')
|
||||
const rampantGrowth = game.addCard('p1', spell('Rampant Growth', [{
|
||||
op: 'search',
|
||||
player: 'you',
|
||||
selector: { types: ['land'], supertypes: ['basic'] },
|
||||
amount: { kind: 'number', value: 1 },
|
||||
destination: 'battlefield',
|
||||
tapped: true,
|
||||
shuffle: true,
|
||||
}]), 'hand')
|
||||
|
||||
game.castSpell('p1', rampantGrowth.id)
|
||||
game.resolveStack()
|
||||
|
||||
assert.equal(game.pendingSearch?.playerId, 'p1')
|
||||
assert.deepEqual(
|
||||
game.searchCandidates('p1').map(object => object.id).sort(),
|
||||
[forestObject.id, islandObject.id].sort(),
|
||||
)
|
||||
assert.equal(forestObject.zone, 'library')
|
||||
assert.throws(() => game.pass('p1'), GameError)
|
||||
|
||||
game.chooseSearchCard('p1', islandObject.id)
|
||||
|
||||
assert.equal(game.pendingSearch, undefined)
|
||||
assert.ok(game.getPlayer('p1').battlefield.includes(islandObject.id))
|
||||
assert.equal(islandObject.tapped, true)
|
||||
assert.ok(game.getPlayer('p1').library.includes(forestObject.id))
|
||||
})
|
||||
|
||||
test('Junk exiles the top card and lets its controller cast it that turn', () => {
|
||||
const game = setup([{ id: 'p1', deck: [card('Filler')] }, { id: 'p2' }])
|
||||
game.start()
|
||||
const exiled = game.addCard('p1', spell('Top Spell', [], ''), 'library')
|
||||
const junk = makeToken(game, { types: ['artifact'], subtypes: ['junk'], colors: [] })
|
||||
|
||||
game.activateAbility('p1', junk.id, 0)
|
||||
game.resolveStack()
|
||||
assert.equal(exiled.zone, 'exile')
|
||||
assert.equal(game.canPlayCard('p1', exiled.id), true)
|
||||
|
||||
game.castSpell('p1', exiled.id)
|
||||
game.resolveStack()
|
||||
assert.equal(exiled.zone, 'graveyard')
|
||||
})
|
||||
|
||||
test('Role tokens attach to the target creature and apply their abilities', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const bear = game.addCard('p1', creature('Bear', 2, 2), 'battlefield')
|
||||
const maker = game.addCard('p1', roleMaker('Monster'), 'battlefield')
|
||||
|
||||
assert.deepEqual(game.legalTargetsForAbility('p1', maker.id, 0), [{ kind: 'object', id: bear.id }])
|
||||
game.activateAbility('p1', maker.id, 0, { targets: [{ kind: 'object', id: bear.id }] })
|
||||
game.resolveStack()
|
||||
|
||||
const role = game.getPlayer('p1').battlefield
|
||||
.map(id => game.getObject(id))
|
||||
.find(object => object.isToken)
|
||||
assert.ok(role)
|
||||
assert.equal(role.definition.name, 'Monster Role')
|
||||
assert.match(role.definition.typeLine.toLowerCase(), /enchantment — aura role/)
|
||||
assert.equal(role.attachedTo, bear.id)
|
||||
assert.equal(game.getPower(bear), 3)
|
||||
assert.equal(game.getToughness(bear), 3)
|
||||
assert.equal(game.hasKeyword(bear, 'Trample'), true)
|
||||
})
|
||||
|
||||
test('Young Hero Role triggers when the enchanted creature attacks with toughness 3 or less', () => {
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
const bear = game.addCard('p1', creature('Bear', 2, 2), 'battlefield')
|
||||
game.start()
|
||||
const maker = game.addCard('p1', roleMaker('Young Hero'), 'battlefield')
|
||||
game.activateAbility('p1', maker.id, 0, { targets: [{ kind: 'object', id: bear.id }] })
|
||||
game.resolveStack()
|
||||
|
||||
game.declareAttackers('p1', [{ attackerId: bear.id, defenderId: 'p2' }])
|
||||
game.resolveStack()
|
||||
assert.equal(bear.counters['+1/+1'], 1)
|
||||
assert.equal(game.getPower(bear), 3)
|
||||
})
|
||||
|
||||
test('token creation replacement swaps the created token', () => {
|
||||
const food: TokenSpec = {
|
||||
name: 'Food',
|
||||
types: ['artifact'],
|
||||
subtypes: ['food'],
|
||||
colors: [],
|
||||
abilities: [{ kind: 'activated', costs: [{ kind: 'tap' }, { kind: 'mana', cost: '{2}' }], effects: [] }],
|
||||
}
|
||||
const treasure: TokenSpec = { name: 'Treasure', types: ['artifact'], subtypes: ['treasure'], colors: [] }
|
||||
const game = setup([{ id: 'p1' }, { id: 'p2' }])
|
||||
game.start()
|
||||
const maker = game.addCard('p1', tokenMaker('Food Maker', food), 'battlefield')
|
||||
game.addCard('p1', card('Token Replacer', {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'token_replacement', from: ['food'], tokens: [food, treasure], who: 'you' }],
|
||||
text: 'If you would create a Food token, instead create a Food token and a Treasure token.',
|
||||
}],
|
||||
}), 'battlefield')
|
||||
|
||||
game.activateAbility('p1', maker.id, 0)
|
||||
game.resolveStack()
|
||||
const tokens = game.getPlayer('p1').battlefield.map(id => game.getObject(id)).filter(object => object.isToken)
|
||||
assert.deepEqual(tokens.map(token => token.definition.name).sort(), ['Food', 'Treasure'])
|
||||
})
|
||||
File diff suppressed because it is too large
Load Diff
159
backend/test/helpers.ts
Normal file
159
backend/test/helpers.ts
Normal file
@@ -0,0 +1,159 @@
|
||||
import assert from 'node:assert/strict'
|
||||
import test from 'node:test'
|
||||
import { Game, GameError } from '../src/game/game.js'
|
||||
import { compileText } from '../src/effects/compile.js'
|
||||
import type { Ability, Effect, TokenSpec } from '../src/effects/types.js'
|
||||
import type { CardDefinition, GameObject } from '../src/game/types.js'
|
||||
|
||||
export function card(name: string, overrides: Partial<CardDefinition> = {}): CardDefinition {
|
||||
return {
|
||||
oracleId: name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
|
||||
name,
|
||||
typeLine: 'Creature — Test',
|
||||
manaValue: 0,
|
||||
colors: [],
|
||||
abilities: [],
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
export function creature(name: string, power: number, toughness: number, abilities: Ability[] = []): CardDefinition {
|
||||
return card(name, { typeLine: 'Creature — Test', power, toughness, abilities })
|
||||
}
|
||||
|
||||
export function spell(name: string, effects: Effect[], manaCost = ''): CardDefinition {
|
||||
return card(name, { typeLine: 'Instant', manaCost, manaValue: 0, abilities: [{ kind: 'spell', effects, optional: false, text: name }] })
|
||||
}
|
||||
|
||||
export function land(name: string, color: string): CardDefinition {
|
||||
return card(name, {
|
||||
typeLine: `Basic Land — ${name}`,
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: [`{${color}}`] } }],
|
||||
optional: false,
|
||||
text: `{T}: Add {${color}}.`,
|
||||
}],
|
||||
})
|
||||
}
|
||||
|
||||
export function exoticOrchard(): CardDefinition {
|
||||
return card('Exotic Orchard', {
|
||||
typeLine: 'Land',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{
|
||||
op: 'add_mana',
|
||||
player: 'you',
|
||||
mana: {
|
||||
kind: 'any_color',
|
||||
amount: { kind: 'number', value: 1 },
|
||||
oneColor: false,
|
||||
restriction: 'a land an opponent controls could produce',
|
||||
},
|
||||
}],
|
||||
optional: false,
|
||||
text: '{T}: Add one mana of any color that a land an opponent controls could produce.',
|
||||
}],
|
||||
})
|
||||
}
|
||||
|
||||
export function setup(players: { id: string; deck?: CardDefinition[]; life?: number }[]): Game {
|
||||
const game = new Game({
|
||||
seed: 7,
|
||||
startingHandSize: 0,
|
||||
players: players.map(player => ({ id: player.id, life: player.life, deck: player.deck ?? [card('Filler')] })),
|
||||
})
|
||||
return game
|
||||
}
|
||||
|
||||
export function tokenMaker(name: string, token: TokenSpec): CardDefinition {
|
||||
return card(name, {
|
||||
typeLine: 'Artifact',
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'create_token', player: 'you', amount: { kind: 'number', value: 1 }, token }],
|
||||
optional: false,
|
||||
text: '{T}: Create a token.',
|
||||
}],
|
||||
})
|
||||
}
|
||||
|
||||
export function tokenDoubler(
|
||||
name: string,
|
||||
multiplier: number,
|
||||
who: 'you' | 'each_player' = 'you',
|
||||
creatureOnly = false,
|
||||
): CardDefinition {
|
||||
return card(name, {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'token_multiplier', multiplier, who, ...(creatureOnly ? { creatureOnly: true } : {}) }],
|
||||
text: 'Token replacement.',
|
||||
}],
|
||||
})
|
||||
}
|
||||
|
||||
export function makeToken(game: Game, token: TokenSpec, playerId = 'p1'): GameObject {
|
||||
const maker = game.addCard(playerId, tokenMaker('Token Maker', token), 'battlefield')
|
||||
game.activateAbility(playerId, maker.id, 0)
|
||||
game.resolveStack()
|
||||
const tokens = game.getPlayer(playerId).battlefield
|
||||
.map(id => game.getObject(id))
|
||||
.filter(object => object.isToken)
|
||||
return tokens[tokens.length - 1]
|
||||
}
|
||||
|
||||
export function addMana(game: Game, ...symbols: string[]): void {
|
||||
for (const symbol of symbols) {
|
||||
const source = game.addCard('p1', land('Mana Land', symbol), 'battlefield')
|
||||
game.activateAbility('p1', source.id, 0)
|
||||
}
|
||||
}
|
||||
|
||||
export function roleMaker(name: string): CardDefinition {
|
||||
return card(`${name} Role Maker`, {
|
||||
typeLine: 'Enchantment',
|
||||
abilities: [{
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{
|
||||
op: 'create_token',
|
||||
player: 'you',
|
||||
amount: { kind: 'number', value: 1 },
|
||||
token: { name, types: ['enchantment'], subtypes: ['aura', 'role'], colors: [] },
|
||||
attachTo: { kind: 'object', selector: { types: ['creature'], controller: 'you' }, mode: 'target' },
|
||||
}],
|
||||
optional: false,
|
||||
text: `{T}: Create a ${name} Role token attached to target creature you control.`,
|
||||
}],
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
export function shockLand(): CardDefinition {
|
||||
return card('Steam Vents', {
|
||||
typeLine: 'Land — Island Mountain',
|
||||
power: undefined,
|
||||
toughness: undefined,
|
||||
abilities: [{
|
||||
kind: 'static',
|
||||
effects: [{ op: 'enters_tapped', target: { kind: 'self' }, unlessCost: { kind: 'pay_life', amount: { kind: 'number', value: 2 } } }],
|
||||
text: "As this land enters, you may pay 2 life. If you don't, it enters tapped.",
|
||||
}, {
|
||||
kind: 'activated',
|
||||
costs: [{ kind: 'tap' }],
|
||||
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{U}', '{R}'], oneOf: true } }],
|
||||
optional: false,
|
||||
text: '{T}: Add {U} or {R}.',
|
||||
}],
|
||||
})
|
||||
}
|
||||
@@ -98,6 +98,7 @@ interface MatchView {
|
||||
sourceId: string
|
||||
sourceName: string
|
||||
amount?: number
|
||||
label?: string
|
||||
options: string[]
|
||||
cards?: CardView[]
|
||||
}
|
||||
@@ -1172,6 +1173,16 @@ async function chooseCreatureType(type: string) {
|
||||
await act({ type: 'choose_type', choice: type })
|
||||
}
|
||||
|
||||
async function chooseColor(color: string) {
|
||||
if (busy.value) return
|
||||
await act({ type: 'choose_color', choice: color })
|
||||
}
|
||||
|
||||
async function chooseOptional(accept: boolean) {
|
||||
if (busy.value) return
|
||||
await act({ type: 'choose_optional', accept })
|
||||
}
|
||||
|
||||
async function chooseCost(pay: boolean) {
|
||||
if (busy.value) return
|
||||
await act({ type: 'choose_cost', pay })
|
||||
@@ -1901,14 +1912,18 @@ onUnmounted(() => {
|
||||
</section>
|
||||
|
||||
<section v-if="pendingChoice && pendingChoice.player !== viewerId" class="panel side search-panel">
|
||||
<h2>{{ pendingChoice.what === 'pay_cost' ? 'Pay a cost' : pendingChoice.what === 'hideaway' ? 'Hideaway' : 'Choose a type' }}</h2>
|
||||
<h2>{{ pendingChoice.what === 'pay_cost' ? 'Pay a cost' : pendingChoice.what === 'hideaway' ? 'Hideaway' : pendingChoice.what === 'color' ? 'Choose a color' : pendingChoice.what === 'optional' ? 'Optional effect' : 'Choose a type' }}</h2>
|
||||
<p class="muted">
|
||||
{{ playerName(pendingChoice.player) }}
|
||||
{{ pendingChoice.what === 'pay_cost'
|
||||
? `is deciding whether to pay ${pendingCostLabel} for ${pendingChoice.sourceName}.`
|
||||
: pendingChoice.what === 'hideaway'
|
||||
? 'is looking at the top cards of their library.'
|
||||
: `is choosing a creature type for ${pendingChoice.sourceName}.` }}
|
||||
: pendingChoice.what === 'color'
|
||||
? `is choosing a color for ${pendingChoice.sourceName}.`
|
||||
: pendingChoice.what === 'optional'
|
||||
? `is deciding whether to use ${pendingChoice.label ?? pendingChoice.sourceName}.`
|
||||
: `is choosing a creature type for ${pendingChoice.sourceName}.` }}
|
||||
</p>
|
||||
</section>
|
||||
|
||||
@@ -2049,10 +2064,12 @@ onUnmounted(() => {
|
||||
<div class="grow">
|
||||
<h2 id="choice-title">{{ pendingChoice.what === 'pay_cost'
|
||||
? `Pay ${pendingCostLabel}?`
|
||||
: pendingChoice.what === 'hideaway' ? 'Hideaway' : 'Choose a creature type' }}</h2>
|
||||
: pendingChoice.what === 'hideaway' ? 'Hideaway' : pendingChoice.what === 'color' ? 'Choose a color' : pendingChoice.what === 'optional' ? 'Use this effect?' : 'Choose a creature type' }}</h2>
|
||||
<p class="muted">{{ pendingChoice.what === 'hideaway'
|
||||
? 'Look at the top cards of your library and exile one face down.'
|
||||
: `${pendingChoice.sourceName} enters.` }}</p>
|
||||
: pendingChoice.what === 'optional'
|
||||
? pendingChoice.label ?? `${pendingChoice.sourceName} gives you a choice.`
|
||||
: `${pendingChoice.sourceName} enters.` }}</p>
|
||||
</div>
|
||||
<span v-if="pendingChoice.what === 'creature_type'" class="tag">{{ filteredChoiceOptions.length }} types</span>
|
||||
<span v-else-if="pendingChoice.what === 'hideaway'" class="tag">{{ pendingChoice.cards?.length ?? 0 }} cards</span>
|
||||
@@ -2093,6 +2110,34 @@ onUnmounted(() => {
|
||||
</div>
|
||||
<p class="muted small">The rest go to the bottom of your library in a random order.</p>
|
||||
</template>
|
||||
<template v-else-if="pendingChoice.what === 'optional'">
|
||||
<div class="choice-grid">
|
||||
<button
|
||||
type="button"
|
||||
class="choice-option"
|
||||
:disabled="busy"
|
||||
@click="chooseOptional(true)"
|
||||
>Use it</button>
|
||||
<button
|
||||
type="button"
|
||||
class="choice-option"
|
||||
:disabled="busy"
|
||||
@click="chooseOptional(false)"
|
||||
>Decline</button>
|
||||
</div>
|
||||
</template>
|
||||
<template v-else-if="pendingChoice.what === 'color'">
|
||||
<div class="choice-grid">
|
||||
<button
|
||||
v-for="color in pendingChoice.options"
|
||||
:key="color"
|
||||
type="button"
|
||||
class="choice-option"
|
||||
:disabled="busy"
|
||||
@click="chooseColor(color)"
|
||||
>{{ color }}</button>
|
||||
</div>
|
||||
</template>
|
||||
<template v-else>
|
||||
<input
|
||||
ref="choiceInput"
|
||||
|
||||
Reference in New Issue
Block a user