Compare commits

...

5 Commits

Author SHA1 Message Date
9ec486274f Fa triggers malament 2026-10-29 20:30:29 +01:00
bc05b63083 Kkdjskjd 2026-10-29 15:21:05 +01:00
bb85881cac kjdskjdsk 2026-10-27 19:14:33 +01:00
c962800876 Merge pull request 'Fix #2: Add animations' (#3) from ai/issue-2 into master
Reviewed-on: #3
2026-10-27 17:27:21 +00:00
Gitea OpenCode Agent
a167649327 Fix issue #2: Add animations 2026-10-27 16:28:34 +00:00
45 changed files with 9697 additions and 5228 deletions

View File

@@ -4,7 +4,7 @@ Online multiplayer Magic: The Gathering (Commander) emulator: Nuxt frontend + Fa
## Layout
- `backend/` — Node 24, Fastify 5, TypeScript (ESM, NodeNext). `src/effects/` is the oracle-text compiler/pseudocode DSL, `src/game/` the rules engine and in-memory match manager.
- `backend/` — Node 24, Fastify 5, TypeScript (ESM, NodeNext). `src/effects/` is the oracle-text compiler/card-source DSL, `src/game/` the rules engine and in-memory match manager.
- `frontend/` — Nuxt 4 / Vue 3, sources under `app/`.
- `backend/docs/card-effects.md` and `backend/docs/game-engine.md` are the detailed references for those subsystems; `README.md` has the full API and config tables.
@@ -16,14 +16,15 @@ cd backend && npm install && npm run dev # API only
cd frontend && npm install && npm run dev # UI only
cd backend && npm test # all backend tests
cd backend && npm run import:cards # Scryfall bulk data -> data/cards.json
cd backend && npm run compile:cards # oracle text -> data/card-effects.json + pseudo.txt
cd backend && npm run compile:cards # oracle text -> data/card-effects.json + card-effects.js
```
## Things to know
- Backend imports need `.js` extensions (`NodeNext`) even though sources are `.ts`.
- `backend/data/cards.json` (~21 MB) and `card-effects.json` are generated, not committed; run the import/compile scripts after changing the importer or compiler. Missing card data makes `/cards` return `503`.
- Manual card implementations live in `backend/data/card-overrides/` (one file per card, pseudocode DSL) and take precedence over generated output when compiling.
- Manual card implementations live in `backend/data/card-overrides/` (one file per card, card-source DSL) and take precedence over generated output when compiling.
- Asked to implement a specific card: write that card's override JS, then implement whatever the effect needs in the game engine (`backend/src/game/`) so the card actually works in a game — an override alone is not a finished card.
- The effect compiler is conservative: unparseable oracle lines become `unsupported` with original text — never guess or silently drop them.
- Matches are in memory and lost on restart; accounts, saved decks, playmat preferences, and per-deck card backs are in MongoDB through `backend/src/accounts.ts`. Game seats still use a per-seat token in the frontend's `sessionStorage`; the account login token is in a cookie so the server can gate pages.
- Keep style of surrounding code: 2-space indent, single quotes. No linter or formatter is configured.

View File

@@ -94,23 +94,24 @@ with its original text, never guessed.
```bash
cd backend
npm run compile:cards # data/card-effects.json + data/card-effects.pseudo.txt
npm run compile:cards # data/card-effects.json + data/card-effects.js
npm test
```
`data/card-effects.pseudo.txt` is the human-readable pseudocode view. The
pseudocode is also an input format: the frontend editor saves one override file
per card under `backend/data/card-overrides/`, and `npm run compile:cards`
validates those files and uses them instead of generated output. See
[backend/docs/card-effects.md](backend/docs/card-effects.md) for the DSL,
`data/card-effects.js` is the human-readable card source. The source is also an
input format: the frontend editor saves one override file per card under
`backend/data/card-overrides/`, and `npm run compile:cards` validates those files
and uses them instead of generated output. Card source looks like JavaScript but
is evaluated by a safe interpreter with a fixed builder API, never by `eval`.
See [backend/docs/card-effects.md](backend/docs/card-effects.md) for the DSL,
current coverage, and how to add support for more cards.
The `/cards` page has an **Editor** view and a **Guide** view that summarizes the
pseudocode syntax. **Draft with AI** sends the selected card's oracle text to an
OpenRouter model and loads the returned pseudocode into the editor without
saving it. The model is instructed to answer with pseudocode only — no
explanations, Markdown or code fences — and the answer must parse before the API
returns it. Set `OPENROUTER_API_KEY` on the backend to enable the button;
source syntax. **Draft with AI** sends the selected card's oracle text to an
OpenRouter model and loads the returned source into the editor without saving
it. The model is instructed to answer with card source only — no explanations,
Markdown or code fences — and the answer must parse before the API returns it.
Set `OPENROUTER_API_KEY` on the backend to enable the button;
`OPENROUTER_MODEL` defaults to `google/gemini-2.5-flash-lite`.
## Game engine
@@ -160,7 +161,7 @@ The frontend has five pages:
- `/` — create a 2–4 player game, join an open lobby, and pick your playmat.
- `/decks` — build a deck, import a Moxfield/Archidekt/Arena text export, and
export it again. Decks are stored with your account.
- `/cards` — the existing card implementation editor and pseudocode guide.
- `/cards` — the existing card implementation editor and source guide.
- `/games/:id` — lobby and game board. The page can also be used as an invite
link; a player with no seat gets a join form.
@@ -208,7 +209,7 @@ image builds TypeScript and installs production dependencies only.
| `BACKEND_PORT` | `4000` | production | Host port for the API |
| `PORT` | `4000` | backend | Port the API listens on inside the container |
| `CARD_OVERRIDES_DIR` | `backend/data/card-overrides` | backend | Where manual implementations are stored |
| `OPENROUTER_API_KEY` | — | backend | Enables the editor's AI pseudocode draft |
| `OPENROUTER_API_KEY` | — | backend | Enables the editor's AI card-source draft |
| `OPENROUTER_MODEL` | `google/gemini-2.5-flash-lite` | backend | OpenRouter model used for translation |
When deploying to a real host, set `NUXT_PUBLIC_API_BASE` and `CORS_ORIGIN` to
@@ -220,15 +221,15 @@ your public URLs. Both values are applied at runtime in the production image.
.
├── backend/
│ ├── scripts/import-cards.ts # Scryfall bulk importer
│ ├── scripts/compile-cards.ts # oracle text -> effect AST + pseudocode
│ ├── scripts/compile-cards.ts # oracle text -> effect AST + card source
│ ├── src/cards.ts # card store, lookup, and search
│ ├── src/images.ts # on-disk cache for Scryfall card art
│ ├── src/effects/ # effect DSL, compiler, formatter, pseudocode parser
│ ├── src/effects/translate.ts # natural language -> pseudocode through OpenRouter
│ ├── src/effects/ # effect DSL, compiler, formatter, source interpreter
│ ├── src/effects/translate.ts # natural language -> card source through OpenRouter
│ ├── src/game/ # rules engine, commander rules, match manager
│ ├── src/accounts.ts # Mongo models, auth, decks, and preferences
│ ├── src/server.ts # Fastify entry point and game/deck routes
│ ├── test/ # compiler, pseudocode, engine, and commander tests
│ ├── test/ # compiler, source, engine, and commander tests
│ ├── docs/card-effects.md # DSL reference and coverage
│ ├── docs/game-engine.md # engine API, rules coverage, limitations
│ ├── data/cards.json # generated by npm run import:cards
@@ -246,7 +247,7 @@ your public URLs. Both values are applied at runtime in the production image.
│ ├── app/middleware/auth.ts # redirect signed-out visitors to /account
│ ├── app/utils/auth.ts # login token storage and headers
│ ├── app/utils/decks.ts # account deck API and validation
│ ├── app/components/PseudoGuide.vue # pseudocode guide view
│ ├── app/components/SourceGuide.vue # card source guide view
│ ├── nuxt.config.ts # runtime config (API base URL)
│ ├── Dockerfile # dev, build, and production stages
│ └── package.json
@@ -271,10 +272,10 @@ your public URLs. Both values are applied at runtime in the production image.
| `GET` | `/cards/:oracleId/art` | Wide card art crop used for playmats, cached on disk |
| `GET` | `/cards?status=needs-work` | Filter by `supported`, `partial`, `unsupported`, `needs-work`, `manual`, `all` |
| `GET` | `/cards?format=modern&color=U&type=creature&rarity=rare&cmcMin=1&cmcMax=3` | Format legality, color identity (`WUBRG` includes that color, `C` colorless, `M` multicolor), card type, rarity, and mana value filters |
| `GET` | `/cards/:oracleId/implementation` | Card, compiled AST, pseudocode source, manual flag |
| `GET` | `/cards/:oracleId/implementation` | Card, compiled AST, card source, manual flag |
| `PUT` | `/cards/:oracleId/implementation` | Validate `{ "source": "..." }` and save the override |
| `DELETE` | `/cards/:oracleId/implementation` | Delete the override and 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 override source, or `404` |
| `GET` | `/stats` | Supported, partial, unsupported, and manual counts |
| `POST` | `/auth/register` | Create an account with `{ username, password }`, returns `{ token, username }` |
@@ -284,6 +285,8 @@ your public URLs. Both values are applied at runtime in the production image.
| `GET` | `/me/decks` | The account's saved decks |
| `PUT` | `/me/decks/:id` | Create or replace a saved deck |
| `DELETE` | `/me/decks/:id` | Delete a saved deck |
| `POST` | `/me/decks/:id/share` | Create (or reuse) a share link token for a saved deck |
| `GET` | `/decks/share/:token` | Public read of a shared deck, used to import a copy |
| `GET` | `/me/preferences` | Saved playmat and card back |
| `PUT` | `/me/preferences` | Update `{ playmat?, cardBack? }` |
| `POST` | `/decks/import` | Parse a text decklist into `{ commander, cards, errors }` |

2
backend/.gitignore vendored
View File

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

View File

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

View File

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

View File

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

View File

@@ -3,9 +3,9 @@
The card database from Scryfall is English prose. The game engine cannot execute
prose, so `backend/src/effects/` compiles every oracle-text line into a small
JSON AST. The AST is the canonical form for the engine. A pretty-printer renders
the same AST as readable pseudocode, and a matching parser reads that pseudocode
back, so a human can replace the generated implementation of a card without
touching JSON.
the same AST as readable card source, and a matching interpreter reads that
source back, so a human can replace the generated implementation of a card
without touching JSON.
This is deliberately **not** a rules engine. It answers "what does the card
say?" in machine-readable form. "What happens when it resolves?" belongs to the
@@ -18,10 +18,10 @@ Scryfall oracle text
-> normalize (card name, "this creature", contractions, reminder text)
-> classify (keyword / triggered / activated / static / spell effect)
-> parse targets, values, costs, conditions, durations
-> JSON AST + pseudocode rendering
-> JSON AST + card-source rendering
data/card-overrides/<oracle_id>.pseudo.txt
-> pseudocode parser
data/card-overrides/<oracle_id>.js
-> safe source interpreter
-> JSON AST used instead of the generated one
```
@@ -34,16 +34,16 @@ a guessed effect. A wrong effect is worse than a missing one.
From `backend/`:
```bash
npm run compile:cards # writes data/card-effects.json and .pseudo.txt
npm test # compiler, pseudocode parser, and engine tests
npm run compile:cards # writes data/card-effects.json and data/card-effects.js
npm test # compiler, source interpreter, and engine tests
npm run dev # API for the frontend editor
```
Current output over the imported Commander pool (32,116 cards):
```text
Cards: 14,141 supported, 10,119 partial, 7,856 unsupported
Ability lines: 37,983/60,470 parsed (62.8%)
Cards: 14,239 supported, 10,088 partial, 7,789 unsupported
Ability lines: 38,132/60,470 parsed (63.1%)
```
- **supported** — every ability line parsed.
@@ -58,40 +58,202 @@ 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`, `withoutColor`, `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 }))
createToken(you, 1, token({ name: 'Monster', types: ['enchantment'], subtypes: ['aura', 'role'] }), { attachTo: target(permanents.withType('creature')) })
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`,
`exileInsteadOfGraveyard` and `tokenMultiplier` (with optional
`who: 'each_player'` or `creatureOnly: true`). `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 +262,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 +272,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 +294,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": [
{
@@ -165,6 +327,8 @@ The types live in `src/effects/types.ts`. A card contains one or more abilities:
| `activated` | Cost `:` effect, including loyalty | `{T}: Add {G}.` |
| `static` | Continuous effect or restriction | `Creatures you control get +1/+1.` |
| `spell` | Effect line of an instant or sorcery | `Draw two cards.` |
| `alternative_cost` | Alternative cast with a condition, possibly free | `If you control a commander, you may cast this without paying its mana cost.` |
| `overload` | Overload alternate cost; the engine widens the spell's targets | `Overload {6}{U}` |
| `unsupported` | Preserved text plus a reason | `Choose one —` |
### Effects
@@ -177,20 +341,30 @@ The types live in `src/effects/types.ts`. A card contains one or more abilities:
| `pump` | `target`, `power`, `toughness`, `duration` |
| `grant` | `target`, `keyword`, optional `value`, `duration` |
| `put_counters`, `remove_counters` | `target`, `counter`, `amount` |
| `create_token` | `player`, `amount`, `token` |
| `create_token` | `player`, `amount`, `token`, optional `attachTo` target |
| `destroy`, `exile`, `tap`, `untap`, `regenerate` | `target` |
| `sacrifice` | `player`, `target`, optional `unless` cost |
| `counter` | `what`, `target`, optional `unless` cost |
| `return_to_hand`, `return_to_battlefield`, `put_on_top` | `target` |
| `search`, `shuffle` | player, selector, destination |
| `search`, `shuffle` | player, selector, destination, optional `split` destination |
| `add_mana` | `player`, `mana` (`symbols` or `any_color`) |
| `scry`, `surveil` | `player`, `amount` |
| `fight` | two targets |
| `energy` | `player`, `amount` |
| `attach` | target to attach this/trigger object to |
| `restriction` | target, rule, duration |
| `keyword_action` | `action`, optional `amount`, `detail`, `target` |
| `keyword_action` | `action`, optional `amount`, `detail`, `target`; the engine implements `explore`, `incubate`, and `impulse` |
| `proliferate` | no payload |
| `hideaway` | `amount`; looks at that many cards and pauses for the controller to exile one face down, linking it to the source |
| `play_exiled` | `player`, optional `free`; plays a card linked with `hideaway` |
| `exile_graveyards` | no payload; exiles all cards from every graveyard |
| `transform` | `target`; swaps the object's front and back faces |
A created token whose name or subtype matches one of the predefined tokens in
comprehensive rules 111.10 gets that token's full characteristics and abilities
from `src/game/tokens.ts`. The compiled `token` spec only needs enough information
to identify it, for example `token({ subtypes: ['treasure'] })` or
`token({ name: 'Monster', subtypes: ['aura', 'role'] })` for a Role.
### Targets, values, costs
@@ -202,8 +376,12 @@ The types live in `src/effects/types.ts`. A card contains one or more abilities:
`source_toughness`, `cards_in_hand`, or `event_amount`.
- **Costs** are mana symbols, tap/untap, tapping another permanent, energy,
loyalty, life, discard, sacrifice, self-exile, mill, and removing counters.
- **Conditions** cover controlling permanents, turn ownership, tapped source,
life totals, and graveyard size.
- **Conditions** cover controlling permanents, commander control, turn ownership,
tapped source, life totals, graveyard/hand/library size, total power, distinct
permanent names, and this-turn attacks and damage.
- **Static effects** include pumps, keyword grants, restrictions, enters
tapped/with counters, control, choices, replacements, cost reduction/increase,
search restriction, and exiling cards instead of putting them into graveyards.
- **Durations** cover permanent, end of turn, your next turn, the end of your
next turn, end of combat, controller's next untap step, and while the source
remains.
@@ -230,7 +408,7 @@ ambiguous pronouns stay unsupported.
## Adding support
For a single card, open the frontend editor, edit the pseudocode, and save; no
For a single card, open the frontend editor, edit the source, and save; no
compiler change is needed. For a whole class of cards:
1. Run `npm run compile:cards` and pick a frequent unsupported pattern.

View File

@@ -18,6 +18,7 @@ const game = new Game({
startingLife: 40,
startingHandSize: 7,
commander: true,
mulligans: true,
players: [
{ id: 'p1', deck: deckFromOracleIds(decklist1), commander: commanderCard1 },
{ id: 'p2', deck: deckFromOracleIds(decklist2), commander: commanderCard2 },
@@ -32,7 +33,9 @@ in `commander.ts` checks size, singleton, color identity, and the commander type
`catalog.ts` merges Scryfall card data with `data/card-effects.json`. It also adds
intrinsic mana abilities for basic lands, because Scryfall's oracle text only has
reminder text for them and the compiler produces no ability.
reminder text for them and the compiler produces no ability. When a compiled card
declares a `typeLine`, that value is used instead of Scryfall's; the generated
card source carries the type line and an override can change it.
For tests or hand-authored cards, build a `CardDefinition` yourself:
@@ -56,19 +59,25 @@ 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 })` | Puts a spell on the stack and pays its mana cost. Accepts a commander in the command zone and adds commander tax. |
| `activateAbility(playerId, sourceId, abilityIndex, { targets, x, mode })` | Activates an ability on a permanent. Mana abilities resolve immediately. |
| `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, manaColor })` | Activates an ability on a permanent. Mana abilities resolve immediately; `manaColor` picks the color when the ability can make several. |
| `movePermanent(playerId, cardId, x, y)` | Cosmetic board layout for a permanent you control; coordinates are 0..1 within the battlefield. |
| `declareAttackers(playerId, [{ attackerId, defenderId }])` | Starts combat from the precombat main if needed. |
| `declareBlockers(playerId, [{ blockerId, attackerId }])` | Declares blocks for one defending player. In multiplayer, combat damage waits until every defending player has declared or passed. |
| `resolveCombatDamage()` | Deals combat damage manually; passing priority also does this. |
| `pass(playerId?)` | Passes priority; when everyone passes, resolves the top of the stack or advances the phase. |
| `chooseSearchCard(playerId, cardId)` | Finishes one pick of a paused library search. |
| `chooseHideawayCard(playerId, cardId)` | Exiles one of the cards looked at with hideaway; the rest go to the bottom in a random order. |
| `chooseCreatureType(playerId, type)` | Answers an "as this enters, choose a creature type" prompt. |
| `resolveStack()` | Convenience for tests/scripts: passes priority until the stack is empty. Does not advance phases. |
| `endTurn(playerId)` | Ends the active player's turn, skipping remaining phases. Requires an empty stack. |
| `canPlayCard(playerId, cardId)` | Whether a hand or command-zone card can legally be played now, including timing, mana, and targets. |
| `legalTargetsForCard(playerId, cardId)`, `legalTargetsForAbility(playerId, sourceId, abilityIndex)` | Legal `TargetChoice`s for a spell or activated ability, so the UI can offer only real targets. |
| `autoAdvance()` | Passes priority for players with nothing meaningful to do; stops when someone can act or the turn ends. |
| `getPower`, `getToughness`, `hasKeyword` | Current characteristics after static and continuous effects. |
| `addCard`, `moveToZone` | Setup helpers for placing cards directly into zones. |
@@ -78,7 +87,17 @@ non-flash spells can only be cast in the active player's main phase with an empt
stack. Targets may be supplied explicitly; if omitted, the first legal target is
chosen automatically, which keeps scripted games short. A search effect that matches
several cards pauses instead: other actions are refused until its controller calls
`chooseSearchCard` (the match API uses the `choose_search` action).
`chooseSearchCard` (the match API uses the `choose_search` action). The match API also
sends the chooser the full searched pool (`searchPool`) so the UI can show and filter
the library; only `searchCandidates` are legal picks. A permanent with "as this enters,
choose a creature type" also pauses play: `pendingChoice` records the controller and
the permanent, and the match API refuses other priority actions until `chooseCreatureType`
(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
@@ -88,55 +107,104 @@ untap -> upkeep -> draw -> precombat main -> begin combat -> declare attackers
-> end step -> cleanup -> next player's turn
```
The starting player skips their first draw. Cleanup discards down to seven cards,
clears damage, expires `until_end_of_turn` and `until_end_of_your_next_turn`
effects, and empties mana pools. The engine advances phases when every living
player passes in turn; it does not stop at every rules-defined priority window.
The match manager calls `autoAdvance()` after each action, so priority is only
shown to players who can actually do something.
The starting player draws on their first turn, as in multiplayer Commander. Cleanup
discards down to seven cards, clears damage, expires `until_end_of_turn` and
`until_end_of_your_next_turn` effects, and empties mana pools. The engine advances
phases when every living player passes in turn; it does not stop at every
rules-defined priority window. The match manager calls `autoAdvance()` after each
action, so priority is only shown to players who can actually do something.
## Supported
- Zones: library, hand, battlefield, graveyard, exile, stack, and command zone. Tokens
cease to exist when they leave the battlefield.
- Commander: command-zone casting, `{2}` tax per previous cast from the command
zone, return to the command zone instead of graveyard/exile/hand/library, and a
loss at 21 combat damage from one commander. Deck construction is validated by
`validateCommanderDeck`.
zone, free alternative costs while you control a commander, return to the command
zone instead of graveyard/exile/hand/library, and a loss at 21 combat damage from
one commander. Deck construction is validated by `validateCommanderDeck`.
- Mana: colored, generic, hybrid, Phyrexian, `{X}`, and `{S}` costs; manual mana
abilities plus automatic tapping of untapped mana sources when paying.
- Costs: tap, untap, tap another permanent, pay life, discard, sacrifice, exile,
putting/removing counters, mill, energy, and choice costs.
- Abilities: spell effects, activated abilities, triggered abilities (enters,
leaves, dies, attacks, blocks, cast, draw, life, upkeep, end step, combat), static
effects, and basic replacement effects for entering tapped/with counters.
putting/removing counters, mill, energy, and choice costs. Static cost reductions
and increases apply while their source is on the battlefield.
- Abilities: spell effects, overload, activated abilities, triggered abilities
(enters, leaves, dies, attacks, blocks, cast, draw, life, upkeep, end step,
combat), static effects, and basic replacement effects for entering tapped/with
counters and exiling cards instead of putting them into graveyards.
- Effects: damage, draw, discard, mill, life, pump/set P/T, grant keyword,
counters, proliferate, tokens, destroy, exile, sacrifice, counter spell/ability,
zone returns, tap/untap, search/shuffle, add mana, fight, regenerate, energy,
attach, restrictions, conditional and modal effects, dig, and divided damage.
counters, proliferate, tokens, destroy, exile, exile all graveyards, sacrifice,
counter spell/ability, zone returns, tap/untap, search/shuffle, add mana, fight,
regenerate, energy, attach, restrictions, conditional and modal effects, dig,
divided damage, hideaway, and playing a card exiled with hideaway.
- Tokens: the predefined tokens from comprehensive rules 111.10 (Treasure, Food,
Gold, Walker, Shard, Clue, Blood, Powerstone, Incubator, Map, Junk, Lander,
Mutagen, Vibranium, Heartwood, and the seven Role tokens). `tokens.ts` supplies
their characteristics and abilities when a created token names that subtype or
name. Role tokens can be created already attached to their target. Incubator
tokens carry their counters and can transform into a Phyrexian.
- Keyword actions: explore, incubate, and impulse. Impulse exiles the top card and
marks it playable from exile until the end of the current turn.
- Restrictions and conditions: activated abilities can be disabled, opponents can
be limited to the top N cards when searching, cards can begin the game on the
battlefield from the opening hand, and conditions can count commander control or
distinct permanent names.
- Combat keywords: flying, reach, first strike, double strike, trample, deathtouch,
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
- Some effect nodes are accepted but intentionally do nothing yet:
`prevent_damage`, `gain_control`, `emblem`, `transform`, `schedule`, `level_up`,
`put_from_among`, `look_top`, `scry`, `surveil`, and `keyword_action`.
Unsupported oracle lines are already marked by the compiler and never reach here.
`prevent_damage`, `gain_control`, `emblem`, `schedule`, `level_up`,
`put_from_among`, `look_top`, `scry`, and `surveil`. Scry and surveil are
no-ops, so an effect that scries and then draws still draws. `keyword_action`
implements explore, incubate, and impulse; any other action is ignored.
`transform` only works on an object that has a back face, currently the
Incubator token. Unsupported oracle lines are already marked by the compiler
and never reach here.
- Explore puts a revealed land card into its controller's hand. For a nonland
card, the exploring creature gets a +1/+1 counter and the card goes to the
graveyard; it does not ask whether to put that card on top instead.
- Impulse grants the engine's play-from-exile permission. The web client marks a
playable exiled card and offers a Play button in the exile browser; other clients
must expose the same cast/play path.
- Powerstone and Vibranium mana carries an "artifact spells" restriction that the
mana pool does not enforce, so it can currently pay for any spell.
- Role and other Aura static abilities use the `attached: enchanted` selector,
which matches any creature that has an Aura attached rather than only that
Aura's own enchanted creature. With several Auras, a pump can apply more widely
than printed.
- Ward is recorded as a keyword and shown on the permanent, but targeting does not
yet ask for its cost, so Royal Role's ward {1} is not enforced.
- 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.
- Opening hands are kept automatically; there is no mulligan flow.
- "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
(color, card name, player, opponent, number) are accepted and ignored. Cavern of
Souls' mana is not restricted to the chosen type and does not make the spell
uncounterable.
- Hideaway pauses for its controller to exile one of the looked-at cards; the
rest go to the bottom in a random order. The exiled card stays face down and is
shown under its source, hidden from every player's card list. `play_exiled` only
supports the free "without paying its mana cost" case.
- 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 use the London mulligan when `mulligans` is enabled: each mulligan
draws seven, then puts one more card on the bottom than the previous one. The
match API starts with mulligans on.
- Replacement/prevention effects, layers, and dependency ordering are simplified.
Continuous effects apply in creation order rather than in full rules order.
- The engine is synchronous and exposes full state. `rooms.ts` owns the in-memory

