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