[duel-design] fromDuel adapter: engine log to match story and recap (#60) #83

Merged
claude merged 2 commits from night2/duel-design/fromduel-wip into night/2026-11-17 2026-11-18 16:15:51 +00:00
2 changed files with 189 additions and 0 deletions
+117
View File
@@ -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<string, StoryCard> = {};
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,
};
}
+72
View File
@@ -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> = {}): 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<string, unknown>) => ({ 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
});