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