1233 lines
42 KiB
TypeScript
1233 lines
42 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import test from 'node:test'
|
|
import { Game, GameError } from '../src/game/game.js'
|
|
import type { Ability, Effect } from '../src/effects/types.js'
|
|
import type { CardDefinition } from '../src/game/types.js'
|
|
|
|
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,
|
|
}
|
|
}
|
|
|
|
function creature(name: string, power: number, toughness: number, abilities: Ability[] = []): CardDefinition {
|
|
return card(name, { typeLine: 'Creature — Test', power, toughness, abilities })
|
|
}
|
|
|
|
function spell(name: string, effects: Effect[], manaCost = ''): CardDefinition {
|
|
return card(name, { typeLine: 'Instant', manaCost, manaValue: 0, abilities: [{ kind: 'spell', effects, optional: false, text: name }] })
|
|
}
|
|
|
|
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}}.`,
|
|
}],
|
|
})
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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, 7)
|
|
assert.equal(game.getPlayer('p1').library.length, 3)
|
|
|
|
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('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('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')
|
|
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(hidden.zone, 'exile')
|
|
assert.deepEqual(land.linkedExile, [hidden.id])
|
|
|
|
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.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')
|
|
|
|
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('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)
|
|
})
|
|
|
|
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('"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('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)
|
|
})
|
|
|
|
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('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)
|
|
})
|
|
|
|
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('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('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, 1)
|
|
|
|
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)
|
|
})
|