From 4d0ffd8d7389773a57c9363fd5aebc5ed5de14b4 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 16 Nov 2026 23:51:32 -0500 Subject: [PATCH] sim-balance: DESIGN 2.1 starter decks, owned-random decks, turn-resolving evaluator, powerDelta, v1.1 variants Co-Authored-By: Claude Opus 5.5 --- scripts/sim/card-pool.ts | 40 +++++++++++++++++++++++-- scripts/sim/run.ts | 18 ++++++++--- scripts/sim/variants/v1.1-keywords.json | 13 ++++++++ scripts/sim/variants/v1.1.json | 6 ++++ shared/bots/game-adapter.ts | 38 +++++++++++++++++++---- 5 files changed, 103 insertions(+), 12 deletions(-) create mode 100644 scripts/sim/variants/v1.1-keywords.json create mode 100644 scripts/sim/variants/v1.1.json diff --git a/scripts/sim/card-pool.ts b/scripts/sim/card-pool.ts index 2d4d779..0586fe6 100644 --- a/scripts/sim/card-pool.ts +++ b/scripts/sim/card-pool.ts @@ -2,7 +2,9 @@ // derived per DESIGN §1 (percentile -> fame -> cost, home stat) and §10.1 (faction keyword). // Percentile cut points come from the file itself. Power is (re)set from the ruleset by the adapter. import { readFileSync } from 'node:fs'; -import { KEYWORDS, type GameCard, type Stat } from '../../shared/game/index.ts'; +import { KEYWORD_IDS, type GameCard, type Stat } from '../../shared/game/index.ts'; +import { mulberry32 } from '../../shared/bots/index.ts'; +import type { DeckSpec } from '../../shared/bots/types.ts'; const STATS: Stat[] = ['attention', 'depth', 'reach']; const HOME_TIE: Stat[] = ['depth', 'reach', 'attention']; @@ -39,10 +41,44 @@ export function loadPool(file: string, opts: PoolOptions = {}): GameCard[] { for (const s of HOME_TIE) { const v = pct[s], cur = pct[home]; if (v !== null && (cur === null || v > cur)) home = s; } const faction = (c.category ?? c.legacyCategory ?? 'Culture') as GameCard['faction']; const kw = FACTION_KEYWORD[faction]; - const keyword = cost === 1 || opts.keywords === 'none' || !kw || !Object.hasOwn(KEYWORDS, kw) ? null : kw; + const keyword = cost === 1 || opts.keywords === 'none' || !kw || !(KEYWORD_IDS as readonly string[]).includes(kw) ? null : kw; return { cardId: `loaner:${c.pageId}`, pageId: c.pageId, title: c.title, faction, rarity: 'Common', cost, power: 0, home, trend: 0, keyword, source: 'loaner', } satisfies GameCard; }); } + +const kebab = (t: string) => t.toLowerCase().normalize('NFKD').replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, ''); + +/** The DESIGN §2.1 starter decks: "**A. Name: ...**" headings followed by | Cost | Card | Faction | Home | tables. */ +export function loadStarterDecks(designMd: string): DeckSpec[] { + const text = readFileSync(designMd, 'utf8'); + const sec = text.slice(text.indexOf('### 2.1'), text.indexOf('## 3.')); + const decks: DeckSpec[] = []; + let cur: { id: string; cards: GameCard[] } | null = null; + for (const line of sec.split('\n')) { + const h = line.match(/^\*\*([A-Z])\. ([^:*]+)/); + if (h) { cur = { id: `starter-${h[1]}-${kebab(h[2])}`, cards: [] }; decks.push({ id: cur.id, tags: ['arch:starter-v1'], payload: cur.cards }); continue; } + const r = line.match(/^\| (\d) \| ([^|]+) \| (\w+) \| (\w+) \|$/); + if (r && cur) { + const [, cost, title, faction, home] = r; + const c = Number(cost), kw = FACTION_KEYWORD[faction]; + cur.cards.push({ + cardId: `loaner:${kebab(title.trim())}`, pageId: null, title: title.trim(), faction: faction as GameCard['faction'], rarity: 'Common', + cost: c, power: 0, home: home as Stat, trend: 0, keyword: c === 1 || !(KEYWORD_IDS as readonly string[]).includes(kw) ? null : kw, source: 'loaner', + }); + } + } + return decks.filter(d => (d.payload as GameCard[]).length === 12); +} + +/** "Realistic owned" decks (DESIGN §2.1 v1.1 note): `n` seeded draws of 12 distinct cards from the pool, real category mix. */ +export function ownedDecks(pool: GameCard[], n: number, size = 12, seed = 7): DeckSpec[] { + const rng = mulberry32(seed); + return Array.from({ length: n }, (_, i) => { + const p = [...pool]; + for (let k = p.length - 1; k > 0; k--) { const j = Math.floor(rng() * (k + 1)); [p[k], p[j]] = [p[j], p[k]]; } + return { id: `owned-${i}`, tags: ['arch:owned-random'], payload: p.slice(0, size).map(c => ({ ...c, cardId: `${c.cardId}:0` })) }; + }); +} diff --git a/scripts/sim/run.ts b/scripts/sim/run.ts index f5511fa..5df0fb0 100644 --- a/scripts/sim/run.ts +++ b/scripts/sim/run.ts @@ -29,11 +29,15 @@ export async function loadEngine(name: string): Promise> } } let pool; + const extraDecks = []; + const cp = await import('./card-pool.ts'); + if (process.env.SIM_STARTERS) extraDecks.push(...cp.loadStarterDecks(process.env.SIM_STARTERS)); if (process.env.SIM_POOL) { - const { loadPool } = await import('./card-pool.ts'); + const { loadPool } = cp; pool = loadPool(process.env.SIM_POOL, { keywords: process.env.SIM_KEYWORDS === 'none' ? 'none' : 'faction', costThresholds: process.env.SIM_COST_THRESHOLDS ? JSON.parse(process.env.SIM_COST_THRESHOLDS) : undefined }); } - return makeGameEngine({ rulesets, pool }); + if (pool && process.env.SIM_OWNED) extraDecks.push(...cp.ownedDecks(pool, Number(process.env.SIM_OWNED))); + return makeGameEngine({ rulesets, pool, extraDecks, seededStarters: !process.env.SIM_STARTERS }); } throw new Error(`unknown engine ${name}`); } @@ -71,6 +75,12 @@ export function schedule(n: number, nDecks: number, baseSeed: number, mix = DEFA return jobs; } +/** Decks for a ruleset, filtered by the SIM_DECKS regex (inherited by child processes). */ +export function decksFor(engine: EngineAdapter, ruleset: string): DeckSpec[] { + const re = process.env.SIM_DECKS ? new RegExp(process.env.SIM_DECKS) : null; + return engine.decks(ruleset).filter(d => !re || re.test(d.id)); +} + function runJobs(engine: EngineAdapter, ruleset: string, decks: DeckSpec[], jobs: Job[], onRecord: (r: MatchRecord | { error: string; job: Job }) => void) { for (const j of jobs) { try { onRecord(playMatch(engine, ruleset, [decks[j.decks[0]], decks[j.decks[1]]], j.bots, j.seed)); } @@ -94,7 +104,7 @@ async function main() { mkdirSync(out, { recursive: true }); const sections: string[] = []; for (const ruleset of rulesets) { - const decks = engine.decks(ruleset); + const decks = decksFor(engine, ruleset); const jobs = schedule(n, decks.length, seed, MIXES[arg('mix', 'default')!]); const records: MatchRecord[] = []; const errors: string[] = []; @@ -135,7 +145,7 @@ if (isEntry && process.argv.includes('--child')) { process.once('message', async (msg: any) => { const { engineName, ruleset, jobs } = msg as { engineName: string; ruleset: string; jobs: Job[] }; const engine = await loadEngine(engineName); - runJobs(engine, ruleset, engine.decks(ruleset), jobs, r => process.send!(r)); + runJobs(engine, ruleset, decksFor(engine, ruleset), jobs, r => process.send!(r)); process.send!('done'); }); } else if (isEntry) main().catch(e => { console.error(e); process.exit(1); }); diff --git a/scripts/sim/variants/v1.1-keywords.json b/scripts/sim/variants/v1.1-keywords.json new file mode 100644 index 0000000..f20ee71 --- /dev/null +++ b/scripts/sim/variants/v1.1-keywords.json @@ -0,0 +1,13 @@ +{ + "k1-nerf3": { "keywordParams": { + "rising": { "amount": 1, "cap": 2, "powerDelta": -1 }, "nostalgic": { "amount": 2, "powerDelta": -1 }, "translated": { "amount": 1, "powerDelta": -1 } } }, + "k2-nerf3-viral": { "keywordParams": { + "rising": { "amount": 1, "cap": 2, "powerDelta": -1 }, "nostalgic": { "amount": 2, "powerDelta": -1 }, "translated": { "amount": 1, "powerDelta": -1 }, + "viral": { "amount": 2, "cap": 3, "powerDelta": 0 } } }, + "k3-plus-ency": { "keywordParams": { + "rising": { "amount": 1, "cap": 2, "powerDelta": -1 }, "nostalgic": { "amount": 2, "powerDelta": -1 }, "translated": { "amount": 1, "powerDelta": -1 }, + "viral": { "amount": 2, "cap": 3, "powerDelta": 0 }, "encyclopedic": { "amount": 3, "powerDelta": 0 } } }, + "k4-soft": { "keywordParams": { + "rising": { "amount": 1, "cap": 1, "powerDelta": 0 }, "nostalgic": { "amount": 1, "powerDelta": 0 }, "translated": { "amount": 1, "powerDelta": -1 }, + "viral": { "amount": 2, "cap": 3, "powerDelta": 0 }, "encyclopedic": { "amount": 3, "powerDelta": 0 } } } +} diff --git a/scripts/sim/variants/v1.1.json b/scripts/sim/variants/v1.1.json new file mode 100644 index 0000000..f4a777e --- /dev/null +++ b/scripts/sim/variants/v1.1.json @@ -0,0 +1,6 @@ +{ + "v1.1-candidate": { "keywordParams": { + "rising": { "amount": 1, "cap": 2, "powerDelta": -1 }, "nostalgic": { "amount": 2, "powerDelta": -1 }, "translated": { "amount": 1, "powerDelta": -1 }, + "viral": { "amount": 2, "cap": 3, "powerDelta": 0 }, "encyclopedic": { "amount": 3, "powerDelta": 0 }, + "local": { "amount": 1, "powerDelta": 0 } } } +} diff --git a/shared/bots/game-adapter.ts b/shared/bots/game-adapter.ts index 6ac82da..09be81a 100644 --- a/shared/bots/game-adapter.ts +++ b/shared/bots/game-adapter.ts @@ -25,10 +25,32 @@ export function projectedLanes(state: MatchState, seat: Seat): [number, number][ } const orient = (p: [number, number], seat: Seat): [number, number] => (seat === 0 ? p : [p[1], p[0]]); -/** Heuristic for `seat` in [-1, 1]: soft lane wins, weighted up as the match nears its end. */ +/** + * Lanes after hypothetically resolving this turn with `seat`'s queue and an opponent who passes + * (its hidden queue is dropped), so on-reveal and end-of-turn keywords and reveal order count. + * Falls back to projectedLanes if the engine refuses. + */ +export function resolvedLanes(state: MatchState, seat: Seat): [number, number][] | MatchState { + try { + let s = { ...state, players: state.players.map(p => ({ ...p })) as MatchState['players'] }; + const o = other(seat); + s.players[o].queue = []; + s.players[o].committed = false; + if (!s.players[seat].committed) s = applyAction(s, { type: 'commit', player: seat }); + s = applyAction(s, { type: 'commit', player: o }); + if (s.result) return s; + return s.lanes.map((_, i) => orient(lanePower(s, i), seat)); + } catch { + return projectedLanes(state, seat); + } +} + +/** Heuristic for `seat` in [-1, 1]: soft lane wins plus total power, from the hypothetically resolved turn. */ export function evaluateFor(state: MatchState, seat: Seat): number { if (state.result) return state.result.winner === null ? 0 : state.result.winner === seat ? 1 : -1; - const lanes = projectedLanes(state, seat); + const r = state.players[seat].queue.length ? resolvedLanes(state, seat) : projectedLanes(state, seat); + if (!Array.isArray(r)) return r.result!.winner === null ? 0 : r.result!.winner === seat ? 0.95 : -0.95; + const lanes = r; const scale = 4; let lane = 0, total = 0; for (const [a, b] of lanes) { lane += Math.tanh((a - b) / scale); total += a - b; } @@ -135,17 +157,19 @@ function curveDeck(pool: GameCard[], size: number, copies: number, filter: (c: G * Sim decks: seeded starter decks (if the engine provides them) plus archetypes built from `pool`: * curve, heavy (cost >= 5 first), swarm (cost <= 2), mono-faction and keyword-focused curve decks. */ -export function defaultDecks(rules: Ruleset, extra: DeckSpec[] = [], pool: GameCard[] = starterPoolCards()): DeckSpec[] { +export function defaultDecks(rules: Ruleset, extra: DeckSpec[] = [], pool: GameCard[] = starterPoolCards(), seededStarters = true): DeckSpec[] { const size = rules.deckSize, copies = rules.maxCopiesPerPage; const decks: DeckSpec[] = []; // DESIGN §1.3: power depends only on cost, so loaners follow the ruleset's powerByCost. - const repower = (c: GameCard): GameCard => (c.source === 'loaner' && rules.powerByCost[c.cost] !== undefined ? { ...c, power: rules.powerByCost[c.cost] + (c.keyword ? 0 : vanillaBonus(rules, c)) } : c); + // §10.1 powerDelta (applied at derivation, not by the engine). + const delta = (c: GameCard) => (c.keyword ? (rules.keywordParams?.[c.keyword]?.powerDelta ?? 0) : 0); + const repower = (c: GameCard): GameCard => (c.source === 'loaner' && rules.powerByCost[c.cost] !== undefined ? { ...c, power: Math.max(0, rules.powerByCost[c.cost] + (c.keyword ? 0 : vanillaBonus(rules, c)) + delta(c)) } : c); pool = pool.map(repower); const add = (id: string, cards: GameCard[] | null, tags: string[]) => { if (cards) cards = cards.map(repower); if (cards && !validateDeck(rules, cards).length) decks.push({ id, tags: tagDeck(cards, tags), payload: cards }); }; - for (let i = 0; i < 6; i++) add(`starter-${i}`, starterDeck(`sim-${i}`), ['arch:starter']); + if (seededStarters) for (let i = 0; i < 6; i++) add(`starter-${i}`, starterDeck(`sim-${i}`), ['arch:starter']); add('curve', curveDeck(pool, size, copies), ['arch:curve']); add('heavy', buildDeck(pool, c => (c.cost >= 5 ? 10 + c.cost : c.cost >= 4 ? 5 : 0), size, copies), ['arch:heavy']); add('top-heavy', curveDeck(pool, size, copies, undefined, [0, 1, 1, 2, 2, 3, 3]), ['arch:top-heavy']); @@ -167,6 +191,8 @@ export interface GameEngineOptions { extraDecks?: DeckSpec[]; /** Card pool for archetype decks (one copy per page). Default: the engine's starter pool. */ pool?: GameCard[]; + /** Include the engine's seeded placeholder starter decks (default true). */ + seededStarters?: boolean; } export function makeGameEngine(opts: GameEngineOptions = {}): EngineAdapter { @@ -183,7 +209,7 @@ export function makeGameEngine(opts: GameEngineOptions = {}): EngineAdapter Object.keys(rulesets), decks(id) { if (!deckCache.has(id)) { - const d = defaultDecks(rules(id), opts.extraDecks, opts.pool); + const d = defaultDecks(rules(id), opts.extraDecks, opts.pool, opts.seededStarters ?? true); for (const deck of d) for (const c of deck.payload as GameCard[]) meta.set(baseId(c.cardId), c); deckCache.set(id, d); }