Play follow-ups: final board before results, Pass label, queued power, no queue-size leak

- After the last turn the board stays up with scoring totals (+N from
  at-scoring Portals) until 'See results' (council-critic playtest #1).
- End turn reads 'Pass' when nothing is queued (#2).
- Queued cards preview their lane power: base + trend + on-topic (#3).
- Drop the opponent '· N queued' chip (night-review); also keeps the UI
  compiling once #38 removes queuedCount from PlayerView.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 00:38:21 -05:00
co-authored by Claude Opus 5.5
parent 361efaa1d6
commit ed47e0d5d1
7 changed files with 45 additions and 29 deletions
+13 -9
View File
@@ -7,8 +7,8 @@ import type { LaneView, MatchView, UIAction, UICard } from './types.ts';
type Sheet = { kind: 'card'; card: UICard; side: 'mine' | 'theirs' } | { kind: 'lane'; lane: LaneView } | { kind: 'concede' } | null;
/** The match screen itself: board, thumb dock and bottom sheets. Controllers (local bot / hosted lobby) feed it. */
export function MatchBoard({ title, opponent, view, legal, onAct, problem, error, onTopicBonus }: {
title: string; opponent: string; view: MatchView; legal: UIAction[]; onAct: (a: UIAction) => void;
export function MatchBoard({ title, opponent, view, legal, onAct, problem, error, onTopicBonus, onResults }: {
onResults?: () => void; title: string; opponent: string; view: MatchView; legal: UIAction[]; onAct: (a: UIAction) => void;
problem?: (a: UIAction) => string | null; error?: string; onTopicBonus: number[];
}) {
const [selected, setSelected] = useState<string>();
@@ -45,12 +45,13 @@ export function MatchBoard({ title, opponent, view, legal, onAct, problem, error
else setSheet({ kind: 'lane', lane });
};
const ending = view.waitingForOpponent;
const queuedCount = view.lanes.reduce((n, l) => n + l.staged.length, 0);
const lastEvent = view.log.at(-1);
return <section className="match" aria-label={title}>
<header className="match-bar">
<span className="match-turn"><Hourglass size={14} /> Turn <b>{view.turn}</b>/{view.maxTurns}</span>
<span className="match-opp" aria-label={`Opponent: ${view.oppHandCount} cards in hand, ${view.oppDeckCount} in deck`}>{opponent} · <Layers3 size={13} /> {view.oppHandCount}{view.oppQueued ? ` · ${view.oppQueued} queued` : ''}</span>
<span className="match-opp" aria-label={`Opponent: ${view.oppHandCount} cards in hand, ${view.oppDeckCount} in deck`}>{opponent} · <Layers3 size={13} /> {view.oppHandCount}</span>
<button className="icon-button" onClick={() => setSheet({ kind: 'concede' })} aria-label="Concede match"><Flag size={16} /></button>
</header>
{banner && <div className="turn-banner" role="status">{banner}</div>}
@@ -67,11 +68,11 @@ export function MatchBoard({ title, opponent, view, legal, onAct, problem, error
</div>
<button className={`lane-plate ${lead}`} onClick={() => tapLane(lane)}
aria-label={target ? `Play ${sel!.title} to ${lane.name}${onTopic ? `, on-topic +${topicBonus}` : ''}` : `${lane.name} Topic (${STAT_LABEL[lane.stat]}): you ${lane.myPower}, opponent ${lane.theirPower}. ${lane.modifier?.text ?? lane.portalNote ?? ''}`}>
<span className="lane-score theirs" aria-hidden="true"><small>Opp</small>{lane.theirPower}</span>
<span className="lane-score theirs" aria-hidden="true"><small>Opp</small>{lane.theirPower}{!!lane.scoringBonus?.[1] && <small className="lane-bonus">+{lane.scoringBonus[1]}</small>}</span>
<span className="lane-name"><StatIcon stat={lane.stat} size={13} /><span>{lane.name}</span>{!lane.revealed && <small>?</small>}
{lane.modifier && <small className="lane-rule">{lane.modifier.text}</small>}
{lane.myPower === lane.theirPower && lane.leader && <small className="lane-tie">Tie: {lane.leader === 'you' ? 'you lead' : 'they lead'} on-topic</small>}</span>
<span className="lane-score mine" aria-hidden="true"><small>You</small>{lane.myPower}</span>
<span className="lane-score mine" aria-hidden="true"><small>You</small>{lane.myPower}{!!lane.scoringBonus?.[0] && <small className="lane-bonus">+{lane.scoringBonus[0]}</small>}</span>
</button>
<div className="lane-side mine" aria-label={`Your cards in ${lane.name}`}>
{lane.mine.map(c => <GameCard key={c.id} card={c} size="board" fresh={fresh.has(c.id)} onClick={() => setSheet({ kind: 'card', card: c, side: 'mine' })} />)}
@@ -84,7 +85,8 @@ export function MatchBoard({ title, opponent, view, legal, onAct, problem, error
<div className="play-dock match-dock">
<p className="dock-note" role="status" aria-live="polite">
{error ? <span className="dock-error">{error}</span>
{view.over ? <>Final board. Topic totals include at-scoring Portals (+N).</>
: error ? <span className="dock-error">{error}</span>
: ending ? <><LoaderCircle className="spin" size={14} /> Opponent is choosing…</>
: sel ? <><Zap size={12} /> <b>{sel.title}</b>{sel.keyword ? ` · ${sel.keyword.name}: ${sel.keyword.text}` : ''} Tap a lane.</>
: lastEvent}
@@ -100,9 +102,11 @@ export function MatchBoard({ title, opponent, view, legal, onAct, problem, error
<b>{view.energy}</b>
</span>
<span className="deck-count"><Layers3 size={13} /> {view.deckCount}</span>
<button className="button dark end-turn" disabled={ending || view.over} onClick={() => { setSelected(undefined); act({ type: 'endTurn' }); }}>
{ending ? 'Waiting…' : view.turn === view.maxTurns ? 'End match' : 'End turn'}
</button>
{view.over ? <button className="button dark end-turn" onClick={onResults} disabled={!onResults}>See results</button>
: <button className={`button ${queuedCount ? 'dark' : 'outline'} end-turn`} disabled={ending} onClick={() => { setSelected(undefined); act({ type: 'endTurn' }); }}
aria-label={queuedCount ? undefined : 'Pass this turn without playing a card'}>
{ending ? 'Waiting…' : !queuedCount ? 'Pass' : view.turn === view.maxTurns ? 'End match' : 'End turn'}
</button>}
</div>
</div>
+1 -2
View File
@@ -23,7 +23,6 @@ export function MatchScreen({ mode, deck, opponentDeck, bot, seed, onFinish }: {
const view = useMemo(() => engine.view(state, 0), [state]);
const legal = useMemo(() => engine.legal(state, 0), [state]);
useEffect(() => { if (engine.isOver(state)) { const t = setTimeout(() => onFinish(engine.result(state, 0)), 900); return () => clearTimeout(t); } }, [state, onFinish]);
// The bot moves once the player has committed (it never sees the player's queued plays).
useEffect(() => {
@@ -47,5 +46,5 @@ export function MatchScreen({ mode, deck, opponentDeck, bot, seed, onFinish }: {
catch (e) { setError(e instanceof Error ? e.message : 'That move isn’t allowed.'); }
};
return <MatchBoard title={`${mode.name} match`} opponent={`${bot.name} bot`} view={view} legal={legal} onAct={act} error={error}
problem={a => engine.problem(state, 0, a)} onTopicBonus={mode.ruleset.onTopicBonus} />;
problem={a => engine.problem(state, 0, a)} onResults={engine.isOver(state) ? () => onFinish(engine.result(state, 0)) : undefined} onTopicBonus={mode.ruleset.onTopicBonus} />;
}
+3 -13
View File
@@ -23,7 +23,6 @@ export function OnlinePlay({ mode, playerName, onExit, onFinish }: {
const [error, setError] = useState('');
const [busy, setBusy] = useState(false);
const inFlight = useRef(false);
const finished = useRef(false);
const done = status?.phase === 'finished' || status?.phase === 'expired';
const refreshLobbies = useCallback(() => {
@@ -50,17 +49,7 @@ export function OnlinePlay({ mode, playerName, onExit, onFinish }: {
return () => clearInterval(t);
}, [seat, poll, done]);
// Once finished, stop polling and show results after a beat. The timer must survive later
// re-renders, so it is only cleared on unmount.
const finishTimer = useRef<ReturnType<typeof setTimeout>>(undefined);
useEffect(() => {
const st = status?.state;
if (finished.current || !status || !seat || status.phase !== 'finished' || !st?.result) return;
finished.current = true;
const names = st.lanes.map(l => l.topic.name);
finishTimer.current = setTimeout(() => onFinish(resultView(st.result!, seat.seat, names, st.lanes.map(l => l.leader))), 900);
}, [status, seat, onFinish]);
useEffect(() => () => clearTimeout(finishTimer.current), []);
// Once finished, stop polling; the final board stays up until the player opens the results.
const enter = async (fn: () => Promise<LobbySeat>) => {
setBusy(true); setError('');
@@ -106,7 +95,8 @@ export function OnlinePlay({ mode, playerName, onExit, onFinish }: {
return void send(() => online.act(seat, engineAction(a, seat.seat)));
};
return <MatchBoard title={`${mode.name} online match`} opponent={opp.slice(0, 24)} view={view} legal={legal} onAct={act}
error={error} onTopicBonus={status.state.ruleset.onTopicBonus} />;
error={error} onTopicBonus={status.state.ruleset.onTopicBonus}
onResults={status.state.result ? () => onFinish(resultView(status.state!.result!, seat.seat, status.state!.lanes.map(l => l.topic.name), status.state!.lanes.map(l => l.leader))) : undefined} />;
}
// ----- draft -----
+10 -3
View File
@@ -88,6 +88,9 @@ function capacityFromView(v: PlayerView, i: number): number {
export function viewFromPlayerView(v: PlayerView, opts: { log?: string[]; capacity?: (lane: number) => number } = {}): MatchView {
const rules = v.ruleset;
const me = v.you;
const opp = me === 0 ? 1 : 0;
// After the last turn, show scoring power (incl. "at scoring" Portals) from the result, from my side.
const final = v.result ? v.result.lanePower.map(p => [p[me], p[opp]] as [number, number]) : undefined;
const onBoard = (c: CardInPlay, power: number, stat: string, allOnTopic: boolean) =>
toUICard(c.card, rules, { id: `${c.owner}:${c.card.cardId}`, power, onTopic: allOnTopic || c.card.home === stat }); // both seats may share loaner cardIds
const lanes: LaneView[] = v.lanes.map((lane, i) => {
@@ -101,9 +104,13 @@ export function viewFromPlayerView(v: PlayerView, opts: { log?: string[]; capaci
theirs: lane.cards[1].map((c, k) => onBoard(c, lane.cardPower[1][k], lane.topic.stat, allOn)),
staged: v.queue.filter(q => q.lane === i).flatMap(q => {
const c = v.hand.find(h => h.cardId === q.cardId);
return c ? [toUICard(c, rules)] : [];
if (!c) return [];
const onTopic = allOn || c.home === lane.topic.stat;
const power = Math.max(0, c.power + c.trend + (onTopic ? rules.onTopicBonus[c.cost] ?? 0 : 0));
return [toUICard(c, rules, { power, onTopic })];
}),
myPower: lane.power[0], theirPower: lane.power[1], leader: lane.leader,
myPower: final ? final[i][0] : lane.power[0], theirPower: final ? final[i][1] : lane.power[1], leader: lane.leader,
scoringBonus: final ? [final[i][0] - lane.power[0], final[i][1] - lane.power[1]] as [number, number] : undefined,
capacity: opts.capacity ? opts.capacity(i) : capacityFromView(v, i),
};
});
@@ -112,7 +119,7 @@ export function viewFromPlayerView(v: PlayerView, opts: { log?: string[]; capaci
me, turn: v.turn, maxTurns: rules.turns, energy: v.energyLeft, maxEnergy: v.energy,
saved: Math.max(0, v.energy - (rules.energyByTurn[v.turn - 1] ?? 0) - rules.bonusEnergy),
hand: v.hand.filter(c => !queued.has(c.cardId)).map(c => toUICard(c, rules)), deckCount: v.deckCount,
oppHandCount: v.opponent.handCount, oppDeckCount: v.opponent.deckCount, oppQueued: v.opponent.queuedCount,
oppHandCount: v.opponent.handCount, oppDeckCount: v.opponent.deckCount,
lanes, log: opts.log ?? [], waitingForOpponent: v.committed && v.phase !== 'over', over: v.phase === 'over',
};
}
+1
View File
@@ -205,3 +205,4 @@ html.wd-in-match .auth-wrap,body:has(.match) .auth-wrap{display:none}
@media(max-width:480px){.hide-narrow{display:none}.play-actions{flex-wrap:nowrap}.play-actions .button{padding-inline:12px}}
.show-narrow{display:none}
@media(max-width:480px){.show-narrow{display:inline}.play-actions .button{min-width:0}}
.lane-bonus{color:var(--ctp-yellow)!important;margin-left:2px}
+1 -1
View File
@@ -39,6 +39,7 @@ export type LaneView = {
theirPower: number;
leader: 'you' | 'opponent' | null;
capacity: number;
scoringBonus?: [number, number]; // at-scoring Portal adjustments (mine, theirs), match over only
};
export type MatchView = {
@@ -52,7 +53,6 @@ export type MatchView = {
deckCount: number;
oppHandCount: number;
oppDeckCount: number;
oppQueued: number;
lanes: LaneView[];
log: string[]; // newest last, this seat's events only
waitingForOpponent: boolean;
+16 -1
View File
@@ -61,7 +61,6 @@ test('my view never shows the opponent’s queued cards', () => {
s = engine.apply(s, 1, play!);
const mine = engine.view(s, 0);
assert.equal(mine.lanes.flatMap(l => [...l.theirs, ...l.staged]).length, 0);
assert.equal(mine.oppQueued, 1);
const theirs = engine.view(s, 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');
@@ -126,3 +125,19 @@ test('leaderboard parsers cap and sanitise host data', async () => {
assert.deepEqual(parseLeaderboard({ entries: [{ name: '', wins: 2 }] }), [{ name: 'Anonymous', wins: 2, losses: 0, draws: 0, played: 0 }]);
assert.deepEqual(parseLeaderboard(42), []);
});
test('the final board shows scoring power, and queued cards preview their lane power', () => {
const s = playOut('final-board');
const v = engine.view(s, 0), r = engine.result(s, 0);
assert.ok(v.over);
v.lanes.forEach((l, i) => { assert.equal(l.myPower, r.lanes[i].myPower); assert.equal(l.theirPower, r.lanes[i].theirPower); });
let m = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck('q')], 'queued-power');
const play = engine.legal(m, 0).find(a => a.type === 'play');
if (play?.type === 'play') {
m = engine.apply(m, 0, play);
const lane = engine.view(m, 0).lanes[play.lane];
const [q] = lane.staged;
const bonus = q.home === lane.stat ? DEFAULT_RULESET.onTopicBonus[q.cost] : 0;
assert.equal(q.power, q.basePower + q.trend + bonus);
}
});