Kkdjskjd
This commit is contained in:
2
backend/.gitignore
vendored
2
backend/.gitignore
vendored
@@ -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
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
export default [
|
||||
activated([tapCost()], [
|
||||
addMana(you, anyColor(1, { restriction: 'a land an opponent controls could produce' })),
|
||||
]),
|
||||
]
|
||||
@@ -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 })),
|
||||
),
|
||||
]
|
||||
@@ -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)
|
||||
@@ -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.
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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}`)
|
||||
|
||||
@@ -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
@@ -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
2484
backend/src/effects/source.ts
Normal file
2484
backend/src/effects/source.ts
Normal file
File diff suppressed because it is too large
Load Diff
@@ -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)}`,
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@@ -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[]
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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')
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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}'] },
|
||||
}])
|
||||
})
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
})
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
@@ -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
194
backend/test/source.test.ts
Normal 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)
|
||||
})
|
||||
@@ -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/)
|
||||
})
|
||||
|
||||
Reference in New Issue
Block a user