View File

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

View File

@@ -69,9 +69,11 @@ const deckSchema = new Schema({
commander: { type: deckCardSchema, required: true },
cards: { type: [deckCardSchema], default: [] },
cardBack: { type: String, default: null },
shareToken: String,
updatedAt: { type: Number, required: true },
})
deckSchema.index({ owner: 1, deckId: 1 }, { unique: true })
deckSchema.index({ shareToken: 1 }, { unique: true, sparse: true })
const User = mongoose.models.User ?? mongoose.model('User', userSchema)
const Session = mongoose.models.Session ?? mongoose.model('Session', sessionSchema)
@@ -83,6 +85,7 @@ interface DeckRow {
commander: DeckCardInput
cards: DeckCardInput[]
cardBack?: string | null
shareToken?: string
updatedAt: number
}
@@ -305,6 +308,34 @@ export function registerAccountRoutes(app: FastifyInstance): void {
return { ok: true }
})
// Reuses the deck's token so re-sharing a deck never breaks an existing link.
app.post<{ Params: { id: string } }>('/me/decks/:id/share', async (request, reply) => {
const user = await authenticate(request)
const deckId = request.params.id
if (!/^[a-zA-Z0-9_-]{1,100}$/.test(deckId)) {
return reply.code(400).send({ error: 'Invalid deck id' })
}
const created = await Deck.findOneAndUpdate(
{ owner: user.id, deckId, shareToken: null },
{ $set: { shareToken: randomBytes(16).toString('base64url') } },
{ returnDocument: 'after' },
).lean<DeckRow>()
if (created?.shareToken) return { token: created.shareToken }
const existing = await Deck.findOne({ owner: user.id, deckId }).lean<DeckRow>()
if (!existing?.shareToken) return reply.code(404).send({ error: 'Deck not found' })
return { token: existing.shareToken }
})
app.get<{ Params: { token: string } }>('/decks/share/:token', async (request, reply) => {
if (!/^[A-Za-z0-9_-]{22}$/.test(request.params.token)) {
return reply.code(404).send({ error: 'Shared deck not found' })
}
const deck = await Deck.findOne({ shareToken: request.params.token }).lean<DeckRow>()
if (!deck) return reply.code(404).send({ error: 'Shared deck not found' })
return { deck: toDeck(deck, await implementationIndex()) }
})
app.get('/me/preferences', async request => {
const user = await authenticate(request)
return preferences(user.id)

View File

@@ -7,6 +7,7 @@ import {
parseSelector,
parseTarget,
parseValue,
ROLE_NAMES,
} from './parse.js'
import type {
Ability,
@@ -397,6 +398,11 @@ function parseTokenBody(text: string, tapped: boolean): TokenSpec | undefined {
}
if (/\bcolorless\b/.test(rest)) colors.push('C')
const role = Object.entries(ROLE_NAMES).find(([name]) => rest.endsWith(`${name} role`))
if (role) {
return { name: role[1], types: ['enchantment'], subtypes: ['aura', 'role'], colors, tapped: tapped || undefined }
}
let power: Value | undefined
let toughness: Value | undefined
const pt = rest.match(/^(\d+|x)\/(\d+|x)\b/)
@@ -448,6 +454,27 @@ function parseDigDestination(text: string): 'hand' | 'graveyard' | 'battlefield'
return 'bottom'
}
function parseSearchDestination(
text: string,
): { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean } | undefined {
switch (text) {
case 'into your hand':
return { destination: 'hand', tapped: false }
case 'onto the battlefield':
return { destination: 'battlefield', tapped: false }
case 'onto the battlefield tapped':
return { destination: 'battlefield', tapped: true }
case 'into your graveyard':
return { destination: 'graveyard', tapped: false }
case 'on top of your library':
return { destination: 'top', tapped: false }
case 'on the bottom of your library':
return { destination: 'bottom', tapped: false }
default:
return undefined
}
}
function parseSearch(text: string): Effect | undefined {
const match = text.match(/^search your (library|library and\/or graveyard) for (.+)$/)
if (!match) return undefined
@@ -476,34 +503,53 @@ function parseSearch(text: string): Effect | undefined {
const revealPrefix = /^reveal (?:it|them|that card|those cards),? (?:and )?/
let destinationText = rest.replace(revealPrefix, '')
let shuffle = false
if (/^then shuffle and put (?:it|them|that card|those cards) on top(?: of your library)?$/.test(destinationText)) {
if (/^then shuffle and put (?:it|them|that card|those cards|the card|the chosen card) on top(?: of your library)?$/.test(destinationText)) {
return { op: 'search', player: 'you', selector, amount, destination: 'top', tapped: false, shuffle: true, ...(zones ? { zones } : {}) }
}
if (/^shuffle and put (?:it|them|that card|those cards) on top(?: of your library)?$/.test(destinationText)) {
if (/^shuffle and put (?:it|them|that card|those cards|the card|the chosen card) on top(?: of your library)?$/.test(destinationText)) {
return { op: 'search', player: 'you', selector, amount, destination: 'top', tapped: false, shuffle: true, ...(zones ? { zones } : {}) }
}
if (/^put (?:it|them|that card|those cards) on top of your library, then shuffle$/.test(destinationText)) {
if (/^put (?:it|them|that card|those cards|the card|the chosen card) on top of your library, then shuffle$/.test(destinationText)) {
return { op: 'search', player: 'you', selector, amount, destination: 'top', tapped: false, shuffle: true, ...(zones ? { zones } : {}) }
}
const split = destinationText.match(/^put one (.+?) and the other (.+?)(, then shuffle)?$/)
if (split && amount.kind === 'number' && amount.value >= 2) {
const first = parseSearchDestination(split[1].trim())
const second = parseSearchDestination(split[2].trim())
if (first && second) {
return {
op: 'search',
player: 'you',
selector,
amount,
destination: first.destination,
tapped: first.tapped,
shuffle: Boolean(split[3]),
split: second,
...(zones ? { zones } : {}),
}
}
}
const put = destinationText.match(
/^put (?:it|them|that card|those cards|the chosen card) (into your hand|onto the battlefield(?: tapped)?|into your graveyard|on top of your library|on the bottom of your library)(?: under your control)?(?:, then shuffle)?$/,
)
if (!put) continue
const destination =
put[1] === 'into your hand'
? 'hand'
: put[1].startsWith('onto the battlefield')
? 'battlefield'
: put[1] === 'into your graveyard'
? 'graveyard'
: put[1] === 'on top of your library'
? 'top'
: 'bottom'
const parsedDestination = parseSearchDestination(put[1])
if (!parsedDestination) continue
shuffle = /then shuffle$/.test(destinationText)
const tapped = /\btapped\b/.test(put[1])
return { op: 'search', player: 'you', selector, amount, destination, tapped, shuffle, ...(zones ? { zones } : {}) }
return {
op: 'search',
player: 'you',
selector,
amount,
destination: parsedDestination.destination,
tapped: parsedDestination.tapped,
shuffle,
...(zones ? { zones } : {}),
}
}
return undefined
@@ -737,6 +783,16 @@ function parseEffect(text: string): Effect | Effect[] | undefined {
}
}
match = sentence.match(/^create (?:(\w+) )?(?:a |an )?(.+?) tokens? attached to (.+)$/)
if (match) {
const amount = match[1] && !['a', 'an'].includes(match[1])
? parseValue(match[1])
: ({ kind: 'number', value: 1 } as Value)
const token = parseToken(match[2])
const attachTo = parseTarget(match[3])
if (amount && token && attachTo) return { op: 'create_token', player: 'you', amount, token, attachTo }
}
match = sentence.match(/^create (?:((?:that many)|\w+) )?(.+?) tokens?(?: (with .+))?$/)
if (match) {
const amount = match[1] ? parseValue(match[1]) : ({ kind: 'number', value: 1 } as Value)
@@ -750,6 +806,8 @@ function parseEffect(text: string): Effect | Effect[] | undefined {
if (target) return { op: 'destroy', target }
}
if (sentence === 'exile all graveyards') return { op: 'exile_graveyards' }
match = sentence.match(/^exile (.+)$/)
if (match) {
const target = parseGroupTarget(match[1])
@@ -955,7 +1013,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)?$/)
@@ -1084,6 +1148,9 @@ function parseEffect(text: string): Effect | Effect[] | undefined {
if (sentence === 'shuffle your library') return { op: 'shuffle', player: 'you' }
match = sentence.match(/^(?:you may )?play the exiled card without paying its mana cost$/)
if (match) return { op: 'play_exiled', player: 'you', free: true }
return undefined
}
@@ -1359,6 +1426,14 @@ function parseEffects(text: string): { effects: Effect[]; optional: boolean } |
return undefined
}
// The search already shuffles; the sentence only spells out when.
if (/^if you search your library this way, shuffle\.?$/i.test(sentence)) {
const last = effects[effects.length - 1]
if (last?.op !== 'search') return undefined
last.shuffle = true
continue
}
const conditional = sentence.match(/^if (.+?), (.+)$/i)
if (conditional) {
const raw = conditional[1].trim().toLowerCase()
@@ -1630,8 +1705,28 @@ function parseStaticTarget(text: string): Target | undefined {
return undefined
}
/** "Each spell you cast that's X" and "X spells and Y spells" reduce on a union. */
function parseCostReductionTarget(text: string): Target | undefined {
const eachSpell = text.match(/^each spell you cast that(?:'s| is) (.+)$/)
const normalized = eachSpell
? `${eachSpell[1].replace(/^an? /, '')} spells you cast`
: text
const target = parseStaticTarget(normalized)
if (!target || target.kind !== 'object') return target
if (!/\band\b|,/.test(normalized)) return target
target.selector.match = 'any'
// parseSelector infers one type from the first subtype; a mixed list has none.
if ((target.selector.subtypes?.length ?? 0) > 1) target.selector.types = []
return target
}
function parseStaticEffects(text: string): StaticEffect[] | undefined {
const sentence = text.trim().replace(/\.$/, '')
const sentence = text
.trim()
.replace(/\.$/, '')
// Clarifies how a colored cost reduction works; our symbols do exactly this.
.replace(/\. this effect reduces only the amount of colored mana you pay$/, '')
let match = sentence.match(/^(?:its|this's) (base )?power and toughness are each equal to (.+)$/)
if (match) {
@@ -1865,6 +1960,26 @@ function parseStaticEffects(text: string): StaticEffect[] | undefined {
if (what) return [{ op: 'choose', what }]
}
match = sentence.match(/^if an effect would create one or more (tokens?|creature tokens?) under your control, it creates (twice|three times) that many of those tokens instead$/)
if (match) {
return [{
op: 'token_multiplier',
multiplier: match[2] === 'twice' ? 2 : 3,
who: 'you',
...(match[1] === 'creature tokens' ? { creatureOnly: true } : {}),
}]
}
match = sentence.match(/^if one or more (tokens?|creature tokens?) would be created( under your control)?, (twice|three times) that many of those tokens are created instead$/)
if (match) {
return [{
op: 'token_multiplier',
multiplier: match[3] === 'twice' ? 2 : 3,
who: match[2] ? 'you' : 'each_player',
...(match[1] === 'creature tokens' ? { creatureOnly: true } : {}),
}]
}
match = sentence.match(/^if this would be put into (?:a|your) graveyard from anywhere, exile it instead$/)
if (match) {
return [{ op: 'replacement', what: 'dies', instead: 'exile', target: { kind: 'self' } }]
@@ -1875,6 +1990,33 @@ function parseStaticEffects(text: string): StaticEffect[] | undefined {
return [{ op: 'replacement', what: 'leaves_battlefield', instead: 'exile', target: { kind: 'self' } }]
}
if (sentence === 'if a card or token would be put into a graveyard from anywhere, exile it instead') {
return [{ op: 'exile_instead_of_graveyard' }]
}
match = sentence.match(/^if a card would be put into (an opponent's|your) graveyard from anywhere, exile it instead$/)
if (match) {
return [{ op: 'exile_instead_of_graveyard', owner: match[1] === 'your' ? 'you' : 'opponent' }]
}
match = sentence.match(/^if (an opponent|you) would search (?:a|their) library, that player searches the top (\w+) cards? of that library instead$/)
if (match) {
const amount = parseValue(match[2])
if (amount) return [{ op: 'search_restriction', who: match[1] === 'you' ? 'you' : 'opponent', amount }]
}
match = sentence.match(/^activated abilities of (.+?) cannot be activated$/)
if (match) {
const target = parseStaticTarget(match[1])
if (target) return [{ op: 'restriction', target, rule: 'cant_activate' }]
}
match = sentence.match(/^(noncreature|creature) spells cost (\{[^}]+\}) more to cast$/)
if (match) {
const amount = parseValue(match[2].slice(1, -1))
if (amount) return [{ op: 'cost_increase', amount, spellType: match[1] === 'creature' ? 'creature' : 'noncreature' }]
}
let costText = sentence
let costCondition: Condition | undefined
let costAmount: Value | undefined
@@ -1896,17 +2038,25 @@ function parseStaticEffects(text: string): StaticEffect[] | undefined {
}
match = costText.match(/^(.+?) costs? ((?:\{[^}]+\})+) less to cast(?: for each (.+))?$/)
if (match) {
const target = parseStaticTarget(match[1])
const target = parseCostReductionTarget(match[1])
let amount: Value | undefined = costAmount
let symbols: string | undefined
if (!amount && match[3]) {
const selector = parseSelector(match[3])
if (selector) amount = { kind: 'count', selector }
} else if (!amount) {
const inner = match[2].match(/\{([^}]+)\}/)?.[1]
if (inner) amount = parseValue(inner.toLowerCase())
const parts = [...match[2].matchAll(/\{([^}]+)\}/g)].map(symbol => symbol[1])
if (parts.some(part => /[WUBRGC]/i.test(part))) symbols = match[2].toUpperCase()
else if (parts[0]) amount = parseValue(parts[0].toLowerCase())
}
if (target && amount) {
return [{ op: 'cost_reduction', target, amount, condition: costCondition }]
if (target && (amount || symbols)) {
return [{
op: 'cost_reduction',
target,
...(amount ? { amount } : {}),
...(symbols ? { symbols } : {}),
...(costCondition ? { condition: costCondition } : {}),
}]
}
}
@@ -1960,6 +2110,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])
@@ -2101,6 +2256,28 @@ function compileLine(rawLine: string, name: string, known: Set<string>, isSpell:
if (/^[•·]/.test(line) || /^choose (?:one|two|three|four|five|one or both|one or more)\b/.test(line.toLowerCase())) {
return { kind: 'unsupported', reason: 'modal', text: line }
}
if (/^if you control a commander, you may cast this without paying its mana cost\.?$/.test(lower)) {
return { kind: 'alternative_cost', costs: [], condition: { kind: 'you_control_commander' }, text: line }
}
const overload = lower.match(/^overload ((?:\{[^}]+\})+)$/)
if (overload) return { kind: 'overload', cost: overload[1].toUpperCase(), text: line }
const hideaway = lower.match(/^hideaway (\d+)(?:, hideaway (\d+))?$/)
if (hideaway) {
const effects: Effect[] = [hideaway[1], hideaway[2]]
.filter((amount): amount is string => Boolean(amount))
.map(amount => ({ op: 'hideaway', amount: { kind: 'number', value: Number(amount) } }))
return {
kind: 'triggered',
event: { kind: 'enters', subject: { kind: 'self' } },
effects,
optional: false,
text: line,
}
}
const chapter = body.match(/^([ivx]+(?:, [ivx]+)*) — (.+)$/i)
if (chapter) {
const effects = parseEffects(resolveIt(chapter[2], 'this'))
@@ -2345,7 +2522,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 {
@@ -2355,7 +2532,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(
@@ -2365,6 +2542,7 @@ export function compileCard(card: Card): CompiledCard {
return {
oracle_id: card.oracle_id,
name: card.name,
typeLine: card.type_line,
status: face.status,
abilities: face.abilities,
}

File diff suppressed because it is too large Load Diff

View File

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

View File

@@ -144,6 +144,16 @@ const NON_CREATURE_SUBTYPES: Record<string, string> = {
desert: 'land',
}
export const ROLE_NAMES: Record<string, string> = {
cursed: 'Cursed',
monster: 'Monster',
royal: 'Royal',
sorcerer: 'Sorcerer',
virtuous: 'Virtuous',
wicked: 'Wicked',
'young hero': 'Young Hero',
}
function typeForSubtype(subtype: string): string {
return NON_CREATURE_SUBTYPES[subtype] ?? 'creature'
}
@@ -350,6 +360,17 @@ function parseQualifierSuffix(rest: string, selector: ObjectSelector): string {
}
}
match = text.match(/^(.+?) with mana value (\w+)$/)
if (match) {
const amount = parseNumber(match[2])
if (amount !== undefined) {
selector.manaValue = { atLeast: amount, atMost: amount }
text = match[1].trim()
changed = true
continue
}
}
match = text.match(/^(.+?) with (.+)$/)
if (match && SELECTOR_KEYWORDS.has(match[2])) {
selector.keywords = [...(selector.keywords ?? []), match[2]]
@@ -451,6 +472,7 @@ export function parseSelector(text: string): ObjectSelector | undefined {
const supertypes: string[] = []
const subtypes: string[] = []
const colors: string[] = []
const excludeColors: string[] = []
let match: ObjectSelector['match']
for (const rawWord of words) {
@@ -495,6 +517,10 @@ export function parseSelector(text: string): ObjectSelector | undefined {
excludeTypes.push(negative[1])
continue
}
if (negative && COLOR_WORDS[negative[1]]) {
excludeColors.push(COLOR_WORDS[negative[1]])
continue
}
if (STATE_WORDS.has(word)) {
if (word === 'token') selector.token = true
@@ -517,7 +543,7 @@ export function parseSelector(text: string): ObjectSelector | undefined {
if (!types.length) {
if (subtypes.length) {
types.push(typeForSubtype(subtypes[0]))
} else if (!(excludeTypes.length || colors.length || supertypes.length || selector.name)) {
} else if (!(excludeTypes.length || excludeColors.length || colors.length || supertypes.length || selector.name)) {
return undefined
}
}
@@ -525,6 +551,7 @@ export function parseSelector(text: string): ObjectSelector | undefined {
selector.types = types
if (match) selector.match = match
if (excludeTypes.length) selector.excludeTypes = excludeTypes
if (excludeColors.length) selector.excludeColors = excludeColors
if (supertypes.length) selector.supertypes = supertypes
if (subtypes.length) selector.subtypes = subtypes
if (colors.length) selector.colors = colors
@@ -805,6 +832,29 @@ export function parseCondition(text: string): Condition | undefined {
}
if (trimmed === "you've cast a spell this turn") return { kind: 'cast_spell_this_turn' }
if (trimmed === 'you have a full party') return { kind: 'full_party' }
if (trimmed === 'you control a commander') return { kind: 'you_control_commander' }
if (trimmed === 'each player has no cards in hand') {
return { kind: 'cards_in_hand_at_most', who: 'each_player', atMost: 0 }
}
const opponentDamage = trimmed.match(/^an opponent was dealt (\w+) or more damage this turn$/)
if (opponentDamage) {
const amount = parseNumber(opponentDamage[1])
if (amount !== undefined) return { kind: 'opponent_damaged_this_turn', atLeast: amount }
}
const attackedCreatures = trimmed.match(/^you attacked with (\w+) or more creatures this turn$/)
if (attackedCreatures) {
const amount = parseNumber(attackedCreatures[1])
if (amount !== undefined) return { kind: 'attacked_with_creatures', atLeast: amount }
}
const libraryAtMost = trimmed.match(/^a library has (\w+) or fewer cards in it$/)
if (libraryAtMost) {
const amount = parseNumber(libraryAtMost[1])
if (amount !== undefined) return { kind: 'library_at_most', atMost: amount }
}
const graveyard = trimmed.match(/^there are (\w+) or more cards in (your|an opponent's|target player's) graveyard$/)
if (graveyard) {
@@ -888,6 +938,13 @@ export function parseCondition(text: string): Condition | undefined {
const above = trimmed.match(/^you have at least (\d+) life more than your starting life total$/)
if (above) return { kind: 'life_above_starting', player: 'you', amount: Number(above[1]) }
const distinctNames = trimmed.match(/^you control (\w+) or more (.+?) with different names$/)
if (distinctNames) {
const amount = parseNumber(distinctNames[1])
const selector = parseSelector(distinctNames[2])
if (amount !== undefined && selector) return { kind: 'distinct_names', selector, atLeast: amount }
}
const control = trimmed.match(/^you control (?:at least )?(one|two|three|four|five|six|seven|eight|nine|ten|\d+) (?:or more )?(.+)$/)
if (control) {
const selector = parseSelector(control[2])

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,13 +1,14 @@
// Natural language -> card pseudocode through an OpenRouter-hosted model.
// The model is told to emit pseudocode only, and the answer is parsed before
// it reaches the editor, so prose or a guess never becomes an implementation.
// Natural language -> card source through an OpenRouter-hosted model.
// The model is told to emit the JavaScript card DSL only, and the answer is
// parsed before it reaches the editor, so prose or a guess never becomes an
// implementation.
import type { Card } from '../cards.js'
import { compileImplementation } from './implementations.js'
export const DEFAULT_MODEL = 'google/gemini-2.5-flash-lite'
const ENDPOINT = 'https://openrouter.ai/api/v1/chat/completions'
const MAX_TOKENS = 700
const MAX_TOKENS = 1200
export class TranslationError extends Error {
readonly status: number
@@ -22,160 +23,165 @@ 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')
.withoutColor('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[, 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 +232,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 +267,7 @@ export async function translateCard(card: Card, options: TranslateOptions = {}):
compileImplementation(card, source)
} catch (error) {
throw new TranslationError(
`The model did not return valid pseudocode: ${error instanceof Error ? error.message : String(error)}`,
`The model did not return valid card source: ${error instanceof Error ? error.message : String(error)}`,
)
}

View File

@@ -3,6 +3,8 @@
export type Zone = 'battlefield' | 'hand' | 'graveyard' | 'library' | 'exile' | 'stack' | 'command'
export type SearchDestination = 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'
export type PlayerRef =
| 'you'
| 'opponent'
@@ -23,6 +25,7 @@ export interface ObjectSelector {
controller?: 'you' | 'opponent' | 'any'
owner?: 'you' | 'opponent'
colors?: string[]
excludeColors?: string[]
other?: boolean
attached?: 'equipped' | 'enchanted'
zone?: Zone
@@ -65,7 +68,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 {
@@ -184,6 +187,12 @@ export type Condition =
| { kind: 'if_you_do' }
| { kind: 'if_you_dont' }
| { kind: 'otherwise' }
| { kind: 'you_control_commander' }
| { kind: 'distinct_names'; selector: ObjectSelector; atLeast: number }
| { kind: 'opponent_damaged_this_turn'; atLeast: number }
| { kind: 'attacked_with_creatures'; atLeast: number }
| { kind: 'library_at_most'; atMost: number }
| { kind: 'event_subject_toughness_at_most'; amount: number }
export type TriggerEvent =
| { kind: 'enters'; subject: Target }
@@ -218,7 +227,7 @@ export type Effect =
| { op: 'put_counters'; target: Target; counter: string; amount: Value }
| { op: 'remove_counters'; target: Target; counter: string; amount: Value }
| { op: 'proliferate' }
| { op: 'create_token'; player: PlayerRef; amount: Value; token: TokenSpec; copyOf?: Target; notLegendary?: boolean }
| { op: 'create_token'; player: PlayerRef; amount: Value; token: TokenSpec; copyOf?: Target; notLegendary?: boolean; attachTo?: Target }
| { op: 'destroy'; target: Target }
| { op: 'exile'; target: Target }
| { op: 'sacrifice'; player: PlayerRef; target: Target; unless?: Cost }
@@ -230,7 +239,7 @@ export type Effect =
| { op: 'untap'; target: Target }
| { op: 'scry'; player: PlayerRef; amount: Value }
| { op: 'surveil'; player: PlayerRef; amount: Value }
| { op: 'search'; player: PlayerRef; selector: ObjectSelector; amount: Value; destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean; shuffle: boolean; zones?: ('library' | 'graveyard')[] }
| { op: 'search'; player: PlayerRef; selector: ObjectSelector; amount: Value; destination: SearchDestination; tapped: boolean; shuffle: boolean; zones?: ('library' | 'graveyard')[]; split?: { destination: SearchDestination; tapped: boolean } }
| { op: 'shuffle'; player: PlayerRef }
| { op: 'add_mana'; player: PlayerRef; mana: ManaSpec }
| { op: 'fight'; a: Target; b: Target }
@@ -252,19 +261,26 @@ export type Effect =
| { op: 'put_from_among'; player: PlayerRef; selector?: ObjectSelector; amount: Value; destination: 'hand' | 'graveyard' | 'battlefield' | 'top' | 'bottom' }
| { op: 'dig'; player: PlayerRef; amount: Value; pick: Value; upTo?: boolean; pickSelector?: ObjectSelector; to: 'hand' | 'battlefield'; rest: 'bottom' | 'graveyard' | 'top'; order?: 'any' | 'random'; optional?: boolean; tapped?: boolean }
| { op: 'damage_divided'; amount: Value; target: Target }
| { op: 'exile_graveyards' }
| { op: 'hideaway'; amount: Value }
| { op: 'play_exiled'; player: PlayerRef; free?: boolean }
export type StaticEffect =
| { op: 'pump'; target: Target; power: Value; toughness: Value }
| { 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 }
| { op: 'choose'; what: 'creature_type' | 'color' | 'card_name' | 'player' | 'opponent' | 'number' }
| { op: 'replacement'; what: 'dies' | 'leaves_battlefield' | 'discard' | 'draw'; instead: 'exile' | 'return_to_hand' | 'return_to_library' | 'prevent'; target?: Target }
| { op: 'cost_reduction'; target: Target; amount: Value; condition?: Condition }
| { op: 'cost_reduction'; target: Target; amount?: Value; symbols?: string; condition?: Condition }
| { op: 'cost_increase'; amount: Value; spellType?: 'noncreature' | 'creature' }
| { op: 'search_restriction'; who: 'opponent' | 'you'; amount: Value }
| { op: 'exile_instead_of_graveyard'; owner?: 'opponent' | 'you' }
| { op: 'token_multiplier'; multiplier: number; who: 'you' | 'each_player'; creatureOnly?: boolean }
export type Ability =
| KeywordAbility
@@ -308,6 +324,17 @@ export type Ability =
optional: boolean
text: string
}
| {
kind: 'alternative_cost'
costs: Cost[]
condition?: Condition
text: string
}
| {
kind: 'overload'
cost: string
text: string
}
| {
kind: 'chapter'
chapters: string[]
@@ -321,6 +348,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[]
}
@@ -328,6 +357,8 @@ export interface CompiledFace {
export interface CompiledCard {
oracle_id: string
name: string
/** Scryfall type line, or the type line declared in card source. */
typeLine?: string
status: 'supported' | 'partial' | 'unsupported'
abilities: Ability[]
faces?: CompiledFace[]

View File

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

View File

@@ -0,0 +1,45 @@
// Scryfall's creature-type catalog (api.scryfall.com/catalog/creature-types).
// Update when a set introduces a new type.
export const CREATURE_TYPES = [
'Advisor', 'Aenar', 'Aetherborn', 'Alien', 'Ally', 'Andorian', 'Android', 'Angel', 'Antelope',
'Ape', 'Archer', 'Archon', 'Armadillo', 'Army', 'Artificer', 'Assassin', 'Assembly-Worker',
'Astartes', 'Atog', 'Aurochs', 'Automaton', 'Avatar', 'Azra', 'Badger', 'Bajoran', 'Balloon',
'Barbarian', 'Bard', 'Basilisk', 'Bat', 'Bear', 'Beast', 'Beaver', 'Beeble', 'Beholder',
'Berserker', 'Betazoid', 'Bird', 'Bison', 'Blinkmoth', 'Boar', 'Borg', 'Brainiac', 'Bringer',
'Brushwagg', "C'tan", 'Caitian', 'Camarid', 'Camel', 'Capybara', 'Cardassian', 'Caribou',
'Carrier', 'Cat', 'Centaur', 'Chicken', 'Child', 'Chimera', 'Citizen', 'Cleric', 'Clown',
'Cockatrice', 'Construct', 'Coward', 'Coyote', 'Crab', 'Crocodile', 'Custodes', 'Cyberman',
'Cyclops', 'Dalek', 'Dauthi', 'Demigod', 'Demon', 'Denobulan', 'Deserter', 'Detective', 'Devil',
'Dinosaur', 'Djinn', 'Doctor', 'Dog', 'Dragon', 'Drake', 'Dreadnought', 'Drix', 'Drone', 'Druid',
'Dryad', 'Dwarf', 'Echidna', 'Efreet', 'Egg', 'El-Aurian', 'Elder', 'Eldrazi', 'Elemental',
'Elephant', 'Elf', 'Elk', 'Employee', 'Eternal', 'Excalbian', 'Eye', 'Faerie', 'Ferengi',
'Ferret', 'Fish', 'Flagbearer', 'Fox', 'Fractal', 'Frog', 'Fungus', 'Gamer', 'Gamma', 'Gargoyle',
'Germ', 'Giant', 'Giraffe', 'Gith', 'Glimmer', 'Gnoll', 'Gnome', 'Goat', 'Goblin', 'God',
'Golem', 'Gorgon', 'Gorn', 'Graveborn', 'Gremlin', 'Griffin', 'Guest', 'Hag', 'Halfling',
'Hamster', 'Harpy', 'Head', 'Hedgehog', 'Hellion', 'Hero', 'Hippo', 'Hippogriff', 'Hirogen',
'Homarid', 'Homunculus', 'Horror', 'Horse', 'Human', 'Hydra', 'Hyena', 'Illusion', 'Illyrian',
'Imp', 'Incarnation', 'Inhuman', 'Inkling', 'Inquisitor', 'Insect', 'Jackal', 'Jellyfish',
'Juggernaut', 'Kangaroo', 'Kavu', 'Kelpien', 'Kirin', 'Kithkin', 'Klingon', 'Knight', 'Kobold',
'Kor', 'Kraken', 'Kree', 'Kwejian', 'Lamia', 'Lammasu', 'Lanthanite', 'Leech', 'Lemur',
'Leviathan', 'Lhurgoyf', 'Licid', 'Lizard', 'Llama', 'Lobster', 'Manticore', 'Masticore',
'Medusan', 'Mercenary', 'Merfolk', 'Metathran', 'Mindless-One', 'Minion', 'Minotaur', 'Mite',
'Mole', 'Monger', 'Mongoose', 'Monk', 'Monkey', 'Moogle', 'Moonfolk', 'Mount', 'Mouse', 'Mutant',
'Myr', 'Mystic', "Na'kuhl", 'Naga', 'Nautilus', 'Necron', 'Nephilim', 'Nightmare', 'Nightstalker',
'Ninja', 'Noble', 'Noggle', 'Nomad', 'Nymph', 'Octopus', 'Officer', 'Ogre', 'Ooze', 'Orb', 'Orc',
'Orgg', 'Orion', 'Otter', 'Ouphe', 'Ox', 'Oyster', 'Pangolin', 'Peasant', 'Pegasus', 'Pentavite',
'Performer', 'Pest', 'Phelddagrif', 'Phoenix', 'Phyrexian', 'Pilot', 'Pincher', 'Pirate',
'Plant', 'Platypus', 'Porcupine', 'Possum', 'Praetor', 'Primarch', 'Prism', 'Processor', 'Q',
'Qu', 'Rabbit', 'Raccoon', 'Ranger', 'Rat', 'Rebel', 'Reflection', 'Reveler', 'Rhino', 'Rigger',
'Robot', 'Rogue', 'Romulan', 'Rukh', 'Sable', 'Salamander', 'Samurai', 'Sand', 'Saproling',
'Satyr', 'Scarecrow', 'Scientist', 'Scion', 'Scorpion', 'Scout', 'Sculpture', 'Seal', 'Serf',
'Serpent', 'Servo', 'Shade', 'Shaman', 'Shapeshifter', 'Shark', 'Sheep', "Shi'ar", 'Siren',
'Skeleton', 'Skrull', 'Skunk', 'Slith', 'Sliver', 'Sloth', 'Slug', 'Snail', 'Snake', 'Soldier',
'Soltari', 'Sorcerer', 'Spawn', 'Specter', 'Spellshaper', 'Sphinx', 'Spider', 'Spike', 'Spirit',
'Splinter', 'Sponge', 'Spy', 'Squid', 'Squirrel', 'Starfish', 'Surrakar', 'Survivor', 'Symbiote',
'Synth', 'Talosian', 'Teddy', 'Tellarite', 'Tentacle', 'Tetravite', 'Thalakos', 'Tholian',
'Thopter', 'Thrull', 'Tiefling', 'Time Lord', 'Tosk', 'Toy', 'Treefolk', 'Tribble', 'Trill',
'Trilobite', 'Triskelavite', 'Troll', 'Turtle', 'Tyranid', 'Unicorn', 'Urzan', 'Utrom',
'Vampire', 'Varmint', 'Vedalken', 'Villain', 'Volver', 'Vorta', 'Vulcan', 'Wall', 'Walrus',
'Warlock', 'Warrior', 'Weasel', 'Weird', 'Werewolf', 'Whale', 'Wizard', 'Wolf', 'Wolverine',
'Wombat', 'Worm', 'Wraith', 'Wurm', 'Xindi', 'Yeti', 'Zombie', 'Zubera',
]

File diff suppressed because it is too large Load Diff

View File

@@ -2,9 +2,10 @@ import { randomUUID } from 'node:crypto'
import { getCard, type Card } from '../cards.js'
import { deletePlaymatImage, PlaymatError, scryfallArtUrl, storePlaymatImage } from '../images.js'
import { getCardDefinition } from './catalog.js'
import { CREATURE_TYPES } from './creature-types.js'
import { validateCommanderDeck } from './commander.js'
import { Game, GameError } from './game.js'
import type { CardDefinition, GameObject, ManaPool, TargetChoice } from './types.js'
import type { CardDefinition, GameObject, ManaColor, ManaPool, TargetChoice } from './types.js'
export class MatchError extends Error {
constructor(message: string, readonly status = 400) {
@@ -25,6 +26,11 @@ export interface ActionPayload {
targets?: TargetChoice[]
x?: number
mode?: number
overload?: boolean
choice?: string
/** Mana color picked when activating a mana ability that can make several. */
color?: string
pay?: boolean
position?: { x?: unknown; y?: unknown }
attackers?: { attackerId: string; defenderId: string }[]
blocks?: { blockerId: string; attackerId: string }[]
@@ -54,7 +60,15 @@ export interface CardView {
attacking?: string
blockedBy: string[]
blocking?: string
abilities: { index: number; kind: string; text?: string }[]
/** Creature type chosen as this permanent entered, if any. */
chosenType?: string
/** Number of face-down cards exiled under this permanent (hideaway). */
hiddenCards?: number
/** This exiled card is face down; its identity is not included. */
faceDown?: boolean
/** Legal choices for this card's targets, for the cast panel. */
targets?: TargetChoice[]
abilities: { index: number; kind: string; text?: string; targets?: TargetChoice[]; manaColors?: string[] }[]
/** Viewer-specific: can this card be played from hand right now? */
playable?: boolean
}
@@ -105,6 +119,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[]
@@ -115,6 +131,21 @@ export interface MatchView {
remaining: number
destination: string
cards: CardView[]
/** Every card in the searched zones, populated only for its chooser. */
library?: CardView[]
}
/** Present while an "as this enters, choose..." prompt waits for its controller. */
pendingChoice?: {
player: string
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[]
/** Cards to choose from for hideaway, populated only for the chooser. */
cards?: CardView[]
}
}
}
@@ -347,6 +378,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,
@@ -403,10 +435,21 @@ export function performAction(matchId: string, token: string | undefined, action
targets,
x: Number.isFinite(action.x) ? Number(action.x) : 0,
mode: Number.isFinite(action.mode) ? Number(action.mode) : 0,
overload: action.overload === true,
manaColor: manaColorOf(action.color),
}
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
@@ -425,6 +468,17 @@ export function performAction(matchId: string, token: string | undefined, action
case 'choose_search':
game.chooseSearchCard(seat.playerId, requireId(action.cardId))
break
case 'choose_hideaway':
game.chooseHideawayCard(seat.playerId, requireId(action.cardId))
break
case 'choose_type':
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 => ({
@@ -463,9 +517,46 @@ function requireId(id: unknown): string {
return id
}
function manaColorOf(value: unknown): ManaColor | undefined {
if (value === undefined) return undefined
if (typeof value !== 'string' || !/^[WUBRGCS]$/i.test(value)) throw new MatchError('Invalid mana color')
return value.toUpperCase() as ManaColor
}
function cardView(game: Game, object: GameObject, abilities = true): CardView {
// Face-down exiled cards (hideaway) keep their identity server-side only.
if (object.faceDown) {
return {
id: object.id,
oracleId: '',
name: 'Face-down card',
typeLine: '',
colors: [],
colorIdentity: [],
tapped: false,
damage: 0,
counters: {},
isToken: false,
isCommander: false,
zone: object.zone,
controller: object.controller,
owner: object.owner,
blockedBy: [],
faceDown: true,
abilities: [],
}
}
const definition = object.definition
const creature = /creature/i.test(definition.typeLine)
const hiddenCards = object.zone === 'battlefield'
? (object.linkedExile ?? []).filter(id => {
const linked = game.objects.get(id)
return linked?.zone === 'exile' && linked.faceDown
}).length
: 0
const targets = object.zone === 'hand' || object.zone === 'command' || object.zone === 'exile'
? game.legalTargetsForCard(object.owner, object.id)
: []
return {
id: object.id,
oracleId: definition.oracleId,
@@ -490,11 +581,18 @@ function cardView(game: Game, object: GameObject, abilities = true): CardView {
attacking: object.attacking,
blockedBy: [...object.blockedBy],
blocking: object.blocking,
chosenType: object.chosenCreatureType,
hiddenCards: hiddenCards || undefined,
targets: targets.length ? targets : undefined,
abilities: abilities
? (definition.abilities ?? []).map((ability, index) => ({
index,
kind: ability.kind,
text: 'text' in ability ? ability.text : undefined,
manaColors: game.manaColorChoices(object, index),
targets: ability.kind === 'activated' && object.zone === 'battlefield'
? game.legalTargetsForAbility(object.controller, object.id, index)
: undefined,
}))
: [],
}
@@ -519,6 +617,16 @@ function serialize(match: Match, viewerId: string): MatchView {
const game = match.game
if (!game) return view
const hiddenUnderSource = new Set<string>()
for (const player of game.players) {
for (const id of player.battlefield) {
for (const linked of game.getObject(id).linkedExile ?? []) {
const object = game.objects.get(linked)
if (object?.zone === 'exile' && object.faceDown) hiddenUnderSource.add(linked)
}
}
}
view.players = match.seats.map(seat => {
const player = game.getPlayer(seat.playerId)
return {
@@ -531,7 +639,15 @@ function serialize(match: Match, viewerId: string): MatchView {
libraryCount: player.library.length,
battlefield: player.battlefield.map(id => cardView(game, game.getObject(id))),
graveyard: player.graveyard.map(id => cardView(game, game.getObject(id), false)),
exile: player.exile.map(id => cardView(game, game.getObject(id), false)),
exile: player.exile
.filter(id => !hiddenUnderSource.has(id))
.map(id => {
const playable = player.id === viewerId && game.canPlayCard(viewerId, id)
return {
...cardView(game, game.getObject(id), playable),
...(playable ? { playable } : {}),
}
}),
command: player.command.map(id => cardView(game, game.getObject(id), false)),
commanderId: player.commanderId,
commanderDamage: Object.entries(player.commanderDamage)
@@ -548,6 +664,7 @@ function serialize(match: Match, viewerId: string): MatchView {
const viewer = game.getPlayer(viewerId)
const search = game.pendingSearch
const choice = game.pendingChoice
view.game = {
turn: game.turn,
activePlayer: game.activePlayer,
@@ -556,6 +673,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,
@@ -568,6 +688,19 @@ function serialize(match: Match, viewerId: string): MatchView {
playable: game.canPlayCard(viewerId, id),
})),
manaPool: { ...viewer.manaPool },
pendingChoice: choice
? {
player: choice.playerId,
what: choice.what,
sourceId: choice.sourceId,
sourceName: game.objects.get(choice.sourceId)?.definition.name ?? 'Permanent',
amount: choice.amount,
options: choice.playerId === viewerId && choice.what === 'creature_type' ? [...CREATURE_TYPES] : [],
cards: choice.playerId === viewerId && choice.what === 'hideaway'
? (choice.cardIds ?? []).map(id => cardView(game, game.getObject(id), false))
: undefined,
}
: undefined,
pendingSearch: search
? {
player: search.playerId,
@@ -576,6 +709,9 @@ function serialize(match: Match, viewerId: string): MatchView {
cards: search.playerId === viewerId
? game.searchCandidates(viewerId).map(object => cardView(game, object, false))
: [],
...(search.playerId === viewerId
? { library: game.searchPool(viewerId).map(object => cardView(game, object, false)) }
: {}),
}
: undefined,
}

414
backend/src/game/tokens.ts Normal file
View File

@@ -0,0 +1,414 @@
import type { Ability, Cost, Effect, StaticEffect } from '../effects/types.js'
/**
* The predefined tokens from rule 111.10. Effects that name one of these
* tokens ("create a Treasure token") use these characteristics instead of
* whatever the oracle parser managed to infer from the words.
*/
export interface PredefinedTokenFace {
name: string
types: string[]
subtypes: string[]
colors: string[]
power?: number
toughness?: number
keywords?: string[]
abilities?: Ability[]
}
export interface PredefinedToken extends PredefinedTokenFace {
/** Back face of a double-faced token, currently only Incubator. */
backFace?: PredefinedTokenFace
}
function activated(costs: Cost[], effects: Effect[], text: string, timing?: 'sorcery'): Ability {
return { kind: 'activated', costs, effects, timing, optional: false, text }
}
function anyColor(): Effect {
return {
op: 'add_mana',
player: 'you',
mana: { kind: 'any_color', amount: { kind: 'number', value: 1 }, oneColor: false },
}
}
function drawOne(): Effect {
return { op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }
}
function pumpEnchanted(power: number, toughness: number): StaticEffect {
return {
op: 'pump',
target: { kind: 'object', selector: { attached: 'enchanted', types: ['creature'] }, mode: 'each' },
power: { kind: 'number', value: power },
toughness: { kind: 'number', value: toughness },
}
}
function grantEnchanted(keyword: string, value?: string): StaticEffect {
return {
op: 'grant',
target: { kind: 'object', selector: { attached: 'enchanted', types: ['creature'] }, mode: 'each' },
keyword,
...(value ? { value } : {}),
}
}
const tap: Cost = { kind: 'tap' }
const sacrificeSelf: Cost = { kind: 'sacrifice_self' }
const mana = (symbols: string): Cost => ({ kind: 'mana', symbols })
const enchantCreature: Ability = { kind: 'keyword', keyword: 'Enchant', value: 'creature' }
function attackTrigger(effects: Effect[], text: string, condition?: Extract<Ability, { kind: 'triggered' }>['condition']): Ability {
return {
kind: 'triggered',
event: {
kind: 'attacks',
subject: { kind: 'object', selector: { attached: 'enchanted', types: ['creature'] }, mode: 'each' },
},
...(condition ? { condition } : {}),
effects,
optional: false,
text,
}
}
export const PREDEFINED_TOKENS: Record<string, PredefinedToken> = {
treasure: {
name: 'Treasure',
types: ['artifact'],
subtypes: ['treasure'],
colors: [],
abilities: [activated(
[tap, sacrificeSelf],
[anyColor()],
'{T}, Sacrifice this artifact: Add one mana of any color.',
)],
},
food: {
name: 'Food',
types: ['artifact'],
subtypes: ['food'],
colors: [],
abilities: [activated(
[mana('{2}'), tap, sacrificeSelf],
[{ op: 'life', player: 'you', amount: { kind: 'number', value: 3 }, mode: 'gain' }],
'{2}, {T}, Sacrifice this artifact: You gain 3 life.',
)],
},
gold: {
name: 'Gold',
types: ['artifact'],
subtypes: ['gold'],
colors: [],
abilities: [activated(
[sacrificeSelf],
[anyColor()],
'Sacrifice this artifact: Add one mana of any color.',
)],
},
walker: {
name: 'Walker',
types: ['creature'],
subtypes: ['zombie'],
colors: ['B'],
power: 2,
toughness: 2,
},
shard: {
name: 'Shard',
types: ['enchantment'],
subtypes: ['shard'],
colors: [],
abilities: [activated(
[mana('{2}'), sacrificeSelf],
[
{ op: 'scry', player: 'you', amount: { kind: 'number', value: 1 } },
drawOne(),
],
'{2}, Sacrifice this enchantment: Scry 1, then draw a card.',
)],
},
clue: {
name: 'Clue',
types: ['artifact'],
subtypes: ['clue'],
colors: [],
abilities: [activated(
[mana('{2}'), sacrificeSelf],
[drawOne()],
'{2}, Sacrifice this artifact: Draw a card.',
)],
},
blood: {
name: 'Blood',
types: ['artifact'],
subtypes: ['blood'],
colors: [],
abilities: [activated(
[mana('{1}'), tap, { kind: 'discard', amount: { kind: 'number', value: 1 }, player: 'you' }, sacrificeSelf],
[drawOne()],
'{1}, {T}, Discard a card, Sacrifice this artifact: Draw a card.',
)],
},
powerstone: {
name: 'Powerstone',
types: ['artifact'],
subtypes: ['powerstone'],
colors: [],
abilities: [activated(
[tap],
[{
op: 'add_mana',
player: 'you',
// shortcut: the pool does not track restricted mana yet, so this is
// usable for any spell. Upgrade when spell-type mana restrictions matter.
mana: { kind: 'symbols', symbols: ['{C}'], restriction: 'artifact spells' },
}],
'{T}: Add {C}. This mana can\'t be spent to cast a nonartifact spell.',
)],
},
incubator: {
name: 'Incubator',
types: ['artifact'],
subtypes: ['incubator'],
colors: [],
abilities: [activated(
[mana('{2}')],
[{ op: 'transform', target: { kind: 'self' } }],
'{2}: Transform this artifact.',
)],
backFace: {
name: 'Phyrexian',
types: ['artifact', 'creature'],
subtypes: ['phyrexian'],
colors: [],
power: 0,
toughness: 0,
},
},
map: {
name: 'Map',
types: ['artifact'],
subtypes: ['map'],
colors: [],
abilities: [activated(
[mana('{1}'), tap, sacrificeSelf],
[{
op: 'keyword_action',
action: 'explore',
target: { kind: 'object', selector: { types: ['creature'], controller: 'you' }, mode: 'target' },
}],
'{1}, {T}, Sacrifice this artifact: Target creature you control explores. Activate only as a sorcery.',
'sorcery',
)],
},
junk: {
name: 'Junk',
types: ['artifact'],
subtypes: ['junk'],
colors: [],
abilities: [activated(
[tap, sacrificeSelf],
[{ op: 'keyword_action', action: 'impulse' }],
'{T}, Sacrifice this artifact: Exile the top card of your library. You may play that card this turn. Activate only as a sorcery.',
'sorcery',
)],
},
lander: {
name: 'Lander',
types: ['artifact'],
subtypes: ['lander'],
colors: [],
abilities: [activated(
[mana('{2}'), tap, sacrificeSelf],
[{
op: 'search',
player: 'you',
selector: { supertypes: ['basic'], types: ['land'] },
amount: { kind: 'number', value: 1 },
destination: 'battlefield',
tapped: true,
shuffle: true,
}],
'{2}, {T}, Sacrifice this artifact: Search your library for a basic land card, put it onto the battlefield tapped, then shuffle.',
)],
},
mutagen: {
name: 'Mutagen',
types: ['artifact'],
subtypes: ['mutagen'],
colors: [],
abilities: [activated(
[mana('{1}'), tap, sacrificeSelf],
[{
op: 'put_counters',
target: { kind: 'object', selector: { types: ['creature'] }, mode: 'target' },
counter: '+1/+1',
amount: { kind: 'number', value: 1 },
}],
'{1}, {T}, Sacrifice this artifact: Put a +1/+1 counter on target creature. Activate only as a sorcery.',
'sorcery',
)],
},
vibranium: {
name: 'Vibranium',
types: ['artifact'],
subtypes: ['vibranium'],
colors: [],
keywords: ['Indestructible'],
abilities: [activated(
[tap],
[{
op: 'add_mana',
player: 'you',
mana: { kind: 'symbols', symbols: ['{C}'], restriction: 'artifact spells' },
}],
'Indestructible\n{T}: Add {C}. This mana can\'t be spent to cast a nonartifact spell.',
)],
},
heartwood: {
name: 'Heartwood',
types: ['artifact'],
subtypes: ['heartwood'],
colors: ['R', 'G'],
abilities: [activated(
[tap],
[{
op: 'add_mana',
player: 'you',
mana: { kind: 'symbols', symbols: ['{R}', '{G}'], oneOf: true },
}],
'{T}: Add {R} or {G}.',
)],
},
cursed: {
name: 'Cursed Role',
types: ['enchantment'],
subtypes: ['aura', 'role'],
colors: [],
abilities: [
enchantCreature,
{
kind: 'static',
effects: [{
op: 'set_pt',
target: { kind: 'object', selector: { attached: 'enchanted', types: ['creature'] }, mode: 'each' },
power: { kind: 'number', value: 1 },
toughness: { kind: 'number', value: 1 },
base: true,
}],
text: 'Enchanted creature has base power and toughness 1/1.',
},
],
},
monster: {
name: 'Monster Role',
types: ['enchantment'],
subtypes: ['aura', 'role'],
colors: [],
abilities: [
enchantCreature,
{ kind: 'static', effects: [pumpEnchanted(1, 1), grantEnchanted('Trample')], text: 'Enchanted creature gets +1/+1 and has trample.' },
],
},
royal: {
name: 'Royal Role',
types: ['enchantment'],
subtypes: ['aura', 'role'],
colors: [],
abilities: [
enchantCreature,
{ kind: 'static', effects: [pumpEnchanted(1, 1), grantEnchanted('Ward', '{1}')], text: 'Enchanted creature gets +1/+1 and has ward {1}.' },
],
},
sorcerer: {
name: 'Sorcerer Role',
types: ['enchantment'],
subtypes: ['aura', 'role'],
colors: [],
abilities: [
enchantCreature,
{ kind: 'static', effects: [pumpEnchanted(1, 1)], text: 'Enchanted creature gets +1/+1.' },
attackTrigger(
[{ op: 'scry', player: 'you', amount: { kind: 'number', value: 1 } }],
'Whenever enchanted creature attacks, scry 1.',
),
],
},
virtuous: {
name: 'Virtuous Role',
types: ['enchantment'],
subtypes: ['aura', 'role'],
colors: [],
abilities: [
enchantCreature,
{
kind: 'static',
effects: [{
op: 'pump',
target: { kind: 'object', selector: { attached: 'enchanted', types: ['creature'] }, mode: 'each' },
power: { kind: 'count', selector: { types: ['enchantment'], controller: 'you' } },
toughness: { kind: 'count', selector: { types: ['enchantment'], controller: 'you' } },
}],
text: 'Enchanted creature gets +1/+1 for each enchantment you control.',
},
],
},
wicked: {
name: 'Wicked Role',
types: ['enchantment'],
subtypes: ['aura', 'role'],
colors: [],
abilities: [
enchantCreature,
{ kind: 'static', effects: [pumpEnchanted(1, 1)], text: 'Enchanted creature gets +1/+1.' },
{
kind: 'triggered',
// Curse of the Werefox and friends put this in the graveyard; the
// engine only distinguishes "died" for creatures, so any leave triggers it.
event: { kind: 'leaves_battlefield', subject: { kind: 'self' } },
effects: [{ op: 'life', player: 'each_opponent', amount: { kind: 'number', value: 1 }, mode: 'lose' }],
optional: false,
text: 'When this token is put into a graveyard from the battlefield, each opponent loses 1 life.',
},
],
},
'young hero': {
name: 'Young Hero Role',
types: ['enchantment'],
subtypes: ['aura', 'role'],
colors: [],
abilities: [
enchantCreature,
attackTrigger(
[{
op: 'put_counters',
target: { kind: 'trigger_subject' },
counter: '+1/+1',
amount: { kind: 'number', value: 1 },
}],
'Whenever enchanted creature attacks, if its toughness is 3 or less, put a +1/+1 counter on it.',
{ kind: 'event_subject_toughness_at_most', amount: 3 },
),
],
},
}
/** Finds a predefined token by subtype or name, including "Cursed Role". */
export function predefinedToken(spec: { name?: string; subtypes: string[] }): PredefinedToken | undefined {
const words = spec.subtypes.map(word => word.toLowerCase())
const roleIndex = words.indexOf('role')
const candidates = roleIndex >= 0 ? [words.slice(0, roleIndex).join(' ')] : []
candidates.push(...words)
for (const candidate of candidates) {
const token = PREDEFINED_TOKENS[candidate]
if (token) return token
}
if (spec.name) {
const name = spec.name.toLowerCase()
return PREDEFINED_TOKENS[name] ?? PREDEFINED_TOKENS[name.replace(/\s+role$/, '')]
}
return undefined
}

View File

@@ -1,6 +1,6 @@
// The runtime game model. Card definitions are immutable input; objects are the
// per-game instances that move between zones.
import type { Ability, Effect, ObjectSelector, TokenSpec, Zone } from '../effects/types.js'
import type { Ability, Cost, Effect, ObjectSelector, TokenSpec, Zone } from '../effects/types.js'
export type ManaColor = 'W' | 'U' | 'B' | 'R' | 'G' | 'C'
export type ManaPool = Record<ManaColor, number>
@@ -38,6 +38,17 @@ export interface GameConfig {
firstPlayer?: string
/** Enables command-zone casting, commander tax, and commander damage. */
commander?: boolean
/** Waits for every player to keep an opening hand before turn 1. */
mulligans?: boolean
}
/** One player's opening-hand choice while the game is in its mulligan step. */
export interface MulliganState {
/** Mulligans taken so far. */
count: number
kept: boolean
/** Cards still to put on the bottom of the library. */
bottom: number
}
export interface PlayerState {
@@ -64,6 +75,8 @@ export interface PlayerState {
creaturesDiedThisTurn: number
nonlandPermanentsEnteredThisTurn: number
attackedThisTurn: boolean
creaturesAttackedThisTurn: number
damageTakenThisTurn: number
energy: number
poison: number
}
@@ -81,6 +94,10 @@ export interface GameObject {
counters: Record<string, number>
isToken: boolean
token?: TokenSpec
/** Back face of a double-faced token (Incubator); transform swaps it in. */
backFace?: CardDefinition
/** Set by impulse effects; the card may be played from exile this turn. */
playableFromExileTurn?: number
isCommander?: boolean
enteredTurn: number
/** Normalized center on the controller's mat; absent means auto-arranged. */
@@ -90,6 +107,12 @@ export interface GameObject {
blocking?: string
attachments: string[]
attachedTo?: string
/** Cards exiled with this object, such as a card hidden by hideaway. */
linkedExile?: string[]
/** Exiled face down (hideaway); its identity is hidden from every view. */
faceDown?: boolean
/** Creature type chosen as this permanent entered (Cavern of Souls). */
chosenCreatureType?: string
regenerationShields: number
activations: Record<number, number>
}
@@ -118,6 +141,9 @@ export interface ActionOptions {
targets?: TargetChoice[]
x?: number
mode?: number
overload?: boolean
/** Color chosen for a mana ability that can produce more than one. */
manaColor?: ManaColor
}
/** A search that is waiting for its player to pick one of several matching cards. */
@@ -129,6 +155,21 @@ export interface PendingSearch {
tapped: boolean
shuffle: boolean
zones?: ('library' | 'graveyard')[]
/** Where the picks after the first one go (Cultivate-style searches). */
split?: { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean }
}
/** A pause such as "as this enters..." or a hideaway look. Blocks all actions until its controller picks. */
export interface PendingChoice {
playerId: string
sourceId: string
what: 'creature_type' | 'pay_cost' | 'hideaway'
/** Cost to pay to avoid entering tapped. */
cost?: Cost
/** Life total to display for a `pay_life` cost. */
amount?: number
/** Cards to choose from for `hideaway`. */
cardIds?: string[]
}
export interface CombatAttack {

View File

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

View File

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

View File

@@ -84,6 +84,46 @@ Deck
assert.match(result.errors.join(' '), /exactly 100/)
})
test('a commander identity mana source only offers colors in the identity', () => {
const game = new Game({
seed: 1,
startingHandSize: 0,
commander: true,
players: [
{ id: 'p1', deck: [basicLand('Forest')], commander: commanderDefinition('Test Commander', { colors: ['U', 'R'], colorIdentity: ['U', 'R'] }) },
{ id: 'p2', deck: [basicLand('Forest')], commander: commanderDefinition('Other Commander') },
],
})
game.start()
const tower = game.addCard('p1', {
oracleId: 'command-tower',
name: 'Command Tower',
typeLine: 'Land',
abilities: [{
kind: 'activated',
costs: [{ kind: 'tap' }],
effects: [{
op: 'add_mana',
player: 'you',
mana: {
kind: 'any_color',
amount: { kind: 'number', value: 1 },
oneColor: false,
restriction: "commander's color identity",
},
}],
optional: false,
text: "{T}: Add one mana of any color in your commander's color identity.",
}],
}, 'battlefield')
assert.deepEqual(game.manaColorChoices(tower, 0), ['U', 'R'])
assert.throws(() => game.activateAbility('p1', tower.id, 0, { manaColor: 'G' }), /cannot produce/)
assert.equal(tower.tapped, false)
game.activateAbility('p1', tower.id, 0, { manaColor: 'R' })
assert.equal(game.getPlayer('p1').manaPool.R, 1)
})
test('a commander starts in the command zone, pays tax, and returns there from the graveyard', () => {
const commander = commanderDefinition('Test Commander')
const game = new Game({
@@ -91,8 +131,8 @@ test('a commander starts in the command zone, pays tax, and returns there from t
startingHandSize: 0,
commander: true,
players: [
{ id: 'p1', deck: [], commander },
{ id: 'p2', deck: [], commander: commanderDefinition('Other Commander') },
{ id: 'p1', deck: [basicLand('Forest')], commander },
{ id: 'p2', deck: [basicLand('Forest')], commander: commanderDefinition('Other Commander') },
],
})
game.start()
@@ -138,8 +178,8 @@ test('twenty-one commander damage loses the game', () => {
startingHandSize: 0,
commander: true,
players: [
{ id: 'p1', deck: [], commander },
{ id: 'p2', deck: [], commander: commanderDefinition('Other Commander') },
{ id: 'p1', deck: [basicLand('Forest')], commander },
{ id: 'p2', deck: [basicLand('Forest')], commander: commanderDefinition('Other Commander') },
],
})
game.start()

View File

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict'
import test from 'node:test'
import { compileText } from '../src/effects/compile.js'
import { formatAbility } from '../src/effects/format.js'
import { parsePseudoCard } from '../src/effects/pseudo.js'
import { parseCardSource } from '../src/effects/source.js'
import type { Ability, Effect, Target } from '../src/effects/types.js'
function creature(text: string, keywords: string[] = []): Ability[] {
@@ -41,6 +41,33 @@ test('activated mana ability', () => {
})
})
test('"or" in a mana ability marks the symbols as a choice', () => {
const [ability] = creature('{T}: Add {G} or {U}.')
assert.equal(ability.kind, 'activated')
if (ability.kind !== 'activated') return
assert.deepEqual(ability.effects[0], {
op: 'add_mana',
player: 'you',
mana: { kind: 'symbols', symbols: ['{G}', '{U}'], oneOf: true },
})
})
test('paying life to enter untapped compiles to an enters-tapped replacement', () => {
const [ability] = compileText(
"As this land enters, you may pay 2 life. If you don't, it enters tapped.",
'Steam Vents',
[],
'Land — Island Mountain',
)
assert.equal(ability.kind, 'static')
if (ability.kind !== 'static') return
assert.deepEqual(ability.effects[0], {
op: 'enters_tapped',
target: { kind: 'self' },
unlessCost: { kind: 'pay_life', amount: { kind: 'number', value: 2 } },
})
})
test('search effect keeps destination, tapped, and shuffle', () => {
const [ability] = spell('Search your library for a basic land card, put it onto the battlefield tapped, then shuffle.')
assert.equal(ability.kind, 'spell')
@@ -56,6 +83,62 @@ test('search effect keeps destination, tapped, and shuffle', () => {
})
})
test('search can put the chosen card on top of the library', () => {
const [ability] = spell('Search your library for a creature card, reveal it, then shuffle and put the card on top.')
assert.equal(ability.kind, 'spell')
if (ability.kind !== 'spell') return
assert.deepEqual(ability.effects[0], {
op: 'search',
player: 'you',
selector: { types: ['creature'] },
amount: { kind: 'number', value: 1 },
destination: 'top',
tapped: false,
shuffle: true,
})
})
test('a two-card search can split between the battlefield and hand', () => {
const [ability] = spell('Search your library for up to two basic land cards, reveal those cards, put one onto the battlefield tapped and the other into your hand, then shuffle.')
assert.equal(ability.kind, 'spell')
if (ability.kind !== 'spell') return
assert.deepEqual(ability.effects[0], {
op: 'search',
player: 'you',
selector: { types: ['land'], supertypes: ['basic'] },
amount: { kind: 'number', value: 2 },
destination: 'battlefield',
tapped: true,
shuffle: true,
split: { destination: 'hand', tapped: false },
})
})
test('"if you search your library this way, shuffle" keeps the search', () => {
const [ability] = spell('Search your library for a card named Sol Ring, reveal it, and put it into your hand. If you search your library this way, shuffle.')
assert.equal(ability.kind, 'spell')
if (ability.kind !== 'spell') return
assert.deepEqual(ability.effects[0], {
op: 'search',
player: 'you',
selector: { name: 'sol ring', types: [] },
amount: { kind: 'number', value: 1 },
destination: 'hand',
tapped: false,
shuffle: true,
})
})
test('search selectors support an exact mana value', () => {
const [ability] = spell('Search your library for an artifact card with mana value 3, reveal it, put it into your hand, then shuffle.')
assert.equal(ability.kind, 'spell')
if (ability.kind !== 'spell') return
const effect = ability.effects[0]
assert.equal(effect.op, 'search')
if (effect.op !== 'search') return
assert.deepEqual(effect.selector, { types: ['artifact'], manaValue: { atLeast: 3, atMost: 3 } })
})
test('"it" refers to the triggering object when unambiguous', () => {
const [ability] = creature('Whenever another creature enters, put a +1/+1 counter on it.')
assert.equal(ability.kind, 'triggered')
@@ -92,6 +175,24 @@ test('static anthem', () => {
assert.equal(target.selector.controller, 'you')
})
test('negative colors become an excluded color filter', () => {
const [ability] = spell('Destroy target nonblack creature.')
assert.equal(ability.kind, 'spell')
if (ability.kind !== 'spell') return
assert.deepEqual(ability.effects[0], {
op: 'destroy',
target: {
kind: 'object',
selector: { types: ['creature'], excludeColors: ['B'] },
mode: 'target',
},
})
const source = formatAbility(ability)
assert.match(source, /withoutColor\('black'\)/)
assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source)
})
test('enters-with-counters is a static replacement effect', () => {
const [ability] = creature('This creature enters with X +1/+1 counters on it.')
assert.equal(ability.kind, 'static')
@@ -113,10 +214,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\)/)
})
@@ -145,7 +246,40 @@ 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('token-doubling replacement lines compile and round-trip', () => {
const cases: Array<[string, object]> = [
[
'If an effect would create one or more tokens under your control, it creates twice that many of those tokens instead.',
{ op: 'token_multiplier', multiplier: 2, who: 'you' },
],
[
'If one or more tokens would be created under your control, twice that many of those tokens are created instead.',
{ op: 'token_multiplier', multiplier: 2, who: 'you' },
],
[
'If one or more tokens would be created, twice that many of those tokens are created instead.',
{ op: 'token_multiplier', multiplier: 2, who: 'each_player' },
],
[
'If one or more creature tokens would be created under your control, three times that many of those tokens are created instead.',
{ op: 'token_multiplier', multiplier: 3, who: 'you', creatureOnly: true },
],
]
for (const [text, expected] of cases) {
const [ability] = creature(text)
assert.equal(ability.kind, 'static')
if (ability.kind !== 'static') return
assert.deepEqual(ability.effects[0], expected)
const source = formatAbility(ability)
assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source)
}
})
test('all effects are typed', () => {
@@ -243,9 +377,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)
}
})
@@ -259,7 +393,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
@@ -268,9 +402,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')
@@ -283,6 +417,53 @@ test('counter-removal costs parse and round-trip through pseudocode', () => {
}])
})
test('hideaway lands exile a card and gate playing it on their condition', () => {
const lands: Array<[string, string, string]> = [
["Clive's Hideaway", `Hideaway 4 (When this land enters, look at the top four cards of your library, exile one face down, then put the rest on the bottom in a random order.)
{T}: Add {C}.
{2}, {T}: You may play the exiled card without paying its mana cost if you control four or more legendary creatures.`, 'you_control'],
['Howltooth Hollow', `Hideaway 4 (When this land enters, look at the top four cards of your library, exile one face down, then put the rest on the bottom in a random order.)
This land enters tapped.
{T}: Add {B}.
{B}, {T}: You may play the exiled card without paying its mana cost if each player has no cards in hand.`, 'cards_in_hand_at_most'],
['Mosswort Bridge', `Hideaway 4 (When this land enters, look at the top four cards of your library, exile one face down, then put the rest on the bottom in a random order.)
This land enters tapped.
{T}: Add {G}.
{G}, {T}: You may play the exiled card without paying its mana cost if creatures you control have total power 10 or greater.`, 'total_power'],
['Shelldock Isle', `Hideaway 4 (When this land enters, look at the top four cards of your library, exile one face down, then put the rest on the bottom in a random order.)
This land enters tapped.
{T}: Add {U}.
{U}, {T}: You may play the exiled card without paying its mana cost if a library has twenty or fewer cards in it.`, 'library_at_most'],
['Spinerock Knoll', `Hideaway 4 (When this land enters, look at the top four cards of your library, exile one face down, then put the rest on the bottom in a random order.)
This land enters tapped.
{T}: Add {R}.
{R}, {T}: You may play the exiled card without paying its mana cost if an opponent was dealt 7 or more damage this turn.`, 'opponent_damaged_this_turn'],
['Windbrisk Heights', `Hideaway 4 (When this land enters, look at the top four cards of your library, exile one face down, then put the rest on the bottom in a random order.)
This land enters tapped.
{T}: Add {W}.
{W}, {T}: You may play the exiled card without paying its mana cost if you attacked with three or more creatures this turn.`, 'attacked_with_creatures'],
]
for (const [name, text, condition] of lands) {
const abilities = compileText(text, name, [], 'Land')
assert.equal(abilities.filter(ability => ability.kind === 'unsupported').length, 0, name)
const hideaway = abilities.find(ability => ability.kind === 'triggered' && ability.effects.some(effect => effect.op === 'hideaway'))
assert.equal(hideaway?.kind, 'triggered', name)
if (hideaway?.kind !== 'triggered') continue
assert.deepEqual(hideaway.effects, [{ op: 'hideaway', amount: { kind: 'number', value: 4 } }], name)
const activated = abilities.at(-1)
assert.equal(activated?.kind, 'activated', name)
if (activated?.kind !== 'activated') continue
const [effect] = activated.effects
assert.equal(effect.op, 'conditional', name)
if (effect.op !== 'conditional') continue
assert.equal(effect.condition.kind, condition, name)
assert.deepEqual(effect.effects, [{ op: 'play_exiled', player: 'you', free: true }], name)
}
})
test('a trigger returns its own card from the graveyard', () => {
const [ability] = creature('When this dies, return this from your graveyard to the battlefield with a finality counter on it.')
assert.equal(ability.kind, 'triggered')
@@ -295,3 +476,173 @@ test('a trigger returns its own card from the graveyard', () => {
counters: { counter: 'finality', amount: { kind: 'number', value: 1 } },
}])
})
test('Commander-batch oracle lines compile to dedicated nodes', () => {
const [free] = spell('If you control a commander, you may cast this without paying its mana cost.')
assert.equal(free.kind, 'alternative_cost')
if (free.kind !== 'alternative_cost') return
assert.deepEqual(free.condition, { kind: 'you_control_commander' })
assert.deepEqual(free.costs, [])
const [overload] = spell('Overload {6}{U}')
assert.deepEqual(overload, { kind: 'overload', cost: '{6}{U}', text: 'Overload {6}{U}' })
const [graves] = creature('When this enters, exile all graveyards.')
assert.equal(graves.kind, 'triggered')
if (graves.kind !== 'triggered') return
assert.deepEqual(graves.effects, [{ op: 'exile_graveyards' }])
const [rest] = creature('If a card or token would be put into a graveyard from anywhere, exile it instead.')
assert.equal(rest.kind, 'static')
if (rest.kind !== 'static') return
assert.deepEqual(rest.effects, [{ op: 'exile_instead_of_graveyard' }])
const [leyline] = creature("If a card would be put into an opponent's graveyard from anywhere, exile it instead.")
assert.equal(leyline.kind, 'static')
if (leyline.kind !== 'static') return
assert.deepEqual(leyline.effects, [{ op: 'exile_instead_of_graveyard', owner: 'opponent' }])
const [thalia] = creature('Noncreature spells cost {1} more to cast.')
assert.equal(thalia.kind, 'static')
if (thalia.kind !== 'static') return
assert.deepEqual(thalia.effects, [{
op: 'cost_increase',
amount: { kind: 'number', value: 1 },
spellType: 'noncreature',
}])
const [linvala] = creature("Activated abilities of creatures your opponents control can't be activated.")
assert.equal(linvala.kind, 'static')
if (linvala.kind !== 'static') return
assert.deepEqual(linvala.effects, [{
op: 'restriction',
target: { kind: 'object', selector: { controller: 'opponent', types: ['creature'] }, mode: 'each' },
rule: 'cant_activate',
}])
const [aven] = creature('If an opponent would search a library, that player searches the top four cards of that library instead.')
assert.equal(aven.kind, 'static')
if (aven.kind !== 'static') return
assert.deepEqual(aven.effects, [{
op: 'search_restriction',
who: 'opponent',
amount: { kind: 'number', value: 4 },
}])
const [field] = compileText(
'Whenever this or another land you control enters, if you control seven or more lands with different names, create a 2/2 black Zombie creature token.',
'Field of the Dead',
[],
'Land',
)
assert.equal(field.kind, 'triggered')
if (field.kind !== 'triggered') return
assert.deepEqual(field.condition, {
kind: 'distinct_names',
selector: { types: ['land'] },
atLeast: 7,
})
})
test('spell cost reductions compile their conditions and mana symbols', () => {
const [bears] = creature('Creature spells you cast cost {1} less to cast.')
assert.equal(bears.kind, 'static')
if (bears.kind !== 'static') return
assert.deepEqual(bears.effects, [{
op: 'cost_reduction',
target: {
kind: 'object',
selector: { controller: 'you', types: ['creature'] },
mode: 'each',
},
amount: { kind: 'number', value: 1 },
}])
const [cantrips] = creature('Instant and sorcery spells cost {2} less to cast.')
assert.equal(cantrips.kind, 'static')
if (cantrips.kind !== 'static') return
assert.deepEqual(cantrips.effects, [{
op: 'cost_reduction',
target: {
kind: 'object',
selector: { match: 'any', types: ['instant', 'sorcery'] },
mode: 'each',
},
amount: { kind: 'number', value: 2 },
}])
const [legendary] = creature('Legendary spells you cast cost {R}{G} less to cast. This effect reduces only the amount of colored mana you pay.')
assert.equal(legendary.kind, 'static')
if (legendary.kind !== 'static') return
assert.deepEqual(legendary.effects, [{
op: 'cost_reduction',
target: {
kind: 'object',
selector: { controller: 'you', supertypes: ['legendary'], types: [] },
mode: 'each',
},
symbols: '{R}{G}',
}])
const [tribal] = creature("Each spell you cast that's a Demon, Horror, or Nightmare costs {1} less to cast.")
assert.equal(tribal.kind, 'static')
if (tribal.kind !== 'static') return
assert.deepEqual(tribal.effects, [{
op: 'cost_reduction',
target: {
kind: 'object',
selector: { controller: 'you', match: 'any', subtypes: ['demon', 'horror', 'nightmare'], types: [] },
mode: 'each',
},
amount: { kind: 'number', value: 1 },
}])
})
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}'),
...creature('When this enters, exile all graveyards.'),
...creature('If a card or token would be put into a graveyard from anywhere, exile it instead.'),
...creature("If a card would be put into an opponent's graveyard from anywhere, exile it instead."),
...creature('Noncreature spells cost {1} more to cast.'),
...creature('Creature spells you cast cost {1} less to cast.'),
...creature('Legendary spells you cast cost {R}{G} less to cast.'),
...creature("Each spell you cast that's a Demon, Horror, or Nightmare costs {1} less to cast."),
...creature("Activated abilities of creatures your opponents control can't be activated."),
...creature('If an opponent would search a library, that player searches the top four cards of that library instead.'),
...compileText(
'Whenever this or another land you control enters, if you control seven or more lands with different names, create a 2/2 black Zombie creature token.',
'Field of the Dead',
[],
'Land',
),
]
for (const ability of abilities) {
const source = formatAbility(ability)
const reparsed = parseCardSource(`export default [${source}]`).abilities[0]
assert.ok(reparsed)
assert.equal(formatAbility(reparsed), source)
}
})
test('Role token creation compiles with the attachment target', () => {
for (const role of ['Cursed', 'Monster', 'Royal', 'Sorcerer', 'Virtuous', 'Wicked', 'Young Hero']) {
const [ability] = spell(`Create a ${role} Role token attached to target creature you control.`)
assert.equal(ability.kind, 'spell')
if (ability.kind !== 'spell') return
const effect = ability.effects[0]
assert.equal(effect.op, 'create_token')
if (effect.op !== 'create_token') return
assert.equal(effect.token.name, role)
assert.deepEqual(effect.token.subtypes, ['aura', 'role'])
assert.deepEqual(effect.attachTo, {
kind: 'object',
selector: { controller: 'you', types: ['creature'] },
mode: 'target',
})
const source = formatAbility(ability)
assert.equal(formatAbility(parseCardSource(`export default [${source}]`).abilities[0]), source)
}
})

File diff suppressed because it is too large Load Diff

View File

@@ -1,92 +0,0 @@
import assert from 'node:assert/strict'
import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import test from 'node:test'
import type { Card } from '../src/cards.js'
import { formatCard } from '../src/effects/format.js'
import {
compileImplementation,
deleteOverride,
readAllOverrides,
readOverride,
writeOverride,
} from '../src/effects/implementations.js'
import { parsePseudoCard, PseudoParseError } from '../src/effects/pseudo.js'
const CARD: Card = {
oracle_id: '00000000-0000-4000-8000-000000000001',
name: 'Test Card',
layout: 'normal',
cmc: 1,
type_line: 'Creature — Human',
colors: [],
color_identity: [],
keywords: [],
}
const SOURCE = `on enters(this):
choose 1:
1. exile(target other creature you own); schedule(next_end_step):
return_to_battlefield(the chosen target)
static:
grant_ability(each enchanted land):
on upkeep(you) (may):
pay({W}{W})
if you do:
gain_life(you, 1)`
test('pseudocode round-trips through the compiler and formatter', () => {
const compiled = compileImplementation(CARD, SOURCE)
assert.equal(compiled.manual, true)
assert.equal(compiled.status, 'supported')
const rendered = formatCard(compiled)
const reparsed = compileImplementation(CARD, rendered)
assert.equal(formatCard(reparsed), rendered)
assert.equal(reparsed.abilities.length, 2)
const [triggered] = reparsed.abilities
assert.equal(triggered.kind, 'triggered')
if (triggered.kind !== 'triggered') return
assert.equal(triggered.effects[0].op, 'modal')
if (triggered.effects[0].op !== 'modal') return
assert.equal(triggered.effects[0].modes[0][1].op, 'schedule')
const staticAbility = reparsed.abilities[1]
assert.equal(staticAbility.kind, 'static')
if (staticAbility.kind !== 'static') return
assert.equal(staticAbility.effects[0].op, 'grant_ability')
if (staticAbility.effects[0].op !== 'grant_ability') return
assert.equal(staticAbility.effects[0].ability.kind, 'triggered')
})
test('invalid pseudocode reports its line', () => {
assert.throws(
() => parsePseudoCard('spell:\n draw(you)'),
(error: unknown) => error instanceof PseudoParseError && error.line === 2,
)
})
test('manual implementations persist one file per card', async (t) => {
const dir = await mkdtemp(join(tmpdir(), 'commander-overrides-'))
const previous = process.env.CARD_OVERRIDES_DIR
process.env.CARD_OVERRIDES_DIR = dir
t.after(async () => {
if (previous === undefined) delete process.env.CARD_OVERRIDES_DIR
else process.env.CARD_OVERRIDES_DIR = previous
await rm(dir, { recursive: true, force: true })
})
await writeOverride(CARD.oracle_id, SOURCE)
const stored = await readOverride(CARD.oracle_id)
assert.equal(stored?.source, `${SOURCE}\n`)
assert.equal((await readAllOverrides()).get(CARD.oracle_id), `${SOURCE}\n`)
const compiled = compileImplementation(CARD, stored!.source)
assert.equal(compiled.manual, true)
assert.equal(compiled.status, 'supported')
await deleteOverride(CARD.oracle_id)
assert.equal(await readOverride(CARD.oracle_id), undefined)
})

View File

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

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

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

View File

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

View File

@@ -298,11 +298,14 @@ button.danger {
}
.badge {
font-size: 0.7rem;
flex: none;
font-size: 0.62rem;
line-height: 1.2;
text-transform: uppercase;
letter-spacing: 0.03em;
letter-spacing: 0.02em;
white-space: nowrap;
border-radius: 99px;
padding: 0.1rem 0.45rem;
padding: 0.04rem 0.35rem;
border: 1px solid currentColor;
color: var(--muted);
}
@@ -319,7 +322,7 @@ button.danger {
color: var(--bad);
}
.badge.manual {
.badge.verified {
color: var(--accent);
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,212 +0,0 @@
<template>
<section class="pseudo-guide">
<header class="guide-head">
<h2>Card pseudocode guide</h2>
<p class="muted">
The editor and the compiler use the same two-way format. The
<strong>Visual</strong> tab is a node canvas: drag sockets to connect an ability to its
effects, and drag green value nodes (players, targets, selectors, costs) into argument
sockets. Selector <strong>OR</strong>/<strong>AND</strong> nodes can combine two selector
slots. It writes the same source as the text editor. Use <strong>Draft with AI</strong> for
a first pass, then review and save.
</p>
</header>
<article>
<h3>Shape</h3>
<p>
One ability per block. The header starts at column 0 and ends with a colon; effects are
indented two spaces, one call per line. A leading <code># Card [status]</code> line is
optional and ignored. Multi-face cards use <code>## Face Name [status]</code> sections in
card order. Use <code>(no abilities)</code> for an empty face.
</p>
<pre># Soul Warden [supported]
on enters(each other creature):
gain_life(you, 1)
# Llanowar Elves [supported]
activate {T}:
add_mana(you, {G})</pre>
</article>
<article>
<h3>Ability blocks</h3>
<table>
<thead>
<tr><th>Header</th><th>Example</th></tr>
</thead>
<tbody>
<tr><td><code>on &lt;trigger&gt;:</code></td><td><code>on dies(this):</code></td></tr>
<tr><td><code>activate &lt;cost&gt;:</code></td><td><code>activate {2}, {T}:</code></td></tr>
<tr><td><code>static:</code></td><td><code>static:</code></td></tr>
<tr><td><code>spell:</code></td><td>An instant or sorcery effect line.</td></tr>
<tr><td><code>keyword &lt;name&gt;</code></td><td><code>keyword Flying</code></td></tr>
<tr><td><code>keywords &lt;a&gt;, &lt;b&gt;</code></td><td><code>keywords Flying, vigilance</code></td></tr>
<tr><td><code>additional cost: &lt;cost&gt;</code></td><td><code>additional cost: pay 2 life</code></td></tr>
<tr><td><code>if &lt;condition&gt;:</code></td><td>Nested effects, indented below.</td></tr>
<tr><td><code>choose &lt;n&gt;:</code></td><td>Numbered modes <code>1.</code>, <code>2.</code></td></tr>
<tr><td><code>schedule(next_upkeep):</code></td><td>Delayed effects.</td></tr>
</tbody>
</table>
</article>
<article>
<h3>Effect calls</h3>
<p>Effects are lowercase calls. Separate several on one line with <code>;</code>.</p>
<pre>damage(target creature, 3)
draw(you, 2)
gain_life(you, 1)
create_token(you, 1, 1/1 red goblin creature)
put_counters(target creature, +1/+1, 2)
destroy(target creature)
exile(target artifact you control)
add_mana(you, {G}{G})
search(you, creature, 1, to hand, shuffle)
scry(you, 2)
pump(each creature you control, 1/1, until end of turn)</pre>
</article>
<article>
<h3>Targets, values and costs</h3>
<table>
<tbody>
<tr>
<th>Targets</th>
<td><code>this</code>, <code>the triggering object</code>, <code>target creature</code>, <code>each opponent</code>, <code>up to 2 target creatures</code>, <code>any target</code></td>
</tr>
<tr>
<th>Selectors</th>
<td><code>other tapped creature you control</code>, <code>red instant from a graveyard</code>, <code>creature with power 4 or greater</code></td>
</tr>
<tr>
<th>Values</th>
<td><code>2</code>, <code>X</code>, <code>count(creature you control)</code>, <code>its power</code>, <code>that much</code></td>
</tr>
<tr>
<th>Costs</th>
<td><code>{2}{U}</code>, <code>{T}</code>, <code>pay 3 life</code>, <code>discard 1 card(s)</code>, <code>sacrifice this</code>, <code>remove 1 +1/+1 counter(s) from this</code></td>
</tr>
<tr>
<th>Durations</th>
<td><code>until end of turn</code>, <code>until your next turn</code>, <code>until the end of your next turn</code>, <code>for as long as this remains on the battlefield</code></td>
</tr>
</tbody>
</table>
</article>
<article>
<h3>Triggers, conditions and modes</h3>
<pre>on attacks(this):
create_token(you, 1, tapped 1/1 red goblin creature)
on upkeep(you):
if you control at least 3 artifacts:
draw(you, 1)
spell:
choose 1:
1. draw(you, 2)
2. gain_life(you, 3)
static:
grant(each creature you control, Flying)</pre>
<p class="muted">
Common triggers: <code>enters</code>, <code>dies</code>, <code>attacks</code>,
<code>upkeep</code>, <code>end_step</code>, <code>cast</code>,
<code>deals_damage</code>. Always check the generated line after saving.
</p>
</article>
<article>
<h3>When the syntax cannot express it</h3>
<p>
Never guess a wrong effect. Use the preserved form and leave the line unsupported:
</p>
<pre>unsupported (modal bullet outside a choose block): Choose one — ...</pre>
<p class="muted">
The full reference lives in <code>backend/docs/card-effects.md</code>.
</p>
</article>
</section>
</template>
<style scoped>
.pseudo-guide {
flex: 1;
min-height: 0;
overflow-y: auto;
background: var(--panel);
border: 1px solid var(--line);
border-radius: 8px;
padding: 1rem 1.25rem;
display: flex;
flex-direction: column;
gap: 1.25rem;
}
.guide-head {
display: flex;
flex-direction: column;
gap: 0.25rem;
}
h3 {
margin-bottom: 0.4rem;
}
p {
line-height: 1.5;
font-size: 0.9rem;
}
code {
font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
font-size: 0.85em;
background: #11151d;
border: 1px solid var(--line);
border-radius: 4px;
padding: 0.05rem 0.3rem;
}
pre {
margin: 0.5rem 0 0;
padding: 0.65rem 0.8rem;
background: #11151d;
border: 1px solid var(--line);
border-radius: 6px;
overflow-x: auto;
font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
font-size: 0.82rem;
line-height: 1.5;
}
table {
border-collapse: collapse;
width: 100%;
font-size: 0.85rem;
}
th,
td {
border-bottom: 1px solid var(--line);
padding: 0.35rem 0.5rem;
text-align: left;
vertical-align: top;
}
th {
white-space: nowrap;
color: var(--muted);
font-weight: 600;
}
tbody th {
width: 7rem;
}
@media (max-width: 800px) {
tbody th {
width: auto;
}
}
</style>

View File

@@ -0,0 +1,227 @@
<template>
<section class="source-guide">
<header class="guide-head">
<h2>Card source guide</h2>
<p class="muted">
Implementations are a small, literal JavaScript expression that the backend evaluates with
its own safe interpreter. It is never run as JavaScript: only the names below exist. The
editor and the compiler use the same two-way format. Use <strong>Draft with AI</strong> for
a first pass, then review and save.
</p>
</header>
<article>
<h3>Shape</h3>
<p>
Export the card's type line and an array of abilities with
<code>card(typeLine, [...])</code>. A leading <code>// Card [status]</code> comment is
optional and ignored. Multi-face cards export
<code>faces(face('Name', 'Type line', [...]), ...)</code> in card order.
</p>
<pre>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}')),
]),
])
export default faces(
face('Front', 'Instant', [spell([draw(you, 2)])]),
face('Back', 'Creature — Human', [keyword('Flying')]),
)</pre>
<p class="muted">
Plain <code>export default [...]</code> is still accepted and uses the Scryfall type line.
Effect lists also accept callbacks: <code>() =&gt; draw(you, 1)</code> for one effect,
or <code>() =&gt; { draw(you, 1); gainLife(you, 1) }</code> for several. Arrays remain
valid; the formatter emits callbacks.
</p>
</article>
<article>
<h3>Abilities</h3>
<table>
<thead>
<tr><th>Call</th><th>Example</th></tr>
</thead>
<tbody>
<tr><td><code>triggered(event, [effects], options)</code></td><td><code>triggered(when.dies(self), [draw(you, 1)])</code></td></tr>
<tr><td><code>activated([costs], [effects], options)</code></td><td><code>activated([manaCost('{2}'), tapCost()], [...])</code></td></tr>
<tr><td><code>staticAbility([effects], options)</code></td><td><code>staticAbility([staticPump(each(creatures.youControl()), 1, 1)])</code></td></tr>
<tr><td><code>spell([effects], options)</code></td><td>An instant or sorcery.</td></tr>
<tr><td><code>keyword(name, value)</code></td><td><code>keyword('Ward', '{2}')</code></td></tr>
<tr><td><code>keywords(...names)</code></td><td><code>keywords('Flying', 'Trample')</code></td></tr>
<tr><td><code>additionalCost([costs])</code></td><td><code>additionalCost([payLife(2)])</code></td></tr>
<tr><td><code>chapter(['I', 'II'], [effects])</code></td><td>Saga chapters.</td></tr>
<tr><td><code>unsupported(reason, text)</code></td><td>Preserve the oracle text when it cannot be expressed.</td></tr>
</tbody>
</table>
<p class="muted">
Options include <code>{ condition, optional }</code>; activated abilities also accept
<code>timing: 'sorcery'</code> and <code>activationsPerTurn</code>.
</p>
</article>
<article>
<h3>Selectors and targets</h3>
<p>
Start from <code>permanents</code>, <code>cards</code> or <code>creatures</code> and chain
filters: <code>withType</code>, <code>withSubtype</code>, <code>withSupertype</code>,
<code>withColor</code>, <code>withKeyword</code>, <code>youControl</code>,
<code>other</code>, <code>tapped</code>, <code>token</code>, <code>powerAtLeast</code>,
<code>manaValueAtMost</code>, <code>named</code>, <code>inZone</code>.
</p>
<pre>target(permanents.withType('creature').other().youControl())
each(creatures.withColor('red').withKeyword('flying'))
pick(cards.withType('land'), { upTo: 2 })
targetSpell(permanents.withType('instant'))
divided(3, creatures.attacking())
self, triggerSubject, previousTarget, anyTarget, targetPlayerOrPlaneswalker</pre>
<p class="muted">
Values: numbers, <code>X</code>, <code>itsPower</code>, <code>itsToughness</code>,
<code>count(selector)</code>, <code>cardsInHand(you)</code>,
<code>totalPower(selector)</code>, <code>eventAmount()</code>.
</p>
</article>
<article>
<h3>Effects and costs</h3>
<pre>damage(target(creature), 3)
draw(you, 2)
gainLife(you, 1)
createToken(you, 1, token({ types: ['creature'], subtypes: ['goblin'], colors: ['red'], power: 1, toughness: 1 }))
putCounters(target(creature), '+1/+1', 2)
destroy(target(creature))
addMana(you, mana('{G}{G}'))
search(you, cards.withType('creature'), 1, { destination: 'battlefield', shuffle: true })
pump(each(creatures.youControl()), 1, 1, untilEndOfTurn)
ifThen(youControl(permanents.withType('artifact'), 3), [draw(you, 1)])
modal(1, 1, [[draw(you, 2)], [gainLife(you, 3)]])</pre>
<p>
Costs are separate: <code>manaCost('{2}{U}')</code>, <code>tapCost()</code>,
<code>sacrificeSelf()</code>, <code>payLife(3)</code>,
<code>discardCost(1)</code>, <code>removeCountersCost('+1/+1', 1)</code>.
</p>
<p class="muted">
Durations: <code>permanent</code>, <code>untilEndOfTurn</code>,
<code>untilYourNextTurn</code>, <code>untilEndOfYourNextTurn</code>,
<code>untilEndOfCombat</code>, <code>whileSourceOnBattlefield</code>.
</p>
</article>
<article>
<h3>Triggers, statics and conditions</h3>
<pre>triggered(when.attacks(self), [
createToken(you, 1, token({ types: ['creature'], subtypes: ['goblin'], colors: ['red'], power: 1, toughness: 1, tapped: true })),
])
triggered(when.upkeep(you), [
ifThen(youControl(permanents.withType('artifact'), 3), [draw(you, 1)]),
])
staticAbility([
staticGrant(each(creatures.youControl()), 'Flying'),
])</pre>
<p class="muted">
Common triggers: <code>when.enters</code>, <code>when.dies</code>,
<code>when.attacks</code>, <code>when.upkeep</code>, <code>when.endStep</code>,
<code>when.cast</code>, <code>when.dealsDamage</code>. Common conditions:
<code>yourTurn()</code>, <code>youControl(selector, n)</code>, <code>wasKicked()</code>,
<code>ifYouDo()</code>, <code>otherwise()</code>. Always check the compiled result after
saving.
</p>
</article>
<article>
<h3>When the syntax cannot express it</h3>
<p>Never guess a wrong effect. Preserve the oracle text and leave it unsupported:</p>
<pre>unsupported('modal bullet outside a modal block', 'Choose one — ...')</pre>
<p class="muted">
The full reference lives in <code>backend/docs/card-effects.md</code>.
</p>
</article>
</section>
</template>
<style scoped>
.source-guide {
flex: 1;
min-height: 0;
overflow-y: auto;
background: var(--panel);
border: 1px solid var(--line);
border-radius: 8px;
padding: 1rem 1.25rem;
display: flex;
flex-direction: column;
gap: 1.25rem;
}
.guide-head {
display: flex;
flex-direction: column;
gap: 0.25rem;
}
h3 {
margin-bottom: 0.4rem;
}
p {
line-height: 1.5;
font-size: 0.9rem;
}
code {
font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
font-size: 0.85em;
background: #11151d;
border: 1px solid var(--line);
border-radius: 4px;
padding: 0.05rem 0.3rem;
}
pre {
margin: 0.5rem 0 0;
padding: 0.65rem 0.8rem;
background: #11151d;
border: 1px solid var(--line);
border-radius: 6px;
overflow-x: auto;
font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
font-size: 0.82rem;
line-height: 1.5;
}
table {
border-collapse: collapse;
width: 100%;
font-size: 0.85rem;
}
th,
td {
border-bottom: 1px solid var(--line);
padding: 0.35rem 0.5rem;
text-align: left;
vertical-align: top;
}
th {
white-space: nowrap;
color: var(--muted);
font-weight: 600;
}
tbody th {
width: 7rem;
}
@media (max-width: 800px) {
tbody th {
width: auto;
}
}
</style>

View File

@@ -1,9 +1,14 @@
<script setup lang="ts">
import CardGraphEditor from '../components/CardGraphEditor.vue'
import PseudoGuide from '../components/PseudoGuide.vue'
import SourceGuide from '../components/SourceGuide.vue'
type Status = 'supported' | 'partial' | 'unsupported'
const statusLabels: Record<Status, string> = {
supported: 'Supported',
partial: 'Partial',
unsupported: 'Unsupported',
}
interface CardSummary {
oracle_id: string
name: string
@@ -87,7 +92,6 @@ const rarityOptions = ['common', 'uncommon', 'rare', 'mythic', 'special', 'bonus
const cmcOptions = ['0', '1', '2', '3', '4', '5', '6', '7+']
const view = ref<'editor' | 'guide'>('editor')
const editorMode = ref<'text' | 'visual'>('text')
const search = ref('')
const statusFilter = ref('needs-work')
const formatFilter = ref('')
@@ -217,7 +221,7 @@ async function translate() {
async function reset() {
if (!detail.value || saving.value) return
if (!window.confirm('Delete the manual implementation and restore the generated one?')) return
if (!window.confirm('Delete the verified implementation and restore the generated one?')) return
saving.value = true
editorError.value = ''
try {
@@ -269,7 +273,7 @@ onMounted(() => {
{{ stats.supported.toLocaleString() }} supported ·
{{ stats.partial.toLocaleString() }} partial ·
{{ stats.unsupported.toLocaleString() }} unsupported ·
{{ stats.manual.toLocaleString() }} manual
{{ stats.manual.toLocaleString() }} verified
</template>
<template v-else>Loading stats…</template>
</p>
@@ -292,7 +296,7 @@ onMounted(() => {
<option value="unsupported">Not implemented</option>
<option value="partial">Partial</option>
<option value="supported">Supported</option>
<option value="manual">Manual</option>
<option value="manual">Verified</option>
<option value="all">All cards</option>
</select>
<button type="submit">Search</button>
@@ -353,8 +357,16 @@ onMounted(() => {
v-if="card.implementation"
class="badge"
:class="card.implementation.status"
>{{ card.implementation.status }}</span>
<span v-if="card.implementation?.manual" class="badge manual">manual</span>
:title="statusLabels[card.implementation.status]"
:aria-label="statusLabels[card.implementation.status]"
>{{ card.implementation.status[0] }}</span>
<span
v-if="card.implementation"
class="badge"
:class="card.implementation.manual ? 'verified' : 'generated'"
:title="card.implementation.manual ? 'Verified' : 'Generated'"
:aria-label="card.implementation.manual ? 'Verified' : 'Generated'"
>{{ card.implementation.manual ? 'V' : 'G' }}</span>
</span>
</button>
</CardHover>
@@ -381,8 +393,18 @@ onMounted(() => {
</p>
</div>
<div class="badges">
<span class="badge" :class="detail.compiled.status">{{ detail.compiled.status }}</span>
<span v-if="detail.manual" class="badge manual">manual</span>
<span
class="badge"
:class="detail.compiled.status"
:title="statusLabels[detail.compiled.status]"
:aria-label="statusLabels[detail.compiled.status]"
>{{ detail.compiled.status[0] }}</span>
<span
class="badge"
:class="detail.manual ? 'verified' : 'generated'"
:title="detail.manual ? 'Verified' : 'Generated'"
:aria-label="detail.manual ? 'Verified' : 'Generated'"
>{{ detail.manual ? 'V' : 'G' }}</span>
</div>
</div>
@@ -402,23 +424,15 @@ onMounted(() => {
</p>
<p v-else-if="editorError" class="error">{{ editorError }}</p>
<div class="row">
<div class="tabs">
<button type="button" :class="{ active: editorMode === 'text' }" @click="editorMode = 'text'">Text</button>
<button type="button" :class="{ active: editorMode === 'visual' }" @click="editorMode = 'visual'">Visual</button>
</div>
<span class="muted grow">{{ editorMode === 'text' ? 'Pseudocode' : 'Node graph' }}</span>
</div>
<span class="muted">Card source</span>
<textarea
v-if="editorMode === 'text'"
v-model="source"
spellcheck="false"
aria-label="Card implementation"
@keydown.ctrl.s.prevent="save"
@keydown.meta.s.prevent="save"
/>
<CardGraphEditor v-else :key="detail.card.oracle_id" v-model="source" />
<div class="actions">
<button type="button" class="primary" :disabled="saving || !dirty" @click="save">
@@ -439,7 +453,7 @@ onMounted(() => {
</section>
</div>
<PseudoGuide v-else />
<SourceGuide v-else />
</main>
</template>

View File

@@ -6,8 +6,10 @@ import {
deleteDeck,
exportDeckText,
loadDecks,
loadSharedDeck,
newDeckId,
saveDeck,
shareDeck,
type ApiCard,
type DeckCard,
type SavedDeck,
@@ -26,6 +28,8 @@ interface DraftDeck {
definePageMeta({ middleware: 'auth' })
const { public: { apiBase } } = useRuntimeConfig()
const route = useRoute()
const router = useRouter()
const BASIC_NAMES = ['Plains', 'Island', 'Swamp', 'Mountain', 'Forest']
const decks = ref<SavedDeck[]>([])
@@ -43,6 +47,8 @@ const importErrors = ref<string[]>([])
const importing = ref(false)
const basics = ref<Record<string, ApiCard>>({})
const showExport = ref(false)
const shareLink = ref('')
const shareCopied = ref(false)
const count = computed(() => 1 + (draft.value?.cards.length ?? 0))
const grouped = computed(() => {
@@ -115,6 +121,30 @@ async function reloadDecks() {
decks.value = (await loadDecks(apiBase)).sort((a, b) => b.updatedAt - a.updatedAt)
}
async function share(deck: SavedDeck) {
error.value = ''
try {
const token = await shareDeck(apiBase, deck.id)
shareLink.value = `${window.location.origin}/decks?share=${token}`
shareCopied.value = false
} catch (caught) {
error.value = errorMessage(caught)
}
}
async function copyShareLink() {
try {
await navigator.clipboard.writeText(shareLink.value)
shareCopied.value = true
} catch {
shareCopied.value = false
}
}
function closeShare() {
shareLink.value = ''
}
function selectDeck(deck: SavedDeck) {
draft.value = {
id: deck.id,
@@ -314,6 +344,27 @@ function errorMessage(caught: unknown): string {
onMounted(async () => {
await reloadDecks()
const sharedToken = route.query.share
if (typeof sharedToken === 'string' && sharedToken) {
try {
const deck = await loadSharedDeck(apiBase, sharedToken)
draft.value = {
id: newDeckId(),
name: deck.name,
commander: { ...deck.commander },
cards: deck.cards.map(card => ({ ...card })),
cardBack: deck.cardBack ?? undefined,
}
notice.value = 'Shared deck loaded. Save it to add it to your account.'
} catch (caught) {
error.value = errorMessage(caught)
}
// Drop the token from the URL so a reload does not import the deck again.
const query = { ...route.query }
delete query.share
await router.replace({ query })
}
try {
const data = await $fetch<{ cards: (ApiCard | null)[] }>(`${apiBase}/cards/resolve`, {
method: 'POST',
@@ -519,19 +570,15 @@ onMounted(async () => {
</header>
<section class="decks-panel">
<p v-if="error" class="error">{{ error }}</p>
<p v-if="!decks.length" class="muted">No saved decks yet.</p>
<div class="deck-grid">
<button type="button" class="deck-tile import-tile" @click="openImport">
<span class="plus" aria-hidden="true">+</span>
<span class="deck-name">Import deck</span>
</button>
<button
v-for="deck in decks"
:key="deck.id"
type="button"
class="deck-tile"
@click="selectDeck(deck)"
>
<div v-for="deck in decks" :key="deck.id" class="deck-cell">
<button type="button" class="deck-tile" @click="selectDeck(deck)">
<span class="deck-stack">
<img :src="commanderImage(deck)" :alt="`${deck.commander.name} card`" loading="lazy">
</span>
@@ -543,9 +590,30 @@ onMounted(async () => {
<span class="muted deck-commander">{{ deck.commander.name }}</span>
</span>
</button>
<button
type="button"
class="mini share-button"
:aria-label="`Share ${deck.name}`"
@click="share(deck)"
>Share</button>
</div>
</div>
</section>
<div v-if="shareLink" class="modal-backdrop" @click.self="closeShare">
<div class="modal">
<h2>Share deck</h2>
<p class="muted">Anyone with this link can view and import a copy of the deck.</p>
<input :value="shareLink" readonly aria-label="Share link">
<div class="row wrap modal-actions">
<button type="button" @click="closeShare">Done</button>
<button type="button" class="primary" @click="copyShareLink">
{{ shareCopied ? 'Copied' : 'Copy link' }}
</button>
</div>
</div>
</div>
<div v-if="importOpen" class="modal-backdrop" @click.self="closeImport">
<form class="modal" @submit.prevent="importDeck">
<h2>Import deck</h2>
@@ -609,6 +677,21 @@ onMounted(async () => {
gap: 1rem;
}
.deck-cell {
display: flex;
flex-direction: column;
gap: 0.4rem;
min-width: 0;
}
.deck-cell .deck-tile {
flex: 1;
}
.share-button {
align-self: flex-end;
}
.deck-tile {
display: flex;
flex-direction: column;

File diff suppressed because it is too large Load Diff

View File

@@ -1,846 +0,0 @@
// Line-level model behind the visual card editor. It mirrors the canonical
// formatter output (abilities at column 0, nested calls indented two spaces) so
// editing a node and serializing it back keeps the pseudocode valid.
export interface GraphNode {
id: number
text: string
kind: 'ability' | 'effect' | 'raw'
children: GraphNode[]
}
let nextId = 1
export function nextNodeId(): number {
return nextId++
}
export function makeNode(text: string, kind: GraphNode['kind'], children: GraphNode[] = []): GraphNode {
return { id: nextNodeId(), text, kind, children }
}
export function parseGraph(source: string): GraphNode[] {
const roots: GraphNode[] = []
const stack: Array<{ indent: number; node: GraphNode }> = []
for (const raw of source.split('\n')) {
if (!raw.trim()) continue
const indent = (raw.match(/^[ \t]*/)?.[0] ?? '').replace(/\t/g, ' ').length
const text = raw.trim()
const kind: GraphNode['kind'] =
text.startsWith('#') || text === '(no abilities)' ? 'raw' : indent === 0 ? 'ability' : 'effect'
const node = makeNode(text, kind)
while (stack.length && stack[stack.length - 1].indent >= indent) stack.pop()
if (stack.length) stack[stack.length - 1].node.children.push(node)
else roots.push(node)
stack.push({ indent, node })
}
return roots
}
export function serializeGraph(list: GraphNode[], depth = 0): string {
return list
.map(node => {
const line = ' '.repeat(depth) + node.text
return node.children.length ? `${line}\n${serializeGraph(node.children, depth + 1)}` : line
})
.join('\n')
}
/** Inserted at the top level by the visual editor's "Add ability" menu. */
export const ABILITY_PALETTE = [
{
group: 'Triggered',
items: [
{ label: 'Enters the battlefield', value: 'on enters(this):' },
{ label: 'Dies', value: 'on dies(this):' },
{ label: 'Attacks', value: 'on attacks(this):' },
{ label: 'Upkeep', value: 'on upkeep(you):' },
{ label: 'Cast a spell', value: 'on cast(you, any spell):' },
{ label: 'Deals damage', value: 'on deals_damage(this, any):' },
],
},
{
group: 'Other',
items: [
{ label: 'Activated {T}', value: 'activate {T}:' },
{ label: 'Activated {2}, {T}', value: 'activate {2}, {T}:' },
{ label: 'Static', value: 'static:' },
{ label: 'Static if a condition', value: 'static if it is your turn:' },
{ label: 'Spell effect', value: 'spell:' },
{ label: 'Keyword: Flying', value: 'keyword Flying' },
],
},
]
/** Appended below an ability or nested block. Keep every value parseable. */
export const EFFECT_PALETTE = [
{
group: 'Removal',
items: [
{ label: 'Damage', value: 'damage(target creature, 3)' },
{ label: 'Destroy', value: 'destroy(target creature)' },
{ label: 'Exile', value: 'exile(target permanent)' },
{ label: 'Tap', value: 'tap(target creature)' },
{ label: 'Counter spell', value: 'counter(spell, target spell)' },
{ label: 'Sacrifice', value: 'sacrifice(you, target creature)' },
],
},
{
group: 'Cards and life',
items: [
{ label: 'Draw', value: 'draw(you, 1)' },
{ label: 'Discard', value: 'discard(you, 1)' },
{ label: 'Mill', value: 'mill(you, 1)' },
{ label: 'Scry', value: 'scry(you, 2)' },
{ label: 'Surveil', value: 'surveil(you, 1)' },
{ label: 'Search library', value: 'search(you, creature, 1, to hand, shuffle)' },
{ label: 'Look at top', value: 'look_top(you, 3)' },
{ label: 'Gain life', value: 'gain_life(you, 2)' },
{ label: 'Lose life', value: 'lose_life(opponent, 2)' },
{ label: 'Energy', value: 'energy(you, 2)' },
],
},
{
group: 'Board',
items: [
{ label: 'Create token', value: 'create_token(you, 1, 1/1 white soldier creature)' },
{ label: 'Create copy token', value: 'create_token(you, 1, copy of the triggering object, not legendary)' },
{ label: 'Put counters', value: 'put_counters(target creature, +1/+1, 1)' },
{ label: 'Pump', value: 'pump(target creature, 2/2, until end of turn)' },
{ label: 'Grant keyword', value: 'grant(each creature you control, Flying)' },
{ label: 'Untap', value: 'untap(target permanent you control)' },
{ label: 'Return to hand', value: 'return_to_hand(target creature)' },
{ label: 'Add mana', value: 'add_mana(you, {G})' },
],
},
{
group: 'Flow',
items: [
{ label: 'If condition', value: 'if you control at least 3 artifacts:' },
],
},
]
/** Static abilities accept a different effect vocabulary than triggered/spell ones. */
export const STATIC_EFFECT_PALETTE = [
{
group: 'Static effects',
items: [
{ label: 'Pump', value: 'pump(each creature you control, 1/1)' },
{ label: 'Grant keyword', value: 'grant(each creature you control, Flying)' },
{ label: 'Enters tapped', value: 'enters_tapped(this)' },
{ label: 'Enters with counters', value: 'enters_with_counters(this, +1/+1, 1)' },
{ label: 'Restrict', value: 'restrict(target creature, cant_attack)' },
{ label: 'Set base P/T', value: 'set_pt(target creature, base, 1/1)' },
],
},
]
/** Value nodes that can be wired into argument sockets. */
export const VALUE_PALETTE = [
{
group: 'Players',
items: [
{ label: 'A player', value: 'target player' },
{ label: 'Each opponent', value: 'each opponent' },
{ label: 'Each player', value: 'each player' },
{ label: 'You', value: 'you' },
{ label: 'That player', value: 'that player' },
{ label: 'Its controller', value: 'its controller' },
],
},
{
group: 'Targets',
items: [
{ label: 'A creature', value: 'target creature' },
{ label: 'A permanent', value: 'target permanent' },
{ label: 'An artifact', value: 'target artifact' },
{ label: 'A land', value: 'target land' },
{ label: 'A spell', value: 'target spell' },
{ label: 'An ability', value: 'target ability' },
{ label: 'Any target', value: 'any target' },
{ label: 'This', value: 'this' },
{ label: 'The triggering object', value: 'the triggering object' },
{ label: 'Each creature you control', value: 'each creature you control' },
{ label: 'Each creature an opponent controls', value: 'each creature an opponent controls' },
],
},
{
group: 'Selectors',
items: [
{ label: 'Creature', value: 'creature' },
{ label: 'Artifact', value: 'artifact' },
{ label: 'Enchantment', value: 'enchantment' },
{ label: 'Land', value: 'land' },
{ label: 'Red', value: 'red' },
{ label: 'Creature you control', value: 'creature you control' },
{ label: 'Artifact you control', value: 'artifact you control' },
{ label: 'Tapped creature', value: 'tapped creature' },
{ label: 'Power 4 or greater', value: 'creature with power 4 or greater' },
{ label: 'Nontoken Dragon', value: 'each other nontoken dragon creature you control' },
{ label: 'Nontoken Angel', value: "each nontoken angel you don't control" },
{ label: 'Selector builder', value: '__selector__' },
],
},
{
group: 'Tokens',
items: [
{ label: '1/1 white Soldier', value: '1/1 white soldier creature' },
{ label: '1/1 red Goblin', value: '1/1 red goblin creature' },
{ label: 'Copy of the triggering object', value: 'copy of the triggering object' },
{ label: 'Copy, not legendary', value: 'copy of the triggering object, not legendary' },
],
},
{
group: 'Values',
items: [
{ label: '1', value: '1' },
{ label: '2', value: '2' },
{ label: '3', value: '3' },
{ label: 'X', value: 'X' },
{ label: 'That much', value: 'that much' },
{ label: 'Its power', value: 'its power' },
{ label: 'Its toughness', value: 'its toughness' },
{ label: 'Count creatures you control', value: 'count(creature you control)' },
{ label: 'Cards in your hand', value: 'cards in your hand' },
],
},
{
group: 'Costs',
items: [
{ label: 'Tap', value: '{T}' },
{ label: 'Mana {2}', value: '{2}' },
{ label: 'Pay 2 life', value: 'pay 2 life' },
{ label: 'Sacrifice this', value: 'sacrifice this' },
{ label: 'Discard 1 card(s)', value: 'discard 1 card(s)' },
{ label: 'Mill 1 card(s)', value: 'mill 1 card(s)' },
{ label: 'Remove 1 +1/+1 counter(s)', value: 'remove 1 +1/+1 counter(s) from this' },
],
},
{
group: 'Conditions',
items: [
{ label: 'It is your turn', value: 'it is your turn' },
{ label: 'This is tapped', value: 'this is tapped' },
{ label: 'You control at least 3 artifacts', value: 'you control at least 3 artifacts' },
{ label: 'You have at least 10 life', value: 'you have at least 10 life' },
],
},
{
group: 'Durations',
items: [
{ label: 'Until end of turn', value: 'until end of turn' },
{ label: 'Until your next turn', value: 'until your next turn' },
{ label: 'Until the end of your next turn', value: 'until the end of your next turn' },
{ label: 'While this remains', value: 'for as long as this remains on the battlefield' },
],
},
{
group: 'Logic',
items: [
{ label: 'Selector OR', value: '__or__' },
{ label: 'Selector AND', value: '__and__' },
],
},
]
/** Human labels for effect/ability argument sockets. */
export const ARG_HINTS: Record<string, string[]> = {
damage: ['target', 'amount', 'source'],
damage_divided: ['amount', 'target'],
draw: ['player', 'amount'],
discard: ['player', 'amount'],
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', 'duration'],
put_counters: ['target', 'counter', 'amount'],
remove_counters: ['target', 'counter', 'amount'],
create_token: ['player', 'amount', 'token', 'options'],
destroy: ['target'],
exile: ['target'],
tap: ['target'],
untap: ['target'],
regenerate: ['target'],
return_to_hand: ['target'],
put_on_top: ['target'],
sacrifice: ['player', 'target'],
counter: ['spell|ability', 'target'],
return_to_battlefield: ['target', 'options'],
scry: ['player', 'amount'],
surveil: ['player', 'amount'],
search: ['player', 'selector', 'amount', 'destination', 'options'],
add_mana: ['player', 'mana'],
fight: ['target', 'target'],
energy: ['player', 'amount'],
attach: ['target'],
restrict: ['target', 'rule'],
prevent_damage: ['target', 'amount', 'duration'],
gain_control: ['target', 'duration'],
look_top: ['player', 'amount', 'options'],
pay: ['cost'],
transform: ['target'],
}
/** Human labels for trigger event arguments. */
const TRIGGER_ARG_HINTS: Record<string, string[]> = {
enters: ['subject'],
dies: ['subject'],
attacks: ['subject'],
blocks: ['subject'],
attacks_or_blocks: ['subject'],
enters_or_attacks: ['subject'],
enters_or_dies: ['subject'],
leaves_battlefield: ['subject'],
deals_damage: ['subject', 'recipient'],
deals_combat_damage: ['subject', 'recipient'],
upkeep: ['player'],
end_step: ['player'],
begin_combat: ['player'],
first_main_phase: ['player'],
postcombat_main_phase: ['player'],
cast: ['player', 'spell'],
becomes_level: ['level'],
draw: ['player'],
counter_placed: ['subject', 'counter'],
becomes_target: ['subject'],
gain_life: ['player'],
lose_life: ['player'],
}
const TRIGGER_SUBJECT_OPTIONS = [
'this',
'each other creature',
'each creature you control',
'each other nontoken dragon creature you control',
"each nontoken angel you don't control",
]
const PLAYER_OPTIONS = ['you', 'target player', 'each opponent', 'each player', 'that player', 'its controller']
const AMOUNT_OPTIONS = ['1', '2', '3', '4', '5', 'X', 'that much', 'count(creature you control)']
const TOKEN_OPTIONS = [
'1/1 white soldier creature',
'1/1 red goblin creature',
'copy of the triggering object',
]
/** Argument slots with fixed choices become dropdowns in the visual editor. */
export const SLOT_OPTIONS: Record<string, string[][]> = {
enters: [TRIGGER_SUBJECT_OPTIONS],
create_token: [PLAYER_OPTIONS, AMOUNT_OPTIONS, TOKEN_OPTIONS, ['not legendary']],
}
/** Splits on `separator` outside parentheses, brackets, braces and quotes. */
export function splitTopLevel(text: string, separator: string): string[] {
const parts: string[] = []
let depth = 0
let quote = false
let escape = false
let start = 0
for (let index = 0; index < text.length; index++) {
const char = text[index]
if (quote) {
if (escape) escape = false
else if (char === '\\') escape = true
else if (char === '"') quote = false
continue
}
if (char === '"') {
quote = true
continue
}
if (char === '(' || char === '[' || char === '{') depth++
else if (char === ')' || char === ']' || char === '}') depth--
else if (depth === 0 && text.startsWith(separator, index)) {
parts.push(text.slice(start, index))
index += separator.length - 1
start = index + 1
}
}
parts.push(text.slice(start))
return parts
}
export function blockOf(text: string): { kind: 'if' | 'choose' | 'schedule'; value: string } | undefined {
const ifMatch = text.match(/^if (.+):$/)
if (ifMatch) return { kind: 'if', value: ifMatch[1] }
const chooseMatch = text.match(/^choose (\d+(?:-\d+)?):$/)
if (chooseMatch) return { kind: 'choose', value: chooseMatch[1] }
const scheduleMatch = text.match(/^schedule\((next_upkeep|next_end_step)\):$/)
if (scheduleMatch) return { kind: 'schedule', value: scheduleMatch[1] }
return undefined
}
/** True for nodes that carry an indented body. Mode lines can nest too. */
export function isBlockText(text: string): boolean {
return Boolean(blockOf(text)) || /^grant_ability\(.*\):$/.test(text) || /^\d+\.\s/.test(text)
}
/** Blocks that are invalid without at least one nested effect. */
function requiresBody(text: string): boolean {
return Boolean(blockOf(text)) || /^grant_ability\(.*\):$/.test(text)
}
export function abilityRequiresEffects(text: string): boolean {
return /^(?:on |activate |static|spell|chapter )/.test(text)
}
/** Reads a `name(arg, arg)` prefix, leaving any suffix after the closing paren. */
export function readCallPrefix(text: string): { name: string; args: string[]; end: number } | undefined {
const match = text.match(/^([a-z][a-z0-9_]*)\s*\(/)
if (!match) return undefined
const open = match[0].length - 1
let depth = 0
let quote = false
let escape = false
for (let index = open; index < text.length; index++) {
const char = text[index]
if (quote) {
if (escape) escape = false
else if (char === '\\') escape = true
else if (char === '"') quote = false
continue
}
if (char === '"') {
quote = true
continue
}
if (char === '(') depth++
else if (char === ')') {
depth--
if (depth === 0) {
const inner = text.slice(open + 1, index).trim()
return {
name: match[1],
args: inner ? splitTopLevel(inner, ',').map(arg => arg.trim()) : [],
end: index + 1,
}
}
}
}
return undefined
}
/** Reads a complete `name(arg, arg)` call; returns undefined for block headers. */
export function parseCall(text: string): { name: string; args: string[] } | undefined {
const trimmed = text.trim()
const call = readCallPrefix(trimmed)
return call && call.end === trimmed.length ? { name: call.name, args: call.args } : undefined
}
/**
* Splits a supported line into fixed text plus argument slots. Unsupported
* lines return undefined and stay as free text.
*/
export function shapeFromText(text: string): NodeShape | undefined {
if (text.startsWith('on ') && text.endsWith(':')) {
const inner = text.slice(3, -1)
const call = readCallPrefix(inner)
if (call) {
const suffix = inner.slice(call.end)
return {
name: `on ${call.name}`,
head: `on ${call.name}(`,
tail: `)${suffix}:`,
separator: ', ',
slots: call.args.map((arg, index) => {
const options = SLOT_OPTIONS[call.name]?.[index]
return {
label: TRIGGER_ARG_HINTS[call.name]?.[index] ?? `arg${index + 1}`,
text: arg,
...(options ? { options } : {}),
}
}),
}
}
}
if (text.startsWith('activate ') && text.endsWith(':')) {
return {
head: 'activate ',
tail: ':',
separator: ', ',
slots: [{ label: 'cost', text: text.slice('activate '.length, -1) }],
}
}
if (text.startsWith('static if ') && text.endsWith(':')) {
return {
head: 'static if ',
tail: ':',
separator: ', ',
slots: [{ label: 'condition', text: text.slice('static if '.length, -1) }],
}
}
const block = blockOf(text)
if (block) {
if (block.kind === 'if') {
return { head: 'if ', tail: ':', separator: ', ', slots: [{ label: 'condition', text: block.value }] }
}
if (block.kind === 'choose') {
return { head: 'choose ', tail: ':', separator: ', ', slots: [{ label: 'modes', text: block.value }] }
}
return { head: 'schedule(', tail: '):', separator: ', ', slots: [{ label: 'when', text: block.value }] }
}
const call = parseCall(text)
if (call) {
return {
head: `${call.name}(`,
tail: ')',
separator: ', ',
slots: call.args.map((arg, index) => {
const options = SLOT_OPTIONS[call.name]?.[index]
return {
label: ARG_HINTS[call.name]?.[index] ?? `arg${index + 1}`,
text: arg,
...(options ? { options } : {}),
}
}),
}
}
return undefined
}
/**
* Rebuilds every shaped line from its slots and connected value nodes. Value
* nodes are evaluated recursively, so `or`/`and` combinators can nest.
*/
export function syncTexts(model: GraphModel): void {
const byId = new Map(model.nodes.map(node => [node.id, node]))
const valueEdges = new Map<string, number>()
for (const edge of model.edges) {
if (edge.port === 'value' && edge.slot !== undefined) {
valueEdges.set(`${edge.to}:${edge.slot}`, edge.from)
}
}
function renderSlot(node: CanvasNode, index: number, stack: Set<number>): string {
const childId = valueEdges.get(`${node.id}:${index}`)
const child = childId !== undefined ? byId.get(childId) : undefined
return child ? render(child, stack) : node.shape?.slots[index]?.text ?? ''
}
function render(node: CanvasNode | undefined, stack: Set<number>): string {
if (!node) return ''
if (stack.has(node.id)) return node.kind === 'value' ? node.literal ?? '' : ''
stack.add(node.id)
let text: string
if (node.kind === 'value' && node.combine) {
text = `${renderSlot(node, 0, stack)} ${node.combine} ${renderSlot(node, 1, stack)}`
} else if (node.shape) {
text = node.shape.head
+ node.shape.slots.map((_, index) => renderSlot(node, index, stack)).join(node.shape.separator)
+ node.shape.tail
} else if (node.kind === 'value') {
text = node.literal ?? node.text
} else {
text = node.text
}
stack.delete(node.id)
node.text = text
return text
}
for (const node of model.nodes) render(node, new Set())
}
// ---------------------------------------------------------------------------
// Node canvas. The tree above is converted into flat nodes with explicit
// `next` (sibling) and `body` (indented) links. Source is regenerated by
// following those links, so the canvas and the pseudocode stay in sync.
// ---------------------------------------------------------------------------
export interface NodeSlot {
label: string
text: string
/** Fixed choices rendered as a dropdown instead of a free-text input. */
options?: string[]
}
/** A line split into a fixed shell and the slots a value node can fill. */
export interface NodeShape {
name?: string
head: string
tail: string
separator: string
slots: NodeSlot[]
}
export interface CanvasNode {
id: number
text: string
kind: 'ability' | 'effect' | 'raw' | 'value'
x: number
y: number
shape?: NodeShape
/** Value nodes: literal source text. */
literal?: string
/** Value nodes: combines its two slots instead of using a literal. */
combine?: 'or' | 'and'
valueLabel?: string
}
export type GraphPort = 'next' | 'body' | 'value'
export interface GraphEdge {
id: number
from: number
port: GraphPort
to: number
/** Target argument index when port is 'value'. */
slot?: number
}
export interface GraphModel {
nodes: CanvasNode[]
edges: GraphEdge[]
}
export interface GraphSource {
source: string
unlinked: number
problems: string[]
}
export const NODE_WIDTH = 230
const CHAIN_GAP = 70
const BODY_INDENT = NODE_WIDTH + 20
const BODY_GAP = 70
const ROOT_GAP = 70
let nextEdgeId = 1
export function estimateNodeHeight(text: string, slots?: number, hasName?: boolean): number {
const count = slots ?? parseCall(text)?.args.length ?? 0
if (!count) return hasName ? 84 : 74
return 64 + count * 48 + (hasName ? 24 : 0)
}
export function hasBodyPort(model: GraphModel, node: CanvasNode): boolean {
return node.kind === 'effect'
&& (isBlockText(node.text) || model.edges.some(edge => edge.from === node.id && edge.port === 'body'))
}
/** Converts pseudocode into nodes and links, laid out roughly left to right. */
export function graphFromSource(source: string): GraphModel {
const model: GraphModel = { nodes: [], edges: [] }
let y = 40
for (const root of parseGraph(source)) {
if (root.kind === 'raw') {
model.nodes.push({ id: root.id, text: root.text, kind: 'raw', x: 40, y })
y += 64
continue
}
const bounds = layoutTreeChain(model, [root], 40, y, 0)
y += bounds.height + ROOT_GAP
}
return model
}
function layoutTreeChain(
model: GraphModel,
list: GraphNode[],
x: number,
y: number,
depth: number,
): { width: number; height: number } {
let cursorX = x
let maxHeight = 0
let previous: number | undefined
for (const treeNode of list) {
const kind: CanvasNode['kind'] = depth === 0 ? treeNode.kind : 'effect'
const node: CanvasNode = {
id: treeNode.id,
text: treeNode.text,
kind,
x: cursorX,
y,
shape: shapeFromText(treeNode.text),
}
model.nodes.push(node)
if (previous !== undefined) {
model.edges.push({ id: nextEdgeId++, from: previous, port: 'next', to: node.id })
}
previous = node.id
const height = estimateNodeHeight(node.text, node.shape?.slots.length, Boolean(node.shape?.name))
let totalHeight = height
let advance = NODE_WIDTH
if (treeNode.children.length) {
if (depth === 0) {
// An ability's output is its effect chain, laid out to the right.
const chain = layoutTreeChain(model, treeNode.children, cursorX + NODE_WIDTH + CHAIN_GAP, y, 1)
model.edges.push({ id: nextEdgeId++, from: node.id, port: 'next', to: treeNode.children[0].id })
totalHeight = Math.max(totalHeight, chain.height)
advance = NODE_WIDTH + CHAIN_GAP + chain.width
} else {
// Blocks own an indented body below and just right of their socket.
const body = layoutTreeChain(model, treeNode.children, cursorX + BODY_INDENT, y + height + BODY_GAP, depth + 1)
model.edges.push({ id: nextEdgeId++, from: node.id, port: 'body', to: treeNode.children[0].id })
totalHeight = Math.max(totalHeight, height + BODY_GAP + body.height)
}
}
maxHeight = Math.max(maxHeight, totalHeight)
cursorX += advance + CHAIN_GAP
}
return { width: cursorX - x, height: maxHeight }
}
/** Rebuilds pseudocode by walking next/body links from every ability root. */
export function sourceFromGraph(model: GraphModel): GraphSource {
syncTexts(model)
const byId = new Map(model.nodes.map(node => [node.id, node]))
const outgoing = new Map<string, GraphEdge>()
for (const edge of model.edges) {
outgoing.set(`${edge.from}:${edge.port}`, edge)
}
const lines: string[] = []
const visited = new Set<number>()
const problems: string[] = []
const label = (text: string) => (text.length > 52 ? `${text.slice(0, 49)}…` : text)
const checkModes = (startId: number) => {
let mode = byId.get(startId)
let expected = 1
const seenModes = new Set<number>()
while (mode && !seenModes.has(mode.id)) {
seenModes.add(mode.id)
const number = mode.text.match(/^(\d+)\.\s/)
if (!number || Number(number[1]) !== expected) {
problems.push('A choose body must be numbered 1, 2, 3…')
return
}
expected++
const next = outgoing.get(`${mode.id}:next`)
mode = next ? byId.get(next.to) : undefined
}
}
const emitChain = (startId: number, depth: number) => {
let current: number | undefined = startId
while (current !== undefined) {
if (visited.has(current)) {
problems.push(`Cycle at ${label(byId.get(current)?.text ?? 'node')}`)
return
}
const node = byId.get(current)
if (!node) return
visited.add(current)
lines.push(`${' '.repeat(depth)}${node.text}`)
const body = outgoing.get(`${current}:body`)
if (body) {
if (blockOf(node.text)?.kind === 'choose') checkModes(body.to)
emitChain(body.to, depth + 1)
} else if (requiresBody(node.text)) {
problems.push(`"${label(node.text)}" has no body`)
}
current = outgoing.get(`${current}:next`)?.to
}
}
for (const node of model.nodes) {
if (node.kind === 'raw') {
if (!visited.has(node.id)) {
visited.add(node.id)
lines.push(node.text)
}
continue
}
if (node.kind !== 'ability' || visited.has(node.id)) continue
visited.add(node.id)
lines.push(node.text)
const next = outgoing.get(`${node.id}:next`)
if (next) emitChain(next.to, 1)
else if (abilityRequiresEffects(node.text)) problems.push(`"${label(node.text)}" has no effects`)
}
const usedValues = new Set(model.edges.filter(edge => edge.port === 'value').map(edge => edge.from))
const unlinked = model.nodes.filter(node =>
(node.kind === 'effect' && !visited.has(node.id))
|| (node.kind === 'value' && !usedValues.has(node.id)),
).length
if (unlinked) {
problems.push(`${unlinked} unconnected node${unlinked === 1 ? '' : 's'} will be ignored`)
}
return { source: lines.join('\n'), unlinked, problems }
}
function reaches(model: GraphModel, start: number, target: number): boolean {
const stack = [start]
const seen = new Set<number>()
while (stack.length) {
const id = stack.pop()!
if (id === target) return true
if (seen.has(id)) continue
seen.add(id)
for (const edge of model.edges) {
if (edge.from === id) stack.push(edge.to)
}
}
return false
}
/** Links an output socket to a node input or an argument slot. */
export function connectNodes(
model: GraphModel,
from: number,
port: GraphPort,
to: number,
slot?: number,
): boolean {
if (from === to) return false
const source = model.nodes.find(node => node.id === from)
const target = model.nodes.find(node => node.id === to)
if (!source || !target) return false
if (port === 'value') {
if (source.kind !== 'value' || !target.shape || slot === undefined || !target.shape.slots[slot]) {
return false
}
} else {
if (target.kind !== 'effect') return false
if (port === 'body' && !hasBodyPort(model, source)) return false
}
if (reaches(model, to, from)) return false
if (port === 'value') {
model.edges = model.edges.filter(edge =>
!(edge.port === 'value' && edge.to === to && edge.slot === slot)
&& !(edge.from === from && edge.port === 'value'),
)
model.edges.push({ id: nextEdgeId++, from, port, to, slot })
} else {
model.edges = model.edges.filter(edge =>
!((edge.port === 'next' || edge.port === 'body') && edge.to === to)
&& !(edge.from === from && edge.port === port),
)
model.edges.push({ id: nextEdgeId++, from, port, to })
}
return true
}

View File

@@ -83,6 +83,21 @@ export async function deleteDeck(apiBase: string, id: string): Promise<void> {
})
}
export async function shareDeck(apiBase: string, id: string): Promise<string> {
const { token } = await $fetch<{ token: string }>(
`${apiBase}/me/decks/${encodeURIComponent(id)}/share`,
{ method: 'POST', headers: authHeaders() },
)
return token
}
export async function loadSharedDeck(apiBase: string, token: string): Promise<SavedDeck> {
const { deck } = await $fetch<{ deck: SavedDeck }>(
`${apiBase}/decks/share/${encodeURIComponent(token)}`,
)
return deck
}
export function isBasicLand(card: DeckCard): boolean {
return /\bbasic\b/i.test(card.typeLine) && /\bland\b/i.test(card.typeLine)
}

View File

@@ -0,0 +1,105 @@
// Animation cues are derived by diffing two match snapshots, so they work for
// every client (including spectators) without adding anything to the wire format.
export interface AnimationCardSnapshot {
id: string
damage?: number
attacking?: string
}
export interface AnimationPlayerSnapshot {
id: string
life?: number
battlefield?: readonly AnimationCardSnapshot[]
}
export interface AnimationStateSnapshot {
id?: string
players?: readonly AnimationPlayerSnapshot[]
game?: {
manaPool?: Record<string, number>
}
}
export interface CardDamageAnimation {
cardId: string
amount: number
}
export interface LifeChangeAnimation {
playerId: string
amount: number
}
export interface ManaGainAnimation {
color: string
amount: number
}
export interface GameAnimations {
enteringCardIds: string[]
attackingCardIds: string[]
damagedCards: CardDamageAnimation[]
lifeChanges: LifeChangeAnimation[]
manaGains: ManaGainAnimation[]
}
function emptyAnimations(): GameAnimations {
return {
enteringCardIds: [],
attackingCardIds: [],
damagedCards: [],
lifeChanges: [],
manaGains: [],
}
}
function cardsByPlayer(state: AnimationStateSnapshot): Map<string, AnimationCardSnapshot> {
const cards = new Map<string, AnimationCardSnapshot>()
for (const player of state.players ?? []) {
for (const card of player.battlefield ?? []) cards.set(card.id, card)
}
return cards
}
/**
* Compare the previous and current match state and return the visual cues that
* should play for the current state. The first snapshot has nothing to compare
* against and produces no animations.
*/
export function diffGameState(
previous: AnimationStateSnapshot | null | undefined,
next: AnimationStateSnapshot,
): GameAnimations {
const animations = emptyAnimations()
if (!previous) return animations
if (previous.id && next.id && previous.id !== next.id) return animations
const previousCards = cardsByPlayer(previous)
const nextCards = cardsByPlayer(next)
for (const [id, card] of nextCards) {
const before = previousCards.get(id)
if (!before) animations.enteringCardIds.push(id)
else {
const amount = (card.damage ?? 0) - (before.damage ?? 0)
if (amount > 0) animations.damagedCards.push({ cardId: id, amount })
}
if (card.attacking && !before?.attacking) animations.attackingCardIds.push(id)
}
for (const player of next.players ?? []) {
const before = previous.players?.find(entry => entry.id === player.id)
if (!before || before.life === undefined || player.life === undefined) continue
const amount = player.life - before.life
if (amount) animations.lifeChanges.push({ playerId: player.id, amount })
}
const previousPool = previous.game?.manaPool ?? {}
const nextPool = next.game?.manaPool ?? {}
for (const color of new Set([...Object.keys(nextPool), ...Object.keys(previousPool)])) {
const amount = (nextPool[color] ?? 0) - (previousPool[color] ?? 0)
if (amount > 0) animations.manaGains.push({ color, amount })
}
return animations
}

View File

@@ -1,215 +0,0 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import {
connectNodes,
graphFromSource,
nextNodeId,
parseCall,
parseGraph,
serializeGraph,
shapeFromText,
sourceFromGraph,
syncTexts,
} from '../app/utils/cardGraph.ts'
import type { GraphModel } from '../app/utils/cardGraph.ts'
const SOURCE = `# Soul Warden [supported]
on enters(each other creature):
gain_life(you, 1)
on upkeep(you):
if you control at least 3 artifacts:
draw(you, 1)
create_token(you, 1, 1/1 white soldier creature)`
test('parseGraph builds ability and nested effect nodes', () => {
const roots = parseGraph(SOURCE)
assert.equal(roots.length, 3)
assert.equal(roots[0].kind, 'raw')
assert.equal(roots[1].kind, 'ability')
assert.equal(roots[1].text, 'on enters(each other creature):')
assert.deepEqual(roots[1].children.map(node => node.text), ['gain_life(you, 1)'])
const upkeep = roots[2]
assert.equal(upkeep.children[0].text, 'if you control at least 3 artifacts:')
assert.deepEqual(upkeep.children[0].children.map(node => node.text), ['draw(you, 1)'])
assert.equal(upkeep.children[1].text, 'create_token(you, 1, 1/1 white soldier creature)')
})
test('serializeGraph round-trips formatter output and normalizes indentation', () => {
assert.equal(serializeGraph(parseGraph(SOURCE)), SOURCE.replace('\n\n', '\n'))
assert.equal(
serializeGraph(parseGraph('on dies(this):\n draw(you, 1)')),
'on dies(this):\n draw(you, 1)',
)
})
test('graph conversion round-trips abilities, chains and nested bodies', () => {
const model = graphFromSource(SOURCE)
const result = sourceFromGraph(model)
assert.equal(result.source, SOURCE.replace('\n\n', '\n'))
assert.equal(result.unlinked, 0)
assert.deepEqual(result.problems, [])
})
test('connectNodes replaces an input link and rejects cycles', () => {
const model = graphFromSource(SOURCE)
const ability = model.nodes.find(node => node.kind === 'ability' && node.text.startsWith('on enters'))
const first = model.nodes.find(node => node.text === 'gain_life(you, 1)')
const second = model.nodes.find(node => node.text === 'create_token(you, 1, 1/1 white soldier creature)')
assert.ok(ability && first && second)
assert.equal(connectNodes(model, ability.id, 'next', second.id), true)
assert.equal(sourceFromGraph(model).unlinked, 1)
assert.equal(connectNodes(model, first.id, 'next', second.id), true)
assert.equal(connectNodes(model, second.id, 'next', first.id), false)
})
test('shapeFromText exposes trigger and effect arguments', () => {
const trigger = shapeFromText('on attacks(this):')
assert.equal(trigger?.name, 'on attacks')
assert.deepEqual(trigger?.slots, [{ label: 'subject', text: 'this' }])
const damage = shapeFromText('damage(target creature, 3)')
assert.deepEqual(damage?.slots.map(slot => slot.label), ['target', 'amount'])
})
test('shapeFromText adds dropdown choices for constant slots', () => {
const enters = shapeFromText('on enters(each other nontoken dragon creature you control):')
assert.deepEqual(enters?.slots[0]?.options, [
'this',
'each other creature',
'each creature you control',
'each other nontoken dragon creature you control',
"each nontoken angel you don't control",
])
const copy = shapeFromText("create_token(you, 1, copy of the triggering object, not legendary)")
assert.deepEqual(copy?.slots.map(slot => slot.label), ['player', 'amount', 'token', 'options'])
assert.ok(copy?.slots[2]?.options?.includes('copy of the triggering object'))
assert.deepEqual(copy?.slots[3]?.options, ['not legendary'])
})
test('value nodes fill trigger and effect argument sockets', () => {
const model = graphFromSource(`# Test [supported]
on attacks(this):
damage(target creature, 3)`)
const trigger = model.nodes.find(node => node.kind === 'ability')
const damage = model.nodes.find(node => node.text.startsWith('damage('))
assert.ok(trigger && damage)
const player = {
id: nextNodeId(),
kind: 'value' as const,
text: 'target player',
literal: 'target player',
valueLabel: 'Players',
x: 0,
y: 0,
}
model.nodes.push(player)
assert.equal(connectNodes(model, player.id, 'value', trigger.id, 0), true)
const artifact = {
id: nextNodeId(),
kind: 'value' as const,
text: 'target artifact',
literal: 'target artifact',
valueLabel: 'Targets',
x: 0,
y: 0,
}
model.nodes.push(artifact)
assert.equal(connectNodes(model, artifact.id, 'value', damage.id, 0), true)
assert.equal(sourceFromGraph(model).source, `# Test [supported]
on attacks(target player):
damage(target artifact, 3)`)
})
test('or and and value nodes combine selector slots', () => {
const model = graphFromSource(`# Test [supported]
spell:
search(you, creature, 1, to hand, shuffle)`)
const search = model.nodes.find(node => node.text.startsWith('search('))
assert.ok(search)
const combo: GraphModel['nodes'][number] = {
id: nextNodeId(),
kind: 'value',
text: '',
combine: 'or',
valueLabel: 'Logic',
x: 0,
y: 0,
shape: {
head: '',
tail: '',
separator: ' or ',
slots: [
{ label: 'left', text: 'creature' },
{ label: 'right', text: 'artifact' },
],
},
}
model.nodes.push(combo)
assert.equal(connectNodes(model, combo.id, 'value', search.id, 1), true)
assert.match(sourceFromGraph(model).source, /search\(you, creature or artifact, 1, to hand, shuffle\)/)
syncTexts(model)
assert.equal(combo.text, 'creature or artifact')
combo.combine = 'and'
combo.shape!.slots[0].text = 'red'
combo.shape!.slots[1].text = 'creature'
syncTexts(model)
assert.equal(combo.text, 'red and creature')
})
test('structured selector value nodes render their slots', () => {
const model = graphFromSource(`# Test [supported]
on enters(this):`)
const trigger = model.nodes.find(node => node.kind === 'ability')
assert.ok(trigger)
const selector: GraphModel['nodes'][number] = {
id: nextNodeId(),
kind: 'value',
text: '',
valueLabel: 'Selector',
x: 0,
y: 0,
shape: {
head: '',
tail: '',
separator: ' ',
slots: [
{ label: 'prefix', text: 'each' },
{ label: 'state', text: 'nontoken' },
{ label: 'type', text: 'angel' },
{ label: 'controller', text: "you don't control" },
],
},
}
model.nodes.push(selector)
assert.equal(connectNodes(model, selector.id, 'value', trigger.id, 0), true)
syncTexts(model)
assert.equal(selector.text, "each nontoken angel you don't control")
assert.equal(sourceFromGraph(model).source, `# Test [supported]
on enters(each nontoken angel you don't control):`)
})
test('parseCall splits arguments outside nested groups', () => {
assert.deepEqual(parseCall('draw(you, 1)'), { name: 'draw', args: ['you', '1'] })
assert.deepEqual(parseCall('proliferate()'), { name: 'proliferate', args: [] })
assert.deepEqual(parseCall('damage(divided(any number, creature), 3)'), {
name: 'damage',
args: ['divided(any number, creature)', '3'],
})
assert.equal(parseCall('if you control at least 3 artifacts:'), undefined)
})

View File

@@ -0,0 +1,85 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { diffGameState } from '../app/utils/gameAnimations.ts'
test('diffGameState ignores the first snapshot', () => {
const animations = diffGameState(undefined, {
id: 'game',
players: [{ id: 'p1', life: 40, battlefield: [{ id: 'card-1' }] }],
game: { manaPool: { G: 2 } },
})
assert.deepEqual(animations, {
enteringCardIds: [],
attackingCardIds: [],
damagedCards: [],
lifeChanges: [],
manaGains: [],
})
})
test('diffGameState detects entering and attacking permanents', () => {
const animations = diffGameState(
{ id: 'game', players: [{ id: 'p1', battlefield: [{ id: 'old' }] }] },
{
id: 'game',
players: [{
id: 'p1',
battlefield: [{ id: 'old' }, { id: 'new', attacking: 'p2' }],
}],
},
)
assert.deepEqual(animations.enteringCardIds, ['new'])
assert.deepEqual(animations.attackingCardIds, ['new'])
})
test('diffGameState reports damage and life changes', () => {
const animations = diffGameState(
{
id: 'game',
players: [
{ id: 'p1', life: 40, battlefield: [{ id: 'creature', damage: 1 }] },
{ id: 'p2', life: 40 },
],
},
{
id: 'game',
players: [
{ id: 'p1', life: 40, battlefield: [{ id: 'creature', damage: 4 }] },
{ id: 'p2', life: 33 },
],
},
)
assert.deepEqual(animations.damagedCards, [{ cardId: 'creature', amount: 3 }])
assert.deepEqual(animations.lifeChanges, [{ playerId: 'p2', amount: -7 }])
})
test('diffGameState only animates mana gains', () => {
const animations = diffGameState(
{ id: 'game', players: [], game: { manaPool: { G: 1, R: 2 } } },
{ id: 'game', players: [], game: { manaPool: { G: 3, R: 0, U: 1 } } },
)
assert.deepEqual(animations.manaGains, [
{ color: 'G', amount: 2 },
{ color: 'U', amount: 1 },
])
})
test('diffGameState is quiet when nothing visible changed', () => {
const state = {
id: 'game',
players: [{ id: 'p1', life: 40, battlefield: [{ id: 'creature', damage: 2 }] }],
game: { manaPool: { W: 1 } },
}
assert.deepEqual(diffGameState(state, state), {
enteringCardIds: [],
attackingCardIds: [],
damagedCards: [],
lifeChanges: [],
manaGains: [],
})
})