diff --git a/shared/duel/story/fromDuel.ts b/shared/duel/story/fromDuel.ts new file mode 100644 index 0000000..9c950b8 --- /dev/null +++ b/shared/duel/story/fromDuel.ts @@ -0,0 +1,117 @@ +/** + * Adapter: duel-core's LogEvent[] (shared/duel/types.ts) → story MatchRecord (DUEL_DESIGN §8). + * Pure. Pass the omniscient `state.log` for recaps, or `logFor(state, seat)` output for a seat's log + * (hidden draws there have no `card`, and stay hidden). + */ +import type { CardInstance, CardRef, LogEvent } from '../types.ts'; +import type { MatchRecord, Seat, StoryCard, StoryEvent, StoryPlayer } from './types.ts'; + +export interface FromDuelInput { + matchId: string; + /** Story seed, opaque: the host derives it (sha256(engineSeed + ':story')). Never the engine seed. */ + storySeed: string; + /** ISO YYYY-MM-DD. */ + date: string; + players: [StoryPlayer, StoryPlayer]; + /** Every card instance of both decks (tokens are picked up from the log). */ + instances: CardInstance[]; + log: LogEvent[]; + startingLife?: number; + hostName?: string; + ratingChange?: [number, number]; +} + +function storyCard(inst: CardInstance): StoryCard { + const c = inst.card; + return { + id: inst.uid, title: c.title, description: c.description, type: c.type, cost: c.cost, portal: c.portal, + revisionId: c.token ? undefined : c.revisionId, tokenId: c.token ? undefined : c.cardId, owner: inst.owner, + token: c.token || undefined, + }; +} + +export function fromDuel(input: FromDuelInput): MatchRecord { + const cards: Record = {}; + for (const inst of input.instances) cards[inst.uid] = storyCard(inst); + /** Tokens (and anything not in the decks) come from their log CardRef: never cited. */ + const ref = (r: CardRef, owner: Seat): string => { + if (!cards[r.uid]) cards[r.uid] = { id: r.uid, title: r.title, type: r.type, cost: 0, owner, token: true }; + return r.uid; + }; + const events: StoryEvent[] = []; + let lastTurn = 0; + for (const e of input.log) { + switch (e.kind) { + case 'turnStart': + lastTurn = e.turn; + events.push({ kind: 'turnStart', turn: e.turn, seat: e.seat }); + break; + case 'draw': + events.push(e.card ? { kind: 'draw', seat: e.seat, card: ref(e.card, e.seat) } : { kind: 'draw', seat: e.seat }); + break; + case 'deploy': + events.push({ kind: 'deploy', seat: e.seat, card: ref(e.card, e.seat) }); + break; + case 'cast': + events.push({ kind: 'cast', seat: e.seat, card: ref(e.card, e.seat) }); + break; + case 'adopt': + events.push({ + kind: 'adopt', seat: e.seat, doctrine: ref(e.card, e.seat), figure: ref(e.to, e.seat), + power: e.to.power ?? 0, toughness: e.to.toughness ?? 0, + }); + break; + case 'tokenCreated': { + const prev = events[events.length - 1]; + const src = ref(e.source, e.seat); + ref(e.card, e.seat); + if (prev && prev.kind === 'tokenCreated' && prev.source === src && prev.token === e.card.title) prev.count += 1; + else events.push({ kind: 'tokenCreated', seat: e.seat, source: src, token: e.card.title, count: 1 }); + break; + } + case 'connected': + events.push({ kind: 'connected', seat: e.seat, a: ref(e.card, e.seat), b: ref(e.with, e.seat), reason: e.via }); + break; + case 'rivalry': + events.push({ kind: 'rivalry', a: ref(e.card, 0), b: ref(e.with, 1), reason: e.via }); + break; + case 'attack': + for (const a of e.attackers) events.push({ kind: 'attack', seat: e.seat, card: ref(a, e.seat), power: a.power ?? 0, toughness: a.toughness ?? 0 }); + break; + case 'block': + for (const b of e.blocks) { + events.push({ + kind: 'block', seat: e.seat, blocker: ref(b.blocker, e.seat), attacker: ref(b.attacker, e.seat === 0 ? 1 : 0), + power: b.blocker.power ?? 0, toughness: b.blocker.toughness ?? 0, + }); + } + break; + case 'lifeGain': + events.push({ kind: 'lifeGain', seat: e.seat, source: ref(e.source, e.seat), amount: e.amount, life: e.life }); + break; + case 'effectDamage': + events.push({ kind: 'effectDamage', source: ref(e.source, 0), target: ref(e.target, 0), amount: e.amount }); + break; + case 'playerDamage': + events.push({ kind: 'playerDamage', seat: e.seat, source: e.source ? ref(e.source, e.seat === 0 ? 1 : 0) : undefined, amount: e.amount, life: e.life }); + break; + case 'destroyed': + events.push({ kind: 'destroyed', card: ref(e.card, e.owner) }); + break; + case 'discard': + events.push({ kind: 'discard', seat: e.seat, card: ref(e.card, e.seat) }); + break; + case 'gameOver': + events.push({ kind: 'gameOver', winner: e.winner, reason: e.reason, turn: e.turn || lastTurn, life: e.life }); + break; + // start, mulligan, keep, effect, combatDamage, bounced, fatigue, concede, timeout: + // not narrated in v1 (combat outcomes are told by destroyed/playerDamage; gameOver covers concede/timeout). + default: + break; + } + } + return { + matchId: input.matchId, seed: input.storySeed, date: input.date, players: input.players, cards, events, + startingLife: input.startingLife, hostName: input.hostName, ratingChange: input.ratingChange, + }; +} diff --git a/tests/duel-design-fromduel.test.ts b/tests/duel-design-fromduel.test.ts new file mode 100644 index 0000000..0e9f972 --- /dev/null +++ b/tests/duel-design-fromduel.test.ts @@ -0,0 +1,72 @@ +import { test } from 'node:test'; +import assert from 'node:assert/strict'; +import type { CardInstance, CardRef, DuelCard, LogEvent } from '../shared/duel/types.ts'; +import { fromDuel } from '../shared/duel/story/fromDuel.ts'; +import { recap, renderLog } from '../shared/duel/story/index.ts'; + +function duelCard(cardId: string, title: string, type: DuelCard['type'], cost: number, extra: Partial = {}): DuelCard { + return { + cardId, pageId: 1, revisionId: 1000 + cost, title, description: `${title} description`, type, subtype: null, + portal: 'Society', cost, power: type === 'Figure' ? 2 : null, toughness: type === 'Figure' ? 2 : null, + keywords: [], effects: [], rulesText: '', flavor: '', ...extra, + }; +} +const inst: CardInstance[] = [ + { uid: '0:0', owner: 0, card: duelCard('tokA', 'Pathrail Mosque', 'Location', 2) }, + { uid: '0:1', owner: 0, card: duelCard('tokB', 'Tom Ewell', 'Figure', 6) }, + { uid: '1:0', owner: 1, card: duelCard('tokC', '1954 Gold Coast general election', 'Event', 3) }, + { uid: '1:1', owner: 1, card: duelCard('tokD', "Pallas's cat", 'Figure', 6) }, +]; +const R = (i: CardInstance, p?: number, t?: number): CardRef => + ({ uid: i.uid, cardId: i.card.cardId, title: i.card.title, pageId: i.card.pageId, type: i.card.type, power: p, toughness: t }); +const tok1: CardRef = { uid: 't:1', cardId: 'token:elected', title: 'Elected Member', pageId: null, type: 'Figure', power: 1, toughness: 1 }; +const tok2: CardRef = { ...tok1, uid: 't:2' }; +let seq = 0; +const E = (turn: number, e: Record) => ({ seq: seq++, turn, ...e }) as LogEvent; +const log: LogEvent[] = [ + E(0, { kind: 'start', firstSeat: 0 }), + E(1, { kind: 'turnStart', seat: 0, citations: 1, life: [20, 20] }), + E(1, { kind: 'deploy', seat: 0, card: R(inst[0], 0, 3) }), + E(2, { kind: 'turnStart', seat: 1, citations: 1, life: [20, 20] }), + E(2, { kind: 'draw', seat: 1 }), + E(2, { kind: 'cast', seat: 1, card: R(inst[2]), targets: [] }), + E(2, { kind: 'tokenCreated', seat: 1, card: tok1, source: R(inst[2]) }), + E(2, { kind: 'tokenCreated', seat: 1, card: tok2, source: R(inst[2]) }), + E(3, { kind: 'turnStart', seat: 0, citations: 2, life: [20, 20] }), + E(3, { kind: 'draw', seat: 0, card: R(inst[1]) }), + E(3, { kind: 'deploy', seat: 0, card: R(inst[1], 5, 5) }), + E(4, { kind: 'turnStart', seat: 1, citations: 2, life: [20, 20] }), + E(4, { kind: 'attack', seat: 1, attackers: [R(inst[3], 5, 5), tok1] }), + E(4, { kind: 'block', seat: 0, blocks: [{ blocker: R(inst[1], 5, 5), attacker: tok1 }] }), + E(4, { kind: 'combatDamage', source: tok1, target: R(inst[1]), amount: 1 }), + E(4, { kind: 'destroyed', card: tok1, owner: 1 }), + E(4, { kind: 'playerDamage', source: R(inst[3]), seat: 0, amount: 5, life: 15, combat: true }), + E(4, { kind: 'lifeGain', source: R(inst[3]), seat: 1, amount: 2, life: 22 }), + E(4, { kind: 'concede', seat: 0 }), + E(4, { kind: 'gameOver', winner: 1, reason: 'concede', life: [15, 22] }), +]; + +test('fromDuel maps duel-core LogEvents onto the story record', () => { + const rec = fromDuel({ + matchId: 'm1', storySeed: 'story-seed', date: '2026-11-17', + players: [{ name: 'alice' }, { name: 'bob' }], instances: inst, log, + }); + assert.deepEqual(rec.events.map(e => e.kind), [ + 'turnStart', 'deploy', 'turnStart', 'draw', 'cast', 'tokenCreated', 'turnStart', 'draw', 'deploy', + 'turnStart', 'attack', 'attack', 'block', 'destroyed', 'playerDamage', 'lifeGain', 'gameOver', + ]); + const tc = rec.events.find(e => e.kind === 'tokenCreated'); + assert.deepEqual(tc, { kind: 'tokenCreated', seat: 1, source: '1:0', token: 'Elected Member', count: 2 }); + assert.equal(rec.cards['t:1'].token, true); + assert.equal(rec.cards['0:1'].tokenId, 'tokB'); + assert.equal(rec.seed, 'story-seed'); + const over = rec.events[rec.events.length - 1]; + assert.deepEqual(over, { kind: 'gameOver', winner: 1, reason: 'concede', turn: 4, life: [15, 22] }); + + const r = recap(rec); + assert.equal(r.title, 'Skirmish at Pathrail Mosque (2026)'); + assert.equal(r.infobox.result, 'bob victory by withdrawal'); + assert.ok(r.references.every(x => !x.title.includes('Elected Member'))); + const forBob = renderLog(rec, 1).lines.map(l => l.text).join(' '); + assert.doesNotMatch(forBob, /Tom Ewell.*drawn|drew \*Tom Ewell/); // alice's draw is hidden from bob +});