This commit is contained in:
2026-10-29 15:21:05 +01:00
parent bb85881cac
commit bc05b63083
36 changed files with 4654 additions and 5080 deletions

2
backend/.gitignore vendored
View File

@@ -3,7 +3,7 @@ dist
.env
data/cards.json
data/card-effects.json
data/card-effects.pseudo.txt
data/card-effects.js
data/images/
data/playmats/
data/*.tmp

View File

@@ -0,0 +1,5 @@
export default [
activated([tapCost()], [
addMana(you, anyColor(1, { restriction: 'a land an opponent controls could produce' })),
]),
]

View File

@@ -0,0 +1,7 @@
export default [
keywords('Flying', 'Ward {2}'),
triggered(
when.enters(each(permanents.other().nontoken().withSubtype('dragon').withType('creature').youControl())),
() => createToken(you, 1, copyOf(triggerSubject, { notLegendary: true })),
),
]

View File

@@ -1,4 +0,0 @@
# Miirym, Sentinel Wyrm [supported]
keywords Flying, Ward {2}
on enters(each other nontoken dragon you control):
create_token(you, 1, copy of the triggering object, not legendary)

View File

@@ -3,9 +3,9 @@
The card database from Scryfall is English prose. The game engine cannot execute
prose, so `backend/src/effects/` compiles every oracle-text line into a small
JSON AST. The AST is the canonical form for the engine. A pretty-printer renders
the same AST as readable pseudocode, and a matching parser reads that pseudocode
back, so a human can replace the generated implementation of a card without
touching JSON.
the same AST as readable card source, and a matching interpreter reads that
source back, so a human can replace the generated implementation of a card
without touching JSON.
This is deliberately **not** a rules engine. It answers "what does the card
say?" in machine-readable form. "What happens when it resolves?" belongs to the
@@ -18,10 +18,10 @@ Scryfall oracle text
-> normalize (card name, "this creature", contractions, reminder text)
-> classify (keyword / triggered / activated / static / spell effect)
-> parse targets, values, costs, conditions, durations
-> JSON AST + pseudocode rendering
-> JSON AST + card-source rendering
data/card-overrides/<oracle_id>.pseudo.txt
-> pseudocode parser
data/card-overrides/<oracle_id>.js
-> safe source interpreter
-> JSON AST used instead of the generated one
```
@@ -34,16 +34,16 @@ a guessed effect. A wrong effect is worse than a missing one.
From `backend/`:
```bash
npm run compile:cards # writes data/card-effects.json and .pseudo.txt
npm test # compiler, pseudocode parser, and engine tests
npm run compile:cards # writes data/card-effects.json and data/card-effects.js
npm test # compiler, source interpreter, and engine tests
npm run dev # API for the frontend editor
```
Current output over the imported Commander pool (32,116 cards):
```text
Cards: 14,141 supported, 10,119 partial, 7,856 unsupported
Ability lines: 37,983/60,470 parsed (62.8%)
Cards: 14,239 supported, 10,088 partial, 7,789 unsupported
Ability lines: 38,132/60,470 parsed (63.1%)
```
- **supported** — every ability line parsed.
@@ -58,40 +58,200 @@ patterns updates the numbers.
| File | Contents |
| ---- | -------- |
| `data/card-effects.json` | Array of `CompiledCard` ASTs, one per oracle card |
| `data/card-effects.pseudo.txt` | The same cards rendered as pseudocode |
| `data/card-overrides/<oracle_id>.pseudo.txt` | Human-authored implementations, one file per card |
| `data/card-effects.js` | The same cards rendered as card source |
| `data/card-overrides/<oracle_id>.js` | Human-authored implementations, one file per card |
The two generated files are git-ignored. Overrides are ordinary source files and
should be committed.
## Pseudocode
Compiled cards carry the Scryfall `typeLine`, and the game catalog uses it.
An override can declare its own type line with `card(...)`; that value wins when
the card is loaded into a game.
```text
# Soul Warden [supported]
on enters(each other creature):
gain_life(you, 1)
## Card source
# Llanowar Elves [supported]
activate {T}:
add_mana(you, {G})
Card source looks like a JavaScript module, but it is **not executed as
JavaScript**. `src/effects/source.ts` tokenizes and evaluates a deliberately
small expression subset against a fixed builder API. There is no `eval`, no
`new Function`, no imports, no property writes and no access to globals: an
unrecognized name or method is a parse error. This matters because
`PUT /cards/:oracleId/implementation` is unauthenticated.
# Krenko, Mob Boss [supported]
activate {T}:
create_token(you, count(creature goblin you control), 1/1 red goblin creature)
A card exports its type line and an array of abilities:
```js
export default card('Creature — Human Cleric', [
keywords('Flying', 'Ward {2}'),
triggered(when.enters(each(permanents.other().withType('creature'))), [
gainLife(you, 1),
]),
activated([tapCost()], [
addMana(you, mana('{G}')),
]),
])
```
Pseudocode is a two-way format. `formatCard` writes it, `parsePseudoCard` reads
it back into the same AST the compiler produces. Blocks are indented two spaces.
A leading `# Card [status]` line is ignored, and `## Face Name [status]` starts a
new section for a multi-face card. Use `(no abilities)` when a face has none.
Plain `export default [...]` is still accepted and uses the Scryfall type line.
Multi-face cards export `faces(face('Name', 'Type line', [...]), ...)` in card order:
```js
export default faces(
face('Front', 'Instant', [spell([draw(you, 2)])]),
face('Back', 'Creature — Human', [keyword('Flying')]),
)
```
Every effect list also accepts a callback. A single expression is one effect; a
block is several effects, separated by newlines, `;` or `,`:
```js
export default card('Creature — Human Cleric', [
triggered(when.enters(self), () => draw(you, 1)),
activated([tapCost()], () => {
gainLife(you, 1)
draw(you, 1)
}),
])
```
Arrays stay valid and are still used for costs, `modal` modes, ability lists,
`card`, `faces` and `face`. The formatter emits callbacks for effect lists and
`card(typeLine, abilities)` at the top level.
The formatter writes the same shape, so a generated implementation can be
copied, edited and saved as an override. `formatCard` and `parseCardSource`
round-trip: comments are ignored, a leading `// Card [status]` line is optional,
and `const` declarations are allowed for reuse:
```js
const dragons = permanents.withType('creature').withSubtype('dragon').youControl()
export default card('Creature — Human Cleric', [
staticAbility([staticPump(each(dragons), 1, 1)]),
])
```
### Abilities
| Call | Meaning |
| ---- | ------- |
| `keyword(name, value)` | One keyword, optionally parameterized |
| `keywords(...names)` | Several keywords from one oracle line |
| `triggered(event, effects, options)` | `When`/`Whenever`/`At` ability |
| `activated(costs, effects, options)` | Cost `:` effect, including loyalty |
| `staticAbility(effects, options)` | Continuous effect or restriction |
| `spell(effects, options)` | Effect line of an instant or sorcery |
| `additionalCost(costs, options)` | Additional cost |
| `alternativeCost(costs, options)` | Alternative cast, possibly free |
| `overload(cost)` | Overload alternate cost |
| `chapter(chapters, effects, options)` | Saga chapter ability |
| `levelBand(min, max, power, toughness)` | Level band |
| `levelPt(power, toughness)` | Level P/T line |
| `unsupported(reason, text)` | Preserved text plus a reason |
`options` accepts `condition` and `optional`; activated abilities also accept
`timing: 'sorcery'` and `activationsPerTurn`.
### Selectors and targets
Selectors start from `permanents`, `cards` or `creatures` and chain filters:
```js
permanents.withType('creature').withSubtype('dragon').withColor('red')
.other().tapped().youControl().powerAtLeast(4)
```
Available filters include `withType`, `withSubtype`, `withSupertype`,
`withColor`, `withKeyword`, `withoutKeyword`, `withoutType`, `other`, `tapped`,
`untapped`, `attacking`, `token`, `nontoken`, `equipped`, `enchanted`,
`youControl`, `opponentControls`, `controlledBy`, `ownedBy`, `named`,
`inZone`, `withCounter`, `powerAtLeast`/`powerAtMost`,
`toughnessAtLeast`/`toughnessAtMost`, `manaValueAtLeast`/`manaValueAtMost`
and `matchingAny`.
Targets wrap a selector or player:
```js
target(permanents.withType('creature'))
each(creatures.withColor('red'))
pick(cards.withType('land'), { upTo: 2 })
divided(3, creatures.attacking())
targetSpell(permanents.withType('instant'))
targetAbility()
```
Fixed targets are `self`, `triggerSubject`, `previousTarget`, `anyTarget` and
`targetPlayerOrPlaneswalker`. Players are `you`, `opponent`, `eachOpponent`,
`eachPlayer`, `targetPlayer`, `thatPlayer`, `itsController` and `itsOwner`.
Values are numbers, `X`, `itsPower`, `itsToughness`, `count(selector)`,
`cardsInHand(player)`, `maxCardsInHand()`, `maxOpponentCount(selector)`,
`totalManaValue(selector)`, `totalPower(selector)`, `anyNumber()` and
`eventAmount()`.
### Effects, costs and statics
Effects are camelCase builders, one array entry or callback statement each:
```js
damage(target(permanents.withType('creature')), 3)
draw(you, 2)
gainLife(you, 1)
createToken(you, 1, token({ types: ['creature'], subtypes: ['goblin'], colors: ['red'], power: 1, toughness: 1 }))
putCounters(target(permanents.withType('creature')), '+1/+1', 2)
destroy(target(permanents.withType('creature')))
addMana(you, mana('{G}{G}'))
search(you, cards.withType('creature'), 1, { destination: 'battlefield', shuffle: true })
pump(each(creatures.youControl()), 1, 1, untilEndOfTurn)
```
Costs are distinct from effects: `manaCost('{2}{U}')`, `tapCost()`,
`untapCost()`, `sacrificeSelf()`, `payLife(3)`, `discardCost(1)`,
`removeCountersCost('+1/+1', 1)`, `exileSelf()`, `choice([...])` and the rest of
the cost builders in `source.ts`.
Static effects are also distinct, so their AST shape is unambiguous:
`staticPump`, `staticGrant`, `staticRestrict`, `staticSetPt`, `grantAbility`,
`entersTapped`, `entersWithCounters`, `control`, `choose`, `replace`,
`costReduction`, `costIncrease`, `searchRestriction` and
`exileInsteadOfGraveyard`. `entersTapped` takes an optional `unlessCost` builder
for "you may pay N life; if you don't, it enters tapped":
`entersTapped(self, { unlessCost: payLife(2) })`.
Durations are `permanent` (default), `untilEndOfTurn`, `untilYourNextTurn`,
`untilEndOfYourNextTurn`, `untilEndOfCombat`,
`untilControllersNextUntapStep` and `whileSourceOnBattlefield`.
Triggers live under `when`: `when.enters`, `when.dies`, `when.attacks`,
`when.blocks`, `when.attacksOrBlocks`, `when.entersOrAttacks`,
`when.entersOrDies`, `when.leavesBattlefield`, `when.dealsDamage`,
`when.upkeep`, `when.endStep`, `when.beginCombat`, `when.firstMainPhase`,
`when.postcombatMainPhase`, `when.cast`, `when.becomesLevel`, `when.draw`,
`when.counterPlaced`, `when.becomesTarget`, `when.lifeGained` and
`when.lifeLost`.
Conditions are top-level calls such as `yourTurn()`, `youControl(selector, n)`,
`opponentControls(selector)`, `lifeAtLeast(player, n)`, `wasKicked()`,
`ifYouDo()`, `ifYouDont()` and `otherwise()`. The full list is the set of
condition builders in `source.ts`.
Nested structures are effect lists (array or callback) or `ifThen`/`modal`:
```js
triggered(when.upkeep(you), [
ifThen(youControl(permanents.withType('artifact'), 3), [draw(you, 1)]),
])
spell([
modal(1, 1, [[draw(you, 2)], [gainLife(you, 3)]]),
])
```
## Manual implementations
The frontend at `/cards` lists cards and filters to `needs-work` by default. Select a
card, edit its pseudocode, and save. The editor toggles between the text view and a
node canvas where sockets are wired to define effect order and nested bodies; both
edit the same source. The API validates the source before writing it, so a typo
never replaces a working file. Overrides take precedence during
card, edit its source, and save. The API validates the source before writing it,
so a typo never replaces a working file. Overrides take precedence during
`npm run compile:cards`; invalid override files stop the compile with the line
number.
@@ -100,7 +260,7 @@ number.
| `GET` | `/cards/:oracleId/implementation` | Card, compiled AST, source, manual flag |
| `PUT` | `/cards/:oracleId/implementation` | Validate and save `{ "source": "..." }` |
| `DELETE` | `/cards/:oracleId/implementation` | Delete the override, restore generated output |
| `POST` | `/cards/:oracleId/translate` | Ask OpenRouter for pseudocode from the card's oracle text |
| `POST` | `/cards/:oracleId/translate` | Ask OpenRouter for card source from the card's oracle text |
| `GET` | `/cards/:oracleId/override` | Raw saved source, `404` when absent |
| `GET` | `/stats` | Supported, partial, unsupported, and manual counts |
@@ -110,21 +270,20 @@ number.
The editor's **Draft with AI** button calls
`POST /cards/:oracleId/translate`. The backend sends the card's oracle text to
an [OpenRouter](https://openrouter.ai/) model and returns pseudocode, without
an [OpenRouter](https://openrouter.ai/) model and returns card source, without
saving it. The response is parsed before it reaches the browser, so prose or a
non-parseable guess is reported as an error instead of replacing the editor.
Set `OPENROUTER_API_KEY` on the backend to enable the route. `OPENROUTER_MODEL`
defaults to `google/gemini-2.5-flash-lite`.
The system prompt contains the syntax reference and a strict output contract:
pseudocode only, no explanations, Markdown, code fences or card header, and no
invented operations. Output is capped at 700 tokens. A fenced answer is
The system prompt contains the source reference and a strict output contract:
card source only, no explanations, Markdown, code fences or card header, and no
invented operations. Output is capped at 1,200 tokens. A fenced answer is
unwrapped defensively, but an invalid answer is not retried (that would spend
more tokens). The translator uses the default model only; there is no per-request
model picker.
## AST
The types live in `src/effects/types.ts`. A card contains one or more abilities:
@@ -133,6 +292,7 @@ The types live in `src/effects/types.ts`. A card contains one or more abilities:
{
"oracle_id": "...",
"name": "Soul Warden",
"typeLine": "Creature — Human Cleric",
"status": "supported",
"abilities": [
{
@@ -239,7 +399,7 @@ ambiguous pronouns stay unsupported.
## Adding support
For a single card, open the frontend editor, edit the pseudocode, and save; no
For a single card, open the frontend editor, edit the source, and save; no
compiler change is needed. For a whole class of cards:
1. Run `npm run compile:cards` and pick a frequent unsupported pattern.

View File

@@ -18,6 +18,7 @@ const game = new Game({
startingLife: 40,
startingHandSize: 7,
commander: true,
mulligans: true,
players: [
{ id: 'p1', deck: deckFromOracleIds(decklist1), commander: commanderCard1 },
{ id: 'p2', deck: deckFromOracleIds(decklist2), commander: commanderCard2 },
@@ -32,7 +33,9 @@ in `commander.ts` checks size, singleton, color identity, and the commander type
`catalog.ts` merges Scryfall card data with `data/card-effects.json`. It also adds
intrinsic mana abilities for basic lands, because Scryfall's oracle text only has
reminder text for them and the compiler produces no ability.
reminder text for them and the compiler produces no ability. When a compiled card
declares a `typeLine`, that value is used instead of Scryfall's; the generated
card source carries the type line and an override can change it.
For tests or hand-authored cards, build a `CardDefinition` yourself:
@@ -56,7 +59,10 @@ const bolt: CardDefinition = {
| Method | Purpose |
| ------ | ------- |
| `start()` | Shuffles libraries, draws opening hands, begins turn 1. |
| `start()` | Shuffles libraries and draws opening hands. With `mulligans: true`, turn 1 waits until every player keeps. |
| `keepHand(playerId)` | Keeps the opening hand; begins turn 1 once every living player has kept. |
| `mulligan(playerId)` | Shuffles the hand back, draws a new opening hand, and queues bottom-of-library choices (one more each time). |
| `putOnBottom(playerId, cardId)` | Puts one chosen card from a mulliganed opening hand on the bottom of its owner's library. |
| `playLand(playerId, cardId)` | Plays a land from hand; once per turn, main phase, empty stack. |
| `castSpell(playerId, cardId, { targets, x, mode, overload })` | Puts a spell on the stack and pays its mana cost. Accepts a commander in the command zone, adds commander tax, and can pay the overload cost instead. |
| `activateAbility(playerId, sourceId, abilityIndex, { targets, x, mode })` | Activates an ability on a permanent. Mana abilities resolve immediately. |
@@ -87,6 +93,10 @@ the permanent, and the match API refuses other priority actions until `chooseCre
(the `choose_type` action) receives one of the creature types in `CREATURE_TYPES`.
The chosen type is stored on the object and cleared when it leaves the battlefield.
With mulligans enabled, the game starts in the `mulligan` status. A mulligan shuffles
the hand back and draws seven; the second mulligan puts one card on the bottom, the
third two, and so on (London rule). Turn 1 begins when every living player has kept.
## Turn structure
```text
@@ -132,8 +142,8 @@ shown to players who can actually do something.
lifelink, vigilance, haste, indestructible. Regeneration shields replace
destruction.
- State-based actions: life at or below zero, ten poison counters, 21 commander
damage from one commander, lethal or deathtouch damage, zero toughness, and
drawing from an empty library.
damage from one commander, lethal or deathtouch damage, zero toughness, the
legend rule, and drawing from an empty library.
## Known limitations
@@ -144,11 +154,13 @@ shown to players who can actually do something.
- Commander support covers single commanders. Partner, backgrounds, companions,
and "choose a commander" variants are not modelled. The engine always takes the
command-zone replacement instead of asking.
- The legend rule, planeswalker loyalty abilities, attacking planeswalkers, and
- Planeswalker loyalty abilities, attacking planeswalkers, and
protection/menace/defender are not implemented unless expressed as a compiled
restriction.
restriction. When the legend rule applies, the engine keeps the first copy it
finds and moves the rest to the graveyard instead of asking the controller.
- Modal spells choose a mode by index (`options.mode`); optional "you may" choices
are not modelled. An optional `pay` is simply not paid when unaffordable. Search
are not modelled, except "pay a cost or enter tapped" which pauses for the
controller. An optional `pay` is simply not paid when unaffordable. Search
effects with several matching cards do pause for the player's pick.
- "As this enters, choose a creature type" pauses for a pick and stores the type on
the permanent, but no effect reads the chosen type yet. The other `choose` kinds
@@ -160,7 +172,9 @@ shown to players who can actually do something.
- Overload widens only top-level effect targets; a nested modal or conditional target
keeps its printed target. Free alternative costs are modelled only for controlling
a commander, and search restrictions cap the searching player's own library.
- Opening hands are kept automatically; there is no mulligan flow.
- Opening hands use the London mulligan when `mulligans` is enabled: each mulligan
draws seven, then puts one more card on the bottom than the previous one. The
match API starts with mulligans on.
- Replacement/prevention effects, layers, and dependency ordering are simplified.
Continuous effects apply in creation order rather than in full rules order.
- The engine is synchronous and exposes full state. `rooms.ts` owns the in-memory

View File

@@ -4,13 +4,13 @@ import type { Card } from '../src/cards.js'
import { compileCard } from '../src/effects/compile.js'
import { formatCard } from '../src/effects/format.js'
import { compileImplementation, readAllOverrides } from '../src/effects/implementations.js'
import { PseudoParseError } from '../src/effects/pseudo.js'
import { SourceParseError } from '../src/effects/source.js'
import type { Ability, CompiledCard } from '../src/effects/types.js'
const DATA_DIR = join(process.cwd(), 'data')
const CARDS_FILE = join(DATA_DIR, 'cards.json')
const AST_FILE = join(DATA_DIR, 'card-effects.json')
const PSEUDO_FILE = join(DATA_DIR, 'card-effects.pseudo.txt')
const SOURCE_FILE = join(DATA_DIR, 'card-effects.js')
function formatBytes(bytes: number): string {
return `${(bytes / 1024 / 1024).toFixed(1)} MB`
@@ -55,7 +55,7 @@ for (const card of cards) {
try {
result = source === undefined ? compileCard(card) : compileImplementation(card, source)
} catch (error) {
if (error instanceof PseudoParseError) {
if (error instanceof SourceParseError) {
console.error(`Invalid manual implementation for ${card.name} (${card.oracle_id}):`)
console.error(` ${error.message}`)
process.exit(1)
@@ -80,9 +80,9 @@ for (const card of cards) {
await mkdir(DATA_DIR, { recursive: true })
const astOutput = JSON.stringify(compiled)
const pseudoOutput = compiled.map(formatCard).join('\n\n')
const sourceOutput = compiled.map(formatCard).join('\n\n')
await writeFile(AST_FILE, astOutput)
await writeFile(PSEUDO_FILE, pseudoOutput)
await writeFile(SOURCE_FILE, sourceOutput)
console.log(`Compiled ${compiled.length} cards (${manualCount} with manual implementations).`)
console.log(
@@ -100,4 +100,4 @@ if (samples.length) {
for (const sample of samples) console.log(` - ${sample}`)
}
console.log(`Wrote ${formatBytes(Buffer.byteLength(astOutput))} to ${AST_FILE}`)
console.log(`Wrote ${formatBytes(Buffer.byteLength(pseudoOutput))} to ${PSEUDO_FILE}`)
console.log(`Wrote ${formatBytes(Buffer.byteLength(sourceOutput))} to ${SOURCE_FILE}`)

View File

@@ -997,7 +997,13 @@ function parseEffect(text: string): Effect | Effect[] | undefined {
match = sentence.match(/^add ((?:\{[^}]+\})(?:,? ?(?:or )?\{[^}]+\})*)$/)
if (match) {
const symbols = match[1].match(/\{[^}]+\}/g)
if (symbols) return { op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols } }
if (symbols) {
return {
op: 'add_mana',
player: 'you',
mana: { kind: 'symbols', symbols, ...(/\bor\b/i.test(match[1]) ? { oneOf: true } : {}) },
}
}
}
match = sentence.match(/^add (one|two|three|four|five|x) mana of any (one )?color( in your commander's color identity)?$/)
@@ -2068,6 +2074,11 @@ function parseStaticEffects(text: string): StaticEffect[] | undefined {
if (sentence === 'this enters tapped') {
return [{ op: 'enters_tapped', target: { kind: 'self' } }]
}
match = sentence.match(/^as this enters, you may pay (\w+) life\. if you don't, it enters tapped$/)
if (match) {
const amount = parseValue(match[1])
if (amount) return [{ op: 'enters_tapped', target: { kind: 'self' }, unlessCost: { kind: 'pay_life', amount } }]
}
const entersTappedUnless = sentence.match(/^this enters tapped unless (.+)$/)
if (entersTappedUnless) {
const unless = parseCondition(entersTappedUnless[1])
@@ -2475,7 +2486,7 @@ function compileFace(face: CardFace | { name: string; oracle_text?: string; type
const ability = compileLine(line, face.name, known, isSpell)
if (!(ability.kind === 'unsupported' && ability.reason === 'empty')) abilities.push(ability)
}
return { name: face.name, status: statusOf(abilities), abilities }
return { name: face.name, typeLine: face.type_line, status: statusOf(abilities), abilities }
}
export function compileCard(card: Card): CompiledCard {
@@ -2485,7 +2496,7 @@ export function compileCard(card: Card): CompiledCard {
const status: Status = statuses.includes('unsupported')
? statuses.every(value => value === 'unsupported') ? 'unsupported' : 'partial'
: statuses.includes('partial') ? 'partial' : 'supported'
return { oracle_id: card.oracle_id, name: card.name, status, abilities: [], faces }
return { oracle_id: card.oracle_id, name: card.name, typeLine: card.type_line, status, abilities: [], faces }
}
const face = compileFace(
@@ -2495,6 +2506,7 @@ export function compileCard(card: Card): CompiledCard {
return {
oracle_id: card.oracle_id,
name: card.name,
typeLine: card.type_line,
status: face.status,
abilities: face.abilities,
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,5 +1,5 @@
// Human-authored card implementations live in one plain-text file per oracle
// id under data/card-overrides/. The file is pseudocode in the same syntax the
// Human-authored card implementations live in one JavaScript file per oracle
// id under data/card-overrides/. The file uses the same builder API the
// formatter prints, so it stays readable and can be re-compiled by the engine.
import { readFileSync, statSync } from 'node:fs'
@@ -9,8 +9,8 @@ import { allCards } from '../cards.js'
import type { Card } from '../cards.js'
import { compileCard, statusOf } from './compile.js'
import { formatCard } from './format.js'
import { parsePseudoCard, PseudoParseError } from './pseudo.js'
import type { CompiledCard, CompiledFace } from './types.js'
import { parseCardSource, SourceParseError } from './source.js'
import type { Ability, CompiledCard, CompiledFace } from './types.js'
export type ImplementationStatus = 'supported' | 'partial' | 'unsupported'
@@ -37,7 +37,7 @@ export function overridesDir(): string {
function overrideFile(oracleId: string): string {
if (!ORACLE_ID.test(oracleId)) throw new Error(`Invalid oracle id: ${oracleId}`)
return join(overridesDir(), `${oracleId}.pseudo.txt`)
return join(overridesDir(), `${oracleId}.js`)
}
function isMissing(error: unknown): boolean {
@@ -67,7 +67,7 @@ export async function readAllOverrides(): Promise<Map<string, string>> {
}
for (const name of names) {
const oracleId = name.replace(/\.pseudo\.txt$/, '')
const oracleId = name.replace(/\.js$/, '')
if (name === oracleId || !ORACLE_ID.test(oracleId)) continue
const override = await readOverride(oracleId)
if (override) result.set(oracleId, override.source)
@@ -99,31 +99,45 @@ function facesStatus(faces: CompiledFace[]): ImplementationStatus {
return faces.some(face => face.status === 'partial') ? 'partial' : 'supported'
}
/** Parses manual pseudocode and turns it into the same AST the compiler emits. */
/** Copies the oracle label onto manual abilities so the stack log stays readable. */
function fillAbilityText(abilities: Ability[], generated: Ability[] | undefined): void {
abilities.forEach((ability, index) => {
const source = generated?.[index]
if (source && 'text' in source && source.text) {
(ability as Ability & { text?: string }).text = source.text
}
})
}
/** Parses manual JavaScript and turns it into the same AST the compiler emits. */
export function compileImplementation(card: Card, source: string): CompiledCard {
const parsed = parsePseudoCard(source)
const parsed = parseCardSource(source)
if (card.card_faces?.length) {
if (!parsed.faces?.length) {
throw new PseudoParseError(
`this card has ${card.card_faces.length} faces; add "## <face name>" sections`,
throw new SourceParseError(
`this card has ${card.card_faces.length} faces; export faces(face(...), ...)`,
1,
)
}
if (parsed.faces.length !== card.card_faces.length) {
throw new PseudoParseError(
throw new SourceParseError(
`expected ${card.card_faces.length} faces, found ${parsed.faces.length}`,
1,
)
}
const generated = compileCard(card)
const faces: CompiledFace[] = card.card_faces.map((face, index) => {
const manualFace = parsed.faces![index]
if (manualFace.name.toLowerCase() !== face.name.toLowerCase()) {
throw new PseudoParseError(`expected face "${face.name}", found "${manualFace.name}"`, 1)
throw new SourceParseError(`expected face "${face.name}", found "${manualFace.name}"`, 1)
}
const generatedFace = generated.faces?.find(entry => entry.name.toLowerCase() === face.name.toLowerCase())
fillAbilityText(manualFace.abilities, generatedFace?.abilities)
return {
name: face.name,
typeLine: manualFace.typeLine ?? face.type_line,
status: statusOf(manualFace.abilities),
abilities: manualFace.abilities,
}
@@ -132,6 +146,7 @@ export function compileImplementation(card: Card, source: string): CompiledCard
return {
oracle_id: card.oracle_id,
name: card.name,
typeLine: card.type_line,
status: facesStatus(faces),
abilities: [],
faces,
@@ -140,12 +155,14 @@ export function compileImplementation(card: Card, source: string): CompiledCard
}
if (parsed.faces?.length) {
throw new PseudoParseError('this card has no faces; remove the "##" sections', 1)
throw new SourceParseError('this card has no faces; export card(...) instead of faces(...)', 1)
}
fillAbilityText(parsed.abilities, compileCard(card).abilities)
return {
oracle_id: card.oracle_id,
name: card.name,
typeLine: parsed.typeLine ?? card.type_line,
status: statusOf(parsed.abilities),
abilities: parsed.abilities,
manual: true,

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,13 +1,14 @@
// Natural language -> card pseudocode through an OpenRouter-hosted model.
// The model is told to emit pseudocode only, and the answer is parsed before
// it reaches the editor, so prose or a guess never becomes an implementation.
// Natural language -> card source through an OpenRouter-hosted model.
// The model is told to emit the JavaScript card DSL only, and the answer is
// parsed before it reaches the editor, so prose or a guess never becomes an
// implementation.
import type { Card } from '../cards.js'
import { compileImplementation } from './implementations.js'
export const DEFAULT_MODEL = 'google/gemini-2.5-flash-lite'
const ENDPOINT = 'https://openrouter.ai/api/v1/chat/completions'
const MAX_TOKENS = 700
const MAX_TOKENS = 1200
export class TranslationError extends Error {
readonly status: number
@@ -22,160 +23,164 @@ export class TranslationError extends Error {
// Kept compact: it is both the model's only context and the format contract.
// Anything not listed here is rejected by the parser, so the model must not
// invent operations.
export const PSEUDO_GUIDE = `Pseudocode is line-oriented. Ability headers sit at column 0 and end with a colon. Their effects are indented two spaces, one call per line. Semicolons separate multiple effects on one line.
export const SOURCE_GUIDE = `The source is a JavaScript expression evaluated by a safe interpreter. It is never run as JavaScript: only the names listed here exist.
Multi-face cards use "## <exact face name>" lines, one section per face, in card order. Use "(no abilities)" for a face with none. A leading "# Card [status]" line is optional and not needed.
A card exports its type line and an array of abilities:
Ability headers:
on <trigger>[ if <condition>][ (may)]:
activate <cost>[, <cost>...][ if <condition>][ (N/turn)][ (sorcery speed)][ (may)]:
static[ if <condition>]:
spell[(may)]:
keyword <Keyword>[ value]
keywords <Keyword>, <Keyword>
additional cost[(may)]: <cost>
chapter <I>, <II>[(may)]:
level <min>-<max>[: <power>/<toughness>]
level <min>+[: <power>/<toughness>]
level_pt(<power>/<toughness>)
export default card('Creature — Human Cleric', [
triggered(when.enters(self), [gainLife(you, 1)]),
activated([tapCost()], [addMana(you, mana('{G}'))]),
])
Triggers:
enters(target), dies(target), attacks(target), blocks(target), attacks_or_blocks(target),
enters_or_attacks(target), enters_or_dies(target), leaves_battlefield(target),
deals_damage(target, player|creature|permanent|any), deals_combat_damage(...),
upkeep(you|opponent|each_player), end_step(...), begin_combat(...),
first_main_phase(...), postcombat_main_phase(...), becomes_level(N),
cast(you|opponent|each_player, <spell selector>|any spell[, targets this][, or copy][, #N each turn]),
draw(you|opponent|each_player[, #N each turn]), counter_placed(target[, counter]),
becomes_target(target), gain_life(you|opponent|each_player), lose_life(...)
Multi-face cards export face sections in card order:
export default faces(
face('Front', 'Instant', [ ...abilities ]),
face('Back', 'Creature — Human', [ ...abilities ]),
)
Abilities:
keyword('Flying') one keyword
keyword('Ward', '{2}') keyword with a value
keywords('Flying', 'Trample') several simple keywords
triggered(event, [effects], { condition, optional })
activated([costs], [effects], { condition, timing: 'sorcery', activationsPerTurn, optional })
staticAbility([staticEffects], { condition })
spell([effects], { optional })
additionalCost([costs], { optional })
alternativeCost([costs], { condition })
overload('{6}{U}')
chapter(['I', 'II'], [effects], { optional })
levelBand(min, max, power, toughness) max may be null
levelPt(power, toughness)
unsupported('short reason', 'original oracle text')
Any effect list (triggered, activated, staticAbility, spell, chapter, ifThen,
schedule and each modal mode) takes an array or a callback: () => effect, or
() => { effect; effect }.
Triggers (when.*):
enters(target), dies(target), attacks(target), blocks(target), attacksOrBlocks(target),
entersOrAttacks(target), entersOrDies(target), leavesBattlefield(target),
dealsDamage(target, 'player'|'creature'|'permanent'|'any', { combat }),
upkeep(who), endStep(who), beginCombat(who), firstMainPhase(who), postcombatMainPhase(who),
cast(who, spellSelector, { targetsSelf, orCopy, ordinal }), becomesLevel(N),
draw(who, ordinal), counterPlaced(target, counter), becomesTarget(target),
lifeGained(who), lifeLost(who)
who is you, opponent or eachPlayer.
Selectors (chainable):
permanents, cards, creatures
.withType('land'), .withSubtype('dragon'), .withSupertype('legendary')
.withColor('white'|'blue'|'black'|'red'|'green'|'colorless')
.withoutType('creature'), .withKeyword('flying'), .withoutKeyword('flying')
.other(), .tapped(), .untapped(), .attacking(), .token(), .nontoken()
.equipped(), .enchanted(), .youControl(), .opponentControls(), .controlledBy('you'|'opponent'|'any')
.ownedBy('you'|'opponent'), .named('Name'), .inZone('battlefield'|'hand'|'graveyard'|'library'|'exile'|'stack'|'command')
.withCounter('+1/+1', 1), .powerAtLeast(N), .powerAtMost(N), .toughnessAtLeast(N),
.toughnessAtMost(N), .manaValueAtLeast(N), .manaValueAtMost(N), .matchingAny()
Targets:
this, the triggering object, the chosen target, any target, target player,
target opponent, each opponent, each player, target player or planeswalker,
target spell, target ability, target <selector>, each <selector>,
up to N target <selector>, N <selector>, this or <selector>, divided(<max>[, <selector>])
self, triggerSubject, previousTarget, anyTarget, targetPlayerOrPlaneswalker
target(selector, { count, upTo, includeSelf }) one target
each(selector) every matching object
pick(selector, { count, upTo }) choose without targeting
divided(N, selector) or divided('any', selector) damage divided among targets
targetSpell(selector), targetAbility(selector)
target(you|opponent|eachOpponent|eachPlayer|targetPlayer|thatPlayer|itsController|itsOwner)
Selectors begin with optional state words: other, tapped, untapped, attacking, token,
equipped, enchanted. Then optional colors (white blue black red green colorless),
supertypes, subtypes, and types. Suffixes: "you control", "an opponent controls",
"you own", "you don't own", "with <keyword>", "without <keyword>",
"power N+" / "power N or less", "toughness N+" / "toughness N or less",
"mana value N+" / "mana value N or less", "named <name>",
"from a graveyard", "from a library", "from a hand", "in exile", "on the battlefield", "on the stack".
Values: a number, X, itsPower, itsToughness, count(selector), cardsInHand(player),
maxCardsInHand(), maxOpponentCount(selector), totalManaValue(selector),
totalPower(selector), anyNumber(), eventAmount()
Values: a number, X, count(<selector>), its power, its toughness,
cards in your hand, cards in that player's hand, total power of <selector>,
total mana value of <selector>, greatest number of <selector> an opponent controls,
that much, any number.
Costs:
manaCost('{2}{G}'), tapCost(), untapCost(), tapOther(selector), energyCost(N),
loyalty(N), payLife(value), discardCost(value, { player, random }), sacrificeCost(selector),
sacrificeSelf(), exileSelf(), exileFromGraveyard(selector, amount), reveal(selector),
choice([[cost, ...], [cost, ...]]), returnToHandCost(selector), behold(selector),
waterbend(value), blight(value), chooseCost('text'), putCounterCost(counter, selector),
removeCountersCost(counter, amount, selector), forage(), collectEvidence(N), millCost(value)
Costs: {T}, {Q}, {2}{G}, {E} xN, +1 loyalty, -2 loyalty, pay N life,
discard N card(s)[ at random], discard your hand, sacrifice this, sacrifice <selector>,
tap <selector>, exile this from a graveyard, exile N <selector> from your graveyard,
reveal <selector> from your hand, return <selector> to its owner's hand,
behold <selector>, waterbend <value>, blight <value>, choose <text>,
put <counter> counter on <selector>, forage, collect evidence N, mill N card(s).
A choice is written (cost or cost) or (cost + cost).
Effects, one call per line:
damage(target, amount[, from source])
damage_divided(amount, target)
draw(player, amount)
discard(player, amount[, at random])
mill(player, amount)
gain_life(player, amount)
lose_life(player, amount)
pump(target, power/toughness[, duration])
set_pt(target, power/toughness[, duration])
grant(target, Keyword[ value][, duration])
put_counters(target, counter, amount)
remove_counters(target, counter, amount)
proliferate()
create_token(player, amount, [tapped ]power/toughness colors subtypes types[ with keyword, keyword])
destroy(target), exile(target), tap(target), untap(target), regenerate(target)
sacrifice(player, target[, unless cost])
counter(spell|ability, target[, unless cost])
return_to_hand(target), put_on_top(target)
return_to_battlefield(target[, tapped][, transformed][, amount counter counters])
scry(player, amount), surveil(player, amount)
search(player, selector, amount, to hand|battlefield|graveyard|top|bottom[, tapped][, shuffle])
shuffle(player)
add_mana(player, {G}{G} | amount mana of any color)
fight(a, b)
energy(player, amount)
attach(this, target)
restrict(target, cant_attack|cant_block|doesnt_untap[, duration])
prevent_damage(target, amount|all[, duration])
prevent_combat_damage(target, amount|all[, duration])
gain_control(target[, duration])
emblem("text")
transform(target)
pay(cost)
look_top(player, amount[, reorder])
level_up(N)
put_from_among(amount[, selector], to hand|graveyard|battlefield|top|bottom)
dig(amount, up to? pick [selector] to hand|battlefield[ tapped], rest bottom|graveyard|top[ any|random][, optional])
Other keyword actions: action_name(target) or action_name(amount, detail)
Nested blocks:
if <condition>:
<effects>
choose <min>[-<max>]:
1. <effects separated by ;>
2. <effects separated by ;>
schedule(next_upkeep|next_end_step):
<effects>
Effects:
damage(target, amount, fromSource), damageDivided(amount, target)
draw(player, amount), discard(player, amount, { random }), mill(player, amount)
gainLife(player, amount), loseLife(player, amount)
pump(target, power, toughness, duration), setPt(target, power, toughness, { duration })
grant(target, keyword, { value, duration }), putCounters(target, counter, amount)
removeCounters(target, counter, amount), proliferate()
createToken(player, amount, token({ types, subtypes, colors, power, toughness, keywords, tapped }))
createToken(player, amount, copyOf(target, { notLegendary }))
destroy(target), exile(target), sacrifice(player, target, unlessCost)
counter('spell'|'ability', target, unlessCost), returnToHand(target)
returnToBattlefield(target, { tapped, transformed, counters: { counter, amount } })
putOnTop(target), tap(target), untap(target), scry(player, amount), surveil(player, amount)
search(player, selector, amount, { destination, tapped, shuffle, zones, split })
shuffle(player), addMana(player, mana('{G}{G}') | anyColor(value, { oneColor, restriction }))
fight(a, b), regenerate(target), energy(player, amount), attach(target)
restrict(target, 'cant_attack'|'cant_block'|'doesnt_untap', duration)
keywordAction('action name', { target, amount, detail })
preventDamage(target, amount | 'all', { combatOnly, duration })
gainControl(target, duration), emblem('text'), transform(target)
pay([costs]), ifThen(condition, [effects]), modal(min, max, [[effects], [effects]])
lookTop(player, amount, { reorder }), schedule('next_upkeep'|'next_end_step', [effects])
levelUp(N), putFromAmong(player, amount, { selector, destination }), dig(player, amount, { ... })
exileGraveyards(), hideaway(amount), playExiled(player, { free })
Static effects:
pump(target, power/toughness)
grant(target, Keyword[ value])
restrict(target, rule[ detail][ if <condition>])
enters_tapped(target[, unless <condition>])
enters_with_counters(target, counter, amount)
grant_ability(target):
<one ability block>
set_pt(target[, base], power/toughness|?)
control(target)
choose(creature_type|color|card_name|player|opponent|number)
replace(dies|leaves_battlefield|discard|draw[, target], instead exile|return_to_hand|return_to_library|prevent)
cost_reduction(target, amount|{R}{G}[, if <condition>])
staticPump(target, power, toughness), staticGrant(target, keyword, { value })
grantAbility(target, ability), staticRestrict(target, rule, { value, comparison, detail, condition })
entersTapped(target, { unless }), entersWithCounters(target, counter, amount)
staticSetPt(target, power, toughness, { base }), control(target)
choose('creature_type'|'color'|'card_name'|'player'|'opponent'|'number')
replace(what, { target, instead }), costReduction(target, amount | '{R}{G}', { condition })
costIncrease(amount, { spellType }), searchRestriction('you'|'opponent', amount),
exileInsteadOfGraveyard('you'|'opponent')
Common conditions: you control <selector>, you control at least N <selector>,
an opponent controls <selector>, it is your turn, it isn't your turn,
this is tapped, this is untapped, this is attacking, <player> has at least N life,
<player> has at most N life, <player> has N+ cards in their graveyard,
<player> has no cards in hand, a creature died this turn,
you gained at least N life this turn, you drew N+ cards this turn,
you cast it from your hand, this is in your graveyard, this is on the battlefield,
you're the monarch, you have the initiative, it was kicked,
you've cast a spell this turn, you've cast a noncreature spell this turn,
no creatures attacked this turn, you do, you don't, otherwise.
Conditions:
youControl(selector, atLeast), opponentControls(selector, atLeast), yourTurn(),
notYourTurn(), sourceTapped(), sourceUntapped(), sourceAttacking(),
lifeAtLeast(player, N), lifeAtMost(player, N), lifeAboveStarting(player, N),
cardsInGraveyard(player, N), handEmpty(player), creatureDiedThisTurn('you'|'opponent'),
youGainedLifeThisTurn(N), youDrewCardsThisTurn(N), spellsCastLastTurn(who, N),
noSpellsLastTurn(), attackedThisTurn(), youAttackedThisTurn(),
defendingPlayerControls(selector), targets(selector), wasKicked(), youCastIt({ fromHand }),
inGraveyard(), onBattlefield(), monarch(), initiative(), citysBlessing(), suspended(),
bargained(), wasCreature(), opponentLostLifeThisTurn(), lifeChangedThisTurn(),
descendedThisTurn(), permanentLeftBattlefieldThisTurn(), nonlandPermanentsEnteredThisTurn(N),
attackedWithTotalPower(N), yourCreaturesTotalPower(N), opponentControlsMoreLands(),
distinctPowers(N), graveyardCardTypes(N), noObjects(selector), cardsInHandAtMost(who, N),
notTheirTurn(), noAttackers(), opponentPoison(N), tributeNotPaid(), hadCounters(counter),
manaFromTreasure(), manaSpent(N), noManaSpent(), manaSymbolSpent('{G}'), kickedWith('{2}'),
moreCardsThanEachOpponent(), firstCombatPhase(), notToken(), castSpellThisTurn({ noncreature }),
fullParty(), graveyardCount(selector, N), creaturePowerGreaterThanBase('power'|'toughness'),
ifYouDo(), ifYouDont(), otherwise(), youControlCommander(), distinctNames(selector, N),
opponentDamagedThisTurn(N), attackedWithCreatures(N), libraryAtMost(N)
Durations: permanent (default), until end of turn, until your next turn,
until end of combat, until its controller's next untap step,
for as long as this remains on the battlefield.
Durations: permanent (default), untilEndOfTurn, untilYourNextTurn,
untilEndOfYourNextTurn, untilEndOfCombat, untilControllersNextUntapStep,
whileSourceOnBattlefield.
Players: you, opponent, each_opponent, each_player, target_player, that_player,
its_controller, its_owner.
Players: you, opponent, eachOpponent, eachPlayer, targetPlayer, thatPlayer,
itsController, itsOwner.
Example:
on enters(this):
gain_life(you, 1)
activate {T}:
add_mana(you, {G})
export default card('Creature — Human Cleric', [
triggered(when.enters(self), [gainLife(you, 1)]),
activated([tapCost()], [addMana(you, mana('{G}'))]),
spell([draw(you, 2)]),
])`
spell:
draw(you, 2)`
const SYSTEM_PROMPT = `You translate Magic: The Gathering card text into the card pseudocode language below.
const SYSTEM_PROMPT = `You translate Magic: The Gathering card text into the JavaScript card source language below.
Output rules:
- Answer with pseudocode only. No explanation, no code fences, no card header, no comments.
- Use only the syntax below. Never invent an operation or a keyword argument.
- If an ability cannot be expressed, use: unsupported (<short reason>): <original oracle text>
- For multi-face cards, output only the "## <face name>" sections in the given order.
- Answer with card source only. No explanation, no code fences, no comments.
- Start with card('Type line', [...]) using the exact type line given for the card.
- Use only the names and shapes below. Never invent an operation or a keyword argument.
- If an ability cannot be expressed, use: unsupported('short reason', 'original oracle text')
- For multi-face cards, output only the faces(...) sections in the given order.
${PSEUDO_GUIDE}`
${SOURCE_GUIDE}`
function describeCard(card: Card): string {
if (card.card_faces?.length) {
@@ -226,7 +231,7 @@ export async function translateCard(card: Card, options: TranslateOptions = {}):
headers: {
Authorization: `Bearer ${apiKey}`,
'Content-Type': 'application/json',
'X-Title': 'Commander card pseudocode translator',
'X-Title': 'Commander card source translator',
},
body: JSON.stringify({
model: options.model ?? process.env.OPENROUTER_MODEL ?? DEFAULT_MODEL,
@@ -261,7 +266,7 @@ export async function translateCard(card: Card, options: TranslateOptions = {}):
compileImplementation(card, source)
} catch (error) {
throw new TranslationError(
`The model did not return valid pseudocode: ${error instanceof Error ? error.message : String(error)}`,
`The model did not return valid card source: ${error instanceof Error ? error.message : String(error)}`,
)
}

View File

@@ -67,7 +67,7 @@ export type Value =
| { kind: 'event_amount' }
export type ManaSpec =
| { kind: 'symbols'; symbols: string[]; restriction?: string }
| { kind: 'symbols'; symbols: string[]; oneOf?: boolean; restriction?: string }
| { kind: 'any_color'; amount: Value; oneColor: boolean; restriction?: string }
export interface TokenSpec {
@@ -268,7 +268,7 @@ export type StaticEffect =
| { op: 'grant'; target: Target; keyword: string; value?: string }
| { op: 'grant_ability'; target: Target; ability: Ability }
| { op: 'restriction'; target: Target; rule: string; value?: Value; comparison?: 'or_greater' | 'or_less'; detail?: string; condition?: Condition }
| { op: 'enters_tapped'; target: Target; unless?: Condition }
| { op: 'enters_tapped'; target: Target; unless?: Condition; unlessCost?: Cost }
| { op: 'enters_with_counters'; target: Target; counter: string; amount: Value }
| { op: 'set_pt'; target: Target; power?: Value; toughness?: Value; base?: boolean }
| { op: 'control'; target: Target }
@@ -345,6 +345,8 @@ export type Ability =
export interface CompiledFace {
name: string
/** Scryfall type line, or the type line declared in card source. */
typeLine?: string
status: 'supported' | 'partial' | 'unsupported'
abilities: Ability[]
}
@@ -352,6 +354,8 @@ export interface CompiledFace {
export interface CompiledCard {
oracle_id: string
name: string
/** Scryfall type line, or the type line declared in card source. */
typeLine?: string
status: 'supported' | 'partial' | 'unsupported'
abilities: Ability[]
faces?: CompiledFace[]

View File

@@ -25,16 +25,22 @@ function numberOrUndefined(value: string | undefined): number | undefined {
}
function basicLandAbility(typeLine: string): Ability[] {
if (!/basic land/i.test(typeLine)) return []
const subtype = typeLine.toLowerCase().split('—').pop()?.trim().split(/\s+/)[0] ?? ''
const color = BASIC_MANA[subtype] ?? (subtype === 'wastes' ? 'C' : undefined)
if (!color) return []
if (!/\bland\b/i.test(typeLine)) return []
const subtypes = typeLine.toLowerCase().split('—').pop()?.trim().split(/\s+/) ?? []
const colors = [...new Set(subtypes.map(subtype => BASIC_MANA[subtype] ?? (subtype === 'wastes' ? 'C' : undefined))
.filter((color): color is string => Boolean(color)))]
if (!colors.length) return []
const symbols = colors.map(color => `{${color}}`)
return [{
kind: 'activated',
costs: [{ kind: 'tap' }],
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: [`{${color}}`] } }],
effects: [{
op: 'add_mana',
player: 'you',
mana: { kind: 'symbols', symbols, ...(symbols.length > 1 ? { oneOf: true } : {}) },
}],
optional: false,
text: `{T}: Add {${color}}.`,
text: `{T}: Add ${symbols.join(' or ')}.`,
}]
}
@@ -43,8 +49,9 @@ function definitionFrom(
compiled: CompiledCard | undefined,
face?: CardFace,
faceAbilities?: Ability[],
typeLineOverride?: string,
): CardDefinition {
const typeLine = face?.type_line ?? card.type_line
const typeLine = typeLineOverride ?? compiled?.typeLine ?? face?.type_line ?? card.type_line
return {
oracleId: card.oracle_id,
name: face?.name ?? card.name,
@@ -64,7 +71,7 @@ function definitionFrom(
export function cardDefinitionFromCard(card: Card, compiled?: CompiledCard): CardDefinition {
const face = card.card_faces?.[0]
const compiledFace = compiled?.faces?.[0]
return definitionFrom(card, compiled, face, compiledFace?.abilities)
return definitionFrom(card, compiled, face, compiledFace?.abilities, compiledFace?.typeLine)
}
function load(): Map<string, CardDefinition> {

View File

@@ -23,6 +23,7 @@ import type {
GameConfig,
ManaColor,
ManaPool,
MulliganState,
PendingChoice,
PendingSearch,
Phase,
@@ -195,8 +196,10 @@ export class Game {
phase: Phase = 'beginning'
step: Step = 'untap'
priority = ''
status: 'not_started' | 'active' | 'finished' = 'not_started'
status: 'not_started' | 'mulligan' | 'active' | 'finished' = 'not_started'
winner?: string
/** Opening-hand choices, keyed by player id. */
readonly mulligans = new Map<string, MulliganState>()
/** Blocks all other actions until the searching player picks a card. */
pendingSearch?: PendingSearch
/** "As this enters, choose..." prompts, in entry order. */
@@ -258,6 +261,9 @@ export class Game {
energy: 0,
poison: 0,
}))
for (const player of this.players) {
this.mulligans.set(player.id, { count: 0, kept: false, bottom: 0 })
}
for (const playerConfig of config.players) {
for (const definition of playerConfig.deck) {
@@ -290,7 +296,10 @@ export class Game {
return object
}
/** Starts the game, shuffles libraries, draws opening hands, and begins turn 1. */
/**
* Starts the game, shuffles libraries, and draws opening hands. With mulligans
* enabled, turn 1 waits until every player keeps; otherwise it begins immediately.
*/
start(): void {
if (this.status !== 'not_started') throw new GameError('Game already started')
for (const player of this.players) this.shuffleLibrary(player)
@@ -301,8 +310,69 @@ export class Game {
}
}
if (!this.config.mulligans) {
this.beginGame()
return
}
this.status = 'mulligan'
this.turn = 1
this.activePlayer = this.firstPlayer
}
/** Keeps the opening hand; turn 1 begins once every living player has kept. */
keepHand(playerId: string): void {
const mulligan = this.requireMulligan(playerId)
if (mulligan.kept) throw new GameError('You already kept your hand')
if (mulligan.bottom > 0) throw new GameError('Put your cards on the bottom first')
mulligan.kept = true
const player = this.getPlayer(playerId)
this.logMessage(`${player.name} keeps their hand${mulligan.count ? ` after ${mulligan.count} mulligan${mulligan.count === 1 ? '' : 's'}` : ''}`)
if (this.players.every(entry => entry.lost || this.mulligans.get(entry.id)?.kept)) this.beginGame()
}
/** Shuffles the hand back and draws a new one; each mulligan bottoms one more card. */
mulligan(playerId: string): void {
const mulligan = this.requireMulligan(playerId)
if (mulligan.kept) throw new GameError('You already kept your hand')
if (mulligan.bottom > 0) throw new GameError('Put your cards on the bottom first')
const player = this.getPlayer(playerId)
for (const id of [...player.hand]) this.moveToZone(id, 'library', { silent: true })
this.shuffleLibrary(player)
for (let i = 0; i < this.startingHandSize; i++) {
if (!player.library.length) break
this.drawCard(player.id, true)
}
mulligan.count++
mulligan.bottom = Math.min(Math.max(0, mulligan.count - 1), player.hand.length)
this.logMessage(`${player.name} mulligans${mulligan.bottom
? ` and puts ${mulligan.bottom} card${mulligan.bottom === 1 ? '' : 's'} on the bottom`
: ''}`)
}
/** Puts one card from a mulliganed opening hand on the bottom of the library. */
putOnBottom(playerId: string, cardId: string): void {
const mulligan = this.requireMulligan(playerId)
if (mulligan.kept) throw new GameError('You already kept your hand')
if (mulligan.bottom <= 0) throw new GameError('You have no cards to put on the bottom')
const player = this.getPlayer(playerId)
if (!player.hand.includes(cardId)) throw new GameError('Card is not in hand')
this.moveToZone(cardId, 'library', { silent: true })
mulligan.bottom--
}
private requireMulligan(playerId: string): MulliganState {
if (this.status !== 'mulligan') throw new GameError('The game is not in its mulligan step')
const player = this.getPlayer(playerId)
if (player.lost) throw new GameError('You have left the game')
const mulligan = this.mulligans.get(playerId)
if (!mulligan) throw new GameError(`Unknown player: ${playerId}`)
return mulligan
}
private beginGame(): void {
// Leyline-style "begin the game with it on the battlefield" cards.
for (const player of this.players) {
if (player.lost) continue
for (const id of [...player.hand]) {
const object = this.getObject(id)
const beginsOnBattlefield = (object.definition.abilities ?? []).some(ability =>
@@ -773,7 +843,7 @@ export class Game {
/** Marks a player as having forfeited. */
concede(playerId: string): void {
if (this.status !== 'active') throw new GameError('Game is not active')
if (this.status !== 'active' && this.status !== 'mulligan') throw new GameError('Game is not active')
this.losePlayer(playerId)
if (this.priority === playerId) this.priority = this.nextAlivePlayer(playerId)
}
@@ -783,7 +853,7 @@ export class Game {
if (this.phase !== 'combat' || this.step !== 'declare_blockers') throw new GameError('Not in the declare blockers step')
if (this.stack.length) throw new GameError('Cannot declare blockers while the stack is not empty')
if (this.pendingSearch) throw new GameError('Choose a card from your library first')
if (this.pendingChoice) throw new GameError('Choose a creature type first')
if (this.pendingChoice) throw new GameError('Resolve the pending choice first')
if (this.priority !== playerId) throw new GameError('You do not have priority')
const seen = new Set<string>()
@@ -843,7 +913,7 @@ export class Game {
pass(playerId?: string): void {
if (this.status !== 'active') throw new GameError('Game is not active')
if (this.pendingSearch) throw new GameError('Choose a card from your library first')
if (this.pendingChoice) throw new GameError('Choose a creature type first')
if (this.pendingChoice) throw new GameError('Resolve the pending choice first')
const actual = playerId ?? this.priority
if (this.priority !== actual) throw new GameError('You do not have priority')
const alive = this.alivePlayers().length
@@ -947,7 +1017,7 @@ export class Game {
chooseSearchCard(playerId: string, cardId: string): void {
const pending = this.pendingSearch
if (!pending) throw new GameError('No search is waiting for a choice')
if (this.pendingChoice) throw new GameError('Choose a creature type first')
if (this.pendingChoice) throw new GameError('Resolve the pending choice first')
if (pending.playerId !== playerId) throw new GameError('You are not searching your library')
const object = this.searchCandidates(playerId).find(candidate => candidate.id === cardId)
if (!object) throw new GameError('That card is not a legal choice')
@@ -992,7 +1062,7 @@ export class Game {
*/
chooseCreatureType(playerId: string, type: string): void {
const pending = this.pendingChoice
if (!pending) throw new GameError('No choice is waiting')
if (!pending || pending.what !== 'creature_type') throw new GameError('No choice is waiting')
if (pending.playerId !== playerId) throw new GameError('You are not choosing this permanent\'s type')
const chosen = CREATURE_TYPES.find(entry => entry.toLowerCase() === type.trim().toLowerCase())
if (!chosen) throw new GameError('Choose a creature type')
@@ -1003,6 +1073,32 @@ export class Game {
this.logMessage(`${this.getPlayer(playerId).name} chooses ${chosen} for ${object.definition.name}`)
}
/**
* Answers an "as this enters, you may pay a cost; otherwise it enters tapped"
* replacement. The match API uses the `choose_cost` action.
*/
chooseCostPayment(playerId: string, pay: boolean): void {
const pending = this.pendingChoice
if (!pending || pending.what !== 'pay_cost' || !pending.cost) throw new GameError('No cost payment is waiting')
if (pending.playerId !== playerId) throw new GameError('You are not choosing this payment')
const object = this.objects.get(pending.sourceId)
if (object && object.zone === 'battlefield') {
if (pay) {
const context = this.contextFor(object, playerId, [], 0, 0)
if (!this.tryPayUnless(pending.cost, playerId, object, context)) throw new GameError('Cannot pay the cost')
this.pendingChoices.shift()
const detail = pending.amount === undefined ? 'the cost' : `${pending.amount} life`
this.logMessage(`${this.getPlayer(playerId).name} pays ${detail} for ${object.definition.name}`)
return
}
this.pendingChoices.shift()
object.tapped = true
this.logMessage(`${object.definition.name} enters tapped`)
return
}
this.pendingChoices.shift()
}
/**
* Passes priority for players who cannot do anything meaningful. Stops at the
* first player who can act, or when the turn ends, so turns never run on.
@@ -1289,10 +1385,15 @@ export class Game {
const source = this.players
.flatMap(entry => entry.battlefield)
.map(id => this.objects.get(id))
.find((object): object is GameObject => Boolean(object && object.zone === 'battlefield'
&& object.controller === player.id
&& !object.tapped
&& this.findFreeManaAbility(object) !== undefined))
.map(object => {
if (!object || object.zone !== 'battlefield' || object.controller !== player.id || object.tapped) return undefined
const found = this.findFreeManaAbility(object)
if (!found) return undefined
return { object, allowed: this.manaAbilityAllowedColors(object, found.ability) }
})
.filter((entry): entry is { object: GameObject; allowed: Set<ManaColor> | undefined } => Boolean(entry))
.filter(entry => this.neededColor(player, cost, entry.allowed) !== undefined)
.sort((a, b) => (a.allowed?.size ?? Number.MAX_SAFE_INTEGER) - (b.allowed?.size ?? Number.MAX_SAFE_INTEGER))[0]?.object
if (!source) break
this.autoManaDepth++
try {
@@ -1321,37 +1422,128 @@ export class Game {
const found = this.findFreeManaAbility(source)
if (!found) return
const player = this.getPlayer(source.controller)
const color = this.manaAbilityColor(source, found.ability, player, cost)
if (!color) return
for (const entry of found.ability.costs) {
if (entry.kind === 'tap') source.tapped = true
}
const color = this.neededColor(player, cost)
for (const effect of found.ability.effects) {
if (effect.op === 'add_mana') this.addMana(source.controller, effect.mana, color)
}
}
private neededColor(player: PlayerState, cost: ManaCost): ManaColor {
for (const color of cost.colored) {
if (player.manaPool[color] <= 0) return color
}
const hybridColor = cost.hybrid.flatMap(entry => entry.colors).find(color => player.manaPool[color] <= 0)
return hybridColor ?? 'W'
private manaAbilityColor(
source: GameObject,
ability: Extract<Ability, { kind: 'activated' }>,
player: PlayerState,
cost: ManaCost,
): ManaColor | undefined {
return this.neededColor(player, cost, this.manaAbilityAllowedColors(source, ability))
}
private addMana(playerId: string, mana: ManaSpec, preferred: ManaColor = 'W'): void {
private manaAbilityAllowedColors(
source: GameObject,
ability: Extract<Ability, { kind: 'activated' }>,
): Set<ManaColor> | undefined {
for (const effect of ability.effects) {
if (effect.op !== 'add_mana') continue
if (effect.mana.kind === 'symbols' && effect.mana.oneOf) {
return new Set(effect.mana.symbols.map(colorOfSymbol))
}
return this.anyColorRestrictionColors(effect.mana, source.controller)
}
return undefined
}
private neededColor(player: PlayerState, cost: ManaCost, allowed?: Set<ManaColor>): ManaColor | undefined {
for (const color of cost.colored) {
if (player.manaPool[color] > 0) continue
return allowed && !allowed.has(color) ? undefined : color
}
for (const hybrid of cost.hybrid) {
if (hybrid.colors.some(color => player.manaPool[color] > 0)) continue
return hybrid.colors.find(color => !allowed || allowed.has(color))
}
if (allowed) return MANA_COLORS.find(color => allowed.has(color))
return 'W'
}
private addMana(playerId: string, mana: ManaSpec, preferred?: ManaColor): void {
const player = this.getPlayer(playerId)
if (mana.kind === 'symbols') {
if (mana.oneOf) {
const colors = mana.symbols.map(colorOfSymbol)
const color = preferred && colors.includes(preferred) ? preferred : colors[0]
if (color) player.manaPool[color]++
return
}
for (const symbol of mana.symbols) player.manaPool[colorOfSymbol(symbol)]++
} else {
const amount = this.value(mana.amount, {
source: this.playerSource(playerId),
controller: playerId,
targets: [],
x: 0,
mode: 0,
})
for (let i = 0; i < amount; i++) player.manaPool[preferred]++
return
}
const amount = this.value(mana.amount, {
source: this.playerSource(playerId),
controller: playerId,
targets: [],
x: 0,
mode: 0,
})
const allowed = this.anyColorRestrictionColors(mana, playerId)
if (allowed?.size === 0) return
let color: ManaColor = preferred ?? 'W'
if (allowed && !allowed.has(color)) {
color = MANA_COLORS.find(entry => allowed.has(entry)) ?? 'W'
}
for (let i = 0; i < amount; i++) player.manaPool[color]++
}
/**
* Colors a land could produce for an "any color that a land ... could
* produce" restriction. Colorless and snow are not colors.
*/
private landManaColors(playerId: string, opponentsOnly: boolean, seen = new Set<string>()): Set<ManaColor> {
const colors = new Set<ManaColor>()
const opponents = this.opponentsOf(playerId)
for (const object of this.battlefieldObjects()) {
if (!this.isLand(object) || seen.has(object.id)) continue
if (opponentsOnly ? !opponents.includes(object.controller) : object.controller !== playerId) continue
seen.add(object.id)
for (const ability of object.definition.abilities ?? []) {
if (ability.kind !== 'activated') continue
for (const effect of ability.effects) {
if (effect.op !== 'add_mana') continue
if (effect.mana.kind === 'symbols') {
for (const symbol of effect.mana.symbols) {
for (const letter of symbol.match(/[WUBRG]/gi) ?? []) colors.add(letter.toUpperCase() as ManaColor)
}
} else {
const nested = this.anyColorRestrictionColors(effect.mana, object.controller, seen)
if (nested) {
for (const color of nested) colors.add(color)
} else {
for (const color of MANA_COLORS) if (color !== 'C') colors.add(color)
}
}
}
}
seen.delete(object.id)
}
return colors
}
/** The colors an any-color mana source may produce, when the restriction is known. */
private anyColorRestrictionColors(
mana: ManaSpec,
playerId: string,
seen?: Set<string>,
): Set<ManaColor> | undefined {
if (mana.kind !== 'any_color') return undefined
if (mana.restriction === 'a land an opponent controls could produce') {
return this.landManaColors(playerId, true, seen)
}
if (mana.restriction === 'a land you control could produce') {
return this.landManaColors(playerId, false, seen)
}
return undefined
}
private payCosts(costs: Cost[], playerId: string, source: GameObject, context: EffectContext): void {
@@ -1378,7 +1570,7 @@ export class Game {
case 'energy':
return player.energy >= cost.amount
case 'pay_life':
return player.life > this.value(cost.amount, this.staticContext(source))
return player.life >= this.value(cost.amount, this.staticContext(source))
case 'discard':
return player.hand.length >= this.value(cost.amount, this.staticContext(source))
case 'sacrifice':
@@ -2497,9 +2689,19 @@ export class Game {
for (const effect of staticSource.ability.effects) {
if (effect.op === 'enters_tapped') {
if (effect.unless && this.checkCondition(effect.unless, staticSource.source)) continue
if (this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) {
object.tapped = true
if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue
if (effect.unlessCost && !object.tapped) {
const context = this.staticContext(staticSource.source)
this.pendingChoices.push({
playerId: object.controller,
sourceId: object.id,
what: 'pay_cost',
cost: effect.unlessCost,
amount: effect.unlessCost.kind === 'pay_life' ? this.value(effect.unlessCost.amount, context) : undefined,
})
continue
}
object.tapped = true
} else if (effect.op === 'enters_with_counters') {
if (!this.staticTargets(staticSource.source, effect.target).some(target => target.id === object.id)) continue
const amount = this.value(effect.amount, this.staticContext(staticSource.source))
@@ -2773,9 +2975,8 @@ export class Game {
/**
* Affordability check that mirrors auto-tapping without changing the game.
* shortcut: any_color sources are counted as flexible even when they must
* produce one color, so rare "one color only" sources can be overestimated;
* upgrade if a card ever needs an exact color split from such a source.
* shortcut: only land-based any_color restrictions are modelled; mana
* restricted by a commander identity or a spell type is still flexible.
*/
private canAffordMana(playerId: string, symbols: string, x: number): boolean {
if (!symbols) return true
@@ -2783,6 +2984,7 @@ export class Game {
const cost = parseManaCost(symbols, x)
const pool = { ...player.manaPool }
let flexible = 0
const restricted: { colors: Set<ManaColor>; amount: number }[] = []
for (const object of this.battlefieldObjects()) {
if (object.controller !== playerId) continue
const found = this.findFreeManaAbility(object)
@@ -2792,23 +2994,32 @@ export class Game {
if (effect.mana.kind === 'symbols') {
for (const symbol of effect.mana.symbols) pool[colorOfSymbol(symbol)]++
} else {
flexible += this.value(effect.mana.amount, {
const amount = this.value(effect.mana.amount, {
source: object,
controller: playerId,
targets: [],
x: 0,
mode: 0,
})
const allowed = this.anyColorRestrictionColors(effect.mana, playerId)
if (!allowed) flexible += amount
else if (allowed.size) restricted.push({ colors: allowed, amount })
}
}
}
let life = player.life
restricted.sort((a, b) => a.colors.size - b.colors.size)
const take = (color: ManaColor): boolean => {
if (pool[color] > 0) {
pool[color]--
return true
}
const source = restricted.find(entry => entry.amount > 0 && entry.colors.has(color))
if (source) {
source.amount--
return true
}
if (flexible > 0) {
flexible--
return true
@@ -2824,7 +3035,9 @@ export class Game {
if (!(hybrid.life > 0 && life >= hybrid.life)) return false
life -= hybrid.life
}
const remaining = MANA_COLORS.reduce((total, color) => total + pool[color], 0) + flexible
const remaining = MANA_COLORS.reduce((total, color) => total + pool[color], 0)
+ flexible
+ restricted.reduce((total, entry) => total + entry.amount, 0)
return remaining >= cost.generic
}
@@ -2923,6 +3136,21 @@ export class Game {
}
changed = true
}
for (const player of this.alivePlayers()) {
const legends = new Map<string, GameObject[]>()
for (const object of this.battlefieldObjects()) {
if (object.controller !== player.id || !/\blegendary\b/i.test(object.definition.typeLine)) continue
const name = object.definition.name.toLowerCase()
legends.set(name, [...(legends.get(name) ?? []), object])
}
for (const copies of legends.values()) {
// shortcut: keeps the first copy found, not the player's choice; ask when the API can pause for it
for (const extra of copies.slice(1)) {
this.moveToZone(extra, 'graveyard', { silent: false })
changed = true
}
}
}
}
}
@@ -3248,7 +3476,7 @@ export class Game {
private requirePriority(playerId: string): void {
if (this.status !== 'active') throw new GameError('Game is not active')
if (this.pendingSearch) throw new GameError('Choose a card from your library first')
if (this.pendingChoice) throw new GameError('Choose a creature type first')
if (this.pendingChoice) throw new GameError('Resolve the pending choice first')
if (this.priority !== playerId) throw new GameError('You do not have priority')
}

View File

@@ -28,6 +28,7 @@ export interface ActionPayload {
mode?: number
overload?: boolean
choice?: string
pay?: boolean
position?: { x?: unknown; y?: unknown }
attackers?: { attackerId: string; defenderId: string }[]
blocks?: { blockerId: string; attackerId: string }[]
@@ -110,6 +111,8 @@ export interface MatchView {
priority: string
status: string
winner?: string
/** Present during the opening mulligan step. */
mulligans?: { player: string; count: number; kept: boolean; bottom: number }[]
stack: { id: string; kind: string; label: string; controller: string }[]
log: string[]
hand: CardView[]
@@ -129,6 +132,8 @@ export interface MatchView {
what: string
sourceId: string
sourceName: string
/** Life total to display for a `pay_life` cost. */
amount?: number
/** Choices to offer, populated only for the chooser. */
options: string[]
}
@@ -363,6 +368,7 @@ export function startMatch(matchId: string, token: string | undefined): void {
startingHandSize: 7,
firstPlayer: match.seats[0].playerId,
commander: true,
mulligans: true,
players: match.seats.map(entry => ({
id: entry.playerId,
name: entry.name,
@@ -424,6 +430,15 @@ export function performAction(matchId: string, token: string | undefined, action
try {
switch (action.type) {
case 'keep_hand':
game.keepHand(seat.playerId)
break
case 'mulligan':
game.mulligan(seat.playerId)
break
case 'mulligan_bottom':
game.putOnBottom(seat.playerId, requireId(action.cardId))
break
case 'play_land':
game.playLand(seat.playerId, requireId(action.cardId))
break
@@ -446,6 +461,10 @@ export function performAction(matchId: string, token: string | undefined, action
if (typeof action.choice !== 'string') throw new MatchError('Missing type choice')
game.chooseCreatureType(seat.playerId, action.choice)
break
case 'choose_cost':
if (typeof action.pay !== 'boolean') throw new MatchError('Missing cost payment choice')
game.chooseCostPayment(seat.playerId, action.pay)
break
case 'attack':
if (!Array.isArray(action.attackers)) throw new MatchError('Invalid attackers')
game.declareAttackers(seat.playerId, action.attackers.map(entry => ({
@@ -579,6 +598,9 @@ function serialize(match: Match, viewerId: string): MatchView {
priority: game.priority,
status: game.status,
winner: game.winner,
mulligans: game.status === 'mulligan'
? game.players.map(player => ({ player: player.id, ...game.mulligans.get(player.id)! }))
: undefined,
stack: game.stack.map(item => ({
id: item.id,
kind: item.kind,
@@ -597,7 +619,8 @@ function serialize(match: Match, viewerId: string): MatchView {
what: choice.what,
sourceId: choice.sourceId,
sourceName: game.objects.get(choice.sourceId)?.definition.name ?? 'Permanent',
options: choice.playerId === viewerId ? [...CREATURE_TYPES] : [],
amount: choice.amount,
options: choice.playerId === viewerId && choice.what === 'creature_type' ? [...CREATURE_TYPES] : [],
}
: undefined,
pendingSearch: search

View File

@@ -1,6 +1,6 @@
// The runtime game model. Card definitions are immutable input; objects are the
// per-game instances that move between zones.
import type { Ability, Effect, ObjectSelector, TokenSpec, Zone } from '../effects/types.js'
import type { Ability, Cost, Effect, ObjectSelector, TokenSpec, Zone } from '../effects/types.js'
export type ManaColor = 'W' | 'U' | 'B' | 'R' | 'G' | 'C'
export type ManaPool = Record<ManaColor, number>
@@ -38,6 +38,17 @@ export interface GameConfig {
firstPlayer?: string
/** Enables command-zone casting, commander tax, and commander damage. */
commander?: boolean
/** Waits for every player to keep an opening hand before turn 1. */
mulligans?: boolean
}
/** One player's opening-hand choice while the game is in its mulligan step. */
export interface MulliganState {
/** Mulligans taken so far. */
count: number
kept: boolean
/** Cards still to put on the bottom of the library. */
bottom: number
}
export interface PlayerState {
@@ -140,11 +151,15 @@ export interface PendingSearch {
split?: { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean }
}
/** An "as this enters, choose..." pause. Blocks all actions until its controller picks. */
/** An "as this enters..." pause. Blocks all actions until its controller picks. */
export interface PendingChoice {
playerId: string
sourceId: string
what: 'creature_type'
what: 'creature_type' | 'pay_cost'
/** Cost to pay to avoid entering tapped. */
cost?: Cost
/** Life total to display for a `pay_life` cost. */
amount?: number
}
export interface CombatAttack {

View File

@@ -23,7 +23,7 @@ import {
writeOverride,
type ImplementationStatus,
} from './effects/implementations.js'
import { PseudoParseError } from './effects/pseudo.js'
import { SourceParseError } from './effects/source.js'
import { translateCard, TranslationError } from './effects/translate.js'
import { importDeckText } from './game/commander.js'
import { cardArt, cardImage, playmatImage, scryfallArtUrl, scryfallImageUrl } from './images.js'
@@ -89,7 +89,7 @@ app.setErrorHandler((error, request, reply) => {
if (error instanceof CardsUnavailableError) {
return reply.code(503).send({ error: error.message })
}
if (error instanceof PseudoParseError) {
if (error instanceof SourceParseError) {
return reply.code(400).send({ error: error.message, line: error.line })
}
if (error instanceof TranslationError || error instanceof MatchError || error instanceof AuthError) {

View File

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict'
import test from 'node:test'
import type { Card } from '../src/cards.js'
import { matchesCardFilters } from '../src/cards.js'
import { cardDefinitionFromCard } from '../src/game/catalog.js'
function card(overrides: Partial<Card> = {}): Card {
return {
@@ -51,3 +52,41 @@ test('card filters match format legality, color identity, type, rarity, and mana
assert.equal(matchesCardFilters(cardByIdentity, { cmcMin: 4 }), false)
assert.equal(matchesCardFilters(cardByIdentity, { cmcMax: 2 }), false)
})
test('compiled card types reach the engine definition', () => {
const definition = cardDefinitionFromCard(card(), {
oracle_id: 'test',
name: 'Test Card',
typeLine: 'Artifact Creature — Golem',
status: 'supported',
abilities: [],
})
assert.equal(definition.typeLine, 'Artifact Creature — Golem')
})
test('lands with basic land types get one intrinsic mana ability for their colors', () => {
const vents = cardDefinitionFromCard(card({
name: 'Steam Vents',
type_line: 'Land — Island Mountain',
colors: [],
color_identity: ['U', 'R'],
}))
assert.deepEqual(vents.abilities, [{
kind: 'activated',
costs: [{ kind: 'tap' }],
effects: [{
op: 'add_mana',
player: 'you',
mana: { kind: 'symbols', symbols: ['{U}', '{R}'], oneOf: true },
}],
optional: false,
text: '{T}: Add {U} or {R}.',
}])
const forest = cardDefinitionFromCard(card({ name: 'Forest', type_line: 'Basic Land — Forest' }))
assert.deepEqual(forest.abilities?.[0]?.effects, [{
op: 'add_mana',
player: 'you',
mana: { kind: 'symbols', symbols: ['{G}'] },
}])
})

View File

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict'
import test from 'node:test'
import { compileText } from '../src/effects/compile.js'
import { formatAbility } from '../src/effects/format.js'
import { parsePseudoCard } from '../src/effects/pseudo.js'
import { parseCardSource } from '../src/effects/source.js'
import type { Ability, Effect, Target } from '../src/effects/types.js'
function creature(text: string, keywords: string[] = []): Ability[] {
@@ -41,6 +41,33 @@ test('activated mana ability', () => {
})
})
test('"or" in a mana ability marks the symbols as a choice', () => {
const [ability] = creature('{T}: Add {G} or {U}.')
assert.equal(ability.kind, 'activated')
if (ability.kind !== 'activated') return
assert.deepEqual(ability.effects[0], {
op: 'add_mana',
player: 'you',
mana: { kind: 'symbols', symbols: ['{G}', '{U}'], oneOf: true },
})
})
test('paying life to enter untapped compiles to an enters-tapped replacement', () => {
const [ability] = compileText(
"As this land enters, you may pay 2 life. If you don't, it enters tapped.",
'Steam Vents',
[],
'Land — Island Mountain',
)
assert.equal(ability.kind, 'static')
if (ability.kind !== 'static') return
assert.deepEqual(ability.effects[0], {
op: 'enters_tapped',
target: { kind: 'self' },
unlessCost: { kind: 'pay_life', amount: { kind: 'number', value: 2 } },
})
})
test('search effect keeps destination, tapped, and shuffle', () => {
const [ability] = spell('Search your library for a basic land card, put it onto the battlefield tapped, then shuffle.')
assert.equal(ability.kind, 'spell')
@@ -169,10 +196,10 @@ test('trigger condition cards in graveyard', () => {
assert.deepEqual(ability.condition, { kind: 'cards_in_graveyard', player: 'you', atLeast: 7 })
})
test('formatter renders pseudocode', () => {
test('formatter renders card source', () => {
const [ability] = creature('When this creature enters, draw a card.')
const text = formatAbility(ability)
assert.match(text, /on enters\(this\)/)
assert.match(text, /triggered\(when\.enters\(self\)/)
assert.match(text, /draw\(you, 1\)/)
})
@@ -201,7 +228,10 @@ test('token copy of the triggering nontoken Dragon loses legendary', () => {
if (effect.op !== 'create_token') return
assert.deepEqual(effect.copyOf, { kind: 'trigger_subject' })
assert.equal(effect.notLegendary, true)
assert.equal(formatAbility(ability), 'on enters(each other nontoken dragon creature you control):\n create_token(you, 1, copy of the triggering object, not legendary)')
assert.equal(
formatAbility(ability),
"triggered(when.enters(each(permanents.other().nontoken().withSubtype('dragon').withType('creature').youControl())), () => createToken(you, 1, copyOf(triggerSubject, { notLegendary: true })))",
)
})
test('all effects are typed', () => {
@@ -299,9 +329,9 @@ test('"until the end of your next turn" gets its own duration', () => {
if (effect.op !== 'pump') return
assert.equal(effect.duration, 'until_end_of_your_next_turn')
const pseudo = formatAbility(ability)
assert.match(pseudo, /until the end of your next turn/)
assert.equal(formatAbility(parsePseudoCard(`# Test [supported]\n${pseudo}`).abilities[0]), pseudo)
const source = formatAbility(ability)
assert.match(source, /untilEndOfYourNextTurn/)
assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source)
}
})
@@ -315,7 +345,7 @@ test('parameterized keywords accept an em dash', () => {
assert.deepEqual(fabricate, { kind: 'keyword', keyword: 'Fabricate', value: '1' })
})
test('counter-removal costs parse and round-trip through pseudocode', () => {
test('counter-removal costs parse and round-trip through card source', () => {
const [self] = creature('{2}{U}, Remove a +1/+1 counter from this: Draw a card, then discard a card.')
assert.equal(self.kind, 'activated')
if (self.kind !== 'activated') return
@@ -324,9 +354,9 @@ test('counter-removal costs parse and round-trip through pseudocode', () => {
{ kind: 'remove_counters', counter: '+1/+1', amount: { kind: 'number', value: 1 } },
])
const pseudo = formatAbility(self)
assert.match(pseudo, /remove 1 \+1\/\+1 counter\(s\) from this/)
assert.equal(formatAbility(parsePseudoCard(`# Test [supported]\n${pseudo}`).abilities[0]), pseudo)
const source = formatAbility(self)
assert.match(source, /removeCountersCost\('\+1\/\+1', 1\)/)
assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source)
const [other] = creature('Remove three spore counters from a creature you control: Create a 1/1 green Saproling creature token.')
assert.equal(other.kind, 'activated')
@@ -520,7 +550,7 @@ test('spell cost reductions compile their conditions and mana symbols', () => {
}])
})
test('new abilities, effects and conditions round-trip through pseudocode', () => {
test('new abilities, effects and conditions round-trip through card source', () => {
const abilities: Ability[] = [
...spell('If you control a commander, you may cast this without paying its mana cost.'),
...spell('Overload {6}{U}'),
@@ -541,9 +571,9 @@ test('new abilities, effects and conditions round-trip through pseudocode', () =
),
]
for (const ability of abilities) {
const pseudo = formatAbility(ability)
const reparsed = parsePseudoCard(`# Test [supported]\n${pseudo}`).abilities[0]
const source = formatAbility(ability)
const reparsed = parseCardSource(`export default [${source}]`).abilities[0]
assert.ok(reparsed)
assert.equal(formatAbility(reparsed), pseudo)
assert.equal(formatAbility(reparsed), source)
}
})

View File

@@ -39,6 +39,30 @@ function land(name: string, color: string): CardDefinition {
})
}
function exoticOrchard(): CardDefinition {
return card('Exotic Orchard', {
typeLine: 'Land',
power: undefined,
toughness: undefined,
abilities: [{
kind: 'activated',
costs: [{ kind: 'tap' }],
effects: [{
op: 'add_mana',
player: 'you',
mana: {
kind: 'any_color',
amount: { kind: 'number', value: 1 },
oneColor: false,
restriction: 'a land an opponent controls could produce',
},
}],
optional: false,
text: '{T}: Add one mana of any color that a land an opponent controls could produce.',
}],
})
}
function setup(players: { id: string; deck?: CardDefinition[]; life?: number }[]): Game {
const game = new Game({
seed: 7,
@@ -77,6 +101,51 @@ test('turns start at the first main phase, draw opening hands, and pass to the n
assert.equal(game.getPlayer('p1').hand.length, 7)
})
test('mulligans draw a new seven and bottom one more card each time', () => {
const game = new Game({
seed: 3,
startingHandSize: 7,
mulligans: true,
players: [
{ id: 'p1', deck: Array.from({ length: 40 }, (_, index) => card(`P1 Card ${index}`)) },
{ id: 'p2', deck: Array.from({ length: 40 }, (_, index) => card(`P2 Card ${index}`)) },
],
})
game.start()
assert.equal(game.status, 'mulligan')
assert.equal(game.getPlayer('p1').hand.length, 7)
game.keepHand('p2')
game.mulligan('p1')
assert.equal(game.getPlayer('p1').hand.length, 7)
assert.equal(game.mulligans.get('p1')?.count, 1)
assert.equal(game.mulligans.get('p1')?.bottom, 0)
game.mulligan('p1')
assert.equal(game.mulligans.get('p1')?.count, 2)
assert.equal(game.mulligans.get('p1')?.bottom, 1)
assert.throws(() => game.keepHand('p1'), /bottom/)
const bottomCard = game.getPlayer('p1').hand[0]
game.putOnBottom('p1', bottomCard)
assert.equal(game.getPlayer('p1').hand.length, 6)
assert.equal(game.getPlayer('p1').library.at(-1), bottomCard)
assert.equal(game.mulligans.get('p1')?.bottom, 0)
game.mulligan('p1')
assert.equal(game.mulligans.get('p1')?.count, 3)
assert.equal(game.mulligans.get('p1')?.bottom, 2)
for (const cardId of [...game.getPlayer('p1').hand.slice(0, 2)]) game.putOnBottom('p1', cardId)
assert.equal(game.getPlayer('p1').hand.length, 5)
game.keepHand('p1')
assert.equal(game.status, 'active')
assert.equal(game.turn, 1)
assert.equal(game.step, 'main')
assert.equal(game.getPlayer('p1').hand.length, 5)
})
test('passing priority twice advances from the main phase into combat', () => {
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()
@@ -290,6 +359,73 @@ test('activated mana abilities produce mana and creatures have summoning sicknes
assert.equal(game.getPlayer('p1').manaPool.G, 1)
})
test('Exotic Orchard is limited to colors an opponent land could produce', () => {
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()
const orchard = game.addCard('p1', exoticOrchard(), 'battlefield')
game.addCard('p2', land('Forest', 'G'), 'battlefield')
const green = game.addCard('p1', spell('Green Spell', [], '{G}'), 'hand')
const blue = game.addCard('p1', spell('Blue Spell', [], '{U}'), 'hand')
assert.equal(game.canPlayCard('p1', green.id), true)
assert.equal(game.canPlayCard('p1', blue.id), false)
assert.throws(() => game.castSpell('p1', blue.id), GameError)
assert.equal(orchard.tapped, false)
assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 })
game.castSpell('p1', green.id)
assert.equal(orchard.tapped, true)
assert.equal(game.getPlayer('p1').manaPool.G, 0)
})
test('Exotic Orchard adds an opponent land color when activated manually', () => {
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()
const orchard = game.addCard('p1', exoticOrchard(), 'battlefield')
game.addCard('p2', land('Island', 'U'), 'battlefield')
game.activateAbility('p1', orchard.id, 0)
assert.equal(game.getPlayer('p1').manaPool.U, 1)
assert.equal(game.getPlayer('p1').manaPool.W, 0)
})
test('Exotic Orchard produces nothing without an opponent land', () => {
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()
const orchard = game.addCard('p1', exoticOrchard(), 'battlefield')
game.activateAbility('p1', orchard.id, 0)
assert.equal(orchard.tapped, true)
assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 })
})
test('a restricted mana source is used before an unrestricted one', () => {
const rainbow = card('Rainbow Land', {
typeLine: 'Land',
power: undefined,
toughness: undefined,
abilities: [{
kind: 'activated',
costs: [{ kind: 'tap' }],
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: false } }],
optional: false,
text: '{T}: Add one mana of any color.',
}],
})
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()
const rainbowLand = game.addCard('p1', rainbow, 'battlefield')
const orchard = game.addCard('p1', exoticOrchard(), 'battlefield')
game.addCard('p2', land('Forest', 'G'), 'battlefield')
const gold = game.addCard('p1', spell('Gold Spell', [], '{G}{U}'), 'hand')
assert.equal(game.canPlayCard('p1', gold.id), true)
game.castSpell('p1', gold.id)
assert.equal(orchard.tapped, true)
assert.equal(rainbowLand.tapped, true)
assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 })
})
test('static pump effects apply to matching creatures only', () => {
const anthem = card('Glorious Anthem', {
typeLine: 'Enchantment',
@@ -625,6 +761,63 @@ test('static replacement effects make permanents enter tapped with counters', ()
assert.equal(game.getToughness(bear), 3)
})
function shockLand(): CardDefinition {
return card('Steam Vents', {
typeLine: 'Land — Island Mountain',
power: undefined,
toughness: undefined,
abilities: [{
kind: 'static',
effects: [{ op: 'enters_tapped', target: { kind: 'self' }, unlessCost: { kind: 'pay_life', amount: { kind: 'number', value: 2 } } }],
text: "As this land enters, you may pay 2 life. If you don't, it enters tapped.",
}, {
kind: 'activated',
costs: [{ kind: 'tap' }],
effects: [{ op: 'add_mana', player: 'you', mana: { kind: 'symbols', symbols: ['{U}', '{R}'], oneOf: true } }],
optional: false,
text: '{T}: Add {U} or {R}.',
}],
})
}
test('a land can pay life to enter untapped or enter tapped', () => {
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()
const vents = game.addCard('p1', shockLand(), 'hand')
game.playLand('p1', vents.id)
assert.equal(vents.tapped, false)
assert.equal(game.pendingChoice?.what, 'pay_cost')
assert.equal(game.pendingChoice?.amount, 2)
assert.throws(() => game.chooseCostPayment('p2', true), GameError)
game.chooseCostPayment('p1', true)
assert.equal(game.getPlayer('p1').life, 38)
assert.equal(vents.tapped, false)
assert.equal(game.pendingChoice, undefined)
const second = game.addCard('p1', shockLand(), 'hand')
game.moveToZone(second, 'battlefield', { controller: 'p1', silent: false })
assert.equal(game.pendingChoice?.what, 'pay_cost')
game.chooseCostPayment('p1', false)
assert.equal(second.tapped, true)
assert.equal(game.getPlayer('p1').life, 38)
})
test('a choice mana ability adds only the color the spell needs', () => {
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()
const vents = game.addCard('p1', shockLand(), 'battlefield')
const red = game.addCard('p1', spell('Red Spell', [], '{R}'), 'hand')
game.castSpell('p1', red.id)
assert.equal(vents.tapped, true)
assert.equal(game.getPlayer('p1').manaPool.R, 0)
assert.equal(game.getPlayer('p1').manaPool.U, 0)
})
test('a player who runs out of cards loses and the last player wins', () => {
const game = new Game({
seed: 3,
@@ -658,6 +851,43 @@ test('lethal damage to a player ends the game', () => {
assert.equal(game.getPlayer('p2').life, 0)
})
test('the legend rule leaves one legendary permanent per name under one controller', () => {
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()
const legend = card('Kiora, the Rising Tide', {
typeLine: 'Legendary Creature — Merfolk Wizard',
power: 1,
toughness: 1,
})
const first = game.addCard('p1', legend, 'battlefield')
const second = game.addCard('p1', legend, 'battlefield')
const forest = game.addCard('p1', land('Forest', 'G'), 'hand')
game.playLand('p1', forest.id)
assert.equal(first.zone, 'battlefield')
assert.equal(second.zone, 'graveyard')
assert.ok(game.getPlayer('p1').graveyard.includes(second.id))
})
test('the legend rule does not apply across controllers', () => {
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()
const legend = card('Kiora, the Rising Tide', {
typeLine: 'Legendary Creature — Merfolk Wizard',
power: 1,
toughness: 1,
})
const mine = game.addCard('p1', legend, 'battlefield')
const theirs = game.addCard('p2', legend, 'battlefield')
const forest = game.addCard('p1', land('Forest', 'G'), 'hand')
game.playLand('p1', forest.id)
assert.equal(mine.zone, 'battlefield')
assert.equal(theirs.zone, 'battlefield')
})
test('a failed mana payment leaves mana sources untapped and the pool unchanged', () => {
const game = setup([{ id: 'p1' }, { id: 'p2' }])
game.start()

View File

@@ -1,92 +0,0 @@
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 { parsePseudoCard, PseudoParseError } from '../src/effects/pseudo.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 = `on enters(this):
choose 1:
1. exile(target other creature you own); schedule(next_end_step):
return_to_battlefield(the chosen target)
static:
grant_ability(each enchanted land):
on upkeep(you) (may):
pay({W}{W})
if you do:
gain_life(you, 1)`
test('pseudocode round-trips through the compiler and formatter', () => {
const compiled = compileImplementation(CARD, SOURCE)
assert.equal(compiled.manual, true)
assert.equal(compiled.status, 'supported')
const rendered = formatCard(compiled)
const reparsed = compileImplementation(CARD, rendered)
assert.equal(formatCard(reparsed), rendered)
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('invalid pseudocode reports its line', () => {
assert.throws(
() => parsePseudoCard('spell:\n draw(you)'),
(error: unknown) => error instanceof PseudoParseError && error.line === 2,
)
})
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)
})

View File

@@ -1,7 +1,7 @@
import assert from 'node:assert/strict'
import test from 'node:test'
import { findCardByName } from '../src/cards.js'
import { createMatch, getMatchView, joinMatch, leaveMatch, setDeck, startMatch } from '../src/game/rooms.js'
import { createMatch, getMatchView, joinMatch, leaveMatch, performAction, setDeck, startMatch } from '../src/game/rooms.js'
function deck(commanderName: string) {
const commander = findCardByName(commanderName)
@@ -36,3 +36,20 @@ test('leaving a started game forfeits the seat instead of erroring', () => {
assert.equal(view.status, 'finished')
assert.equal(view.players.find(player => player.id === host.playerId)?.lost, true)
})
test('started matches wait for both players to keep their opening hands', () => {
const host = createMatch('Host', deck("Atraxa, Praetors' Voice"), 2)
const guest = joinMatch(host.matchId, 'Guest', deck('Kenrith, the Returned King'))
startMatch(host.matchId, host.token)
let view = getMatchView(host.matchId, host.token)
assert.equal(view.status, 'active')
assert.equal(view.game?.status, 'mulligan')
assert.equal(view.game?.mulligans?.length, 2)
performAction(host.matchId, host.token, { type: 'keep_hand' })
performAction(host.matchId, guest.token, { type: 'keep_hand' })
view = getMatchView(host.matchId, host.token)
assert.equal(view.game?.status, 'active')
})

194
backend/test/source.test.ts Normal file
View File

@@ -0,0 +1,194 @@
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)
})

View File

@@ -46,40 +46,40 @@ function fakeOpenRouter(content: string) {
}
}
test('translation asks for pseudocode only and validates the answer', async () => {
const fake = fakeOpenRouter('spell:\n draw(you, 2)')
test('translation asks for card source only and validates the answer', async () => {
const fake = fakeOpenRouter('export default [spell([draw(you, 2)])]')
const source = await translateCard(CARD, {
apiKey: 'test-key',
model: 'test/model',
fetch: fake.fetchImpl,
})
assert.equal(source, 'spell:\n draw(you, 2)')
assert.equal(source, 'export default [spell([draw(you, 2)])]')
assert.equal(fake.body.model, 'test/model')
assert.equal(fake.body.temperature, 0)
assert.equal(fake.body.max_tokens, 700)
assert.equal(fake.body.max_tokens, 1200)
assert.equal(fake.headers.Authorization, 'Bearer test-key')
assert.match(fake.body.messages[0].content, /pseudocode only/i)
assert.match(fake.body.messages[0].content, /card source only/i)
assert.match(fake.body.messages[0].content, /Never invent an operation/)
assert.match(fake.body.messages[1].content, /Draw two cards\./)
})
test('a model code fence is removed before saving', async () => {
const fake = fakeOpenRouter('```\nspell:\n draw(you, 2)\n```')
const fake = fakeOpenRouter('```\nexport default [spell([draw(you, 2)])]\n```')
const source = await translateCard(CARD, {
apiKey: 'test-key',
model: 'test/model',
fetch: fake.fetchImpl,
})
assert.equal(source, 'spell:\n draw(you, 2)')
assert.equal(cleanTranslation(' spell:\n draw(you, 2) '), 'spell:\n draw(you, 2)')
assert.equal(source, 'export default [spell([draw(you, 2)])]')
assert.equal(cleanTranslation(' export default [spell([draw(you, 2)])] '), 'export default [spell([draw(you, 2)])]')
})
test('prose instead of pseudocode is rejected', async () => {
test('prose instead of card source is rejected', async () => {
const fake = fakeOpenRouter('Here is the translated card. It draws two cards.')
await assert.rejects(
translateCard(CARD, { apiKey: 'test-key', model: 'test/model', fetch: fake.fetchImpl }),
(error: unknown) => error instanceof TranslationError && /valid pseudocode/.test(error.message),
(error: unknown) => error instanceof TranslationError && /valid card source/.test(error.message),
)
})
@@ -105,13 +105,13 @@ test('multi-face cards receive their face names in the prompt', async () => {
{ name: 'Back', type_line: 'Creature', oracle_text: 'Flying', colors: [] },
],
}
const fake = fakeOpenRouter('## Front\non enters(this):\n draw(you, 1)\n\n## Back\nkeyword Flying')
const fake = fakeOpenRouter("export default faces(face('Front', [triggered(when.enters(self), [draw(you, 1)])]), face('Back', [keyword('Flying')]))")
const source = await translateCard(faces, {
apiKey: 'test-key',
model: 'test/model',
fetch: fake.fetchImpl,
})
assert.equal(source, '## Front\non enters(this):\n draw(you, 1)\n\n## Back\nkeyword Flying')
assert.equal(source, "export default faces(face('Front', [triggered(when.enters(self), [draw(you, 1)])]), face('Back', [keyword('Flying')]))")
assert.match(fake.body.messages[1].content, /## Front/)
assert.match(fake.body.messages[1].content, /## Back/)
})