Play: bots see only viewFor output (MatchView.engine = { view, seat })

Per night-lead's rule on #5 the adapter no longer exposes MatchState to
bots; a test checks no RNG state, seed or deck order leaks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 23:55:58 -05:00
co-authored by Claude Opus 5.5
parent fa1fee98f8
commit c4636530ef
4 changed files with 123 additions and 113 deletions
+1 -1
View File
@@ -98,7 +98,7 @@ export function OnlinePlay({ mode, playerName, onExit, onFinish }: {
const phase = status?.phase; const phase = status?.phase;
// ----- match ----- // ----- match -----
if ((phase === 'playing' || phase === 'finished') && status?.state) { if ((phase === 'playing' || phase === 'finished') && status?.state) {
const view = viewFromPlayerView(status.state); const view = { ...viewFromPlayerView(status.state), engine: { view: status.state, seat: seat.seat } };
const legal = uiActions(status.legalActions ?? []); const legal = uiActions(status.legalActions ?? []);
const opp = status.players.find((_, i) => i !== seat.seat)?.name ?? 'Opponent'; const opp = status.players.find((_, i) => i !== seat.seat)?.name ?? 'Opponent';
const act = (a: UIAction) => { const act = (a: UIAction) => {
+2 -1
View File
@@ -68,7 +68,8 @@ export const engine = {
for (const l of state.lanes) for (const side of l.cards) for (const c of side) titles.set(c.card.cardId, c.card.title); for (const l of state.lanes) for (const side of l.cards) for (const c of side) titles.set(c.card.cardId, c.card.title);
const log = state.log.filter(e => e.t !== 'draw') const log = state.log.filter(e => e.t !== 'draw')
.map(e => logLine(e, me, id => titles.get(id) ?? 'a card')).filter((x): x is string => !!x).slice(-30); .map(e => logLine(e, me, id => titles.get(id) ?? 'a card')).filter((x): x is string => !!x).slice(-30);
return { ...viewFromPlayerView(viewFor(state, me), { log, capacity: i => laneCapacity(state, i) }), engine: { state, seat: me } }; const pv = viewFor(state, me);
return { ...viewFromPlayerView(pv, { log, capacity: i => laneCapacity(state, i) }), engine: { view: pv, seat: me } };
}, },
isOver: (s: MatchState) => isOver(s), isOver: (s: MatchState) => isOver(s),
result(state: MatchState, me: PlayerId): ResultView { result(state: MatchState, me: PlayerId): ResultView {
+3 -3
View File
@@ -1,6 +1,6 @@
// UI-side view models for the Play section. Screens consume only these; adapter.ts maps the // UI-side view models for the Play section. Screens consume only these; adapter.ts maps the
// shared/game engine (docs/game/ENGINE_API.md) onto them. // shared/game engine (docs/game/ENGINE_API.md) onto them.
import type { Action, GameCard, MatchResult, MatchState, PlayerId, Ruleset, Stat } from '../../shared/game/index.ts'; import type { Action, GameCard, MatchResult, PlayerId, PlayerView, Ruleset, Stat } from '../../shared/game/index.ts';
export type PlayerIndex = PlayerId; export type PlayerIndex = PlayerId;
export type { Stat }; export type { Stat };
@@ -56,8 +56,8 @@ export type MatchView = {
log: string[]; // newest last, this seat's events only log: string[]; // newest last, this seat's events only
waitingForOpponent: boolean; waitingForOpponent: boolean;
over: boolean; over: boolean;
/** For bots that reuse shared/bots (ui-b): the full state and this seat. Never render it. */ /** For engine-level bots (ui-b): this seat's hidden-information view only (night-lead: never the full MatchState). */
engine?: { state: MatchState; seat: PlayerId }; engine?: { view: PlayerView; seat: PlayerId };
}; };
export type UIAction = ( export type UIAction = (
+117 -108
View File
@@ -1,108 +1,117 @@
import test from 'node:test'; import test from 'node:test';
import assert from 'node:assert/strict'; import assert from 'node:assert/strict';
import { DEFAULT_RULESET } from '../shared/game/index.ts'; import { DEFAULT_RULESET } from '../shared/game/index.ts';
import { engine } from '../src/game/adapter.ts'; import { engine } from '../src/game/adapter.ts';
import { randomBot } from '../src/game/bots.ts'; import { randomBot } from '../src/game/bots.ts';
import { cardFromBlock, loanerPool, opponentDeck, starterDeck } from '../src/game/cards.ts'; import { cardFromBlock, loanerPool, opponentDeck, starterDeck } from '../src/game/cards.ts';
import { deckProblem, deckWarning } from '../src/game/DeckBuilder.tsx'; import { deckProblem, deckWarning } from '../src/game/DeckBuilder.tsx';
import { parseModeList } from '../src/game/useModes.ts'; import { parseModeList } from '../src/game/useModes.ts';
import type { PlayerIndex } from '../src/game/types.ts'; import type { PlayerIndex } from '../src/game/types.ts';
import type { TestnetBlock } from '../shared/testnet.ts'; import type { TestnetBlock } from '../shared/testnet.ts';
function rand(seed: number) { return () => ((seed = (seed * 1103515245 + 12345) >>> 0) / 4294967296); } function rand(seed: number) { return () => ((seed = (seed * 1103515245 + 12345) >>> 0) / 4294967296); }
/** Both seats driven by the UI bot through the UI adapter, exactly as the match screen does. */ /** Both seats driven by the UI bot through the UI adapter, exactly as the match screen does. */
function playOut(seed: string) { function playOut(seed: string) {
let s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck(seed)], seed); let s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck(seed)], seed);
const r = rand(seed.length * 7919 + 1); const r = rand(seed.length * 7919 + 1);
for (let steps = 0; steps < 2000 && !engine.isOver(s); steps++) { for (let steps = 0; steps < 2000 && !engine.isOver(s); steps++) {
for (const p of [0, 1] as PlayerIndex[]) { for (const p of [0, 1] as PlayerIndex[]) {
const legal = engine.legal(s, p).filter(a => a.type !== 'concede'); const legal = engine.legal(s, p).filter(a => a.type !== 'concede');
if (!legal.length) continue; if (!legal.length) continue;
s = engine.apply(s, p, randomBot.choose(engine.view(s, p), legal, r)); s = engine.apply(s, p, randomBot.choose(engine.view(s, p), legal, r));
} }
} }
return s; return s;
} }
test('the starter deck is a legal Standard deck and the bot gets a legal deck too', () => { test('the starter deck is a legal Standard deck and the bot gets a legal deck too', () => {
assert.equal(deckProblem(starterDeck(), DEFAULT_RULESET), ''); assert.equal(deckProblem(starterDeck(), DEFAULT_RULESET), '');
assert.equal(deckProblem(opponentDeck('x'), DEFAULT_RULESET), ''); assert.equal(deckProblem(opponentDeck('x'), DEFAULT_RULESET), '');
assert.match(deckProblem(starterDeck().slice(1), DEFAULT_RULESET), /exactly 12/); assert.match(deckProblem(starterDeck().slice(1), DEFAULT_RULESET), /exactly 12/);
}); });
test('the deck curve warning is soft advice for fewer than 4 cards of cost 2 or less', () => { test('the deck curve warning is soft advice for fewer than 4 cards of cost 2 or less', () => {
const pool = loanerPool(); const pool = loanerPool();
const heavy = pool.filter(c => c.cost >= 3).slice(0, 12); const heavy = pool.filter(c => c.cost >= 3).slice(0, 12);
assert.match(deckWarning(heavy), /cost 2 or less/); assert.match(deckWarning(heavy), /cost 2 or less/);
assert.equal(deckWarning(starterDeck()), ''); assert.equal(deckWarning(starterDeck()), '');
}); });
test('UI-driven random play always finishes within the turn cap and is deterministic', () => { test('UI-driven random play always finishes within the turn cap and is deterministic', () => {
for (let i = 0; i < 40; i++) { for (let i = 0; i < 40; i++) {
const a = playOut(`seed-${i}`), b = playOut(`seed-${i}`); const a = playOut(`seed-${i}`), b = playOut(`seed-${i}`);
assert.ok(engine.isOver(a), `match ${i} finished`); assert.ok(engine.isOver(a), `match ${i} finished`);
const ra = engine.result(a, 0); const ra = engine.result(a, 0);
assert.ok(ra.turns <= DEFAULT_RULESET.turns, `match ${i}: ${JSON.stringify(ra)}`); assert.ok(ra.turns <= DEFAULT_RULESET.turns, `match ${i}: ${JSON.stringify(ra)}`);
assert.deepEqual(ra, engine.result(b, 0)); assert.deepEqual(ra, engine.result(b, 0));
const rb = engine.result(a, 1); const rb = engine.result(a, 1);
assert.equal(rb.winner, ra.winner === null ? null : 1 - ra.winner, 'each side sees the other side of the same result'); assert.equal(rb.winner, ra.winner === null ? null : 1 - ra.winner, 'each side sees the other side of the same result');
assert.deepEqual(rb.totalPower, [ra.totalPower[1], ra.totalPower[0]]); assert.deepEqual(rb.totalPower, [ra.totalPower[1], ra.totalPower[0]]);
} }
}); });
test('my view never shows the opponent’s queued cards', () => { test('my view never shows the opponent’s queued cards', () => {
// Find a seed where the opponent has a turn-1 play (cost 1 in the opening hand). // Find a seed where the opponent has a turn-1 play (cost 1 in the opening hand).
let s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck('h0')], 'hidden-0'); let s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck('h0')], 'hidden-0');
for (let i = 1; i < 50 && !engine.legal(s, 1).some(a => a.type === 'play'); i++) for (let i = 1; i < 50 && !engine.legal(s, 1).some(a => a.type === 'play'); i++)
s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck(`h${i}`)], `hidden-${i}`); s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck(`h${i}`)], `hidden-${i}`);
const play = engine.legal(s, 1).find(a => a.type === 'play'); const play = engine.legal(s, 1).find(a => a.type === 'play');
assert.ok(play, 'some seed gives the opponent a turn-1 play'); assert.ok(play, 'some seed gives the opponent a turn-1 play');
s = engine.apply(s, 1, play!); s = engine.apply(s, 1, play!);
const mine = engine.view(s, 0); const mine = engine.view(s, 0);
assert.equal(mine.lanes.flatMap(l => [...l.theirs, ...l.staged]).length, 0); assert.equal(mine.lanes.flatMap(l => [...l.theirs, ...l.staged]).length, 0);
assert.equal(mine.oppQueued, 1); assert.equal(mine.oppQueued, 1);
const theirs = engine.view(s, 1); const theirs = engine.view(s, 1);
assert.equal(theirs.lanes.flatMap(l => l.staged).length, 1); assert.equal(theirs.lanes.flatMap(l => l.staged).length, 1);
assert.ok(!theirs.hand.some(c => play!.type === 'play' && c.id === play!.cardId), 'a queued card leaves the visible hand'); assert.ok(!theirs.hand.some(c => play!.type === 'play' && c.id === play!.cardId), 'a queued card leaves the visible hand');
}); });
test('unstage refunds energy, and illegal plays are explained', () => { test('unstage refunds energy, and illegal plays are explained', () => {
let s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck('e')], 'energy'); let s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck('e')], 'energy');
const v = engine.view(s, 0); const v = engine.view(s, 0);
const expensive = v.hand.find(c => c.cost > v.energy); const expensive = v.hand.find(c => c.cost > v.energy);
if (expensive) assert.ok(engine.problem(s, 0, { type: 'play', cardId: expensive.id, lane: 0 })); if (expensive) assert.ok(engine.problem(s, 0, { type: 'play', cardId: expensive.id, lane: 0 }));
const play = engine.legal(s, 0).find(a => a.type === 'play'); const play = engine.legal(s, 0).find(a => a.type === 'play');
if (play?.type === 'play') { if (play?.type === 'play') {
s = engine.apply(s, 0, play); s = engine.apply(s, 0, play);
assert.ok(engine.view(s, 0).energy < v.energy); assert.ok(engine.view(s, 0).energy < v.energy);
s = engine.apply(s, 0, { type: 'unstage', cardId: play.cardId }); s = engine.apply(s, 0, { type: 'unstage', cardId: play.cardId });
assert.equal(engine.view(s, 0).energy, v.energy); assert.equal(engine.view(s, 0).energy, v.energy);
} }
}); });
test('an owned NFT maps to a sidegrade card that the engine accepts', () => { test('an owned NFT maps to a sidegrade card that the engine accepts', () => {
const block = { tokenId: 'ab'.repeat(32), powHash: '00'.repeat(32), article: { pageId: 42, title: 'Test', category: 'Space', image: undefined }, const block = { tokenId: 'ab'.repeat(32), powHash: '00'.repeat(32), article: { pageId: 42, title: 'Test', category: 'Space', image: undefined },
statsSnapshot: { stats: { attention: 100, depth: 100, reach: 100 } } } as unknown as TestnetBlock; statsSnapshot: { stats: { attention: 100, depth: 100, reach: 100 } } } as unknown as TestnetBlock;
const card = cardFromBlock(block); const card = cardFromBlock(block);
assert.equal(card.source, 'nft'); assert.equal(card.source, 'nft');
assert.ok(card.cost <= DEFAULT_RULESET.uncheckedCostCap, 'forged max stats are capped'); assert.ok(card.cost <= DEFAULT_RULESET.uncheckedCostCap, 'forged max stats are capped');
assert.equal(card.basePower, DEFAULT_RULESET.powerByCost[card.cost]); assert.equal(card.basePower, DEFAULT_RULESET.powerByCost[card.cost]);
const deck = [card, ...starterDeck().slice(1)]; const deck = [card, ...starterDeck().slice(1)];
assert.equal(deckProblem(deck, DEFAULT_RULESET), ''); assert.equal(deckProblem(deck, DEFAULT_RULESET), '');
}); });
test('peer mode lists are parsed defensively', () => { test('peer mode lists are parsed defensively', () => {
const modes = parseModeList({ host: { origin: 'http://192.168.1.32:3102', operator: 'node-b' }, modes: [ const modes = parseModeList({ host: { origin: 'http://192.168.1.32:3102', operator: 'node-b' }, modes: [
{ mode: { id: 'trending', name: 'Trending', description: 'x'.repeat(1000), rules: { turns: 5 } }, stats: { playersOnline: 3, matchesPlayed: 9 } }, { mode: { id: 'trending', name: 'Trending', description: 'x'.repeat(1000), rules: { turns: 5 } }, stats: { playersOnline: 3, matchesPlayed: 9 } },
{ mode: { id: 'bad', name: 'Bad rules', rules: { turns: 999 } } }, { mode: { id: 'bad', name: 'Bad rules', rules: { turns: 999 } } },
{ mode: { name: 'no id' } }, 'junk', null, { mode: { name: 'no id' } }, 'junk', null,
] }, { self: false, origin: 'http://192.168.1.32:3102' }); ] }, { self: false, origin: 'http://192.168.1.32:3102' });
assert.equal(modes.length, 1); assert.equal(modes.length, 1);
const [m] = modes; const [m] = modes;
assert.equal(m.host.kind === 'peer' && m.host.name, 'node-b'); assert.equal(m.host.kind === 'peer' && m.host.name, 'node-b');
assert.equal(m.ruleset.turns, 5); assert.equal(m.ruleset.turns, 5);
assert.ok(m.description.length <= 280); assert.ok(m.description.length <= 280);
assert.equal(m.players, 3); assert.equal(m.players, 3);
assert.deepEqual(parseModeList('nope', { self: true, origin: '' }), []); assert.deepEqual(parseModeList('nope', { self: true, origin: '' }), []);
}); });
test('bots get only the hidden-information view, never the full match state', () => {
const s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck('v')], 'view-only');
const v = engine.view(s, 1);
assert.ok(v.engine?.view);
const json = JSON.stringify(v);
assert.ok(!json.includes('"rng"') && !json.includes('"seed"'), 'no RNG state or seed');
assert.ok(!('deck' in (v.engine!.view as object)), 'no deck order');
});