Files
commander/backend/test/game-rules.test.ts
2026-11-04 17:10:22 +01:00

664 lines
24 KiB
TypeScript

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