Files
commander/backend/src/effects/format.ts
2026-10-29 20:30:29 +01:00

731 lines
32 KiB
TypeScript

import type {
Ability,
CompiledCard,
Condition,
Cost,
Duration,
Effect,
ManaSpec,
ObjectSelector,
PlayerRef,
StaticEffect,
Target,
TokenSpec,
TriggerEvent,
Value,
} from './types.js'
const COLOR_NAMES: Record<string, string> = { W: 'white', U: 'blue', B: 'black', R: 'red', G: 'green', C: 'colorless' }
const PLAYER_NAMES: Record<PlayerRef, string> = {
you: 'you',
opponent: 'opponent',
each_opponent: 'eachOpponent',
each_player: 'eachPlayer',
target_player: 'targetPlayer',
that_player: 'thatPlayer',
its_controller: 'itsController',
its_owner: 'itsOwner',
}
const DURATION_NAMES: Record<Duration, string> = {
permanent: 'permanent',
until_end_of_turn: 'untilEndOfTurn',
until_your_next_turn: 'untilYourNextTurn',
until_end_of_your_next_turn: 'untilEndOfYourNextTurn',
until_end_of_combat: 'untilEndOfCombat',
until_controllers_next_untap_step: 'untilControllersNextUntapStep',
while_source_on_battlefield: 'whileSourceOnBattlefield',
}
function quote(text: string): string {
return `'${text.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n').replace(/\r/g, '\\r')}'`
}
function indent(text: string, spaces = 2): string {
const pad = ' '.repeat(spaces)
return text.split('\n').map(line => `${pad}${line}`).join('\n')
}
function list(items: string[]): string {
if (!items.length) return '[]'
return `[\n${items.map(item => indent(item)).join(',\n')},\n]`
}
function callback(items: string[]): string {
if (!items.length) return '() => {}'
if (items.length === 1) return `() => ${items[0]}`
return `() => {\n${items.map(item => indent(item)).join('\n')}\n}`
}
function options(entries: Array<[string, string | undefined]>): string | undefined {
const parts = entries.filter(([, value]) => value !== undefined).map(([key, value]) => `${key}: ${value}`)
return parts.length ? `{ ${parts.join(', ')} }` : undefined
}
function optionArg(entries: Array<[string, string | undefined]>): string {
const value = options(entries)
return value ? `, ${value}` : ''
}
function formatPlayer(player: PlayerRef): string {
return PLAYER_NAMES[player]
}
function formatValue(value: Value): string {
switch (value.kind) {
case 'number':
return String(value.value)
case 'x':
return 'X'
case 'count':
return `count(${formatSelector(value.selector)})`
case 'source_power':
return 'itsPower'
case 'source_toughness':
return 'itsToughness'
case 'cards_in_hand':
return `cardsInHand(${formatPlayer(value.player)})`
case 'max_cards_in_hand':
return 'maxCardsInHand()'
case 'max_opponent_count':
return `maxOpponentCount(${formatSelector(value.selector)})`
case 'total_mana_value':
return `totalManaValue(${formatSelector(value.selector)})`
case 'total_power':
return `totalPower(${formatSelector(value.selector)})`
case 'any_number':
return 'anyNumber()'
case 'event_amount':
return 'eventAmount()'
}
}
function formatSelector(selector: ObjectSelector): string {
let text = 'permanents'
if (selector.other) text += '.other()'
if (selector.tapped === true) text += '.tapped()'
if (selector.tapped === false) text += '.untapped()'
if (selector.attacking) text += '.attacking()'
if (selector.token === true) text += '.token()'
if (selector.token === false) text += '.nontoken()'
if (selector.attached === 'equipped') text += '.equipped()'
if (selector.attached === 'enchanted') text += '.enchanted()'
if (selector.colors?.length) {
text += `.withColor(${selector.colors.map(color => quote(COLOR_NAMES[color] ?? color)).join(', ')})`
}
if (selector.excludeColors?.length) {
text += `.withoutColor(${selector.excludeColors.map(color => quote(COLOR_NAMES[color] ?? color)).join(', ')})`
}
if (selector.supertypes?.length) {
text += `.withSupertype(${selector.supertypes.map(quote).join(', ')})`
}
if (selector.subtypes?.length) {
text += `.withSubtype(${selector.subtypes.map(quote).join(', ')})`
}
if (selector.types?.length) {
text += `.withType(${selector.types.map(quote).join(', ')})`
}
if (selector.excludeTypes?.length) {
text += `.withoutType(${selector.excludeTypes.map(quote).join(', ')})`
}
if (selector.counters) {
text += `.withCounter(${quote(selector.counters.counter)}, ${selector.counters.atLeast})`
}
if (selector.keywords?.length) {
text += `.withKeyword(${selector.keywords.map(quote).join(', ')})`
}
if (selector.excludeKeywords?.length) {
text += `.withoutKeyword(${selector.excludeKeywords.map(quote).join(', ')})`
}
if (selector.power?.atLeast !== undefined) text += `.powerAtLeast(${selector.power.atLeast})`
if (selector.power?.atMost !== undefined) text += `.powerAtMost(${selector.power.atMost})`
if (selector.toughness?.atLeast !== undefined) text += `.toughnessAtLeast(${selector.toughness.atLeast})`
if (selector.toughness?.atMost !== undefined) text += `.toughnessAtMost(${selector.toughness.atMost})`
if (selector.manaValue?.atLeast !== undefined) text += `.manaValueAtLeast(${selector.manaValue.atLeast})`
if (selector.manaValue?.atMost !== undefined) text += `.manaValueAtMost(${selector.manaValue.atMost})`
if (selector.name) text += `.named(${quote(selector.name)})`
if (selector.controller === 'you') text += '.youControl()'
else if (selector.controller === 'opponent') text += '.opponentControls()'
else if (selector.controller === 'any') text += `.controlledBy('any')`
if (selector.owner === 'you') text += `.ownedBy('you')`
else if (selector.owner === 'opponent') text += `.ownedBy('opponent')`
if (selector.zone) text += `.inZone(${quote(selector.zone)})`
if (selector.match === 'any') text += '.matchingAny()'
return text
}
function isBareSelector(selector: ObjectSelector): boolean {
return selector.types?.length === 0 && Object.keys(selector).every(key => key === 'types')
}
function formatTargetOptions(target: Extract<Target, { kind: 'object' }>): string {
return optionArg([
['count', target.count !== undefined ? String(target.count) : undefined],
['upTo', target.upTo ? 'true' : undefined],
['includeSelf', target.includeSelf ? 'true' : undefined],
]).replace(/^, /, '')
}
export function formatTarget(target: Target): string {
switch (target.kind) {
case 'self':
return 'self'
case 'trigger_subject':
return 'triggerSubject'
case 'previous_target':
return 'previousTarget'
case 'any':
return 'anyTarget'
case 'player_or_planeswalker':
return 'targetPlayerOrPlaneswalker'
case 'player':
return target.mode === 'each'
? `each(${formatPlayer(target.who)})`
: `target(${formatPlayer(target.who)})`
case 'object': {
const name = target.mode === 'target' ? 'target' : target.mode === 'each' ? 'each' : 'pick'
const extra = formatTargetOptions(target)
return `${name}(${formatSelector(target.selector)}${extra ? `, ${extra}` : ''})`
}
case 'spell':
return isBareSelector(target.selector) ? 'targetSpell()' : `targetSpell(${formatSelector(target.selector)})`
case 'ability':
return target.selector ? `targetAbility(${formatSelector(target.selector)})` : 'targetAbility()'
case 'divided':
return `divided(${target.max === 'any' ? quote('any') : target.max}${target.selector ? `, ${formatSelector(target.selector)}` : ''})`
}
}
function formatMana(mana: ManaSpec): string {
if (mana.kind === 'symbols') {
return `mana(${quote(mana.symbols.join(''))}${optionArg([
['oneOf', mana.oneOf ? 'true' : undefined],
['restriction', mana.restriction ? quote(mana.restriction) : undefined],
])})`
}
return `anyColor(${formatValue(mana.amount)}${optionArg([
['oneColor', mana.oneColor ? 'true' : undefined],
['restriction', mana.restriction ? quote(mana.restriction) : undefined],
])})`
}
function formatCost(cost: Cost): string {
switch (cost.kind) {
case 'mana':
return `manaCost(${quote(cost.symbols)})`
case 'tap':
return 'tapCost()'
case 'untap':
return 'untapCost()'
case 'tap_other':
return `tapOther(${formatSelector(cost.selector)})`
case 'energy':
return `energyCost(${cost.amount})`
case 'loyalty':
return `loyalty(${cost.amount})`
case 'pay_life':
return `payLife(${formatValue(cost.amount)})`
case 'discard':
return `discardCost(${formatValue(cost.amount)}${optionArg([
['player', cost.player === 'you' ? undefined : formatPlayer(cost.player)],
['random', cost.random ? 'true' : undefined],
])})`
case 'sacrifice':
return `sacrificeCost(${formatSelector(cost.selector)})`
case 'sacrifice_self':
return 'sacrificeSelf()'
case 'exile_self':
return 'exileSelf()'
case 'exile_from_graveyard':
return `exileFromGraveyard(${formatSelector(cost.selector)}${cost.amount ? `, ${formatValue(cost.amount)}` : ''})`
case 'reveal':
return `reveal(${formatSelector(cost.selector)})`
case 'choice':
return `choice([${cost.options.map(option => `[${option.map(formatCost).join(', ')}]`).join(', ')}])`
case 'return_to_hand':
return `returnToHandCost(${formatSelector(cost.selector)})`
case 'behold':
return `behold(${formatSelector(cost.selector)})`
case 'waterbend':
return `waterbend(${formatValue(cost.amount)})`
case 'blight':
return `blight(${formatValue(cost.amount)})`
case 'choose':
return `chooseCost(${quote(cost.what)})`
case 'put_counter':
return `putCounterCost(${quote(cost.counter)}, ${formatSelector(cost.selector)})`
case 'remove_counters':
return `removeCountersCost(${quote(cost.counter)}, ${formatValue(cost.amount)}${cost.selector ? `, ${formatSelector(cost.selector)}` : ''})`
case 'forage':
return 'forage()'
case 'collect_evidence':
return `collectEvidence(${cost.amount})`
case 'mill':
return `millCost(${formatValue(cost.amount)})`
}
}
function formatDuration(duration: Duration): string | undefined {
return duration === 'permanent' ? undefined : DURATION_NAMES[duration]
}
function formatToken(token: TokenSpec): string {
return `token(${options([
['name', token.name ? quote(token.name) : undefined],
['types', token.types.length ? `[${token.types.map(quote).join(', ')}]` : undefined],
['subtypes', token.subtypes.length ? `[${token.subtypes.map(quote).join(', ')}]` : undefined],
['colors', token.colors.length ? `[${token.colors.map(color => quote(COLOR_NAMES[color] ?? color)).join(', ')}]` : undefined],
['power', token.power ? formatValue(token.power) : undefined],
['toughness', token.toughness ? formatValue(token.toughness) : undefined],
['keywords', token.keywords?.length ? `[${token.keywords.map(quote).join(', ')}]` : undefined],
['tapped', token.tapped ? 'true' : undefined],
])})`
}
function formatEffectList(effects: Effect[]): string {
return callback(effects.map(formatEffect))
}
export function formatEffect(effect: Effect): string {
switch (effect.op) {
case 'damage':
return `damage(${formatTarget(effect.target)}, ${formatValue(effect.amount)}${effect.source ? `, ${formatTarget(effect.source)}` : ''})`
case 'draw':
return `draw(${formatPlayer(effect.player)}, ${formatValue(effect.amount)})`
case 'discard':
return `discard(${formatPlayer(effect.player)}, ${formatValue(effect.amount)}${optionArg([['random', effect.random ? 'true' : undefined]])})`
case 'mill':
return `mill(${formatPlayer(effect.player)}, ${formatValue(effect.amount)})`
case 'life':
return `${effect.mode === 'gain' ? 'gainLife' : 'loseLife'}(${formatPlayer(effect.player)}, ${formatValue(effect.amount)})`
case 'pump':
return `pump(${formatTarget(effect.target)}, ${formatValue(effect.power)}, ${formatValue(effect.toughness)}${formatDuration(effect.duration) ? `, ${formatDuration(effect.duration)}` : ''})`
case 'grant':
return `grant(${formatTarget(effect.target)}, ${quote(effect.keyword)}${optionArg([
['value', effect.value ? quote(effect.value) : undefined],
['duration', formatDuration(effect.duration)],
])})`
case 'put_counters':
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 'proliferate':
return 'proliferate()'
case 'create_token':
return effect.copyOf
? `createToken(${formatPlayer(effect.player)}, ${formatValue(effect.amount)}, copyOf(${formatTarget(effect.copyOf)}${effect.notLegendary ? ', { notLegendary: true }' : ''}))`
: `createToken(${formatPlayer(effect.player)}, ${formatValue(effect.amount)}, ${formatToken(effect.token)}${effect.attachTo ? `, { attachTo: ${formatTarget(effect.attachTo)} }` : ''})`
case 'destroy':
return `destroy(${formatTarget(effect.target)})`
case 'exile':
return `exile(${formatTarget(effect.target)})`
case 'sacrifice':
return `sacrifice(${formatPlayer(effect.player)}, ${formatTarget(effect.target)}${effect.unless ? `, ${formatCost(effect.unless)}` : ''})`
case 'counter':
return `counter(${quote(effect.what)}, ${formatTarget(effect.target)}${effect.unless ? `, ${formatCost(effect.unless)}` : ''})`
case 'return_to_hand':
return `returnToHand(${formatTarget(effect.target)})`
case 'return_to_battlefield':
return `returnToBattlefield(${formatTarget(effect.target)}${optionArg([
['tapped', effect.tapped ? 'true' : undefined],
['transformed', effect.transformed ? 'true' : undefined],
['counters', effect.counters ? `{ counter: ${quote(effect.counters.counter)}, amount: ${formatValue(effect.counters.amount)} }` : undefined],
])})`
case 'set_pt':
return `setPt(${formatTarget(effect.target)}, ${formatValue(effect.power)}, ${formatValue(effect.toughness)}${optionArg([['duration', formatDuration(effect.duration)]])})`
case 'put_on_top':
return `putOnTop(${formatTarget(effect.target)})`
case 'tap':
return `tap(${formatTarget(effect.target)})`
case 'untap':
return `untap(${formatTarget(effect.target)})`
case 'scry':
return `scry(${formatPlayer(effect.player)}, ${formatValue(effect.amount)})`
case 'surveil':
return `surveil(${formatPlayer(effect.player)}, ${formatValue(effect.amount)})`
case 'search':
return `search(${formatPlayer(effect.player)}, ${formatSelector(effect.selector)}, ${formatValue(effect.amount)}${optionArg([
['destination', quote(effect.destination)],
['tapped', effect.tapped ? 'true' : undefined],
['shuffle', effect.shuffle ? 'true' : undefined],
['zones', effect.zones?.length ? `[${effect.zones.map(quote).join(', ')}]` : undefined],
['split', effect.split ? `{ destination: ${quote(effect.split.destination)}, tapped: ${effect.split.tapped ? 'true' : 'false'} }` : undefined],
])})`
case 'shuffle':
return `shuffle(${formatPlayer(effect.player)})`
case 'add_mana':
return `addMana(${formatPlayer(effect.player)}, ${formatMana(effect.mana)})`
case 'fight':
return `fight(${formatTarget(effect.a)}, ${formatTarget(effect.b)})`
case 'regenerate':
return `regenerate(${formatTarget(effect.target)})`
case 'energy':
return `energy(${formatPlayer(effect.player)}, ${formatValue(effect.amount)})`
case 'attach':
return `attach(${formatTarget(effect.target)})`
case 'restriction':
return `restrict(${formatTarget(effect.target)}, ${quote(effect.rule)}${formatDuration(effect.duration) ? `, ${formatDuration(effect.duration)}` : ''})`
case 'keyword_action':
return `keywordAction(${quote(effect.action)}${optionArg([
['target', effect.target ? formatTarget(effect.target) : undefined],
['amount', effect.amount ? formatValue(effect.amount) : undefined],
['detail', effect.detail ? quote(effect.detail) : undefined],
])})`
case 'prevent_damage':
return `preventDamage(${formatTarget(effect.target)}, ${effect.amount === 'all' ? quote('all') : formatValue(effect.amount)}${optionArg([
['combatOnly', effect.combatOnly ? 'true' : undefined],
['duration', formatDuration(effect.duration)],
])})`
case 'gain_control':
return `gainControl(${formatTarget(effect.target)}${formatDuration(effect.duration) ? `, ${formatDuration(effect.duration)}` : ''})`
case 'emblem':
return `emblem(${quote(effect.text)})`
case 'transform':
return `transform(${formatTarget(effect.target)})`
case 'pay':
return `pay([${effect.costs.map(formatCost).join(', ')}])`
case 'conditional':
return `ifThen(${formatCondition(effect.condition)}, ${formatEffectList(effect.effects)})`
case 'modal':
return `modal(${effect.min}, ${effect.max}, ${list(effect.modes.map(mode => formatEffectList(mode)))})`
case 'look_top':
return `lookTop(${formatPlayer(effect.player)}, ${formatValue(effect.amount)}${optionArg([['reorder', effect.reorder ? 'true' : undefined]])})`
case 'schedule':
return `schedule(${quote(effect.when)}, ${formatEffectList(effect.effects)})`
case 'level_up':
return `levelUp(${effect.level})`
case 'put_from_among':
return `putFromAmong(${formatPlayer(effect.player)}, ${formatValue(effect.amount)}${optionArg([
['selector', effect.selector ? formatSelector(effect.selector) : undefined],
['destination', quote(effect.destination)],
])})`
case 'dig':
return `dig(${formatPlayer(effect.player)}, ${formatValue(effect.amount)}${optionArg([
['pick', formatValue(effect.pick)],
['upTo', effect.upTo ? 'true' : undefined],
['pickSelector', effect.pickSelector ? formatSelector(effect.pickSelector) : undefined],
['to', quote(effect.to)],
['rest', quote(effect.rest)],
['order', effect.order ? quote(effect.order) : undefined],
['optional', effect.optional ? 'true' : undefined],
['tapped', effect.tapped ? 'true' : undefined],
])})`
case 'damage_divided':
return `damageDivided(${formatValue(effect.amount)}, ${formatTarget(effect.target)})`
case 'exile_graveyards':
return 'exileGraveyards()'
case 'hideaway':
return `hideaway(${formatValue(effect.amount)})`
case 'play_exiled':
return `playExiled(${formatPlayer(effect.player)}${optionArg([['free', effect.free ? 'true' : undefined]])})`
}
}
function formatCondition(condition: Condition): string {
switch (condition.kind) {
case 'you_control':
return `youControl(${formatSelector(condition.selector)}${condition.atLeast !== undefined ? `, ${condition.atLeast}` : ''})`
case 'opponent_controls':
return `opponentControls(${formatSelector(condition.selector)}${condition.atLeast !== undefined ? `, ${condition.atLeast}` : ''})`
case 'your_turn':
return 'yourTurn()'
case 'not_your_turn':
return 'notYourTurn()'
case 'source_tapped':
return 'sourceTapped()'
case 'source_untapped':
return 'sourceUntapped()'
case 'source_attacking':
return 'sourceAttacking()'
case 'life_at_least':
return `lifeAtLeast(${formatPlayer(condition.player)}, ${condition.amount})`
case 'life_at_most':
return `lifeAtMost(${formatPlayer(condition.player)}, ${condition.amount})`
case 'life_above_starting':
return `lifeAboveStarting(${formatPlayer(condition.player)}, ${condition.amount})`
case 'cards_in_graveyard':
return `cardsInGraveyard(${formatPlayer(condition.player)}, ${condition.atLeast})`
case 'hand_empty':
return `handEmpty(${formatPlayer(condition.player)})`
case 'creature_died_this_turn':
return `creatureDiedThisTurn(${condition.controller ? quote(condition.controller) : ''})`
case 'you_gained_life_this_turn':
return `youGainedLifeThisTurn(${condition.atLeast !== undefined ? condition.atLeast : ''})`
case 'you_drew_cards_this_turn':
return `youDrewCardsThisTurn(${condition.atLeast !== undefined ? condition.atLeast : ''})`
case 'spells_cast_last_turn':
return `spellsCastLastTurn(${quote(condition.who)}, ${condition.atLeast})`
case 'no_spells_last_turn':
return 'noSpellsLastTurn()'
case 'attacked_this_turn':
return 'attackedThisTurn()'
case 'you_attacked_this_turn':
return 'youAttackedThisTurn()'
case 'defending_player_controls':
return `defendingPlayerControls(${formatSelector(condition.selector)})`
case 'targets':
return `targets(${formatSelector(condition.selector)})`
case 'was_kicked':
return 'wasKicked()'
case 'cast':
return `youCastIt(${condition.fromHand ? `{ fromHand: true }` : ''})`
case 'in_graveyard':
return 'inGraveyard()'
case 'on_battlefield':
return 'onBattlefield()'
case 'monarch':
return 'monarch()'
case 'initiative':
return 'initiative()'
case 'citys_blessing':
return 'citysBlessing()'
case 'suspended':
return 'suspended()'
case 'bargained':
return 'bargained()'
case 'was_creature':
return 'wasCreature()'
case 'opponent_lost_life_this_turn':
return 'opponentLostLifeThisTurn()'
case 'life_changed_this_turn':
return 'lifeChangedThisTurn()'
case 'descended_this_turn':
return 'descendedThisTurn()'
case 'permanent_left_battlefield_this_turn':
return 'permanentLeftBattlefieldThisTurn()'
case 'nonland_permanents_entered_this_turn':
return `nonlandPermanentsEnteredThisTurn(${condition.atLeast})`
case 'attacked_with_total_power':
return `attackedWithTotalPower(${condition.atLeast})`
case 'total_power':
return `yourCreaturesTotalPower(${condition.atLeast})`
case 'opponent_controls_more_lands':
return 'opponentControlsMoreLands()'
case 'distinct_powers':
return `distinctPowers(${condition.atLeast})`
case 'graveyard_card_types':
return `graveyardCardTypes(${condition.atLeast})`
case 'no_objects':
return `noObjects(${formatSelector(condition.selector)})`
case 'cards_in_hand_at_most':
return `cardsInHandAtMost(${formatPlayer(condition.who)}, ${condition.atMost})`
case 'not_their_turn':
return 'notTheirTurn()'
case 'no_attackers':
return 'noAttackers()'
case 'opponent_poison':
return `opponentPoison(${condition.atLeast})`
case 'tribute_not_paid':
return 'tributeNotPaid()'
case 'had_counters':
return `hadCounters(${condition.counter ? quote(condition.counter) : ''})`
case 'mana_from_treasure':
return 'manaFromTreasure()'
case 'mana_spent':
return `manaSpent(${condition.atLeast})`
case 'no_mana_spent':
return 'noManaSpent()'
case 'mana_symbol_spent':
return `manaSymbolSpent(${quote(condition.symbols)})`
case 'kicked_with':
return `kickedWith(${quote(condition.cost)})`
case 'more_cards_than_each_opponent':
return 'moreCardsThanEachOpponent()'
case 'first_combat_phase':
return 'firstCombatPhase()'
case 'not_token':
return 'notToken()'
case 'cast_spell_this_turn':
return `castSpellThisTurn(${condition.noncreature ? `{ noncreature: true }` : ''})`
case 'full_party':
return 'fullParty()'
case 'graveyard_count':
return `graveyardCount(${formatSelector(condition.selector)}, ${condition.atLeast})`
case 'creature_power_greater_than_base':
return `creaturePowerGreaterThanBase(${quote(condition.stat)})`
case 'if_you_do':
return 'ifYouDo()'
case 'if_you_dont':
return 'ifYouDont()'
case 'otherwise':
return 'otherwise()'
case 'you_control_commander':
return 'youControlCommander()'
case 'distinct_names':
return `distinctNames(${formatSelector(condition.selector)}, ${condition.atLeast})`
case 'opponent_damaged_this_turn':
return `opponentDamagedThisTurn(${condition.atLeast})`
case 'attacked_with_creatures':
return `attackedWithCreatures(${condition.atLeast})`
case 'library_at_most':
return `libraryAtMost(${condition.atMost})`
case 'event_subject_toughness_at_most':
return `eventSubjectToughnessAtMost(${condition.amount})`
}
}
function formatTrigger(event: TriggerEvent): string {
switch (event.kind) {
case 'enters':
return `when.enters(${formatTarget(event.subject)})`
case 'dies':
return `when.dies(${formatTarget(event.subject)})`
case 'attacks':
return `when.attacks(${formatTarget(event.subject)})`
case 'blocks':
return `when.blocks(${formatTarget(event.subject)})`
case 'attacks_or_blocks':
return `when.attacksOrBlocks(${formatTarget(event.subject)})`
case 'enters_or_attacks':
return `when.entersOrAttacks(${formatTarget(event.subject)})`
case 'enters_or_dies':
return `when.entersOrDies(${formatTarget(event.subject)})`
case 'leaves_battlefield':
return `when.leavesBattlefield(${formatTarget(event.subject)})`
case 'deals_damage':
return `when.dealsDamage(${formatTarget(event.subject)}, ${quote(event.recipient)}${optionArg([['combat', event.combat ? 'true' : undefined]])})`
case 'upkeep':
return `when.upkeep(${formatPlayer(event.who)})`
case 'end_step':
return `when.endStep(${formatPlayer(event.who)})`
case 'begin_combat':
return `when.beginCombat(${formatPlayer(event.who)})`
case 'main_phase':
return `when.${event.phase === 'first' ? 'firstMainPhase' : 'postcombatMainPhase'}(${formatPlayer(event.who)})`
case 'cast':
return `when.cast(${formatPlayer(event.who)}${isBareSelector(event.spell) ? '' : `, ${formatSelector(event.spell)}`}${optionArg([
['targetsSelf', event.targetsSelf ? 'true' : undefined],
['orCopy', event.orCopy ? 'true' : undefined],
['ordinal', event.ordinal !== undefined ? String(event.ordinal) : undefined],
])})`
case 'becomes_level':
return `when.becomesLevel(${event.level})`
case 'draw':
return `when.draw(${formatPlayer(event.who)}${event.ordinal !== undefined ? `, ${event.ordinal}` : ''})`
case 'counter_placed':
return `when.counterPlaced(${formatTarget(event.subject)}${event.counter ? `, ${quote(event.counter)}` : ''})`
case 'becomes_target':
return `when.becomesTarget(${formatTarget(event.subject)})`
case 'life':
return `when.${event.mode === 'gain' ? 'lifeGained' : 'lifeLost'}(${formatPlayer(event.who)})`
}
}
function formatStaticEffect(effect: StaticEffect): string {
switch (effect.op) {
case 'pump':
return `staticPump(${formatTarget(effect.target)}, ${formatValue(effect.power)}, ${formatValue(effect.toughness)})`
case 'grant':
return `staticGrant(${formatTarget(effect.target)}, ${quote(effect.keyword)}${optionArg([['value', effect.value ? quote(effect.value) : undefined]])})`
case 'grant_ability':
return `grantAbility(${formatTarget(effect.target)}, ${formatAbility(effect.ability)})`
case 'restriction':
return `staticRestrict(${formatTarget(effect.target)}, ${quote(effect.rule)}${optionArg([
['value', effect.value ? formatValue(effect.value) : undefined],
['comparison', effect.comparison ? quote(effect.comparison) : undefined],
['detail', effect.detail ? quote(effect.detail) : undefined],
['condition', effect.condition ? formatCondition(effect.condition) : undefined],
])})`
case 'enters_tapped':
return `entersTapped(${formatTarget(effect.target)}${optionArg([
['unless', effect.unless ? formatCondition(effect.unless) : undefined],
['unlessCost', effect.unlessCost ? formatCost(effect.unlessCost) : undefined],
])})`
case 'enters_with_counters':
return `entersWithCounters(${formatTarget(effect.target)}, ${quote(effect.counter)}, ${formatValue(effect.amount)})`
case 'set_pt':
return `staticSetPt(${formatTarget(effect.target)}, ${effect.power ? formatValue(effect.power) : 'null'}, ${effect.toughness ? formatValue(effect.toughness) : 'null'}${optionArg([['base', effect.base ? 'true' : undefined]])})`
case 'control':
return `control(${formatTarget(effect.target)})`
case 'choose':
return `choose(${quote(effect.what)})`
case 'replacement':
return `replace(${quote(effect.what)}${optionArg([
['target', effect.target ? formatTarget(effect.target) : undefined],
['instead', quote(effect.instead)],
])})`
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':
return `costIncrease(${formatValue(effect.amount)}${optionArg([['spellType', effect.spellType ? quote(effect.spellType) : undefined]])})`
case 'search_restriction':
return `searchRestriction(${quote(effect.who)}, ${formatValue(effect.amount)})`
case 'exile_instead_of_graveyard':
return `exileInsteadOfGraveyard(${effect.owner ? quote(effect.owner) : ''})`
case 'token_multiplier':
return `tokenMultiplier(${effect.multiplier}${optionArg([
['who', effect.who === 'each_player' ? quote('each_player') : undefined],
['creatureOnly', effect.creatureOnly ? 'true' : undefined],
])})`
}
}
function formatStaticEffectList(effects: StaticEffect[]): string {
return callback(effects.map(formatStaticEffect))
}
export function formatAbility(ability: Ability): string {
switch (ability.kind) {
case 'keyword':
return `keyword(${quote(ability.keyword)}${ability.value ? `, ${quote(ability.value)}` : ''})`
case 'keywords':
return `keywords(${ability.keywords.map(keyword => quote(`${keyword.keyword}${keyword.value ? ` ${keyword.value}` : ''}`)).join(', ')})`
case 'triggered':
return `triggered(${formatTrigger(ability.event)}, ${formatEffectList(ability.effects)}${optionArg([
['condition', ability.condition ? formatCondition(ability.condition) : undefined],
['optional', ability.optional ? 'true' : undefined],
])})`
case 'activated':
return `activated([${ability.costs.map(formatCost).join(', ')}], ${formatEffectList(ability.effects)}${optionArg([
['condition', ability.condition ? formatCondition(ability.condition) : undefined],
['timing', ability.timing ? quote(ability.timing) : undefined],
['activationsPerTurn', ability.activationsPerTurn !== undefined ? String(ability.activationsPerTurn) : undefined],
['optional', ability.optional ? 'true' : undefined],
])})`
case 'static':
return `staticAbility(${formatStaticEffectList(ability.effects)}${optionArg([
['condition', ability.condition ? formatCondition(ability.condition) : undefined],
])})`
case 'spell':
return `spell(${formatEffectList(ability.effects)}${optionArg([['optional', ability.optional ? 'true' : undefined]])})`
case 'additional_cost':
return `additionalCost([${ability.costs.map(formatCost).join(', ')}]${optionArg([['optional', ability.optional ? 'true' : undefined]])})`
case 'alternative_cost':
return `alternativeCost([${ability.costs.map(formatCost).join(', ')}]${optionArg([
['condition', ability.condition ? formatCondition(ability.condition) : undefined],
])})`
case 'overload':
return `overload(${quote(ability.cost)})`
case 'chapter':
return `chapter([${ability.chapters.map(quote).join(', ')}], ${formatEffectList(ability.effects)}${optionArg([['optional', ability.optional ? 'true' : undefined]])})`
case 'level_band':
return `levelBand(${ability.min}, ${ability.max !== undefined ? ability.max : 'null'}${ability.power ? `, ${formatValue(ability.power)}, ${formatValue(ability.toughness!)}` : ''})`
case 'level_pt':
return `levelPt(${formatValue(ability.power)}, ${formatValue(ability.toughness)})`
case 'unsupported':
return `unsupported(${quote(ability.reason)}, ${quote(ability.text)})`
}
}
function formatAbilityList(abilities: Ability[]): string {
return list(abilities.map(formatAbility))
}
export function formatCard(card: CompiledCard): string {
const header = `// ${card.name} [${card.status}]`
if (card.faces?.length) {
const faces = card.faces.map(face => {
const typeLine = face.typeLine ? `${quote(face.typeLine)}, ` : ''
return `face(${quote(face.name)}, ${typeLine}${formatAbilityList(face.abilities)})`
})
return `${header}\nexport default faces(\n${faces.map(face => indent(face)).join(',\n')},\n)`
}
const abilities = formatAbilityList(card.abilities)
const body = card.typeLine ? `card(${quote(card.typeLine)}, ${abilities})` : abilities
return `${header}\nexport default ${body}`
}