import type { Ability, Condition, Cost, Duration, Effect, ManaSpec, ObjectSelector, PlayerRef, StaticEffect, Target, TokenSpec, TriggerEvent, Value, Zone, } from '../effects/types.js' import type { ActionOptions, CardDefinition, CombatAttack, CombatBlock, GameObject, GameConfig, ManaColor, ManaPool, MulliganState, PendingChoice, PendingSearch, Phase, PlayerState, StackItem, Step, TargetChoice, } from './types.js' import { CREATURE_TYPES } from './creature-types.js' import { predefinedToken } from './tokens.js' export type ResolvedTarget = | { kind: 'player'; id: string } | { kind: 'object'; object: GameObject } | { kind: 'stack'; item: StackItem } export interface EventContext { kind: TriggerEvent['kind'] player?: string subject?: GameObject amount?: number counter?: string ordinal?: number mode?: 'gain' | 'lose' recipient?: 'player' | 'creature' | 'permanent' | 'any' combat?: boolean spell?: GameObject spellItem?: StackItem } export interface EffectContext { source: GameObject controller: string targets: TargetChoice[] lastTarget?: ResolvedTarget /** Objects dealt damage by the most recent damage effect, for "dealt damage this way". */ lastDamaged?: GameObject[] triggerSubject?: GameObject eventPlayer?: string eventAmount?: number x: number mode: number /** Color picked for a mana ability, so choice effects produce it. */ manaColor?: ManaColor /** Whether the "you may" branch was taken; undefined means no branch was offered. */ optionalTaken?: boolean } export interface ContinuousEffect { id: string sourceId: string controller: string effect: Extract affectedIds: string[] duration: Duration createdTurn: number } export interface DamageShield { /** Object or player ids this shield covers; empty with `global` covers everything. */ ids: Set global: boolean /** When set, only damage dealt by these source objects is prevented. */ sourceIds?: Set /** When set, only damage from sources matching this selector is prevented. */ sourceSelector?: ObjectSelector remaining: number | 'all' combatOnly: boolean /** "If damage is prevented this way, ..." follow-up. */ then?: Effect[] sourceId?: string controller?: string /** Target choices left over when the shield was made, for its follow-up. */ targets?: TargetChoice[] /** Recipient the shield was made for, so "that creature" resolves in the follow-up. */ lastTarget?: ResolvedTarget } export interface ManaCost { generic: number colored: ManaColor[] hybrid: { colors: ManaColor[]; life: number }[] } export const MANA_COLORS: ManaColor[] = ['W', 'U', 'B', 'R', 'G', 'C'] export const COLOR_NAMES: Record = { white: 'W', blue: 'U', black: 'B', red: 'R', green: 'G', colorless: 'C', } export function emptyPool(): ManaPool { return { W: 0, U: 0, B: 0, R: 0, G: 0, C: 0 } } export function parseManaCost(symbols: string, x = 0): ManaCost { const cost: ManaCost = { generic: 0, colored: [], hybrid: [] } for (const match of symbols.matchAll(/\{([^}]+)\}/g)) { const symbol = match[1].toUpperCase() if (/^\d+$/.test(symbol)) { cost.generic += Number(symbol) } else if (symbol === 'X') { cost.generic += x } else if (symbol === 'S') { cost.colored.push('C') } else if (/^[WUBRGC]$/.test(symbol)) { cost.colored.push(symbol as ManaColor) } else if (symbol.includes('/')) { const parts = symbol.split('/') const colors = parts .filter(part => /^[WUBRG]$/.test(part)) .map(part => part as ManaColor) if (colors.length) cost.hybrid.push({ colors, life: parts.includes('P') ? 2 : 0 }) else cost.generic += 1 } else { cost.generic += 1 } } return cost } export 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. */ export 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('') } export function manaValueOf(definition: CardDefinition): number { if (definition.manaValue !== undefined) return definition.manaValue const cost = parseManaCost(definition.manaCost ?? '') return cost.generic + cost.colored.length + cost.hybrid.length } export function colorOfSymbol(symbol: string): ManaColor { const bare = symbol.replace(/[{}]/g, '').toUpperCase() if (bare === 'S') return 'C' if (/^[WUBRGC]$/.test(bare)) return bare as ManaColor return 'C' } export function tokenCard(token: { name?: string types: string[] subtypes: string[] colors: string[] power?: number toughness?: number keywords?: string[] }): { definition: CardDefinition; backFace?: CardDefinition } { const predefined = predefinedToken(token) const types = predefined?.types ?? token.types const subtypes = predefined?.subtypes ?? token.subtypes const colors = [...new Set([...(predefined?.colors ?? []), ...token.colors])] const keywords = [...(predefined?.keywords ?? []), ...(token.keywords ?? [])] const definition = tokenFace({ name: predefined?.name ?? token.name ?? (subtypes.map(capitalize).join(' ') || 'Token'), types, subtypes, colors, power: token.power ?? predefined?.power, toughness: token.toughness ?? predefined?.toughness, keywords, abilities: predefined?.abilities, }) const backFace = predefined?.backFace ? tokenFace({ ...predefined.backFace, keywords: predefined.backFace.keywords ?? [] }) : undefined return { definition, backFace } } export function capitalize(word: string): string { return word[0]?.toUpperCase() + word.slice(1) } export function tokenFace(fields: { name: string types: string[] subtypes: string[] colors: string[] power?: number toughness?: number keywords?: string[] abilities?: Ability[] }): CardDefinition { return { oracleId: `token:${fields.name}`, name: fields.name, typeLine: [fields.types.join(' '), fields.subtypes.length ? `— ${fields.subtypes.join(' ')}` : ''].join(' ').trim(), manaValue: 0, colors: fields.colors, power: fields.power, toughness: fields.toughness, abilities: [ ...(fields.abilities ?? []), ...(fields.keywords ?? []).map(keyword => ({ kind: 'keyword' as const, keyword })), ], } } export class GameError extends Error {} export function mulberry32(seed: number): () => number { let state = seed >>> 0 return () => { state = (state + 0x6d2b79f5) >>> 0 let value = state value = Math.imul(value ^ (value >>> 15), value | 1) value ^= value + Math.imul(value ^ (value >>> 7), value | 61) return ((value ^ (value >>> 14)) >>> 0) / 4294967296 } }