195 lines
7.0 KiB
TypeScript
195 lines
7.0 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import { mkdtemp, rm } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
import test from 'node:test'
|
|
import type { Card } from '../src/cards.js'
|
|
import { formatCard } from '../src/effects/format.js'
|
|
import {
|
|
compileImplementation,
|
|
deleteOverride,
|
|
readAllOverrides,
|
|
readOverride,
|
|
writeOverride,
|
|
} from '../src/effects/implementations.js'
|
|
import { parseCardSource, SourceParseError } from '../src/effects/source.js'
|
|
|
|
const CARD: Card = {
|
|
oracle_id: '00000000-0000-4000-8000-000000000001',
|
|
name: 'Test Card',
|
|
layout: 'normal',
|
|
cmc: 1,
|
|
type_line: 'Creature — Human',
|
|
colors: [],
|
|
color_identity: [],
|
|
keywords: [],
|
|
}
|
|
|
|
const SOURCE = `export default [
|
|
triggered(when.enters(self), [
|
|
modal(1, 1, [
|
|
[
|
|
exile(target(permanents.withType('creature').other().ownedBy('you'))),
|
|
schedule('next_end_step', [returnToBattlefield(previousTarget)]),
|
|
],
|
|
]),
|
|
]),
|
|
staticAbility([
|
|
grantAbility(each(permanents.withType('land').enchanted()), triggered(when.upkeep(you), [
|
|
pay([manaCost('{W}{W}')]),
|
|
ifThen(ifYouDo(), [gainLife(you, 1)]),
|
|
], { optional: true })),
|
|
]),
|
|
]`
|
|
|
|
test('card source round-trips through the compiler and formatter', () => {
|
|
const compiled = compileImplementation(CARD, SOURCE)
|
|
assert.equal(compiled.manual, true)
|
|
assert.equal(compiled.status, 'supported')
|
|
assert.equal(compiled.typeLine, CARD.type_line)
|
|
|
|
const rendered = formatCard(compiled)
|
|
assert.match(rendered, /export default card\('Creature — Human', \[/)
|
|
const reparsed = compileImplementation(CARD, rendered)
|
|
assert.equal(formatCard(reparsed), rendered)
|
|
assert.equal(reparsed.typeLine, CARD.type_line)
|
|
assert.equal(reparsed.abilities.length, 2)
|
|
|
|
const [triggered] = reparsed.abilities
|
|
assert.equal(triggered.kind, 'triggered')
|
|
if (triggered.kind !== 'triggered') return
|
|
assert.equal(triggered.effects[0].op, 'modal')
|
|
if (triggered.effects[0].op !== 'modal') return
|
|
assert.equal(triggered.effects[0].modes[0][1].op, 'schedule')
|
|
|
|
const staticAbility = reparsed.abilities[1]
|
|
assert.equal(staticAbility.kind, 'static')
|
|
if (staticAbility.kind !== 'static') return
|
|
assert.equal(staticAbility.effects[0].op, 'grant_ability')
|
|
if (staticAbility.effects[0].op !== 'grant_ability') return
|
|
assert.equal(staticAbility.effects[0].ability.kind, 'triggered')
|
|
})
|
|
|
|
test('card source declares the card type line for the engine', () => {
|
|
const compiled = compileImplementation(CARD, `export default card('Artifact Creature — Golem', [keyword('Vigilance')])`)
|
|
assert.equal(compiled.typeLine, 'Artifact Creature — Golem')
|
|
assert.match(formatCard(compiled), /export default card\('Artifact Creature — Golem', \[/)
|
|
})
|
|
|
|
test('multi-face card source declares one type line per face', () => {
|
|
const faces: Card = {
|
|
...CARD,
|
|
layout: 'transform',
|
|
card_faces: [
|
|
{ name: 'Front', type_line: 'Sorcery', colors: [] },
|
|
{ name: 'Back', type_line: 'Creature — Human', colors: [] },
|
|
],
|
|
}
|
|
const source = `export default faces(
|
|
face('Front', 'Instant', [spell([draw(you, 2)])]),
|
|
face('Back', 'Creature — Human', [keyword('Flying')]),
|
|
)`
|
|
const compiled = compileImplementation(faces, source)
|
|
assert.deepEqual(compiled.faces?.map(face => face.typeLine), ['Instant', 'Creature — Human'])
|
|
const rendered = formatCard(compiled)
|
|
assert.equal(formatCard(compileImplementation(faces, rendered)), rendered)
|
|
})
|
|
|
|
test('effect lists accept callbacks in place of arrays', () => {
|
|
const CALLBACK_SOURCE = `export default [
|
|
triggered(when.enters(self), () => draw(you, 1)),
|
|
triggered(when.dies(self), () => {
|
|
draw(you, 1)
|
|
gainLife(you, 1);
|
|
}),
|
|
staticAbility(() => staticPump(each(creatures.youControl()), 1, 1)),
|
|
spell([
|
|
modal(1, 1, [
|
|
() => draw(you, 2),
|
|
() => { gainLife(you, 3) },
|
|
]),
|
|
]),
|
|
]`
|
|
|
|
const compiled = compileImplementation(CARD, CALLBACK_SOURCE)
|
|
assert.equal(compiled.status, 'supported')
|
|
|
|
const [enters, dies, staticAbility, spell] = compiled.abilities
|
|
assert.equal(enters.kind, 'triggered')
|
|
if (enters.kind !== 'triggered') return
|
|
assert.deepEqual(enters.effects.map(effect => effect.op), ['draw'])
|
|
|
|
assert.equal(dies.kind, 'triggered')
|
|
if (dies.kind !== 'triggered') return
|
|
assert.deepEqual(dies.effects.map(effect => effect.op), ['draw', 'life'])
|
|
|
|
assert.equal(staticAbility.kind, 'static')
|
|
if (staticAbility.kind !== 'static') return
|
|
assert.deepEqual(staticAbility.effects.map(effect => effect.op), ['pump'])
|
|
|
|
assert.equal(spell.kind, 'spell')
|
|
if (spell.kind !== 'spell') return
|
|
assert.equal(spell.effects[0].op, 'modal')
|
|
if (spell.effects[0].op !== 'modal') return
|
|
assert.deepEqual(spell.effects[0].modes.map(mode => mode.map(effect => effect.op)), [['draw'], ['life']])
|
|
})
|
|
|
|
test('invalid source reports its line', () => {
|
|
assert.throws(
|
|
() => parseCardSource('export default [\n draw(you)\n]'),
|
|
(error: unknown) => error instanceof SourceParseError && error.line === 2,
|
|
)
|
|
})
|
|
|
|
test('unknown AST discriminants are rejected', () => {
|
|
assert.throws(
|
|
() => parseCardSource("export default [spell([{ op: 'nope' }])]"),
|
|
(error: unknown) => error instanceof SourceParseError && /expected an effect/.test(error.message),
|
|
)
|
|
assert.throws(
|
|
() => parseCardSource("export default [{ kind: 'nope' }]"),
|
|
(error: unknown) => error instanceof SourceParseError && /expected an ability/.test(error.message),
|
|
)
|
|
assert.throws(
|
|
() => parseCardSource("export default [triggered(when.nope(self), [])]"),
|
|
(error: unknown) => error instanceof SourceParseError,
|
|
)
|
|
})
|
|
|
|
test('manual implementations persist one file per card', async (t) => {
|
|
const dir = await mkdtemp(join(tmpdir(), 'commander-overrides-'))
|
|
const previous = process.env.CARD_OVERRIDES_DIR
|
|
process.env.CARD_OVERRIDES_DIR = dir
|
|
t.after(async () => {
|
|
if (previous === undefined) delete process.env.CARD_OVERRIDES_DIR
|
|
else process.env.CARD_OVERRIDES_DIR = previous
|
|
await rm(dir, { recursive: true, force: true })
|
|
})
|
|
|
|
await writeOverride(CARD.oracle_id, SOURCE)
|
|
const stored = await readOverride(CARD.oracle_id)
|
|
assert.equal(stored?.source, `${SOURCE}\n`)
|
|
assert.equal((await readAllOverrides()).get(CARD.oracle_id), `${SOURCE}\n`)
|
|
|
|
const compiled = compileImplementation(CARD, stored!.source)
|
|
assert.equal(compiled.manual, true)
|
|
assert.equal(compiled.status, 'supported')
|
|
|
|
await deleteOverride(CARD.oracle_id)
|
|
assert.equal(await readOverride(CARD.oracle_id), undefined)
|
|
})
|
|
|
|
test('entersTapped accepts an unlessCost builder and round-trips', () => {
|
|
const source = `export default [
|
|
staticAbility([entersTapped(self, { unlessCost: payLife(2) })]),
|
|
]`
|
|
const compiled = compileImplementation(CARD, source)
|
|
assert.equal(compiled.status, 'supported')
|
|
|
|
const rendered = formatCard(compiled)
|
|
assert.match(rendered, /entersTapped\(self, \{ unlessCost: payLife\(2\) \}\)/)
|
|
|
|
const reparsed = compileImplementation(CARD, rendered)
|
|
assert.deepEqual(reparsed.abilities, compiled.abilities)
|
|
})
|