diff --git a/README.md b/README.md index 8eccd69..ef50cd2 100644 --- a/README.md +++ b/README.md @@ -284,6 +284,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 }` | diff --git a/backend/docs/card-effects.md b/backend/docs/card-effects.md index 5a5efe2..c8c04cc 100644 --- a/backend/docs/card-effects.md +++ b/backend/docs/card-effects.md @@ -165,6 +165,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 @@ -182,7 +184,7 @@ The types live in `src/effects/types.ts`. A card contains one or more abilities: | `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 | @@ -191,6 +193,9 @@ The types live in `src/effects/types.ts`. A card contains one or more abilities: | `restriction` | target, rule, duration | | `keyword_action` | `action`, optional `amount`, `detail`, `target` | | `proliferate` | no payload | +| `hideaway` | `amount`; exiles the top card and links 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 | ### Targets, values, costs @@ -202,8 +207,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. diff --git a/backend/docs/game-engine.md b/backend/docs/game-engine.md index a4978d7..7e46257 100644 --- a/backend/docs/game-engine.md +++ b/backend/docs/game-engine.md @@ -58,7 +58,7 @@ const bolt: CardDefinition = { | ------ | ------- | | `start()` | Shuffles libraries, draws opening hands, begins turn 1. | | `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. | +| `castSpell(playerId, cardId, { targets, x, mode, overload })` | Puts a spell on the stack and pays its mana cost. Accepts a commander in the command zone, adds commander tax, and can pay the overload cost instead. | | `activateAbility(playerId, sourceId, abilityIndex, { targets, x, mode })` | Activates an ability on a permanent. Mana abilities resolve immediately. | | `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. | @@ -66,6 +66,7 @@ const bolt: CardDefinition = { | `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. | +| `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. | @@ -78,7 +79,13 @@ 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. ## Turn structure @@ -100,20 +107,27 @@ shown to players who can actually do something. - 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. +- 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. @@ -136,6 +150,16 @@ shown to players who can actually do something. - 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 effects with several matching cards do pause for the player's pick. +- "As this enters, choose a creature type" pauses for a pick and stores the type on + the permanent, but no effect reads the chosen type yet. The other `choose` kinds + (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 automatically exiles the top card and does not track cards as face down. + `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 are kept automatically; there is no mulligan flow. - Replacement/prevention effects, layers, and dependency ordering are simplified. Continuous effects apply in creation order rather than in full rules order. diff --git a/backend/src/accounts.ts b/backend/src/accounts.ts index e10e689..0833ce7 100644 --- a/backend/src/accounts.ts +++ b/backend/src/accounts.ts @@ -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() + if (created?.shareToken) return { token: created.shareToken } + + const existing = await Deck.findOne({ owner: user.id, deckId }).lean() + 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() + 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) diff --git a/backend/src/effects/compile.ts b/backend/src/effects/compile.ts index 07469a8..c91128e 100644 --- a/backend/src/effects/compile.ts +++ b/backend/src/effects/compile.ts @@ -448,6 +448,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 +497,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 @@ -750,6 +790,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]) @@ -1084,6 +1126,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 +1404,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 +1683,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) { @@ -1875,6 +1948,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 +1996,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 } : {}), + }] } } @@ -2101,6 +2209,28 @@ function compileLine(rawLine: string, name: string, known: Set, 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')) diff --git a/backend/src/effects/format.ts b/backend/src/effects/format.ts index e28b7e5..69a5131 100644 --- a/backend/src/effects/format.ts +++ b/backend/src/effects/format.ts @@ -58,11 +58,12 @@ function formatSelector(selector: ObjectSelector): string { if (selector.token) parts.push('token') if (selector.token === false) parts.push('nontoken') if (selector.attached) parts.push(selector.attached) + const joiner = selector.match === 'any' ? ' or ' : ' and ' if (selector.colors?.length) { - parts.push(selector.colors.map(color => COLOR_NAMES[color] ?? color).join(' and ')) + parts.push(selector.colors.map(color => COLOR_NAMES[color] ?? color).join(joiner)) } - if (selector.supertypes?.length) parts.push(...selector.supertypes) - if (selector.subtypes?.length) parts.push(selector.subtypes.join(' ')) + if (selector.supertypes?.length) parts.push(selector.supertypes.join(joiner)) + if (selector.subtypes?.length) parts.push(selector.subtypes.join(joiner)) if (selector.types?.length) { parts.push(selector.types.join(selector.match === 'any' ? ' or ' : ' ')) } @@ -281,7 +282,7 @@ export function formatEffect(effect: Effect): string { case 'surveil': return `surveil(${effect.player}, ${formatValue(effect.amount)})` case 'search': - return `search(${effect.player}, ${formatSelector(effect.selector)}, ${formatValue(effect.amount)}, to ${effect.destination}${effect.zones?.length === 2 ? ', library+graveyard' : ''}${effect.tapped ? ', tapped' : ''}${effect.shuffle ? ', shuffle' : ''})` + return `search(${effect.player}, ${formatSelector(effect.selector)}, ${formatValue(effect.amount)}, to ${effect.destination}${effect.zones?.length === 2 ? ', library+graveyard' : ''}${effect.tapped ? ', tapped' : ''}${effect.split ? `, then ${effect.split.destination}${effect.split.tapped ? ' tapped' : ''}` : ''}${effect.shuffle ? ', shuffle' : ''})` case 'shuffle': return `shuffle(${effect.player})` case 'add_mana': @@ -329,6 +330,12 @@ export function formatEffect(effect: Effect): string { return `schedule(${effect.when}):\n${indent(effect.effects.map(formatEffect).join('\n'))}` case 'damage_divided': return `damage_divided(${formatValue(effect.amount)}, ${formatTarget(effect.target)})` + case 'exile_graveyards': + return 'exile_graveyards()' + case 'hideaway': + return `hideaway(${formatValue(effect.amount)})` + case 'play_exiled': + return `play_exiled(${effect.player}${effect.free ? ', free' : ''})` } } @@ -460,6 +467,16 @@ function formatCondition(condition: Condition): string { return "you don't" case 'otherwise': return 'otherwise' + case 'you_control_commander': + return 'you control a commander' + case 'distinct_names': + return `you control ${condition.atLeast}+ ${formatSelector(condition.selector)} with different names` + case 'opponent_damaged_this_turn': + return `an opponent was dealt ${condition.atLeast}+ damage this turn` + case 'attacked_with_creatures': + return `you attacked with ${condition.atLeast}+ creatures this turn` + case 'library_at_most': + return `a library has ${condition.atMost} or fewer cards in it` } } @@ -536,7 +553,13 @@ function formatStaticEffect(effect: StaticEffect): string { case 'replacement': return `replace(${effect.what}${effect.target ? `, ${formatTarget(effect.target)}` : ''}, instead ${effect.instead})` case 'cost_reduction': - return `cost_reduction(${formatTarget(effect.target)}, ${formatValue(effect.amount)}${effect.condition ? `, if ${formatCondition(effect.condition)}` : ''})` + return `cost_reduction(${formatTarget(effect.target)}, ${effect.symbols ?? (effect.amount ? formatValue(effect.amount) : '0')}${effect.condition ? `, if ${formatCondition(effect.condition)}` : ''})` + case 'cost_increase': + return `cost_increase(${formatValue(effect.amount)}${effect.spellType ? `, ${effect.spellType}` : ''})` + case 'search_restriction': + return `search_restriction(${effect.who}, ${formatValue(effect.amount)})` + case 'exile_instead_of_graveyard': + return `exile_instead_of_graveyard(${effect.owner ?? ''})` } } @@ -575,6 +598,12 @@ export function formatAbility(ability: Ability): string { return `spell${ability.optional ? ' (may)' : ''}:\n${indent(ability.effects.map(formatEffect).join('\n'))}` case 'additional_cost': return `additional cost${ability.optional ? ' (may)' : ''}: ${ability.costs.map(formatCost).join(', ')}` + case 'alternative_cost': { + const condition = ability.condition ? ` if ${formatCondition(ability.condition)}` : '' + return `alternative cost${condition}: ${ability.costs.length ? ability.costs.map(formatCost).join(', ') : 'free'}` + } + case 'overload': + return `overload ${ability.cost}` case 'chapter': return `chapter ${ability.chapters.join(', ')}${ability.optional ? ' (may)' : ''}:\n${indent(ability.effects.map(formatEffect).join('\n'))}` case 'level_band': { diff --git a/backend/src/effects/parse.ts b/backend/src/effects/parse.ts index 1fac006..32ec982 100644 --- a/backend/src/effects/parse.ts +++ b/backend/src/effects/parse.ts @@ -350,6 +350,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]] @@ -805,6 +816,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 +922,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]) diff --git a/backend/src/effects/pseudo.ts b/backend/src/effects/pseudo.ts index e027258..211bb01 100644 --- a/backend/src/effects/pseudo.ts +++ b/backend/src/effects/pseudo.ts @@ -816,6 +816,16 @@ function parseEffectExpr(text: string, line: SourceLine): Effect { } case 'proliferate': return { op: 'proliferate' } + case 'exile_graveyards': + return { op: 'exile_graveyards' } + case 'hideaway': + return { op: 'hideaway', amount: parseValueText(arg(args, 0, line), line) } + case 'play_exiled': + return { + op: 'play_exiled', + player: parsePlayer(arg(args, 0, line), line), + free: args[1]?.trim() === 'free' || undefined, + } case 'create_token': { const rest = args.slice(2).join(', ').trim() if (rest.startsWith('copy of ')) { @@ -903,6 +913,20 @@ function parseEffectExpr(text: string, line: SourceLine): Effect { if (!['hand', 'battlefield', 'graveyard', 'top', 'bottom'].includes(destination)) { fail(line, `unknown search destination "${destination}"`) } + const splitIndex = args.findIndex(value => /^then /.test(value.trim())) + let split: { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean } | undefined + if (splitIndex >= 0) { + const splitText = args[splitIndex].trim().replace(/^then /, '') + const splitTapped = / tapped$/.test(splitText) + const splitDestination = splitText.replace(/ tapped$/, '') + if (!['hand', 'battlefield', 'graveyard', 'top', 'bottom'].includes(splitDestination)) { + fail(line, `unknown search destination "${splitDestination}"`) + } + split = { + destination: splitDestination as 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom', + tapped: splitTapped, + } + } const before = args.slice(1, destinationIndex) const amountText = before[before.length - 1] if (amountText === undefined) fail(line, 'search needs an amount') @@ -914,6 +938,7 @@ function parseEffectExpr(text: string, line: SourceLine): Effect { destination: destination as 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom', tapped: args.includes('tapped'), shuffle: args.includes('shuffle'), + ...(split ? { split } : {}), ...(args.includes('library+graveyard') ? { zones: ['library', 'graveyard'] as ('library' | 'graveyard')[] } : {}), } } @@ -1164,6 +1189,7 @@ function parseConditionText(text: string, line: SourceLine): Condition { return { kind: 'cast_spell_this_turn', noncreature: true } } if (trimmed === 'you have a full party') return { kind: 'full_party' } + if (trimmed === 'you control a commander') return { kind: 'you_control_commander' } if (trimmed === 'no spells were cast last turn') return { kind: 'no_spells_last_turn' } if (trimmed === 'no creatures attacked this turn') return { kind: 'no_attackers' } if (trimmed === "tribute wasn't paid") return { kind: 'tribute_not_paid' } @@ -1188,8 +1214,17 @@ function parseConditionText(text: string, line: SourceLine): Condition { if (trimmed === 'otherwise') return { kind: 'otherwise' } if (trimmed === 'defending player controls') return fail(line, 'missing defending-player selector') - let match = trimmed.match(/^you control (\d+)\+ creatures with different powers$/) + let match = trimmed.match(/^an opponent was dealt (\d+)\+ damage this turn$/) + if (match) return { kind: 'opponent_damaged_this_turn', atLeast: Number(match[1]) } + match = trimmed.match(/^you attacked with (\d+)\+ creatures this turn$/) + if (match) return { kind: 'attacked_with_creatures', atLeast: Number(match[1]) } + match = trimmed.match(/^a library has (\d+) or fewer cards in it$/) + if (match) return { kind: 'library_at_most', atMost: Number(match[1]) } + + match = trimmed.match(/^you control (\d+)\+ creatures with different powers$/) if (match) return { kind: 'distinct_powers', atLeast: Number(match[1]) } + match = trimmed.match(/^you control (\d+)\+ (.+?) with different names$/) + if (match) return { kind: 'distinct_names', selector: parseSelector(match[2], line), atLeast: Number(match[1]) } match = trimmed.match(/^you control a creature with (power|toughness) greater than its base (?:power|toughness)$/) if (match) { return { kind: 'creature_power_greater_than_base', controller: 'you', stat: match[1] as 'power' | 'toughness' } @@ -1572,13 +1607,39 @@ function parseStaticEffect(text: string, line: SourceLine): StaticEffect { } case 'cost_reduction': { const rest = args[2]?.trim() + const value = arg(args, 1, line).trim() return { op: 'cost_reduction', target: parseTarget(arg(args, 0, line), line), - amount: parseValueText(arg(args, 1, line), line), + ...(/^(?:\{[^}]+\})+$/.test(value) + ? { symbols: value } + : { amount: parseValueText(value, line) }), ...(rest?.startsWith('if ') ? { condition: parseConditionText(rest.slice(3), line) } : {}), } } + case 'cost_increase': { + const spellType = args[1]?.trim() + if (spellType && spellType !== 'noncreature' && spellType !== 'creature') { + fail(line, `unknown spell type "${spellType}"`) + } + return { + op: 'cost_increase', + amount: parseValueText(arg(args, 0, line), line), + ...(spellType ? { spellType: spellType as 'noncreature' | 'creature' } : {}), + } + } + case 'search_restriction': { + const who = arg(args, 0, line) + if (who !== 'opponent' && who !== 'you') fail(line, `unknown search restriction player "${who}"`) + return { op: 'search_restriction', who, amount: parseValueText(arg(args, 1, line), line) } + } + case 'exile_instead_of_graveyard': { + const owner = args[0]?.trim() + if (owner && owner !== 'opponent' && owner !== 'you') { + fail(line, `unknown replacement owner "${owner}"`) + } + return { op: 'exile_instead_of_graveyard', ...(owner ? { owner: owner as 'opponent' | 'you' } : {}) } + } case 'unsupported': return fail(line, 'unsupported is an ability, not a static effect') default: @@ -1643,6 +1704,20 @@ function parseAbilityBlock(block: Block): Ability { return { kind: 'additional_cost', costs: parseCosts(costsText, block.header), optional: Boolean(match[1]), text: header } } + match = header.match(/^alternative cost(?: if (.+?))?: ?(.*)$/) + if (match) { + const costsText = match[2].trim() + return { + kind: 'alternative_cost', + costs: costsText === 'free' ? [] : parseCosts(costsText, block.header), + ...(match[1] ? { condition: parseConditionText(match[1], block.header) } : {}), + text: header, + } + } + + match = header.match(/^overload ((?:\{[^}]+\})+)$/) + if (match) return { kind: 'overload', cost: match[1], text: header } + if (!header.endsWith(':')) fail(block.header, `expected an ability block, got "${header}"`) let rest = header.slice(0, -1) diff --git a/backend/src/effects/translate.ts b/backend/src/effects/translate.ts index 723004d..6c7ff62 100644 --- a/backend/src/effects/translate.ts +++ b/backend/src/effects/translate.ts @@ -137,7 +137,7 @@ Static effects: 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 ]) + cost_reduction(target, amount|{R}{G}[, if ]) Common conditions: you control , you control at least N , an opponent controls , it is your turn, it isn't your turn, diff --git a/backend/src/effects/types.ts b/backend/src/effects/types.ts index 53ec32a..aab189e 100644 --- a/backend/src/effects/types.ts +++ b/backend/src/effects/types.ts @@ -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' @@ -184,6 +186,11 @@ 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 } export type TriggerEvent = | { kind: 'enters'; subject: Target } @@ -230,7 +237,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,6 +259,9 @@ 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 } @@ -264,7 +274,10 @@ export type StaticEffect = | { 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' } export type Ability = | KeywordAbility @@ -308,6 +321,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[] diff --git a/backend/src/game/creature-types.ts b/backend/src/game/creature-types.ts new file mode 100644 index 0000000..c706da6 --- /dev/null +++ b/backend/src/game/creature-types.ts @@ -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', +] diff --git a/backend/src/game/game.ts b/backend/src/game/game.ts index 1643752..c3edac8 100644 --- a/backend/src/game/game.ts +++ b/backend/src/game/game.ts @@ -23,6 +23,7 @@ import type { GameConfig, ManaColor, ManaPool, + PendingChoice, PendingSearch, Phase, PlayerState, @@ -30,6 +31,7 @@ import type { Step, TargetChoice, } from './types.js' +import { CREATURE_TYPES } from './creature-types.js' export class GameError extends Error {} @@ -120,6 +122,37 @@ function parseManaCost(symbols: string, x = 0): ManaCost { return cost } +interface CostReduction { + generic: number + colored: ManaColor[] +} + +/** + * Generic reductions only remove generic mana; colored ones remove matching pips. + * shortcut: hybrid and phyrexian pips are not reduced; upgrade when a card needs it. + */ +function reduceManaSymbols(symbols: string, reduction: CostReduction): string { + let generic = reduction.generic + const colored = [...reduction.colored] + const result: string[] = [] + for (const match of symbols.matchAll(/\{([^}]+)\}/g)) { + const symbol = match[1].toUpperCase() + if (/^\d+$/.test(symbol) && generic > 0) { + const remaining = Math.max(0, Number(symbol) - generic) + generic = Math.max(0, generic - Number(symbol)) + if (remaining > 0) result.push(`{${remaining}}`) + continue + } + const index = colored.indexOf(symbol as ManaColor) + if (index >= 0) { + colored.splice(index, 1) + continue + } + result.push(`{${match[1]}}`) + } + return result.join('') +} + function manaValueOf(definition: CardDefinition): number { if (definition.manaValue !== undefined) return definition.manaValue const cost = parseManaCost(definition.manaCost ?? '') @@ -166,6 +199,12 @@ export class Game { winner?: string /** Blocks all other actions until the searching player picks a card. */ pendingSearch?: PendingSearch + /** "As this enters, choose..." prompts, in entry order. */ + readonly pendingChoices: PendingChoice[] = [] + + get pendingChoice(): PendingChoice | undefined { + return this.pendingChoices[0] + } private readonly config: GameConfig private readonly rng: () => number @@ -214,6 +253,8 @@ export class Game { creaturesDiedThisTurn: 0, nonlandPermanentsEnteredThisTurn: 0, attackedThisTurn: false, + creaturesAttackedThisTurn: 0, + damageTakenThisTurn: 0, energy: 0, poison: 0, })) @@ -260,6 +301,17 @@ export class Game { } } + // Leyline-style "begin the game with it on the battlefield" cards. + for (const player of this.players) { + for (const id of [...player.hand]) { + const object = this.getObject(id) + const beginsOnBattlefield = (object.definition.abilities ?? []).some(ability => + ability.kind === 'static' && ability.effects.some(effect => + effect.op === 'restriction' && effect.rule === 'begin_on_battlefield')) + if (beginsOnBattlefield) this.moveToZone(object, 'battlefield', { controller: player.id, silent: true }) + } + } + this.status = 'active' this.turn = 1 this.activePlayer = this.firstPlayer @@ -302,9 +354,10 @@ export class Game { const object = typeof objectOrId === 'string' ? this.getObject(objectOrId) : objectOrId // A commander may go to the command zone instead of the graveyard, exile, // hand, or library. This engine always takes that replacement. - const destination: Zone = object.isCommander && zone !== 'battlefield' && zone !== 'stack' && zone !== 'command' + let destination: Zone = object.isCommander && zone !== 'battlefield' && zone !== 'stack' && zone !== 'command' ? 'command' : zone + if (destination === 'graveyard' && this.exilesInsteadOfGraveyard(object)) destination = 'exile' const from = object.zone this.removeFromZone(object) object.zone = destination @@ -318,6 +371,7 @@ export class Game { object.blockedBy = [] object.blocking = undefined object.activations = {} + object.chosenCreatureType = undefined object.enteredTurn = this.turn this.getPlayer(object.controller).battlefield.push(object.id) if (from !== 'battlefield') { @@ -326,12 +380,14 @@ export class Game { } if (!options.silent) { this.applyEntersReplacements(object) + this.queueEnterChoices(object) this.dispatchEvent({ kind: 'enters', player: object.controller, subject: object }) } } } else { object.position = undefined object.controller = object.owner + object.chosenCreatureType = undefined const owner = this.getPlayer(object.owner) if (destination === 'hand') owner.hand.push(object.id) else if (destination === 'graveyard') owner.graveyard.push(object.id) @@ -517,11 +573,25 @@ export class Game { } const abilities = object.definition.abilities ?? [] - const effects = abilities.filter((ability): ability is Extract => ability.kind === 'spell') + const overload = abilities.find((ability): ability is Extract => ability.kind === 'overload') + if (options.overload && !overload) throw new GameError('That spell has no overload') + const baseEffects = abilities.filter((ability): ability is Extract => ability.kind === 'spell') .flatMap(ability => ability.effects) + const effects = options.overload ? this.overloadEffects(baseEffects) : baseEffects const targets = this.selectTargets(effects, object, playerId, options.targets ?? [], options.mode ?? 0) const tax = fromCommand ? (player.commanderCasts[object.id] ?? 0) * 2 : 0 - this.payMana(playerId, `${object.definition.manaCost ?? ''}${'{2}'.repeat(tax / 2)}`, options.x ?? 0) + const taxSymbols = '{2}'.repeat(tax / 2) + const extra = this.spellCostIncrease(object) + const alternative = this.alternativeCostFor(object) + if (options.overload && overload) { + this.payMana(playerId, `${this.reducedSpellCost(object, overload.cost)}${taxSymbols}${extra ? `{${extra}}` : ''}`, options.x ?? 0) + } else if (alternative) { + this.payAlternativeCost(alternative, playerId, object) + if (extra) this.payMana(playerId, `{${extra}}`, 0) + } else { + const cost = this.reducedSpellCost(object, object.definition.manaCost ?? '') + this.payMana(playerId, `${cost}${taxSymbols}${extra ? `{${extra}}` : ''}`, options.x ?? 0) + } this.moveToZone(object, 'stack', { controller: playerId, silent: true }) if (fromCommand) player.commanderCasts[object.id] = (player.commanderCasts[object.id] ?? 0) + 1 @@ -545,11 +615,80 @@ export class Game { return item } + private alternativeCostFor(object: GameObject): Extract | undefined { + return (object.definition.abilities ?? []).find(ability => + ability.kind === 'alternative_cost' + && (!ability.condition || this.checkCondition(ability.condition, object))) as + | Extract + | undefined + } + + private payAlternativeCost( + ability: Extract, + playerId: string, + source: GameObject, + ): void { + if (!ability.costs.length) return + this.payCosts(ability.costs, playerId, source, this.contextFor(source, playerId, [], 0, 0)) + } + + private spellCostIncrease(object: GameObject): number { + let extra = 0 + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'cost_increase') continue + if (effect.spellType === 'noncreature' && this.isCreature(object)) continue + if (effect.spellType === 'creature' && !this.isCreature(object)) continue + extra += this.value(effect.amount, this.staticContext(source)) + } + } + return extra + } + + // shortcut: only static reducers on the battlefield; a card's own "this spell + // costs less" text is not applied yet. Upgrade when self-cost cards matter. + private spellCostReduction(object: GameObject): CostReduction { + const reduction: CostReduction = { generic: 0, colored: [] } + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'cost_reduction' || effect.target.kind !== 'object') continue + if (!this.matchesSelector(object, effect.target.selector, source, object.zone)) continue + if (effect.amount) reduction.generic += this.value(effect.amount, this.staticContext(source)) + if (effect.symbols) { + const cost = parseManaCost(effect.symbols) + reduction.generic += cost.generic + reduction.colored.push(...cost.colored) + } + } + } + return reduction + } + + private reducedSpellCost(object: GameObject, symbols: string): string { + return reduceManaSymbols(symbols, this.spellCostReduction(object)) + } + + // shortcut: overload only widens top-level targets; modal/conditional nested + // effects keep their original targets. Upgrade when an overload card nests them. + private overloadEffects(effects: Effect[]): Effect[] { + return effects.map(effect => ('target' in effect && effect.target + ? { ...effect, target: this.overloadTarget(effect.target) } + : effect)) + } + + private overloadTarget(target: Target): Target { + if (target.kind === 'object' || target.kind === 'player' || target.kind === 'spell') { + return { ...target, mode: 'each' } + } + return target + } + activateAbility(playerId: string, sourceId: string, abilityIndex: number, options: ActionOptions = {}): StackItem | undefined { this.requirePriority(playerId) const source = this.getObject(sourceId) if (source.zone !== 'battlefield') throw new GameError('Ability source is not on the battlefield') if (source.controller !== playerId) throw new GameError('You do not control that permanent') + if (this.hasRestriction(source, 'cant_activate')) throw new GameError('That permanent cannot activate abilities') const ability = (source.definition.abilities ?? [])[abilityIndex] if (!ability || ability.kind !== 'activated') throw new GameError('That is not an activated ability') if (ability.condition && !this.checkCondition(ability.condition, source)) throw new GameError('Ability condition is not met') @@ -621,6 +760,7 @@ export class Game { attacker.attacking = attack.defenderId if (!this.hasKeyword(attacker, 'Vigilance')) attacker.tapped = true this.getPlayer(playerId).attackedThisTurn = true + this.getPlayer(playerId).creaturesAttackedThisTurn++ this.dispatchEvent({ kind: 'attacks', player: playerId, subject: attacker }) } @@ -643,6 +783,7 @@ export class Game { if (this.phase !== 'combat' || this.step !== 'declare_blockers') throw new GameError('Not in the declare blockers step') if (this.stack.length) throw new GameError('Cannot declare blockers while the stack is not empty') if (this.pendingSearch) throw new GameError('Choose a card from your library first') + if (this.pendingChoice) throw new GameError('Choose a creature type first') if (this.priority !== playerId) throw new GameError('You do not have priority') const seen = new Set() @@ -702,6 +843,7 @@ export class Game { pass(playerId?: string): void { if (this.status !== 'active') throw new GameError('Game is not active') if (this.pendingSearch) throw new GameError('Choose a card from your library first') + if (this.pendingChoice) throw new GameError('Choose a creature type first') const actual = playerId ?? this.priority if (this.priority !== actual) throw new GameError('You do not have priority') const alive = this.alivePlayers().length @@ -740,7 +882,8 @@ export class Game { /** Convenience for tests and scripted games: resolve the stack without advancing phases. */ resolveStack(): void { let guard = 0 - while (this.stack.length && this.status === 'active' && !this.pendingSearch && guard++ < 1000) { + while (this.stack.length && this.status === 'active' && !this.pendingSearch && !this.pendingChoice + && guard++ < 1000) { this.pass(this.priority) } } @@ -755,7 +898,7 @@ export class Game { this.step = 'end_step' this.dispatchEvent({ kind: 'end_step', player: playerId }) this.resolveStack() - if (this.status !== 'active' || this.pendingSearch) return + if (this.status !== 'active' || this.pendingSearch || this.pendingChoice) return this.finishTurn() } @@ -764,7 +907,7 @@ export class Game { * right now. Used for the client's playable state and for auto-passing. */ canPlayCard(playerId: string, cardId: string): boolean { - if (this.status !== 'active' || this.priority !== playerId || this.pendingSearch) return false + if (this.status !== 'active' || this.priority !== playerId || this.pendingSearch || this.pendingChoice) return false const player = this.getPlayer(playerId) const fromCommand = player.command.includes(cardId) if (!fromCommand && !player.hand.includes(cardId)) return false @@ -780,9 +923,20 @@ export class Game { if (!this.canCastAtThisTime(playerId, object)) return false const tax = fromCommand ? (player.commanderCasts[cardId] ?? 0) * 2 : 0 - if (!this.canAffordMana(playerId, `${object.definition.manaCost ?? ''}${'{2}'.repeat(tax / 2)}`, 0)) { + const extra = this.spellCostIncrease(object) + const alternative = this.alternativeCostFor(object) + if (alternative) { + for (const cost of alternative.costs) { + if (cost.kind !== 'mana' || !this.canAffordMana(playerId, cost.symbols, 0)) return false + } + } else if (!this.canAffordMana( + playerId, + `${this.reducedSpellCost(object, object.definition.manaCost ?? '')}${'{2}'.repeat(tax / 2)}${extra ? `{${extra}}` : ''}`, + 0, + )) { return false } + if (alternative && extra && !this.canAffordMana(playerId, `{${extra}}`, 0)) return false return this.hasLegalTargets(object, playerId) } @@ -793,12 +947,18 @@ export class Game { chooseSearchCard(playerId: string, cardId: string): void { const pending = this.pendingSearch if (!pending) throw new GameError('No search is waiting for a choice') + if (this.pendingChoice) throw new GameError('Choose a creature type first') if (pending.playerId !== playerId) throw new GameError('You are not searching your library') const object = this.searchCandidates(playerId).find(candidate => candidate.id === cardId) if (!object) throw new GameError('That card is not a legal choice') this.moveSearchedCard(object, playerId, pending.destination, pending.tapped) pending.remaining-- + if (pending.remaining > 0 && pending.split) { + pending.destination = pending.split.destination + pending.tapped = pending.split.tapped + pending.split = undefined + } if (pending.remaining <= 0 || !this.searchCandidates(playerId).length) { this.pendingSearch = undefined if (pending.shuffle) this.shuffleLibrary(this.getPlayer(playerId)) @@ -816,17 +976,45 @@ export class Game { return this.findSearchCandidates(playerId, pending.selector, pending.zones) } + /** + * Every card in the zones a pending search can look at, in search order. This + * is what the chooser sees while deciding; others get an empty list. + */ + searchPool(playerId: string): GameObject[] { + const pending = this.pendingSearch + if (!pending || pending.playerId !== playerId) return [] + return this.searchableObjects(playerId, pending.zones) + } + + /** + * Answers an "as this enters, choose a creature type" prompt. The match API + * uses the `choose_type` action. + */ + chooseCreatureType(playerId: string, type: string): void { + const pending = this.pendingChoice + if (!pending) throw new GameError('No choice is waiting') + if (pending.playerId !== playerId) throw new GameError('You are not choosing this permanent\'s type') + const chosen = CREATURE_TYPES.find(entry => entry.toLowerCase() === type.trim().toLowerCase()) + if (!chosen) throw new GameError('Choose a creature type') + const object = this.objects.get(pending.sourceId) + if (!object || object.zone !== 'battlefield') throw new GameError('That permanent is no longer on the battlefield') + object.chosenCreatureType = chosen + this.pendingChoices.shift() + this.logMessage(`${this.getPlayer(playerId).name} chooses ${chosen} for ${object.definition.name}`) + } + /** * Passes priority for players who cannot do anything meaningful. Stops at the * first player who can act, or when the turn ends, so turns never run on. */ autoAdvance(): void { - if (this.status !== 'active' || this.pendingSearch || this.autoAdvanceDepth > 0) return + if (this.status !== 'active' || this.pendingSearch || this.pendingChoice || this.autoAdvanceDepth > 0) return this.autoAdvanceDepth++ const turn = this.turn try { let guard = 0 - while (this.status === 'active' && !this.pendingSearch && this.turn === turn && guard++ < 100) { + while (this.status === 'active' && !this.pendingSearch && !this.pendingChoice + && this.turn === turn && guard++ < 100) { const actor = this.priority if (!actor || this.hasMeaningfulAction(actor)) break this.pass(actor) @@ -853,6 +1041,8 @@ export class Game { player.creaturesDiedThisTurn = 0 player.nonlandPermanentsEnteredThisTurn = 0 player.attackedThisTurn = false + player.creaturesAttackedThisTurn = 0 + player.damageTakenThisTurn = 0 player.manaPool = emptyPool() this.removeExpiringEffects(player.id) @@ -1688,6 +1878,12 @@ export class Game { } break } + case 'exile_graveyards': { + for (const player of this.players) { + for (const id of [...player.graveyard]) this.moveToZone(id, 'exile', { silent: false }) + } + break + } case 'sacrifice': { const players = this.playersForEffect(effect.player, context) if (effect.unless && this.tryPayUnless(effect.unless, players[0], context.source, context)) break @@ -1751,7 +1947,7 @@ export class Game { case 'search': { const amount = Math.max(0, this.value(effect.amount, context)) for (const playerId of this.playersForEffect(effect.player, context)) { - this.searchLibrary(playerId, effect.selector, amount, effect.destination, effect.tapped, effect.shuffle, effect.zones) + this.searchLibrary(playerId, effect.selector, amount, effect.destination, effect.tapped, effect.shuffle, effect.zones, effect.split) } break } @@ -1835,10 +2031,87 @@ export class Game { } break } + case 'hideaway': + this.hideaway(context, effect) + break + case 'play_exiled': { + const playerId = this.playersForEffect(effect.player, context)[0] + const cardId = context.source.linkedExile?.find(id => this.getObject(id).zone === 'exile') + if (!playerId || !cardId) break + const object = this.getObject(cardId) + if (this.playExiledCard(playerId, object, effect.free)) { + context.source.linkedExile = context.source.linkedExile?.filter(id => id !== cardId) + } + break + } } } } + private hideaway(context: EffectContext, effect: Extract): void { + // shortcut: auto-pick the top card; face-down exile and the look/choice are not modelled. + const player = this.getPlayer(context.controller) + const amount = this.value(effect.amount, context) + const top = player.library.slice(0, amount).map(id => this.getObject(id)) + const hidden = top.shift() + if (!hidden) return + + this.moveToZone(hidden, 'exile', { silent: true }) + context.source.linkedExile = [...(context.source.linkedExile ?? []), hidden.id] + + for (let index = top.length - 1; index > 0; index--) { + const swap = Math.floor(this.rng() * (index + 1)) + const temp = top[index] + top[index] = top[swap] + top[swap] = temp + } + for (const object of top) this.moveToZone(object, 'library', { silent: true }) + this.logMessage(`${player.name} hides away a card`) + } + + private playExiledCard(playerId: string, object: GameObject, free: boolean | undefined): boolean { + if (!free) return false + if (this.isLand(object)) { + const player = this.getPlayer(playerId) + if (player.landPlayedThisTurn || !this.isMainPhaseWithEmptyStack(playerId)) return false + player.landPlayedThisTurn = true + this.moveToZone(object, 'battlefield', { controller: playerId, silent: false }) + this.logMessage(`${this.getPlayer(playerId).name} plays ${object.definition.name} from exile`) + return true + } + if (!this.canCastAtThisTime(playerId, object)) return false + + const effects = (object.definition.abilities ?? []) + .filter((ability): ability is Extract => ability.kind === 'spell') + .flatMap(ability => ability.effects) + let targets: TargetChoice[] + try { + targets = this.selectTargets(effects, object, playerId, [], 0) + } catch { + return false + } + + this.moveToZone(object, 'stack', { controller: playerId, silent: true }) + const item: StackItem = { + id: this.generateId('stack'), + kind: 'spell', + source: object, + controller: playerId, + label: object.definition.name, + effects, + targets, + x: 0, + mode: 0, + } + this.stack.push(item) + this.getPlayer(playerId).spellsCastThisTurn++ + this.passesInRow = 0 + this.priority = this.nextAlivePlayer(playerId) + this.dispatchEvent({ kind: 'cast', player: playerId, subject: object, spell: object, spellItem: item }) + this.logMessage(`${this.getPlayer(playerId).name} casts ${object.definition.name} from exile`) + return true + } + private dig( context: EffectContext, effect: Extract, @@ -1965,6 +2238,7 @@ export class Game { const defender = this.getPlayer(target.id) defender.commanderDamage[source.id] = (defender.commanderDamage[source.id] ?? 0) + amount } + this.getPlayer(target.id).damageTakenThisTurn += amount this.loseLife(target.id, amount) this.dispatchEvent({ kind: 'deals_damage', player: source.controller, subject: source, recipient: 'player', amount, combat }) } else if (target.kind === 'object') { @@ -2206,6 +2480,18 @@ export class Game { return this.objectsMatching(target.selector, source) } + private exilesInsteadOfGraveyard(object: GameObject): boolean { + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'exile_instead_of_graveyard') continue + if (effect.owner === 'opponent' && object.owner === source.controller) continue + if (effect.owner === 'you' && object.owner !== source.controller) continue + return true + } + } + return false + } + private applyEntersReplacements(object: GameObject): void { for (const staticSource of this.staticAbilities()) { for (const effect of staticSource.ability.effects) { @@ -2223,6 +2509,16 @@ export class Game { } } + /** Queues the "as this enters, choose a creature type" prompt for a new permanent. */ + private queueEnterChoices(object: GameObject): void { + for (const ability of object.definition.abilities ?? []) { + if (ability.kind !== 'static') continue + if (!ability.effects.some(effect => effect.op === 'choose' && effect.what === 'creature_type')) continue + this.pendingChoices.push({ playerId: object.controller, sourceId: object.id, what: 'creature_type' }) + return + } + } + private hasRestriction(object: GameObject, rule: string): boolean { for (const staticSource of this.staticAbilities()) { for (const effect of staticSource.ability.effects) { @@ -2278,11 +2574,22 @@ export class Game { return this.getPlayer(controller).attackedThisTurn case 'you_attacked_this_turn': return this.getPlayer(controller).attackedThisTurn + case 'attacked_with_creatures': + return this.getPlayer(controller).creaturesAttackedThisTurn >= condition.atLeast + case 'opponent_damaged_this_turn': + return this.opponentsOf(controller) + .some(playerId => this.getPlayer(playerId).damageTakenThisTurn >= condition.atLeast) + case 'library_at_most': + return this.alivePlayers().some(player => player.library.length <= condition.atMost) case 'no_objects': return this.objectsMatching(condition.selector, source).length === 0 - case 'cards_in_hand_at_most': - return this.playersForValue(condition.who, this.staticContext(source)) - .some(playerId => this.getPlayer(playerId).hand.length <= condition.atMost) + case 'cards_in_hand_at_most': { + const players = this.playersForValue(condition.who, this.staticContext(source)) + const check = (playerId: string): boolean => this.getPlayer(playerId).hand.length <= condition.atMost + return condition.who === 'each_player' || condition.who === 'each_opponent' + ? players.every(check) + : players.some(check) + } case 'on_battlefield': return source.zone === 'battlefield' case 'in_graveyard': @@ -2291,6 +2598,16 @@ export class Game { return !source.isToken case 'full_party': return false + case 'you_control_commander': + return this.battlefieldObjects().some(object => object.controller === controller && object.isCommander) + case 'distinct_names': + return new Set(this.objectsMatching(condition.selector, source) + .filter(object => object.controller === controller) + .map(object => object.definition.name.toLowerCase())).size >= condition.atLeast + case 'total_power': + return this.battlefieldObjects() + .filter(object => object.controller === controller && this.isCreature(object)) + .reduce((total, object) => total + this.getPower(object), 0) >= condition.atLeast default: return false } @@ -2382,7 +2699,7 @@ export class Game { } private hasMeaningfulAction(playerId: string): boolean { - if (this.status !== 'active' || this.priority !== playerId) return false + if (this.status !== 'active' || this.priority !== playerId || this.pendingChoice) return false const player = this.getPlayer(playerId) if (player.lost) return false @@ -2420,6 +2737,7 @@ export class Game { ability: Extract, ): boolean { if (source.zone !== 'battlefield' || source.controller !== playerId) return false + if (this.hasRestriction(source, 'cant_activate')) return false if (ability.condition && !this.checkCondition(ability.condition, source)) return false if (ability.timing === 'sorcery' && !this.isMainPhaseWithEmptyStack(playerId)) return false if (ability.costs.some(cost => cost.kind === 'tap') && this.isCreature(source) @@ -2553,6 +2871,7 @@ export class Game { object.attacking = undefined object.blockedBy = [] object.blocking = undefined + object.linkedExile = undefined for (let index = this.continuousEffects.length - 1; index >= 0; index--) { const effect = this.continuousEffects[index] @@ -2687,6 +3006,7 @@ export class Game { tapped: boolean, shuffle: boolean, zones?: ('library' | 'graveyard')[], + split?: { destination: 'hand' | 'battlefield' | 'graveyard' | 'top' | 'bottom'; tapped: boolean }, ): void { // shortcut: a search only pauses itself; later effects in the same ability // still run before the pick, and a second search in that ability is skipped. @@ -2694,15 +3014,28 @@ export class Game { if (this.pendingSearch) return const player = this.getPlayer(playerId) let remaining = amount + let first = true while (remaining > 0) { + const pickDestination = first ? destination : (split?.destination ?? destination) + const pickTapped = first ? tapped : (split?.tapped ?? tapped) const candidates = this.findSearchCandidates(playerId, selector, zones) if (!candidates.length) break if (candidates.length > 1) { - this.pendingSearch = { playerId, selector, remaining, destination, tapped, shuffle, zones } + this.pendingSearch = { + playerId, + selector, + remaining, + destination: pickDestination, + tapped: pickTapped, + shuffle, + zones, + ...(first && split && remaining > 1 ? { split } : {}), + } return } - this.moveSearchedCard(candidates[0], playerId, destination, tapped) + this.moveSearchedCard(candidates[0], playerId, pickDestination, pickTapped) remaining-- + first = false } if (shuffle) this.shuffleLibrary(player) } @@ -2712,14 +3045,20 @@ export class Game { selector: ObjectSelector, zones?: ('library' | 'graveyard')[], ): GameObject[] { - const player = this.getPlayer(playerId) const source = this.playerSource(playerId) + return this.searchableObjects(playerId, zones) + .filter(object => this.matchesSelector(object, selector, source, object.zone)) + } + + private searchableObjects(playerId: string, zones?: ('library' | 'graveyard')[]): GameObject[] { + const player = this.getPlayer(playerId) const allowed = zones ?? ['library'] - const ids = allowed.includes('library') ? [...player.library] : [] + const libraryLimit = this.searchLibraryLimit(playerId) + const ids = allowed.includes('library') + ? player.library.slice(0, libraryLimit ?? player.library.length) + : [] if (allowed.includes('graveyard')) ids.push(...player.graveyard) - return ids.map(id => this.getObject(id)) - .filter(object => object.owner === playerId - && this.matchesSelector(object, selector, source, object.zone)) + return ids.map(id => this.getObject(id)).filter(object => object.owner === playerId) } private moveSearchedCard( @@ -2741,6 +3080,23 @@ export class Game { } } + // shortcut: the limit is recomputed after each pick, so a multi-card search + // can see one new card per pick. Upgrade when a card searches for several + // cards while Aven Mindcensor is out. + private searchLibraryLimit(playerId: string): number | undefined { + let limit: number | undefined + for (const { source, ability } of this.staticAbilities()) { + for (const effect of ability.effects) { + if (effect.op !== 'search_restriction') continue + const applies = effect.who === 'you' ? playerId === source.controller : playerId !== source.controller + if (!applies) continue + const amount = this.value(effect.amount, this.staticContext(source)) + limit = limit === undefined ? amount : Math.min(limit, amount) + } + } + return limit + } + private shuffleLibrary(player: PlayerState): void { for (let index = player.library.length - 1; index > 0; index--) { const swap = Math.floor(this.rng() * (index + 1)) @@ -2774,13 +3130,16 @@ export class Game { const typeLine = object.definition.typeLine.toLowerCase() const words = new Set(typeLine.split(/[\s—–\-/,()]+/).filter(Boolean)) - if (selector.types?.length) { - const matches = selector.types.map(type => words.has(type.toLowerCase())) - if (selector.match === 'any' ? !matches.some(Boolean) : !matches.every(Boolean)) return false + const matchesWords = (values: string[]): boolean => { + const matches = values.map(value => words.has(value.toLowerCase())) + return selector.match === 'any' ? matches.some(Boolean) : matches.every(Boolean) } + // "Permanent" is a zone property, not a word on the type line. + const types = selector.types?.filter(type => type.toLowerCase() !== 'permanent') + if (types?.length && !matchesWords(types)) return false if (selector.excludeTypes?.some(type => words.has(type.toLowerCase()))) return false - if (selector.supertypes?.some(type => !words.has(type.toLowerCase()))) return false - if (selector.subtypes?.some(type => !words.has(type.toLowerCase()))) return false + if (selector.supertypes?.length && !matchesWords(selector.supertypes)) return false + if (selector.subtypes?.length && !matchesWords(selector.subtypes)) return false if (selector.controller === 'you' && object.controller !== source.controller) return false if (selector.controller === 'opponent' && object.controller === source.controller) return false @@ -2788,7 +3147,10 @@ export class Game { if (selector.owner === 'opponent' && object.owner === source.controller) return false const colors = object.definition.colors ?? [] - if (selector.colors?.some(color => !colors.includes(color))) return false + if (selector.colors?.length) { + const matches = selector.colors.map(color => colors.includes(color)) + if (selector.match === 'any' ? !matches.some(Boolean) : !matches.every(Boolean)) return false + } if (selector.tapped !== undefined && object.tapped !== selector.tapped) return false if (selector.attacking !== undefined && Boolean(object.attacking) !== selector.attacking) return false if (selector.token !== undefined && object.isToken !== selector.token) return false @@ -2886,6 +3248,7 @@ export class Game { private requirePriority(playerId: string): void { if (this.status !== 'active') throw new GameError('Game is not active') if (this.pendingSearch) throw new GameError('Choose a card from your library first') + if (this.pendingChoice) throw new GameError('Choose a creature type first') if (this.priority !== playerId) throw new GameError('You do not have priority') } diff --git a/backend/src/game/rooms.ts b/backend/src/game/rooms.ts index f870a3b..8709bbf 100644 --- a/backend/src/game/rooms.ts +++ b/backend/src/game/rooms.ts @@ -2,6 +2,7 @@ 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' @@ -25,6 +26,8 @@ export interface ActionPayload { targets?: TargetChoice[] x?: number mode?: number + overload?: boolean + choice?: string position?: { x?: unknown; y?: unknown } attackers?: { attackerId: string; defenderId: string }[] blocks?: { blockerId: string; attackerId: string }[] @@ -54,6 +57,8 @@ export interface CardView { attacking?: string blockedBy: string[] blocking?: string + /** Creature type chosen as this permanent entered, if any. */ + chosenType?: string abilities: { index: number; kind: string; text?: string }[] /** Viewer-specific: can this card be played from hand right now? */ playable?: boolean @@ -115,6 +120,17 @@ 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 + /** Choices to offer, populated only for the chooser. */ + options: string[] } } } @@ -403,6 +419,7 @@ 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, } try { @@ -425,6 +442,10 @@ export function performAction(matchId: string, token: string | undefined, action case 'choose_search': game.chooseSearchCard(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 'attack': if (!Array.isArray(action.attackers)) throw new MatchError('Invalid attackers') game.declareAttackers(seat.playerId, action.attackers.map(entry => ({ @@ -490,6 +511,7 @@ function cardView(game: Game, object: GameObject, abilities = true): CardView { attacking: object.attacking, blockedBy: [...object.blockedBy], blocking: object.blocking, + chosenType: object.chosenCreatureType, abilities: abilities ? (definition.abilities ?? []).map((ability, index) => ({ index, @@ -548,6 +570,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, @@ -568,6 +591,15 @@ 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', + options: choice.playerId === viewerId ? [...CREATURE_TYPES] : [], + } + : undefined, pendingSearch: search ? { player: search.playerId, @@ -576,6 +608,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, } diff --git a/backend/src/game/types.ts b/backend/src/game/types.ts index 1a7174d..368b7b8 100644 --- a/backend/src/game/types.ts +++ b/backend/src/game/types.ts @@ -64,6 +64,8 @@ export interface PlayerState { creaturesDiedThisTurn: number nonlandPermanentsEnteredThisTurn: number attackedThisTurn: boolean + creaturesAttackedThisTurn: number + damageTakenThisTurn: number energy: number poison: number } @@ -90,6 +92,10 @@ export interface GameObject { blocking?: string attachments: string[] attachedTo?: string + /** Cards exiled with this object, such as a card hidden by hideaway. */ + linkedExile?: string[] + /** Creature type chosen as this permanent entered (Cavern of Souls). */ + chosenCreatureType?: string regenerationShields: number activations: Record } @@ -118,6 +124,7 @@ export interface ActionOptions { targets?: TargetChoice[] x?: number mode?: number + overload?: boolean } /** A search that is waiting for its player to pick one of several matching cards. */ @@ -129,6 +136,15 @@ 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 } +} + +/** An "as this enters, choose..." pause. Blocks all actions until its controller picks. */ +export interface PendingChoice { + playerId: string + sourceId: string + what: 'creature_type' } export interface CombatAttack { diff --git a/backend/test/effects.test.ts b/backend/test/effects.test.ts index 293cf81..5ee8c84 100644 --- a/backend/test/effects.test.ts +++ b/backend/test/effects.test.ts @@ -56,6 +56,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') @@ -283,6 +339,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 +398,152 @@ 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 pseudocode', () => { + 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 pseudo = formatAbility(ability) + const reparsed = parsePseudoCard(`# Test [supported]\n${pseudo}`).abilities[0] + assert.ok(reparsed) + assert.equal(formatAbility(reparsed), pseudo) + } +}) diff --git a/backend/test/game.test.ts b/backend/test/game.test.ts index 8e8351f..9a76284 100644 --- a/backend/test/game.test.ts +++ b/backend/test/game.test.ts @@ -127,6 +127,104 @@ test('permanents can be repositioned by their controller and positions are clear assert.equal(bear.position, undefined) }) +test('hideaway exiles a card and its linked ability plays it for free once the condition is met', () => { + const hideawayLand = card('Hideaway Test', { + typeLine: 'Land', + abilities: [ + { + kind: 'triggered', + event: { kind: 'enters', subject: { kind: 'self' } }, + effects: [{ op: 'hideaway', amount: { kind: 'number', value: 4 } }], + optional: false, + text: 'Hideaway 4', + }, + { + kind: 'activated', + costs: [], + effects: [{ + op: 'conditional', + condition: { kind: 'total_power', controller: 'you', atLeast: 10 }, + effects: [{ op: 'play_exiled', player: 'you', free: true }], + }], + optional: false, + text: 'Play the exiled card without paying its mana cost if creatures you control have total power 10 or greater.', + }, + ], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const hidden = game.addCard('p1', creature('Hidden Bear', 2, 2), 'library') + const library = game.getPlayer('p1').library + library.splice(library.indexOf(hidden.id), 1) + library.unshift(hidden.id) + const land = game.addCard('p1', hideawayLand, 'hand') + + game.playLand('p1', land.id) + game.resolveStack() + + assert.equal(hidden.zone, 'exile') + assert.deepEqual(land.linkedExile, [hidden.id]) + + game.activateAbility('p1', land.id, 1) + game.resolveStack() + assert.equal(hidden.zone, 'exile') + + game.addCard('p1', creature('Big Bear', 10, 10), 'battlefield') + game.activateAbility('p1', land.id, 1) + game.resolveStack() + + assert.equal(hidden.zone, 'battlefield') + assert.ok(game.getPlayer('p1').battlefield.includes(hidden.id)) +}) + +test('playing a card hidden by hideaway uses the land drop', () => { + const hideawayLand = card('Hideaway Land', { + typeLine: 'Land', + abilities: [ + { + kind: 'triggered', + event: { kind: 'enters', subject: { kind: 'self' } }, + effects: [{ op: 'hideaway', amount: { kind: 'number', value: 1 } }], + optional: false, + text: 'Hideaway 1', + }, + { + kind: 'activated', + costs: [], + effects: [{ + op: 'conditional', + condition: { kind: 'total_power', controller: 'you', atLeast: 0 }, + effects: [{ op: 'play_exiled', player: 'you', free: true }], + }], + optional: false, + text: 'Play the exiled card without paying its mana cost.', + }, + ], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const hidden = game.addCard('p1', land('Island', 'U'), 'library') + const library = game.getPlayer('p1').library + library.splice(library.indexOf(hidden.id), 1) + library.unshift(hidden.id) + const source = game.addCard('p1', hideawayLand, 'hand') + + game.playLand('p1', source.id) + game.resolveStack() + assert.equal(hidden.zone, 'exile') + + game.getPlayer('p1').landPlayedThisTurn = true + game.activateAbility('p1', source.id, 1) + game.resolveStack() + assert.equal(hidden.zone, 'exile') + + game.getPlayer('p1').landPlayedThisTurn = false + game.activateAbility('p1', source.id, 1) + game.resolveStack() + assert.equal(hidden.zone, 'battlefield') + assert.equal(game.getPlayer('p1').landPlayedThisTurn, true) +}) + test('enters triggers from compiled card code fire and resolve through the stack', () => { const soulWarden = card('Soul Warden', { typeLine: 'Creature — Human Cleric', @@ -414,6 +512,69 @@ test('search effects let the player pick among multiple matching cards', () => { assert.ok(game.getPlayer('p1').library.includes(forestObject.id)) }) +test('as-enters creature type choices pause until the controller picks', () => { + const cavern = card('Cavern of Souls', { + typeLine: 'Land', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'static', + effects: [{ op: 'choose', what: 'creature_type' }], + text: 'As this enters, choose a creature type.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const object = game.addCard('p1', cavern, 'hand') + game.playLand('p1', object.id) + + assert.equal(game.pendingChoice?.sourceId, object.id) + assert.equal(game.pendingChoice?.playerId, 'p1') + assert.throws(() => game.pass('p1'), GameError) + assert.throws(() => game.chooseCreatureType('p2', 'Elf'), GameError) + assert.throws(() => game.chooseCreatureType('p1', 'Not A Type'), GameError) + + game.chooseCreatureType('p1', 'elf') + assert.equal(object.chosenCreatureType, 'Elf') + assert.equal(game.pendingChoice, undefined) + + game.moveToZone(object, 'graveyard') + assert.equal(object.chosenCreatureType, undefined) + game.moveToZone(object, 'battlefield', { silent: false }) + assert.equal(game.pendingChoice?.sourceId, object.id) +}) + +test('a split search sends the first pick to the battlefield and the next to hand', () => { + const forest = land('Forest', 'G') + const island = land('Island', 'U') + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const forestObject = game.addCard('p1', forest, 'library') + const islandObject = game.addCard('p1', island, 'library') + const cultivate = game.addCard('p1', spell('Cultivate', [{ + 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 }, + }]), 'hand') + + game.castSpell('p1', cultivate.id) + game.resolveStack() + + game.chooseSearchCard('p1', islandObject.id) + assert.equal(game.pendingSearch?.destination, 'hand') + game.chooseSearchCard('p1', forestObject.id) + + assert.equal(game.pendingSearch, undefined) + assert.ok(game.getPlayer('p1').battlefield.includes(islandObject.id)) + assert.equal(islandObject.tapped, true) + assert.ok(game.getPlayer('p1').hand.includes(forestObject.id)) +}) + test('autoAdvance stops instead of passing while a search needs a pick', () => { const game = setup([{ id: 'p1' }, { id: 'p2' }]) game.start() @@ -645,3 +806,427 @@ test('counter-removal costs are paid and fail when counters run out', () => { assert.throws(() => game.activateAbility('p1', source.id, 0), GameError) assert.equal(source.counters.spore, 1) }) + +test('a free alternative cost needs a commander and skips the mana cost', () => { + const maneuver = card('Flawless Maneuver', { + typeLine: 'Instant', + manaCost: '{2}{W}', + manaValue: 3, + abilities: [ + { + kind: 'alternative_cost', + costs: [], + condition: { kind: 'you_control_commander' }, + text: 'If you control a commander, you may cast this spell without paying its mana cost.', + }, + { + kind: 'spell', + effects: [{ + op: 'grant', + target: { kind: 'object', selector: { controller: 'you', types: ['creature'] }, mode: 'each' }, + keyword: 'Indestructible', + duration: 'until_end_of_turn', + }], + optional: false, + text: 'Creatures you control gain indestructible until end of turn.', + }, + ], + }) + const game = new Game({ + seed: 1, + startingHandSize: 0, + commander: true, + players: [ + { id: 'p1', deck: [card('Filler')], commander: creature('Test Commander', 2, 2) }, + { id: 'p2', deck: [card('Filler')], commander: creature('Other Commander', 2, 2) }, + ], + }) + game.start() + const spell = game.addCard('p1', maneuver, 'hand') + + assert.equal(game.canPlayCard('p1', spell.id), false) + assert.throws(() => game.castSpell('p1', spell.id), GameError) + + game.moveToZone(game.getPlayer('p1').commanderId!, 'battlefield', { silent: true }) + + assert.equal(game.canPlayCard('p1', spell.id), true) + game.castSpell('p1', spell.id) + assert.equal(game.stack.length, 1) + assert.deepEqual(game.getPlayer('p1').manaPool, { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 }) +}) + +test('overload pays the overload cost and widens the spell target', () => { + const rift = card('Cyclonic Rift', { + typeLine: 'Instant', + manaCost: '{U}', + manaValue: 1, + abilities: [ + { + kind: 'spell', + effects: [{ + op: 'return_to_hand', + target: { + kind: 'object', + selector: { controller: 'opponent', types: ['permanent'], excludeTypes: ['land'] }, + mode: 'target', + }, + }], + optional: false, + text: "Return target nonland permanent you don't control to its owner's hand.", + }, + { kind: 'overload', cost: '{1}{U}', text: 'Overload {1}{U}' }, + ], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const island = game.addCard('p1', land('Island', 'U'), 'battlefield') + const wastes = game.addCard('p1', land('Wastes', 'C'), 'battlefield') + const ownCreature = game.addCard('p1', creature('Own Bear', 2, 2), 'battlefield') + const theirCreature = game.addCard('p2', creature('Their Bear', 2, 2), 'battlefield') + const theirArtifact = game.addCard('p2', card('Their Rock', { + typeLine: 'Artifact', + power: undefined, + toughness: undefined, + }), 'battlefield') + const theirLand = game.addCard('p2', land('Forest', 'G'), 'battlefield') + const spell = game.addCard('p1', rift, 'hand') + + game.castSpell('p1', spell.id, { overload: true }) + + assert.equal(island.tapped, true) + assert.equal(wastes.tapped, true) + game.resolveStack() + + assert.ok(game.getPlayer('p2').hand.includes(theirCreature.id)) + assert.ok(game.getPlayer('p2').hand.includes(theirArtifact.id)) + assert.ok(game.getPlayer('p2').battlefield.includes(theirLand.id)) + assert.ok(game.getPlayer('p1').battlefield.includes(ownCreature.id)) +}) + +test('a noncreature cost increase taxes spells but not creatures', () => { + const thalia = card('Thalia, Guardian of Thraben', { + typeLine: 'Legendary Creature — Human Soldier', + power: 2, + toughness: 1, + abilities: [{ + kind: 'static', + effects: [{ op: 'cost_increase', amount: { kind: 'number', value: 1 }, spellType: 'noncreature' }], + text: 'Noncreature spells cost {1} more to cast.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', thalia, 'battlefield') + const first = game.addCard('p1', land('Wastes', 'C'), 'battlefield') + const instant = game.addCard('p1', spell('Ponder', [ + { op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }, + ], '{1}'), 'hand') + const bears = game.addCard('p1', card('Grizzly Bears', { + typeLine: 'Creature — Bear', + power: 2, + toughness: 2, + manaCost: '{1}', + }), 'hand') + + assert.equal(game.canPlayCard('p1', instant.id), false) + assert.equal(game.canPlayCard('p1', bears.id), true) + + game.addCard('p1', land('Wastes', 'C'), 'battlefield') + assert.equal(game.canPlayCard('p1', instant.id), true) + game.castSpell('p1', instant.id) + assert.equal(first.tapped, true) +}) + +test('spell cost reductions match the spell type and controller', () => { + const baral = card('Baral, Chief of Compliance', { + typeLine: 'Legendary Creature — Human Wizard', + power: 1, + toughness: 3, + abilities: [{ + kind: 'static', + effects: [{ + op: 'cost_reduction', + target: { kind: 'object', selector: { controller: 'you', types: ['instant', 'sorcery'], match: 'any' }, mode: 'each' }, + amount: { kind: 'number', value: 1 }, + }], + text: 'Instant and sorcery spells you cast cost {1} less to cast.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', baral, 'battlefield') + const wastes = game.addCard('p1', land('Wastes', 'C'), 'battlefield') + const sorcery = game.addCard('p1', card('Divination', { + typeLine: 'Sorcery', + manaCost: '{2}', + abilities: [{ kind: 'spell', effects: [{ op: 'draw', player: 'you', amount: { kind: 'number', value: 1 } }], optional: false, text: 'Draw a card.' }], + }), 'hand') + const bears = game.addCard('p1', card('Grizzly Bears', { + typeLine: 'Creature — Bear', + power: 2, + toughness: 2, + manaCost: '{2}', + }), 'hand') + + assert.equal(game.canPlayCard('p1', sorcery.id), true) + assert.equal(game.canPlayCard('p1', bears.id), false) + + game.castSpell('p1', sorcery.id) + assert.equal(wastes.tapped, true) +}) + +test('a colored cost reduction removes matching pips and nothing else', () => { + const edgewalker = card('Edgewalker', { + typeLine: 'Creature — Human Cleric', + power: 2, + toughness: 2, + abilities: [{ + kind: 'static', + effects: [{ + op: 'cost_reduction', + target: { kind: 'object', selector: { controller: 'you', types: ['creature'], match: 'any', subtypes: ['cleric', 'soldier'] }, mode: 'each' }, + symbols: '{W}{B}', + }], + text: 'Cleric spells you cast cost {W}{B} less to cast.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', edgewalker, 'battlefield') + game.addCard('p1', land('Plains', 'W'), 'battlefield') + game.addCard('p1', land('Swamp', 'B'), 'battlefield') + const cleric = game.addCard('p1', card('Cleric Test', { + typeLine: 'Creature — Human Cleric', + power: 2, + toughness: 2, + colors: ['W', 'B'], + manaCost: '{1}{W}{B}', + manaValue: 3, + }), 'hand') + const soldier = game.addCard('p1', card('Soldier Test', { + typeLine: 'Creature — Human Soldier', + power: 2, + toughness: 2, + colors: ['W', 'B'], + manaCost: '{1}{W}{B}', + manaValue: 3, + }), 'hand') + const bear = game.addCard('p1', card('Bear Test', { + typeLine: 'Creature — Bear', + power: 2, + toughness: 2, + colors: ['W', 'B'], + manaCost: '{1}{W}{B}', + manaValue: 3, + }), 'hand') + + assert.equal(game.canPlayCard('p1', cleric.id), true) + assert.equal(game.canPlayCard('p1', soldier.id), true) + assert.equal(game.canPlayCard('p1', bear.id), false) + game.castSpell('p1', cleric.id) +}) + +test('Linvala stops only opponents from activating creature abilities', () => { + const linvala = card('Linvala, Keeper of Silence', { + typeLine: 'Legendary Creature — Angel', + power: 3, + toughness: 4, + abilities: [{ + kind: 'static', + effects: [{ + op: 'restriction', + target: { kind: 'object', selector: { controller: 'opponent', types: ['creature'] }, mode: 'each' }, + rule: 'cant_activate', + }], + text: "Activated abilities of creatures your opponents control can't be activated.", + }], + }) + const drawAbility = { + kind: 'activated' as const, + costs: [], + effects: [{ op: 'draw' as const, player: 'you' as const, amount: { kind: 'number' as const, value: 1 } }], + optional: false, + text: 'Draw a card.', + } + const game = setup([{ id: 'p1', deck: [card('Filler'), card('Filler')] }, { id: 'p2' }]) + game.start() + game.addCard('p1', linvala, 'battlefield') + const own = game.addCard('p1', creature('Own Cleric', 1, 1, [drawAbility]), 'battlefield') + const theirs = game.addCard('p2', creature('Their Cleric', 1, 1, [drawAbility]), 'battlefield') + + game.activateAbility('p1', own.id, 0) + assert.equal(game.stack.length, 1) + + game.resolveStack() + game.pass('p1') + assert.throws(() => game.activateAbility('p2', theirs.id, 0), /cannot activate/) +}) + +test('Aven Mindcensor limits an opponent search to the top four cards', () => { + const aven = card('Aven Mindcensor', { + typeLine: 'Creature — Bird Wizard', + power: 2, + toughness: 1, + abilities: [{ + kind: 'static', + effects: [{ op: 'search_restriction', who: 'opponent', amount: { kind: 'number', value: 4 } }], + text: 'If an opponent would search a library, that player searches the top four cards of that library instead.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2', deck: [] }]) + game.start() + game.addCard('p1', aven, 'battlefield') + for (const name of ['Forest', 'Island', 'Mountain', 'Plains', 'Swamp', 'Wastes']) { + game.addCard('p2', land(name, 'C'), 'library') + } + const topFour = game.getPlayer('p2').library.slice(0, 4) + const growth = game.addCard('p2', spell('Rampant Growth', [{ + op: 'search', + player: 'you', + selector: { types: ['land'] }, + amount: { kind: 'number', value: 1 }, + destination: 'battlefield', + shuffle: true, + }]), 'hand') + + game.pass('p1') + game.castSpell('p2', growth.id) + game.resolveStack() + + assert.deepEqual( + game.searchCandidates('p2').map(object => object.id).sort(), + [...topFour].sort(), + ) +}) + +test('Rest in Peace exiles all graveyards and replaces later graveyard moves', () => { + const rest = card('Rest in Peace', { + typeLine: 'Enchantment', + power: undefined, + toughness: undefined, + abilities: [ + { + kind: 'triggered', + event: { kind: 'enters', subject: { kind: 'self' } }, + effects: [{ op: 'exile_graveyards' }], + optional: false, + text: 'When this enchantment enters, exile all graveyards.', + }, + { + kind: 'static', + effects: [{ op: 'exile_instead_of_graveyard' }], + text: 'If a card or token would be put into a graveyard from anywhere, exile it instead.', + }, + ], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + const oldSpell = game.addCard('p1', spell('Old Spell', []), 'graveyard') + const oldCreature = game.addCard('p2', creature('Old Bear', 2, 2), 'graveyard') + const doomed = game.addCard('p1', creature('Doomed Bear', 2, 2), 'battlefield') + + game.addCard('p1', rest, 'battlefield', { silent: false }) + game.resolveStack() + + assert.ok(game.getPlayer('p1').exile.includes(oldSpell.id)) + assert.ok(game.getPlayer('p2').exile.includes(oldCreature.id)) + assert.deepEqual(game.getPlayer('p1').graveyard, []) + assert.deepEqual(game.getPlayer('p2').graveyard, []) + + game.moveToZone(doomed, 'graveyard') + + assert.equal(doomed.zone, 'exile') + assert.ok(game.getPlayer('p1').exile.includes(doomed.id)) +}) + +test("Leyline of the Void exiles only opponents' cards and starts on the battlefield", () => { + const leyline = card('Leyline of the Void', { + typeLine: 'Enchantment', + power: undefined, + toughness: undefined, + abilities: [ + { + kind: 'static', + effects: [{ op: 'restriction', target: { kind: 'self' }, rule: 'begin_on_battlefield' }], + text: 'If this card is in your opening hand, you may begin the game with it on the battlefield.', + }, + { + kind: 'static', + effects: [{ op: 'exile_instead_of_graveyard', owner: 'opponent' }], + text: "If a card would be put into an opponent's graveyard from anywhere, exile it instead.", + }, + ], + }) + const game = new Game({ + seed: 3, + startingHandSize: 0, + players: [{ id: 'p1', deck: [card('Filler')] }, { id: 'p2', deck: [card('Filler')] }], + }) + const leylineObject = game.addCard('p1', leyline, 'hand') + game.start() + + assert.ok(game.getPlayer('p1').battlefield.includes(leylineObject.id)) + assert.ok(!game.getPlayer('p1').hand.includes(leylineObject.id)) + + const theirs = game.addCard('p2', creature('Their Bear', 2, 2), 'battlefield') + const own = game.addCard('p1', creature('Own Bear', 2, 2), 'battlefield') + game.moveToZone(theirs, 'graveyard') + game.moveToZone(own, 'graveyard') + + assert.equal(theirs.zone, 'exile') + assert.equal(own.zone, 'graveyard') +}) + +test('Field of the Dead makes a Zombie at seven differently named lands', () => { + const field = card('Field of the Dead', { + typeLine: 'Land', + power: undefined, + toughness: undefined, + abilities: [{ + kind: 'triggered', + event: { + kind: 'enters', + subject: { + kind: 'object', + selector: { other: true, controller: 'you', types: ['land'] }, + mode: 'each', + includeSelf: true, + }, + }, + condition: { kind: 'distinct_names', selector: { types: ['land'] }, atLeast: 7 }, + effects: [{ + op: 'create_token', + player: 'you', + amount: { kind: 'number', value: 1 }, + token: { + types: ['creature'], + subtypes: ['zombie'], + colors: ['B'], + power: { kind: 'number', value: 2 }, + toughness: { kind: 'number', value: 2 }, + }, + }], + optional: false, + text: 'Whenever this or another land you control enters, if you control seven or more lands with different names, create a 2/2 black Zombie creature token.', + }], + }) + const game = setup([{ id: 'p1' }, { id: 'p2' }]) + game.start() + game.addCard('p1', field, 'battlefield') + for (const name of ['Forest', 'Island', 'Mountain', 'Plains']) { + game.addCard('p1', land(name, 'C'), 'battlefield') + } + + game.addCard('p1', land('Swamp', 'C'), 'battlefield', { silent: false }) + game.resolveStack() + assert.equal(game.getPlayer('p1').battlefield + .map(id => game.getObject(id)).filter(object => object.isToken).length, 0) + + game.addCard('p1', land('Wastes', 'C'), 'battlefield', { silent: false }) + game.resolveStack() + + const tokens = game.getPlayer('p1').battlefield + .map(id => game.getObject(id)).filter(object => object.isToken) + assert.equal(tokens.length, 1) + assert.equal(tokens[0].definition.typeLine.toLowerCase().includes('zombie'), true) +}) diff --git a/frontend/app/pages/decks.vue b/frontend/app/pages/decks.vue index 30521fa..4ac812d 100644 --- a/frontend/app/pages/decks.vue +++ b/frontend/app/pages/decks.vue @@ -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([]) @@ -43,6 +47,8 @@ const importErrors = ref([]) const importing = ref(false) const basics = ref>({}) 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,33 +570,50 @@ onMounted(async () => {
+

{{ error }}

No saved decks yet.

- + {{ deck.name }} + + + {{ deck.cards.length + 1 }}/100 + + {{ deck.commander.name }} + + + +
+ + + +
+ +
+
+ + +
+ +
+
+