This commit is contained in:
2026-11-04 17:10:22 +01:00
parent 9ec486274f
commit c742d0cfa8
40 changed files with 12394 additions and 9414 deletions

View File

@@ -0,0 +1,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
// ---------------------------------------------------------------------------