Merge remote-tracking branch 'origin/night/2026-11-16' into night/engine/v1-1

This commit is contained in:
2026-11-17 00:45:18 -05:00
20 changed files with 1487 additions and 5 deletions
+6 -5
View File
@@ -1,7 +1,7 @@
import { useEffect, useRef, useState } from 'react';
import { ArrowDownLeft, ArrowLeftRight, ArrowRight, ArrowUpRight, BookOpen, Check, ChevronRight, CircleHelp,
Copy, Cpu, Download, ExternalLink, Globe2, Layers3, LayoutDashboard, LoaderCircle,
Pickaxe, Search, Shield, Sparkles, Wallet as WalletIcon, X } from 'lucide-react';
Pickaxe, Search, Shield, Sparkles, Swords, Wallet as WalletIcon, X } from 'lucide-react';
import { rarity } from '../shared/protocol.ts';
import { CONSENSUS, NETWORK, isNftTrade, nftTransferMessage, testnetOwnerOf, transactionCardIds,
type TestnetBlock, type TestnetSnapshot } from '../shared/testnet.ts';
@@ -14,11 +14,12 @@ import { LoginButton } from './auth/LoginButton.tsx';
import { TradeDesk } from './TradeDesk.tsx';
import { IS_MAINNET, NETWORK_GENESIS_TIME, NETWORK_LABEL } from '../shared/network.ts';
import { StateClient } from '../shared/rpc-client.ts';
import { PlaySection } from './game/PlaySection.tsx';
import { isNativeApp } from './native.ts';
import './App.css';
import './testnet.css';
type View = 'Discover' | 'My collection' | 'Block explorer' | 'Trade cards';
type View = 'Discover' | 'Play' | 'My collection' | 'Block explorer' | 'Trade cards';
const short = (s: string) => s ? `${s.slice(0, 6)}…${s.slice(-4)}` : '—';
const asCard = (block: TestnetBlock): CardData => ({ article: block.article, hash: block.powHash, block });
const message = (error: unknown) => error instanceof Error ? error.message : 'Request failed. Please try again.';
@@ -163,8 +164,8 @@ export default function App() {
<aside className="sidebar">
<a href="#" className="brand" onClick={e => { e.preventDefault(); setView('Discover'); }}><span className="brand-mark" aria-hidden="true">W<span>✦</span></span>wikideck<span className="brand-dot">.</span></a>
<div className="sidebar-label">YOUR NEXT DISCOVERY</div>
<nav aria-label="Main navigation">{(['Discover', 'My collection', 'Block explorer', 'Trade cards'] as View[]).map((item, i) => {
const Icon = [LayoutDashboard, Layers3, Globe2, ArrowLeftRight][i];
<nav aria-label="Main navigation">{(['Discover', 'Play', 'My collection', 'Block explorer', 'Trade cards'] as View[]).map((item, i) => {
const Icon = [LayoutDashboard, Swords, Layers3, Globe2, ArrowLeftRight][i];
return <button key={item} aria-label={item} aria-current={view === item ? 'page' : undefined} className={`nav-item ${view === item ? 'active' : ''}`} onClick={() => { setView(item); setQuery(''); setCategory('All cards'); }}><Icon size={18} />{item}{item === 'My collection' && <span className="nav-count">{owned.length}</span>}</button>;
})}</nav>
<div className="sidebar-note"><span className="tiny-spark">✦</span><h3>Mine together.<br />Trade your way.</h3><p>Discover illustrated Wikipedia cards, build a deck around what you love, and find your collector community.</p><button onClick={() => setDialog('guide')}>How it works <ArrowUpRight size={15} /></button></div>
@@ -197,7 +198,7 @@ export default function App() {
<article><ArrowLeftRight size={22}/><div className="section-eyebrow">TRADE · PLAYER TO PLAYER</div><h2>Swap cards directly.</h2><p>Prepare a signed offer for another collector and exchange card bundles atomically when the trade is mined. No prices or checkout.</p><button className="text-button" onClick={()=>setView('Trade cards')}>Trade cards <ArrowRight size={14}/></button></article>
</section>
</>}
{view === 'Trade cards' ? <TradeDesk wallet={wallet} snapshot={snapshot} rpcAvailable={rpcAvailable} onNotice={setToast} /> : view !== 'Block explorer' ? <section className="discover-section">
{view === 'Play' ? <PlaySection owned={owned} /> : view === 'Trade cards' ? <TradeDesk wallet={wallet} snapshot={snapshot} rpcAvailable={rpcAvailable} onNotice={setToast} /> : view !== 'Block explorer' ? <section className="discover-section">
<div className="section-heading"><div><div className="section-eyebrow">{view === 'My collection' ? 'YOUR PERSONAL ENCYCLOPEDIA' : 'AN ENCYCLOPEDIA, REIMAGINED'}</div><h2>{view === 'My collection' ? 'Your cabinet of curiosities' : 'A world of possible discoveries'}<span className="count-badge">{visibleCards.length}</span></h2><p>{view === 'My collection' ? 'Confirmed native NFT ownership. Pending transfers stay here until mined.' : snapshot?.blocks.length ? 'Recent native NFTs on this node’s canonical chain.' : 'Sample previews only; mined NFTs use random Wikipedia pages with pictures. The same page may be minted more than once.'}</p></div>{view === 'Discover' && <button className="text-button" onClick={() => setView('My collection')}>My collection <ArrowRight size={16} /></button>}</div>
<div className="filter-bar"><div className="category-tabs">{['All cards', 'Nature', 'Space', 'Science', 'People', 'History', 'Culture'].map(c => <button key={c} className={category === c ? 'selected' : ''} onClick={() => setCategory(c)}>{c}</button>)}</div><label className="search-input"><Search size={15} /><input aria-label="Search cards" placeholder="Find a discovery…" value={query} onChange={e => setQuery(e.target.value)} /></label></div>
{filtered.length ? <div className="card-grid">{filtered.map(c => <div className="card-wrap" key={c.block?.tokenId ?? c.hash}><Card card={c} onClick={() => { setSelected(c); setTransferError(''); }} /><div className="card-list-caption"><span>{c.block ? `Block #${c.block.height}` : 'Example discovery'}</span><span className="caption-dot" />{c.block && snapshot ? short(testnetOwnerOf(snapshot, c.block.tokenId) ?? '') : 'Not owned'}</div>{c.block && snapshot?.pendingTransfers.some(tx => transactionCardIds(tx).includes(c.block!.tokenId)) && <span className="pending-label">Transfer or trade pending mining</span>}</div>)}</div> : <div className="empty-state"><img className="empty-state-logo" src="/original-logo.svg" alt="Wikideck" /><h3>{query || category !== 'All cards' ? 'No discoveries here. Yet.' : 'Your first discovery is waiting.'}</h3><p>{query || category !== 'All cards' ? 'Try another search or explore a different category.' : 'Use the native miner or receive a mined transfer on this chain. Restore a backup to access an existing wallet.'}</p><button className="button dark" onClick={goMine}><Pickaxe size={16} /> Explore native mining</button></div>}
+66
View File
@@ -0,0 +1,66 @@
import { useMemo, useState } from 'react';
import { Check, RotateCcw, Trash2 } from 'lucide-react';
import { GameCard } from './GameCard.tsx';
import { STARTERS, starterDeck } from './cards.ts';
import { validateDeck, type Ruleset } from '../../shared/game/index.ts';
import type { UICard } from './types.ts';
export function deckProblem(deck: UICard[], ruleset: Ruleset): string {
if (deck.length !== ruleset.deckSize) return `A deck needs exactly ${ruleset.deckSize} cards (${deck.length} now).`;
return validateDeck(ruleset, deck.map(c => c.game))[0] ?? '';
}
/** Soft advice (DESIGN.md s8): warn, never block, when the early curve is thin. */
export function deckWarning(deck: UICard[]): string {
const cheap = deck.filter(c => c.cost <= 2).length;
return cheap < 4 ? `Only ${cheap} card${cheap === 1 ? '' : 's'} cost 2 or less. Aim for at least 4 so you have early plays.` : '';
}
export function DeckBuilder({ pool, deck, ruleset, modeName, onSave, onCancel }: {
modeName: string; pool: UICard[]; deck: UICard[]; ruleset: Ruleset; onSave: (deck: UICard[]) => void; onCancel: () => void;
}) {
const [draft, setDraft] = useState<UICard[]>(deck);
const [filter, setFilter] = useState<'all' | 'starter' | 'nft'>('all');
const inDeck = new Set(draft.map(c => c.id));
const shown = pool.filter(c => filter === 'all' || c.source === filter).sort((a, b) => a.cost - b.cost || a.title.localeCompare(b.title));
const curve = useMemo(() => [1, 2, 3, 4, 5, 6].map(n => draft.filter(c => Math.min(c.cost, 6) === n).length), [draft]);
const nftCount = pool.filter(c => c.source === 'nft').length;
const problem = deckProblem(draft, ruleset);
const warning = deckWarning(draft);
const toggle = (card: UICard) => {
if (inDeck.has(card.id)) setDraft(d => d.filter(c => c.id !== card.id));
else if (draft.length < ruleset.deckSize) setDraft(d => [...d, card]);
};
const full = draft.length >= ruleset.deckSize;
return <section className="play-panel deck-builder" aria-labelledby="deck-title">
<div className="section-eyebrow">DECK BUILDER · {modeName.toUpperCase()}</div>
<h2 id="deck-title">Your deck <span className={`count-badge ${problem ? '' : 'ok'}`}>{draft.length} / {ruleset.deckSize}</span></h2>
<p className="muted">Tap a card to add it or take it out. Loaner cards are free previews, not NFTs; nothing you do here moves a card on-chain.</p>
<div className="deck-curve" aria-label="Cost curve">{curve.map((n, i) => <div key={i}><span style={{ height: `${Math.min(100, n * 22)}%` }} /><b>{i + 1}{i === 5 ? '+' : ''}</b><small>{n}</small></div>)}</div>
<div className="deck-strip" aria-label="Cards in deck">
{draft.length ? [...draft].sort((a, b) => a.cost - b.cost).map(c => <GameCard key={c.id} card={c} size="board" onClick={() => toggle(c)} label={`Remove ${c.title} from deck`} />)
: <p className="muted">Empty. Add cards below or use the starter deck.</p>}
</div>
<h3 className="lobby-label"><RotateCcw size={13} /> Start from a loaner deck</h3>
<div className="category-tabs starter-picks">{STARTERS.map(d => <button key={d.id} onClick={() => setDraft(starterDeck(ruleset, d.id))}>{d.name}</button>)}</div>
<div className="category-tabs deck-filter" role="tablist">
{([['all', 'All'], ['starter', 'Loaner'], ['nft', `My NFTs (${nftCount})`]] as const).map(([k, label]) =>
<button key={k} role="tab" aria-selected={filter === k} className={filter === k ? 'selected' : ''} onClick={() => setFilter(k)}>{label}</button>)}
</div>
{filter === 'nft' && !nftCount && <p className="muted">You don’t own any cards on this network yet. Mine a block or receive a transfer, and it shows up here.</p>}
<div className="pool-grid">
{shown.map(c => <GameCard key={c.id} card={c} size="deck" selected={inDeck.has(c.id)} dim={!inDeck.has(c.id) && full}
onClick={() => toggle(c)} label={`${inDeck.has(c.id) ? 'Remove' : 'Add'} ${c.title}, cost ${c.cost}, power ${c.power}${c.keyword ? `, ${c.keyword.name}` : ''}`} />)}
</div>
<div className="play-dock">
{problem ? <p className="dock-note" role="status">{problem}</p>
: warning && <p className="dock-note deck-warning" role="status">{warning}</p>}
<div className="play-actions">
<button className="button outline" onClick={() => setDraft([])} aria-label="Clear deck"><Trash2 size={16} /></button>
<button className="button outline" onClick={onCancel}>Cancel</button>
<button className="button dark" disabled={!!problem} onClick={() => onSave(draft)}><Check size={16} /> Save deck</button>
</div>
</div>
</section>;
}
+42
View File
@@ -0,0 +1,42 @@
import { BookOpen, ChevronDown, ChevronUp, Eye, Globe2, Landmark, Leaf, Library, Orbit, Palette, Users, Zap } from 'lucide-react';
import type { Stat, UICard } from './types.ts';
import { STAT_LABEL } from './rulesText.ts';
const ICONS: Record<string, typeof Leaf> = { Space: Orbit, Nature: Leaf, People: Users, Science: BookOpen, History: Landmark, Culture: Palette };
export const CategoryIcon = ({ category, size = 14 }: { category: string; size?: number }) => {
const Icon = ICONS[category] ?? Palette;
return <Icon size={size} aria-hidden="true" />;
};
const STAT_ICONS: Record<Stat, typeof Eye> = { attention: Eye, depth: Library, reach: Globe2 };
export const StatIcon = ({ stat, size = 12 }: { stat: Stat; size?: number }) => {
const Icon = STAT_ICONS[stat];
return <Icon size={size} aria-hidden="true" />;
};
export function cardLabel(card: UICard) {
return `${card.title}, cost ${card.cost}, power ${card.power}, home stat ${STAT_LABEL[card.home]}${card.trend ? `, trending ${card.trend > 0 ? 'up' : 'down'}` : ''}${card.onTopic ? ', on-topic' : ''}${card.keyword ? `, ${card.keyword.name}: ${card.keyword.text}` : ''}`;
}
/** Phone-readable card face (DESIGN §1.9): cost, power, home-stat icon, trend arrow, one keyword. Nothing needs hover. */
export function GameCard({ card, size = 'hand', selected, dim, onClick, label, fresh }: {
card: UICard; size?: 'hand' | 'board' | 'deck'; selected?: boolean; dim?: boolean; fresh?: boolean;
onClick?: () => void; label?: string;
}) {
const buffed = card.power > card.basePower, nerfed = card.power < card.basePower;
const Tag = onClick ? 'button' : 'div';
return <Tag {...(onClick ? { type: 'button' as const, onClick, 'aria-pressed': selected } : { role: 'img' })}
className={`gcard gcard-${size} cat-${card.category.toLowerCase()} ${selected ? 'is-selected' : ''} ${dim ? 'is-dim' : ''} ${fresh ? 'is-fresh' : ''} ${card.onTopic ? 'is-on-topic' : ''}`}
aria-label={label ?? cardLabel(card)}>
<span className="gcard-cost" aria-hidden="true">{card.cost}</span>
<span className={`gcard-power ${buffed ? 'up' : nerfed ? 'down' : ''}`} aria-hidden="true">{card.power}</span>
<span className="gcard-art" aria-hidden="true">
{card.image ? <img src={card.image} alt="" loading="lazy" referrerPolicy="no-referrer" onError={e => { e.currentTarget.style.display = 'none'; }} /> : null}
<CategoryIcon category={card.category} size={size === 'board' ? 12 : 18} />
</span>
<span className="gcard-home" aria-hidden="true" title={STAT_LABEL[card.home]}><StatIcon stat={card.home} size={size === 'board' ? 10 : 12} />
{card.trend > 0 && <ChevronUp size={11} className="trend up" />}{card.trend < 0 && <ChevronDown size={11} className="trend down" />}</span>
<span className="gcard-title">{card.title}</span>
{card.keyword && size !== 'board' && <span className="gcard-keyword"><Zap size={10} aria-hidden="true" />{card.keyword.name}</span>}
{card.source === 'nft' && size !== 'board' && <span className="gcard-nft">NFT</span>}
</Tag>;
}
+49
View File
@@ -0,0 +1,49 @@
import { useEffect, useState } from 'react';
import { Server, Trophy } from 'lucide-react';
import type { GameMode } from './types.ts';
// Host credit (modes, #6): per-mode player leaderboard and the network's host leaderboard.
// Same-origin GETs only; every string is untrusted and rendered as text.
type Entry = { name: string; wins: number; losses: number; draws: number; played: number };
type Host = { operator: string; matchesHosted: number; playersOnline: number; self: boolean; reachable: boolean };
const str = (v: unknown, max = 40) => (typeof v === 'string' ? v.slice(0, max) : '');
const num = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? Math.floor(v) : 0);
const rows = (v: unknown, key: string): Record<string, unknown>[] => {
const list = v && typeof v === 'object' ? (v as Record<string, unknown>)[key] : undefined;
return Array.isArray(list) ? list.filter((x): x is Record<string, unknown> => !!x && typeof x === 'object').slice(0, 10) : [];
};
const get = (path: string) => fetch(path, { cache: 'no-store', signal: AbortSignal.timeout(8000) })
.then(r => (r.ok && r.headers.get('content-type')?.includes('json') ? r.json() : Promise.reject(new Error('unavailable'))));
export function parseLeaderboard(v: unknown): Entry[] {
return rows(v, 'entries').map(e => ({ name: str(e.name, 24) || 'Anonymous', wins: num(e.wins), losses: num(e.losses), draws: num(e.draws), played: num(e.played) }));
}
export function parseHosts(v: unknown): Host[] {
return rows(v, 'hosts').map(h => ({ operator: str(h.operator, 60) || str(h.origin, 60) || 'unknown host', matchesHosted: num(h.matchesHosted),
playersOnline: num(h.playersOnline), self: h.self === true, reachable: h.reachable !== false }));
}
export function Leaderboards({ mode }: { mode: GameMode }) {
const [players, setPlayers] = useState<Entry[]>();
const [hosts, setHosts] = useState<Host[]>();
const hosted = mode.host.kind === 'peer' && mode.host.self;
const remoteId = mode.remoteId;
useEffect(() => {
let active = true;
get('/api/game/hosts/leaderboard').then(d => { if (active) setHosts(parseHosts(d)); }, () => { if (active) setHosts([]); });
if (hosted && remoteId) get(`/api/game/modes/${encodeURIComponent(remoteId)}/leaderboard`)
.then(d => { if (active) setPlayers(parseLeaderboard(d)); }, () => { if (active) setPlayers([]); });
else setPlayers(undefined);
return () => { active = false; };
}, [hosted, remoteId]);
if (!hosts?.length && !players?.length) return null;
return <details className="leaderboards">
<summary><Trophy size={14} /> Leaderboards</summary>
{players && <><h4>{mode.name}: top players</h4>{players.length
? <ol className="board-list">{players.map((p, i) => <li key={i}><span>{p.name}</span><b>{p.wins}W</b><small>{p.losses}L · {p.draws}D</small></li>)}</ol>
: <p className="muted small">No finished matches yet. Be the first.</p>}</>}
{!!hosts?.length && <><h4><Server size={13} /> Top hosts · matches hosted</h4>
<ol className="board-list">{hosts.map((h, i) => <li key={i} className={h.self ? 'self' : ''}><span>{h.operator}{h.self ? ' (this node)' : ''}{h.reachable ? '' : ' · offline'}</span><b>{h.matchesHosted}</b><small>{h.playersOnline} online</small></li>)}</ol>
<p className="muted small">Run a WikiDeck node and host your own modes to appear here.</p></>}
</details>;
}
+126
View File
@@ -0,0 +1,126 @@
import { useEffect, useRef, useState } from 'react';
import { Flag, Hourglass, Layers3, LoaderCircle, X, Zap } from 'lucide-react';
import { GameCard, StatIcon } from './GameCard.tsx';
import { STAT_HINT, STAT_LABEL } from './rulesText.ts';
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;
problem?: (a: UIAction) => string | null; error?: string; onTopicBonus: number[];
}) {
const [selected, setSelected] = useState<string>();
const [sheet, setSheet] = useState<Sheet>(null);
const [banner, setBanner] = useState('');
const prevBoard = useRef(new Set<string>());
const [fresh, setFresh] = useState(new Set<string>());
const boardKey = view.lanes.map(l => [...l.mine, ...l.theirs].map(c => c.id).join(',')).join('|');
// Turn feedback: banner on turn change, and a short highlight on newly revealed cards.
const lastTurn = useRef(view.turn);
useEffect(() => {
const ids = new Set(boardKey.split(/[|,]/).filter(Boolean));
const added = new Set([...ids].filter(id => !prevBoard.current.has(id)));
prevBoard.current = ids;
if (added.size) { setFresh(added); const t = setTimeout(() => setFresh(new Set()), 900); return () => clearTimeout(t); }
}, [boardKey]);
useEffect(() => {
if (view.turn !== lastTurn.current && !view.over) {
lastTurn.current = view.turn;
const saved = view.saved ? ` (+${view.saved} saved)` : '';
setBanner(view.turn === view.maxTurns ? `Final turn · ${view.maxEnergy} energy${saved}` : `Turn ${view.turn} · ${view.maxEnergy} energy${saved}`);
const t = setTimeout(() => setBanner(''), 1400);
return () => clearTimeout(t);
}
}, [view.turn, view.over, view.maxTurns, view.maxEnergy, view.saved]);
const act = onAct;
const canPlay = (cardId: string, lane: number) => legal.some(a => a.type === 'play' && a.cardId === cardId && a.lane === lane);
const playable = (cardId: string) => legal.some(a => a.type === 'play' && a.cardId === cardId);
const sel = view.hand.find(c => c.id === selected);
const tapLane = (lane: LaneView) => {
if (sel && canPlay(sel.id, lane.index)) { act({ type: 'play', cardId: sel.id, lane: lane.index }); setSelected(undefined); }
else setSheet({ kind: 'lane', lane });
};
const ending = view.waitingForOpponent;
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>
<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>}
<div className="lanes" style={{ gridTemplateColumns: `repeat(${view.lanes.length}, minmax(0, 1fr))` }}>
{view.lanes.map(lane => {
const target = !!sel && canPlay(sel.id, lane.index);
const lead = lane.leader === 'you' ? 'ahead' : lane.leader === 'opponent' ? 'behind' : 'even';
const onTopic = !!sel && (sel.home === lane.stat || (lane.revealed && lane.modifier?.name === 'Disambiguation'));
const topicBonus = sel ? onTopicBonus[sel.cost] ?? 0 : 0;
return <div key={lane.index} className={`lane ${target ? 'is-target' : ''} ${sel && !target ? 'is-blocked' : ''}`}>
<div className="lane-side theirs" aria-label={`Opponent cards in ${lane.name}`}>
{lane.theirs.map(c => <GameCard key={c.id} card={c} size="board" fresh={fresh.has(c.id)} onClick={() => setSheet({ kind: 'card', card: c, side: 'theirs' })} />)}
</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-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>
</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' })} />)}
{lane.staged.map(c => <GameCard key={c.id} card={c} size="board" label={`Take back ${c.title}`} onClick={() => act({ type: 'unstage', cardId: c.id })} selected />)}
{target && <span className={`lane-drop ${onTopic ? 'on-topic' : ''}`}>{onTopic ? `On-topic +${topicBonus}` : 'Play here'}</span>}
</div>
</div>;
})}
</div>
<div className="play-dock match-dock">
<p className="dock-note" role="status" aria-live="polite">
{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}
</p>
<div className="hand" aria-label="Your hand">
{view.hand.length ? view.hand.map(c => <GameCard key={c.id} card={c} selected={selected === c.id} dim={!playable(c.id)}
onClick={ending ? undefined : () => setSelected(selected === c.id ? undefined : c.id)} />)
: <span className="muted">No cards in hand.</span>}
</div>
<div className="dock-row">
<span className="energy" aria-label={`${view.energy} of ${view.maxEnergy} energy left`}>
{Array.from({ length: view.maxEnergy }, (_, i) => <i key={i} className={i < view.energy ? 'on' : ''} />)}
<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>
</div>
</div>
{sheet && <div className="sheet-backdrop" onClick={e => { if (e.target === e.currentTarget) setSheet(null); }}>
<div className="sheet" role="dialog" aria-modal="true" aria-label="Details">
<button className="modal-close" onClick={() => setSheet(null)} aria-label="Close"><X size={18} /></button>
{sheet.kind === 'card' && <><div className="sheet-card"><GameCard card={sheet.card} /></div>
<h3>{sheet.card.title}</h3><p className="muted">{sheet.side === 'mine' ? 'Your card' : 'Opponent card'} · {sheet.card.category} · cost {sheet.card.cost} · power {sheet.card.power} · home {STAT_LABEL[sheet.card.home]}{sheet.card.trend ? (sheet.card.trend > 0 ? ' · trending ▲' : ' · trending ▼') : ''}{sheet.card.onTopic ? ' · on-topic' : ''}{sheet.card.power !== sheet.card.basePower ? ` (base ${sheet.card.basePower})` : ''}</p>
{sheet.card.keyword && <p><b>{sheet.card.keyword.name}.</b> {sheet.card.keyword.text}</p>}</>}
{sheet.kind === 'lane' && <><h3><StatIcon stat={sheet.lane.stat} size={18} /> {sheet.lane.name}</h3>
<p>Judged on <b>{STAT_LABEL[sheet.lane.stat]}</b> ({STAT_HINT[sheet.lane.stat]}). Cards whose home stat is {STAT_LABEL[sheet.lane.stat]} get an on-topic bonus here.</p>
{sheet.lane.modifier ? <p><b>Portal: {sheet.lane.modifier.name}.</b> {sheet.lane.modifier.text}</p> : sheet.lane.portalNote && <p className="muted">{sheet.lane.portalNote}.</p>}
<p className="muted">You {sheet.lane.myPower} · Opponent {sheet.lane.theirPower} · up to {sheet.lane.capacity} cards each.</p>
{sel && !canPlay(sel.id, sheet.lane.index) && <p className="dock-error">{sel.title} can’t go here: {problem?.({ type: 'play', cardId: sel.id, lane: sheet.lane.index }) ?? (sel.cost > view.energy ? 'not enough energy' : 'no room')}.</p>}</>}
{sheet.kind === 'concede' && <><h3>Concede this match?</h3><p className="muted">It counts as a loss. Nothing on-chain changes.</p>
<div className="play-actions"><button className="button outline" onClick={() => setSheet(null)}>Keep playing</button>
<button className="button dark" onClick={() => { setSheet(null); act({ type: 'concede' }); }}><Flag size={15} /> Concede</button></div></>}
</div>
</div>}
</section>;
}
+51
View File
@@ -0,0 +1,51 @@
import { useEffect, useMemo, useRef, useState } from 'react';
import type { MatchState } from '../../shared/game/index.ts';
import { engine } from './adapter.ts';
import type { Bot } from './bots.ts';
import { MatchBoard } from './MatchBoard.tsx';
import type { GameMode, ResultView, UIAction, UICard } from './types.ts';
const BOT_DELAY_MS = 450;
function seededRand(seed: string) {
let h = 1779033703 ^ seed.length;
for (let i = 0; i < seed.length; i++) h = Math.imul(h ^ seed.charCodeAt(i), 3432918353);
return () => { h = Math.imul(h ^ (h >>> 16), 2246822507); h = Math.imul(h ^ (h >>> 13), 3266489909); return ((h ^= h >>> 16) >>> 0) / 4294967296; };
}
/** Local match against a bot: the engine runs in the browser, the bot plays seat 1. */
export function MatchScreen({ mode, deck, opponentDeck, bot, seed, onFinish }: {
mode: GameMode; deck: UICard[]; opponentDeck: UICard[]; bot: Bot; seed: string; onFinish: (r: ResultView) => void;
}) {
const [state, setState] = useState<MatchState>(() => engine.createMatch(mode.ruleset, [deck, opponentDeck], seed));
const [error, setError] = useState('');
const rand = useRef(seededRand(`${seed}:bot`));
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(() => {
if (!view.waitingForOpponent) return;
const t = setTimeout(() => {
let cur = state;
for (let guard = 0; guard < 40 && !engine.isOver(cur); guard++) {
const acts = engine.legal(cur, 1);
if (!acts.length) break;
const choice = bot.choose(engine.view(cur, 1), acts.filter(a => a.type !== 'concede'), rand.current);
try { cur = engine.apply(cur, 1, choice); } catch { cur = engine.apply(cur, 1, { type: 'endTurn' }); }
if (choice.type === 'endTurn') break;
}
setState(cur);
}, BOT_DELAY_MS);
return () => clearTimeout(t);
}, [view.waitingForOpponent, state, bot]);
const act = (a: UIAction) => {
try { setState(engine.apply(state, 0, a)); setError(''); }
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} />;
}
+138
View File
@@ -0,0 +1,138 @@
import { useCallback, useEffect, useRef, useState } from 'react';
import { ArrowLeft, LoaderCircle, Plus, RefreshCw, Users } from 'lucide-react';
import { DEFAULT_RULESET, type Faction, type GameCard, type Stat } from '../../shared/game/index.ts';
import { engineAction, resultView, uiActions, viewFromPlayerView } from './adapter.ts';
import { toUICard } from './cards.ts';
import { GameCard as GameCardFace } from './GameCard.tsx';
import { MatchBoard } from './MatchBoard.tsx';
import { online, type LobbySeat, type LobbyStatus, type OpenLobby } from './online.ts';
import type { GameMode, ResultView, UIAction } from './types.ts';
const POLL_MS = 1000;
const message = (e: unknown) => (e instanceof Error ? e.message : 'The host is unreachable.');
/** Human vs human on a mode hosted by this node: lobby list → (draft) → match, all via the host API. */
export function OnlinePlay({ mode, playerName, onExit, onFinish }: {
mode: GameMode; playerName: string; onExit: () => void; onFinish: (r: ResultView) => void;
}) {
const modeId = mode.remoteId ?? mode.id;
const hostOrigin = (mode.host.kind === 'peer' && mode.host.url) || location.origin;
const [lobbies, setLobbies] = useState<OpenLobby[]>();
const [seat, setSeat] = useState<LobbySeat>();
const [status, setStatus] = useState<LobbyStatus>();
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(() => {
online.openLobbies(modeId).then(l => { setLobbies(l); setError(''); }, e => setError(message(e)));
}, [modeId]);
useEffect(() => {
if (seat) return;
refreshLobbies();
const t = setInterval(refreshLobbies, 4000);
return () => clearInterval(t);
}, [seat, refreshLobbies]);
const poll = useCallback(async () => {
if (!seat || inFlight.current) return;
inFlight.current = true;
try { setStatus(await online.status(seat)); setError(''); }
catch (e) { setError(message(e)); }
finally { inFlight.current = false; }
}, [seat]);
useEffect(() => {
if (!seat || done) return;
void poll();
const t = setInterval(() => { void poll(); }, POLL_MS);
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), []);
const enter = async (fn: () => Promise<LobbySeat>) => {
setBusy(true); setError('');
try { setSeat(await fn()); } catch (e) { setError(message(e)); } finally { setBusy(false); }
};
const leave = async () => {
if (seat && status && !['finished', 'expired'].includes(status.phase)) await online.resign(seat).catch(() => {});
onExit();
};
const send = async (fn: () => Promise<LobbyStatus>) => {
try { setStatus(await fn()); setError(''); } catch (e) { setError(message(e)); void poll(); }
};
// ----- lobby list -----
if (!seat) return <section className="play-panel online-lobby" aria-labelledby="online-title">
<div className="section-eyebrow">{mode.name.toUpperCase()} · ONLINE</div>
<h2 id="online-title">Play a person</h2>
<p className="muted">Matches run on this node{mode.host.kind === 'peer' ? `, hosted by ${mode.host.name}` : ''}. Decks come from the mode’s rules. You play as <b>{playerName}</b>.</p>
<h3 className="lobby-label">Open lobbies <button className="icon-button" onClick={refreshLobbies} aria-label="Refresh lobbies"><RefreshCw size={14} /></button></h3>
<div className="mode-list">
{lobbies === undefined ? <p className="muted small"><LoaderCircle className="spin" size={13} /> Loading…</p>
: lobbies.length ? lobbies.map(l => <button key={l.lobbyId} className="mode" disabled={busy} onClick={() => enter(() => online.join(l.lobbyId, playerName, hostOrigin))}>
<span className="mode-icon"><Users size={18} /></span>
<span className="mode-copy"><b>{String(l.host).slice(0, 24)}</b><small>Waiting {Math.max(0, Math.round((Date.now() - l.createdAt) / 60000))} min · tap to join</small></span>
</button>)
: <p className="muted small">No one is waiting. Create a lobby and share this page with a friend.</p>}
</div>
{error && <p className="dock-error small" role="alert">{error}</p>}
<div className="play-dock"><div className="play-actions">
<button className="button outline" onClick={onExit}><ArrowLeft size={16} /> Back</button>
<button className="button dark play-cta" disabled={busy} onClick={() => enter(() => online.create(modeId, playerName, hostOrigin))}><Plus size={16} /> Create lobby</button>
</div></div>
</section>;
const phase = status?.phase;
// ----- match -----
if ((phase === 'playing' || phase === 'finished') && status?.state) {
const view = { ...viewFromPlayerView(status.state), engine: { view: status.state, seat: seat.seat } };
const legal = uiActions(status.legalActions ?? []);
const opp = status.players.find((_, i) => i !== seat.seat)?.name ?? 'Opponent';
const act = (a: UIAction) => {
if (a.type === 'concede') return void send(() => online.resign(seat));
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} />;
}
// ----- draft -----
if (phase === 'drafting' && status?.draft) {
const mine = status.draft.toPick === seat.seat;
const toCard = (c: NonNullable<LobbyStatus['draft']>['pool'][number]['card']) => toUICard({ ...c, rarity: 'Common', source: 'loaner', check: 'loaner',
faction: c.faction as Faction, home: c.home as Stat, trend: (Math.sign(c.trend) as -1 | 0 | 1) } as GameCard, DEFAULT_RULESET);
return <section className="play-panel" aria-labelledby="draft-title">
<div className="section-eyebrow">{mode.name.toUpperCase()} · DRAFT</div>
<h2 id="draft-title">{mine ? 'Your pick' : 'Opponent is picking…'}</h2>
<p className="muted">Take turns picking cards for your deck. {Math.max(0, Math.round((status.draft.deadline - Date.now()) / 1000))} s left on this pick.</p>
<div className="pool-grid">{status.draft.pool.map(p => <GameCardFace key={p.index} card={toCard(p.card)} size="deck"
selected={p.takenBy === seat.seat} dim={p.takenBy !== null && p.takenBy !== seat.seat}
onClick={mine && p.takenBy === null ? () => void send(() => online.pick(seat, p.index)) : undefined} />)}</div>
{error && <p className="dock-error small" role="alert">{error}</p>}
<div className="play-dock"><div className="play-actions"><button className="button outline" onClick={leave}>Resign</button></div></div>
</section>;
}
// ----- waiting / starting / expired -----
return <section className="play-panel" aria-labelledby="wait-title">
<div className="section-eyebrow">{mode.name.toUpperCase()} · LOBBY</div>
<h2 id="wait-title">{phase === 'expired' ? 'This lobby expired' : phase === 'waiting' ? 'Waiting for an opponent' : 'Starting…'}</h2>
<p className="muted">{phase === 'expired' ? 'Nobody joined in time. Create a new lobby to try again.'
: <><LoaderCircle className="spin" size={14} /> {phase === 'waiting' ? 'Your lobby is listed for other players on this node.' : 'Setting up the match.'}</>}</p>
{error && <p className="dock-error small" role="alert">{error}</p>}
<div className="play-dock"><div className="play-actions"><button className="button outline" onClick={leave}><ArrowLeft size={16} /> {phase === 'expired' ? 'Back' : 'Cancel'}</button></div></div>
</section>;
}
+128
View File
@@ -0,0 +1,128 @@
import { useCallback, useEffect, useMemo, useState } from 'react';
import { CircleHelp, ExternalLink, Globe2, Layers3, Play, Server, Swords, UserRound, Users } from 'lucide-react';
import type { TestnetBlock } from '../../shared/testnet.ts';
import { Avatar } from '../auth/LoginButton.tsx';
import { BOTS, type Bot } from './bots.ts';
import { DEFAULT_STARTER, STARTERS, cardFromBlock, loanerPool, opponentDeck as botDeck, starterDeck } from './cards.ts';
import { DeckBuilder, deckProblem, deckWarning } from './DeckBuilder.tsx';
import { CategoryIcon } from './GameCard.tsx';
import { Leaderboards } from './Leaderboards.tsx';
import { MatchScreen } from './MatchScreen.tsx';
import { lobbyName } from './online.ts';
import { OnlinePlay } from './OnlinePlay.tsx';
import { Results } from './Results.tsx';
import { Tutorial } from './Tutorial.tsx';
import type { GameMode, ResultView } from './types.ts';
import { useAccount } from './useAccount.ts';
import { useModes } from './useModes.ts';
import './play.css';
type Screen = 'lobby' | 'deck' | 'match' | 'online' | 'results' | 'tutorial';
const DECK_KEY = 'wikideck-play-deck-v1';
const TUTORIAL_KEY = 'wikideck-play-tutorial-v1';
const STARTER_KEY = 'wikideck-play-starter-v1';
const store = {
get: (k: string) => { try { return localStorage.getItem(k); } catch { return null; } },
set: (k: string, v: string) => { try { localStorage.setItem(k, v); } catch { /* storage unavailable */ } },
};
const playsHere = (m: GameMode) => m.host.kind === 'local' || m.host.self;
export function PlaySection({ owned }: { owned: TestnetBlock[] }) {
const { modes, status } = useModes();
const account = useAccount();
const [screen, setScreen] = useState<Screen>(() => store.get(TUTORIAL_KEY) ? 'lobby' : 'tutorial');
const [modeId, setModeId] = useState('standard');
const [bot, setBot] = useState<Bot>(BOTS[0]);
const [savedIds, setSavedIds] = useState<string[] | null>(() => { try { return JSON.parse(store.get(DECK_KEY) ?? 'null'); } catch { return null; } });
const [seed, setSeed] = useState('');
const [starterId, setStarterId] = useState(() => { const s = store.get(STARTER_KEY); return STARTERS.some(d => d.id === s) ? s! : DEFAULT_STARTER; });
const [result, setResult] = useState<ResultView>();
const mode = modes.find(m => m.id === modeId) ?? modes[0];
const rules = mode.ruleset;
const pool = useMemo(() => [...loanerPool(rules), ...owned.map(b => cardFromBlock(b, rules))], [owned, rules]);
// Rebuild the saved deck from current cards; NFTs you no longer own simply drop out.
const deck = useMemo(() => {
if (!savedIds) return starterDeck(rules, starterId);
const byId = new Map(pool.map(c => [c.id, c]));
return savedIds.flatMap(id => byId.get(id) ?? []);
}, [savedIds, pool, rules, starterId]);
const problem = deckProblem(deck, rules);
const warning = deckWarning(deck);
const opponent = useMemo(() => botDeck(seed, rules), [seed, rules]);
const [lastOnline, setLastOnline] = useState(false);
const start = () => { setLastOnline(false); setSeed(`${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`); setScreen('match'); };
const finish = useCallback((r: ResultView) => { setResult(r); setScreen('results'); }, []);
useEffect(() => { window.scrollTo?.({ top: 0 }); }, [screen]);
// While a match is on screen, hide the floating eom.dev account button (it sits over the dock on phones).
useEffect(() => {
document.documentElement.classList.toggle('wd-in-match', screen === 'match' || screen === 'online');
document.documentElement.classList.add('wd-play');
return () => document.documentElement.classList.remove('wd-in-match', 'wd-play');
}, [screen]);
if (screen === 'tutorial') return <Tutorial onDone={() => { store.set(TUTORIAL_KEY, '1'); setScreen('lobby'); }} />;
if (screen === 'deck') return <DeckBuilder modeName={mode.name} pool={pool} deck={deck} ruleset={rules} onCancel={() => setScreen('lobby')}
onSave={d => { const ids = d.map(c => c.id); store.set(DECK_KEY, JSON.stringify(ids)); setSavedIds(ids); setScreen('lobby'); }} />;
if (screen === 'match') return <MatchScreen key={seed} mode={mode} deck={deck} opponentDeck={opponent} bot={bot} seed={seed} onFinish={finish} />;
if (screen === 'online') return <OnlinePlay key={mode.id} mode={mode} playerName={lobbyName(account?.name || account?.username)} onExit={() => setScreen('lobby')} onFinish={finish} />;
if (screen === 'results' && result) return <Results result={result} modeName={mode.name} onRematch={lastOnline ? () => setScreen('online') : start} onLobby={() => setScreen('lobby')} />;
const remote = mode.host.kind === 'peer' && !mode.host.self ? mode.host : null;
const hosted = mode.host.kind === 'peer' && mode.host.self;
return <section className="play-panel lobby" aria-labelledby="lobby-title">
<div className="lobby-head">
<div><div className="section-eyebrow">PLAY · OFF-CHAIN MATCHES</div><h2 id="lobby-title">Play WikiDeck</h2></div>
<div className="account-chip" aria-label="eom.dev account">{account
? <><Avatar name={account.name || account.username} seed={account.sub} /><span>{account.name || account.username}</span></>
: <><UserRound size={15} /><span>Guest</span></>}
</div>
</div>
<p className="muted">Three Topics, six turns: win two Topics. Each Topic is judged on one Wikipedia stat, and cards are stronger on their home stat. New here? You already have a loaner starter deck. Matches never move or burn your cards.</p>
<h3 className="lobby-label">Mode</h3>
<div className="mode-list" role="radiogroup" aria-label="Game mode">
{modes.map(m => <button key={m.id} role="radio" aria-checked={m.id === mode.id} className={`mode ${m.id === mode.id ? 'selected' : ''}`} onClick={() => setModeId(m.id)}>
<span className="mode-icon">{m.host.kind === 'local' ? <Swords size={18} /> : <Server size={18} />}</span>
<span className="mode-copy"><b>{m.name}</b>{m.description && <small>{m.description}</small>}
<small className="mode-host">{m.host.kind === 'local' ? 'Built in · plays in your browser' : `Hosted by ${m.host.name}`}
{m.players !== undefined ? ` · ${m.players} online` : ''}{m.matchesPlayed !== undefined ? ` · ${m.matchesPlayed} played` : ''}</small></span>
</button>)}
{status === 'loading' && <p className="muted small"><Globe2 size={13} /> Looking for peer-hosted modes…</p>}
{status === 'unavailable' && <p className="muted small"><Globe2 size={13} /> No peer-hosted modes reachable from this node.</p>}
</div>
{status === 'ok' && <Leaderboards key={mode.id} mode={mode} />}
{remote ? <>
<p className="muted small">This mode runs on {remote.name}’s node. Open it there to play; your eom.dev account works on every node.</p>
<div className="play-dock"><div className="play-actions">
<button className="button outline" aria-label="How to play" onClick={() => setScreen('tutorial')}><CircleHelp size={16} /><span className="hide-narrow">How to play</span></button>
{remote.url ? <a className="button dark play-cta" href={remote.url} target="_blank" rel="noopener noreferrer">Play on {remote.name} <ExternalLink size={16} /></a>
: <button className="button dark play-cta" disabled>Host address unavailable</button>}
</div></div>
</> : <>
<h3 className="lobby-label">Opponent</h3>
<div className="category-tabs">{BOTS.map(b => <button key={b.id} className={bot.id === b.id ? 'selected' : ''} onClick={() => setBot(b)}>{b.name} bot</button>)}</div>
<h3 className="lobby-label">Deck <span className="count-badge">{deck.length}</span></h3>
<button className="deck-summary" onClick={() => setScreen('deck')} aria-label="Edit deck">
<span className="deck-fan" aria-hidden="true">{deck.slice(0, 4).map(c => <span key={c.id} className={`fan-chip cat-${c.category.toLowerCase()}`}><CategoryIcon category={c.category} size={14} /></span>)}</span>
<span><b>{savedIds ? 'Your deck' : `Starter: ${STARTERS.find(d => d.id === starterId)?.name}`}</b><small>{deck.filter(c => c.source === 'nft').length} NFTs · {deck.filter(c => c.source === 'starter').length} loaners</small></span>
<Layers3 size={18} />
</button>
{!savedIds && <div className="category-tabs starter-picks" role="radiogroup" aria-label="Starter deck">{STARTERS.map(d =>
<button key={d.id} role="radio" aria-checked={starterId === d.id} className={starterId === d.id ? 'selected' : ''}
onClick={() => { setStarterId(d.id); store.set(STARTER_KEY, d.id); }}>{d.name}</button>)}</div>}
{savedIds && <button className="text-button" onClick={() => { setSavedIds(null); try { localStorage.removeItem(DECK_KEY); } catch { /* ignore */ } }}>Use a starter deck instead</button>}
{problem ? <p className="dock-error small">{problem} Edit your deck to play {mode.name}.</p>
: warning && <p className="deck-warning small">{warning}</p>}
<div className="play-dock"><div className="play-actions">
<button className="button outline" aria-label="How to play" onClick={() => setScreen('tutorial')}><CircleHelp size={16} /><span className="hide-narrow">How to play</span></button>
{hosted && <button className="button outline" aria-label="Play a person online" onClick={() => { setLastOnline(true); setScreen('online'); }}><Users size={16} /><span className="hide-narrow">Play a person</span><span className="show-narrow">Online</span></button>}
<button className="button dark play-cta" aria-label={`Play vs ${bot.name}`} disabled={!!problem} onClick={start}><Play size={16} /><span className="hide-narrow">Play vs {bot.name}</span><span className="show-narrow">Play</span></button>
</div></div>
</>}
</section>;
}
+26
View File
@@ -0,0 +1,26 @@
import { ArrowLeft, RotateCcw, Trophy } from 'lucide-react';
import type { ResultView } from './types.ts';
export function Results({ result, modeName, onRematch, onLobby }: { result: ResultView; modeName: string; onRematch: () => void; onLobby: () => void }) {
const outcome = result.winner === null ? 'draw' : result.winner === 0 ? 'win' : 'loss';
const won = result.lanes.filter(l => l.winner === 0).length;
const lost = result.lanes.filter(l => l.winner === 1).length;
const tiebreak = result.reason === 'totalPower';
return <section className={`play-panel results ${outcome}`} aria-labelledby="result-title">
<div className="result-mark" aria-hidden="true"><Trophy size={34} /></div>
<div className="section-eyebrow">{modeName.toUpperCase()} · {result.turns} TURNS</div>
<h2 id="result-title">{outcome === 'win' ? 'Victory!' : outcome === 'loss' ? 'Defeat' : 'Draw'}</h2>
<p className="muted">{result.reason === 'concede' ? (outcome === 'win' ? 'Your opponent conceded.' : 'You conceded.')
: `You won ${won} of ${result.lanes.length} Topics${tiebreak ? ', so total power decided it' : ''}.`}</p>
<ol className="result-lanes">
{result.lanes.map(l => <li key={l.name} className={l.winner === 0 ? 'won' : l.winner === 1 ? 'lost' : 'tied'}>
<span>{l.name}</span><b>{l.myPower} – {l.theirPower}</b><small>{l.winner === 0 ? 'Won' : l.winner === 1 ? 'Lost' : 'Tied'}</small>
</li>)}
</ol>
<p className="muted small">Matches are off-chain. No card was moved or burned.</p>
<div className="play-actions">
<button className="button outline" onClick={onLobby}><ArrowLeft size={16} /> Lobby</button>
<button className="button dark" onClick={onRematch}><RotateCcw size={16} /> Rematch</button>
</div>
</section>;
}
+51
View File
@@ -0,0 +1,51 @@
import { useState } from 'react';
import { ArrowLeft, ArrowRight, Check } from 'lucide-react';
import { GameCard, StatIcon } from './GameCard.tsx';
import { starterDeck } from './cards.ts';
import type { Stat } from './types.ts';
const demo = starterDeck();
const pick = (cost: number) => demo.find(c => c.cost === cost) ?? demo[0];
const TOPICS: [string, Stat, string][] = [['Current Events', 'attention', '9 – 5'], ['Archive', 'depth', '4 – 7'], ['Translations', 'reach', '6 – 3']];
const STEPS = [
{ title: 'Win two of three Topics', show: 'lanes',
body: 'The board has three Topics (lanes). After turn 6, whoever has more power in a Topic leads it. Lead two Topics to win. If that’s tied, total power decides.' },
{ title: 'Every card shows a few things', show: 'card',
body: 'Top left is cost: the energy it takes to play. Top right is power. The small icon is the card’s home stat, and the word at the bottom is its keyword. Tap any card on the board to read what it does.' },
{ title: 'Play on-topic for a bonus', show: 'stats',
body: 'Each Topic is judged on one Wikipedia stat: Attention (readers), Depth (article length) or Reach (languages). A card whose home stat matches gets extra power there. The lane says “On-topic +N” when you pick a matching card.' },
{ title: 'Energy grows each turn', show: 'energy',
body: 'You get 1 energy on turn 1, 2 on turn 2, up to 6. You can carry 1 unspent energy to the next turn. Famous articles cost more, but they aren’t more efficient: it’s a trade-off.' },
{ title: 'Tap a card, then tap a Topic', show: 'play',
body: 'Tap a card in your hand to pick it up, then tap a Topic to queue it there. Tap a queued card to take it back. Each Topic holds 3 of your cards. Press End turn when you’re done.' },
{ title: 'Reveals take turns', show: 'reveal',
body: 'Both players plan in secret. Then the cards reveal one at a time, alternating, starting with whoever has initiative (it swaps every turn). Some keywords care about what’s already there, so order matters.' },
{ title: 'Portals change the rules', show: 'portal',
body: 'Each Topic hides a Portal that reveals on turn 2, 3 or 4. Portals bend that Topic’s rules, for example “Only 2 cards per player fit here.” Tap a Topic to read its Portal.' },
];
export function Tutorial({ onDone }: { onDone: () => void }) {
const [i, setI] = useState(0);
const step = STEPS[i];
return <section className="play-panel tutorial" aria-labelledby="tutorial-title">
<div className="section-eyebrow">HOW TO PLAY · {i + 1} / {STEPS.length}</div>
<h2 id="tutorial-title">{step.title}</h2>
<div className="tutorial-visual" aria-hidden="true">
{step.show === 'lanes' && <div className="tut-lanes">{TOPICS.map(([n, stat, score], k) => <div key={n} className={k === 1 ? 'lost' : 'won'}><StatIcon stat={stat} size={14} /><span>{n}</span><b>{score}</b></div>)}</div>}
{step.show === 'card' && <div className="tut-card"><GameCard card={pick(3)} /><ul><li><b>{pick(3).cost}</b> cost</li><li><b>{pick(3).power}</b> power</li><li><StatIcon stat={pick(3).home} /> home stat</li><li><b>{pick(3).keyword?.name}</b> keyword</li></ul></div>}
{step.show === 'stats' && <div className="tut-lanes">{TOPICS.map(([, stat]) => <div key={stat} className={stat === 'depth' ? 'won' : ''}><StatIcon stat={stat} size={18} /><span>{stat[0].toUpperCase() + stat.slice(1)}</span>{stat === 'depth' && <b>+1</b>}</div>)}</div>}
{step.show === 'energy' && <div className="tut-energy">{[1, 2, 3, 4, 5, 6].map(n => <span key={n} style={{ height: `${n * 10 + 10}px` }}>{n}</span>)}</div>}
{step.show === 'play' && <div className="tut-card"><GameCard card={pick(1)} selected /><ArrowRight size={22} /><div className="tut-lane-target">Archive<small>On-topic +1</small></div></div>}
{step.show === 'reveal' && <div className="tut-card"><div className="tut-facedown">1</div><div className="tut-facedown">2</div><div className="tut-facedown">3</div><ArrowRight size={22} /><GameCard card={pick(4)} size="deck" /></div>}
{step.show === 'portal' && <div className="tut-lane-target portal">Stub<small>Only 2 cards per player fit here.</small></div>}
</div>
<p>{step.body}</p>
<div className="play-actions">
<button className="button outline" onClick={() => setI(i - 1)} disabled={i === 0}><ArrowLeft size={16} /> Back</button>
{i < STEPS.length - 1
? <button className="button dark" onClick={() => setI(i + 1)}>Next <ArrowRight size={16} /></button>
: <button className="button dark" onClick={onDone}><Check size={16} /> Got it</button>}
</div>
<button className="text-button skip" onClick={onDone}>Skip tutorial</button>
</section>;
}
+137
View File
@@ -0,0 +1,137 @@
// The single place the Play UI touches the engine (import only from shared/game/index.ts).
import {
DEFAULT_RULESET, applyAction, actionProblem, createMatch, isOver, laneCapacity, legalActions, result, viewFor,
type Action, type CardInPlay, type LogEvent, type MatchResult, type MatchState, type PlayerId, type PlayerView, type Ruleset,
} from '../../shared/game/index.ts';
import { toUICard } from './cards.ts';
import { portalInfo, STAT_LABEL } from './rulesText.ts';
import type { GameMode, LaneView, MatchView, ResultView, UIAction, UICard } from './types.ts';
export const STANDARD_RULESET: Ruleset = DEFAULT_RULESET;
export const LOCAL_MODES: GameMode[] = [{
id: 'standard', name: 'Standard', host: { kind: 'local' }, ruleset: DEFAULT_RULESET,
description: 'Three Topics, six turns. Win two Topics.',
}];
function toUI(a: Action): UIAction {
switch (a.type) {
case 'play': return { type: 'play', cardId: a.cardId, lane: a.lane, engine: a };
case 'undo': return { type: 'unstage', cardId: a.cardId, engine: a };
case 'concede': return { type: 'concede', engine: a };
default: return { type: 'endTurn', engine: a };
}
}
function toEngine(a: UIAction, player: PlayerId): Action {
if (a.engine) return { ...a.engine, player } as Action;
switch (a.type) {
case 'play': return { type: 'play', player, cardId: a.cardId, lane: a.lane };
case 'unstage': return { type: 'undo', player, cardId: a.cardId };
case 'concede': return { type: 'concede', player };
default: return { type: 'commit', player };
}
}
function logLine(e: LogEvent, me: PlayerId, title: (id: string) => string): string | null {
const who = (p: PlayerId) => (p === me ? 'You' : 'Opponent');
switch (e.t) {
case 'turnStart': return `Turn ${e.turn}. ${e.initiative === me ? 'You reveal first.' : 'Opponent reveals first.'}`;
case 'portalRevealed': return `Portal revealed: ${e.topic.name}.`;
case 'underdog': return `${who(e.player)} got the underdog bonus.`;
case 'reveal': return `${who(e.player)} played ${title(e.cardId)}.`;
case 'fizzle': return e.player === me ? `Your ${title(e.cardId)} fizzled (no room) and went back to hand.` : 'An opponent play fizzled.'; // never name a card in their hand
case 'effect': return `${e.source}: ${e.text}`;
case 'concede': return `${who(e.player)} ${e.afk ? 'timed out' : 'conceded'}.`;
case 'matchOver': return 'Match over.';
default: return null; // draws are private
}
}
export const engine = {
name: 'shared/game v1', mock: false,
createMatch(ruleset: Ruleset, decks: [UICard[], UICard[]], seed: string): MatchState {
return createMatch(ruleset, [decks[0].map(c => c.game), decks[1].map(c => c.game)], seed);
},
legal(state: MatchState, player: PlayerId): UIAction[] {
if (isOver(state)) return [];
const acts = legalActions(state, player).map(toUI);
return acts.length ? [...acts, { type: 'concede', engine: { type: 'concede', player } }] : acts;
},
apply(state: MatchState, player: PlayerId, action: UIAction): MatchState {
return applyAction(state, toEngine(action, player));
},
problem(state: MatchState, player: PlayerId, action: UIAction): string | null {
return actionProblem(state, toEngine(action, player));
},
view(state: MatchState, me: PlayerId): MatchView {
const titles = new Map<string, string>();
for (const p of state.players) for (const c of [...p.hand, ...p.deck]) titles.set(c.cardId, c.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')
.map(e => logLine(e, me, id => titles.get(id) ?? 'a card')).filter((x): x is string => !!x).slice(-30);
const pv = viewFor(state, me);
return { ...viewFromPlayerView(pv, { log, capacity: i => laneCapacity(state, i) }), engine: { view: pv, seat: me } };
},
isOver: (s: MatchState) => isOver(s),
result(state: MatchState, me: PlayerId): ResultView {
return resultView(result(state)!, me, state.lanes.map(l => l.topic.name), viewFor(state, me).lanes.map(l => l.leader));
},
};
/** Stub-style Portals cap a lane; online views don't carry state, so read the cap from the ruleset. */
function capacityFromView(v: PlayerView, i: number): number {
const t = v.lanes[i].topic, r = v.ruleset;
if (v.lanes[i].portalRevealed && t.portal === 'stub') return (r.portalParams[t.id] ?? r.portalParams.stub)?.capacity ?? Math.min(2, r.laneCapacity);
return r.laneCapacity;
}
/** Build the screen model from what one seat may see (local engine or a hosting node). */
export function viewFromPlayerView(v: PlayerView, opts: { log?: string[]; capacity?: (lane: number) => number } = {}): MatchView {
const rules = v.ruleset;
const me = v.you;
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) => {
const portal = lane.portalRevealed ? portalInfo(lane.topic.portal, lane.topic.id, rules) : undefined;
const allOn = lane.portalRevealed && lane.topic.portal === 'disambiguation';
return {
index: i, stat: lane.topic.stat, revealed: lane.portalRevealed,
name: lane.portalRevealed ? lane.topic.name : STAT_LABEL[lane.topic.stat],
modifier: portal, portalNote: lane.portalRevealed ? undefined : `Portal reveals on turn ${rules.portalReveal[i]}`,
mine: lane.cards[0].map((c, k) => onBoard(c, lane.cardPower[0][k], lane.topic.stat, allOn)),
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)] : [];
}),
myPower: lane.power[0], theirPower: lane.power[1], leader: lane.leader,
capacity: opts.capacity ? opts.capacity(i) : capacityFromView(v, i),
};
});
const queued = new Set(v.queue.map(q => q.cardId));
return {
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,
lanes, log: opts.log ?? [], waitingForOpponent: v.committed && v.phase !== 'over', over: v.phase === 'over',
};
}
/** Results from `me`'s point of view: in a ResultView, 0 always means "you" and 1 "your opponent". */
export function resultView(r: MatchResult, me: PlayerId, laneNames: string[], leaders?: ('you' | 'opponent' | null)[]): ResultView {
const opp: PlayerId = me === 0 ? 1 : 0;
return {
winner: r.winner === null ? null : r.winner === me ? 0 : 1, turns: r.turns, reason: r.reason,
totalPower: [r.totalPower[me], r.totalPower[opp]],
lanes: r.lanePower.map((pw, i) => {
const a = pw[me], b = pw[opp];
const lead = leaders?.[i]; // the consensus tie-break (on-topic count) can decide an equal lane
const winner = lead !== undefined ? (lead === 'you' ? 0 : lead === 'opponent' ? 1 : null) : a === b ? null : a > b ? 0 : 1;
return { name: laneNames[i] ?? `Topic ${i + 1}`, myPower: a, theirPower: b, winner };
}),
};
}
/** Engine actions from a host's legalActions, mapped for the UI (the host checks the seat). */
export const uiActions = (acts: Action[]): UIAction[] => acts.map(toUI);
export const engineAction = toEngine;
+16
View File
@@ -0,0 +1,16 @@
// AI opponents. ui-b owns the real easy/normal bots in src/game/ai/; this file is the plug-in point.
import type { MatchView, UIAction } from './types.ts';
export type Bot = { id: string; name: string; choose(view: MatchView, legal: UIAction[], rand: () => number): UIAction };
/** Fallback: queues random affordable plays, then commits. */
export const randomBot: Bot = {
id: 'random', name: 'Random',
choose(_view, legal, rand) {
const plays = legal.filter(a => a.type === 'play');
if (plays.length && rand() < 0.85) return plays[Math.floor(rand() * plays.length)];
return legal.find(a => a.type === 'endTurn') ?? { type: 'endTurn' };
},
};
export const BOTS: Bot[] = [randomBot];
+46
View File
@@ -0,0 +1,46 @@
import { rarity } from '../../shared/protocol.ts';
import type { TestnetBlock } from '../../shared/testnet.ts';
import {
DEFAULT_RULESET, STARTER_DECKS, deriveCard, starterDeckById, type Faction, type GameCard, type PercentileTable, type Ruleset,
} from '../../shared/game/index.ts';
import { percentiles as samplePercentiles } from '../../docs/game/card-sample.json';
import { keywordInfo } from './rulesText.ts';
import type { UICard } from './types.ts';
export const CATEGORIES: Faction[] = ['Space', 'Nature', 'People', 'Science', 'History', 'Culture'];
/** council-data's reference cut points (§1.1), from docs/game/card-sample.json. */
const PERCENTILES = samplePercentiles as unknown as PercentileTable;
export function toUICard(card: GameCard, rules: Ruleset = DEFAULT_RULESET, extra: Partial<UICard> = {}): UICard {
return { id: card.cardId, pageId: card.pageId, title: card.title, category: card.faction, cost: card.cost,
power: card.power, basePower: card.power, home: card.home, trend: card.trend, keyword: keywordInfo(card.keyword, rules),
source: card.source === 'owned' ? 'nft' : 'starter', rarity: card.rarity, game: card, ...extra };
}
/** The four DESIGN §2.1 loaner decks. New players start with the first. */
export const STARTERS = STARTER_DECKS.map(d => ({ id: d.id, name: d.name }));
export const DEFAULT_STARTER = STARTERS[0].id;
export const starterDeck = (rules: Ruleset = DEFAULT_RULESET, id = DEFAULT_STARTER) => starterDeckById(id, rules).map(c => toUICard(c, rules));
/** The bot plays one of the starter decks, picked from the match seed. */
export function opponentDeck(seed: string, rules: Ruleset = DEFAULT_RULESET): UICard[] {
let h = 0; for (const ch of seed) h = (h * 31 + ch.charCodeAt(0)) >>> 0;
return starterDeck(rules, STARTERS[h % STARTERS.length].id);
}
/** Every loaner card once (all four starter decks), for the deck builder. */
export function loanerPool(rules: Ruleset = DEFAULT_RULESET): UICard[] {
const seen = new Set<string>();
return STARTERS.flatMap(d => starterDeck(rules, d.id)).filter(c => !seen.has(c.id) && !!seen.add(c.id));
}
/**
* Owned NFT → GameCard with the engine's §1 derivation. A practice match in the browser can't verify the
* snapshot (§1.10) and doesn't fetch live trends, so the card is 'unchecked' (cost capped) with no trend.
*/
export function cardFromBlock(block: TestnetBlock, rules: Ruleset = DEFAULT_RULESET): UICard {
const st = block.statsSnapshot?.stats;
const category = (CATEGORIES.includes(block.article.category as Faction) ? block.article.category : 'Culture') as Faction;
const card = deriveCard({ cardId: block.tokenId, pageId: block.article.pageId, title: block.article.title, category,
rarity: rarity(block.powHash), snapshot: { stats: { attention: st?.attention ?? null, depth: st?.depth ?? 0, reach: st?.reach ?? 0 } },
live: { trendPercent: null, dailyAverage: null }, check: 'unchecked' }, PERCENTILES, rules);
return toUICard(card, rules, { image: block.article.image, tokenId: block.tokenId });
}
+76
View File
@@ -0,0 +1,76 @@
// Client for lobbies hosted by this node (modes team, docs/game/HOSTING.md §3). Same-origin only:
// peers' modes are opened on the peer's own site. Every response is untrusted input.
import type { Action, PlayerView } from '../../shared/game/index.ts';
export type LobbySeat = { lobbyId: string; seat: 0 | 1; token: string };
export type DraftCard = { index: number; takenBy: 0 | 1 | null; card: { cardId: string; title: string; pageId: number | null; faction: string; cost: number; power: number; home: string; trend: number; keyword: string | null } };
export type LobbyStatus = {
lobbyId: string; phase: 'waiting' | 'starting' | 'drafting' | 'playing' | 'finished' | 'expired';
seat: 0 | 1 | null; players: { id: string; name: string }[];
outcome: { winner: 0 | 1 | null; reason: string } | null;
state?: PlayerView; legalActions?: Action[];
draft?: { pool: DraftCard[]; toPick: 0 | 1 | null; deadline: number };
};
export type OpenLobby = { lobbyId: string; host: string; createdAt: number };
const MASTER_KEY = 'wikideck-player-master';
const b64url = (bytes: Uint8Array) => btoa(String.fromCharCode(...bytes)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
function masterSecret(): string {
try {
const existing = localStorage.getItem(MASTER_KEY);
if (existing && /^[A-Za-z0-9_-]{43}$/.test(existing)) return existing;
const fresh = b64url(crypto.getRandomValues(new Uint8Array(32)));
localStorage.setItem(MASTER_KEY, fresh);
return fresh;
} catch { return b64url(crypto.getRandomValues(new Uint8Array(32))); } // storage blocked: per-session identity
}
/**
* Per-host player secret: base64url(HMAC-SHA256(master, hostOrigin)), 43 chars. A host derives the
* leaderboard id from it, so a malicious host can't replay it on another host (night-review, #5).
*/
export async function playerSecret(hostOrigin: string): Promise<string> {
const key = await crypto.subtle.importKey('raw', new TextEncoder().encode(masterSecret()), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
return b64url(new Uint8Array(await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(hostOrigin))));
}
/** A random 4-character tag for guest names, separate from the secret. */
function guestTag(): string {
const KEY = 'wikideck-guest-tag';
try {
const t = localStorage.getItem(KEY);
if (t && /^[A-Za-z0-9]{4}$/.test(t)) return t;
const fresh = b64url(crypto.getRandomValues(new Uint8Array(6))).replace(/[^A-Za-z0-9]/g, '').slice(0, 4).padEnd(4, 'x');
localStorage.setItem(KEY, fresh);
return fresh;
} catch { return 'anon'; }
}
/** Host display names allow 1–24 letters, digits, spaces and _ . - */
export function lobbyName(name: string | undefined): string {
const clean = (name ?? '').normalize('NFC').replace(/[^\p{L}\p{N} _.-]/gu, '').trim().slice(0, 24);
return clean || `Guest ${guestTag()}`;
}
async function call<T>(path: string, init: { method?: string; body?: unknown; token?: string } = {}): Promise<T> {
const res = await fetch(`/api/game/${path}`, {
method: init.method ?? (init.body === undefined ? 'GET' : 'POST'), cache: 'no-store', signal: AbortSignal.timeout(10000),
headers: { ...(init.body === undefined ? {} : { 'Content-Type': 'application/json' }), ...(init.token ? { Authorization: `Bearer ${init.token}` } : {}) },
...(init.body === undefined ? {} : { body: JSON.stringify(init.body) }),
});
const data = res.headers.get('content-type')?.includes('json') ? await res.json().catch(() => ({})) : {};
if (!res.ok) throw new Error(typeof data?.error === 'string' ? data.error.slice(0, 200) : `The host answered ${res.status}.`);
return data as T;
}
const id = (s: string) => encodeURIComponent(s);
export const online = {
openLobbies: (modeId: string) => call<{ lobbies: OpenLobby[] }>(`modes/${id(modeId)}/lobbies`).then(r => Array.isArray(r.lobbies) ? r.lobbies.slice(0, 50) : []),
create: async (modeId: string, name: string, hostOrigin: string) => call<LobbySeat>(`modes/${id(modeId)}/lobbies`, { body: { name, secret: await playerSecret(hostOrigin) } }),
join: async (lobbyId: string, name: string, hostOrigin: string) => call<LobbySeat>(`lobbies/${id(lobbyId)}/join`, { body: { name, secret: await playerSecret(hostOrigin) } }),
status: (s: LobbySeat) => call<LobbyStatus>(`lobbies/${id(s.lobbyId)}`, { token: s.token }),
act: (s: LobbySeat, action: Action) => call<LobbyStatus>(`lobbies/${id(s.lobbyId)}/actions`, { body: { action }, token: s.token }),
pick: (s: LobbySeat, index: number) => call<LobbyStatus>(`lobbies/${id(s.lobbyId)}/pick`, { body: { index }, token: s.token }),
resign: (s: LobbySeat) => call<LobbyStatus>(`lobbies/${id(s.lobbyId)}/resign`, { body: {}, token: s.token }),
};
+207
View File
@@ -0,0 +1,207 @@
/* Play section. Mobile-first: 360px minimum, thumb-reachable bottom dock, no hover-only states. */
.play-panel{max-width:760px;margin:0 auto 32px;padding:20px 16px 0;border:1px solid var(--theme-border);background:var(--ctp-mantle);border-radius:14px;color:var(--ctp-text)}
.play-panel h2{font-size:26px;letter-spacing:-.6px;margin:4px 0 8px;display:flex;align-items:center;flex-wrap:wrap;gap:8px}
.play-panel .count-badge{margin-left:0}
.play-panel .count-badge.ok{color:var(--ctp-green);border-color:var(--ctp-green)}
.play-panel .muted{font-size:13px;line-height:1.6;color:var(--ctp-subtext0)}
.play-panel .muted.small,.small{font-size:11px}
.play-panel .section-eyebrow{font-size:10px}
.play-actions{display:flex;gap:10px;flex-wrap:wrap;justify-content:flex-end}
.play-actions .button{min-height:48px;font-size:13px;padding:12px 16px;flex:1 1 auto}
.play-actions .button.outline{flex:0 1 auto}
.play-actions .button:disabled{opacity:.45;cursor:not-allowed}
.play-dock{position:sticky;bottom:0;z-index:5;margin:18px -16px 0;padding:10px 16px calc(12px + env(safe-area-inset-bottom));background:var(--ctp-mantle);border-top:1px solid var(--theme-border);border-radius:0 0 14px 14px}
.dock-note{min-height:20px;margin:0 0 8px;font-size:12px;color:var(--ctp-subtext1);display:flex;align-items:center;gap:6px;line-height:1.35}
.dock-error{color:var(--ctp-red)}
.icon-button{display:inline-flex;align-items:center;justify-content:center;min-width:40px;min-height:40px;border-radius:8px;background:var(--ctp-surface0);color:var(--ctp-subtext1)}
/* Card faces */
.gcard{position:relative;display:flex;flex-direction:column;align-items:stretch;text-align:left;background:var(--ctp-base);color:var(--ctp-text);border:1.5px solid var(--ctp-surface1);border-radius:10px;padding:0;overflow:hidden;transition:transform .15s ease,border-color .15s ease,box-shadow .15s ease;--cat:var(--ctp-overlay1)}
.gcard:disabled{cursor:default;opacity:1}
.gcard.cat-space{--cat:var(--ctp-lavender)}.gcard.cat-nature{--cat:var(--ctp-green)}.gcard.cat-people{--cat:var(--ctp-peach)}
.gcard.cat-science{--cat:var(--ctp-sky)}.gcard.cat-history{--cat:var(--ctp-yellow)}.gcard.cat-culture{--cat:var(--ctp-pink)}
.gcard-art{display:flex;align-items:center;justify-content:center;height:46px;background:color-mix(in srgb,var(--cat) 28%,var(--ctp-surface0));color:var(--cat);position:relative;overflow:hidden}
.gcard-art img{position:absolute;inset:0;width:100%;height:100%;object-fit:cover}
.gcard-art svg{position:relative}
.gcard-cost,.gcard-power{position:absolute;top:4px;z-index:2;min-width:24px;height:24px;border-radius:50%;display:flex;align-items:center;justify-content:center;font-weight:800;font-size:14px;box-shadow:0 1px 3px rgb(0 0 0/.35)}
.gcard-cost{left:4px;background:var(--ctp-blue);color:var(--ctp-crust)}
.gcard-power{right:4px;background:var(--ctp-peach);color:var(--ctp-crust);border-radius:6px}
.gcard-power.up{background:var(--ctp-green)}.gcard-power.down{background:var(--ctp-red)}
.gcard-title{font-size:12px;font-weight:700;line-height:1.2;padding:6px 7px 2px;overflow:hidden;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;min-height:2.4em}
.gcard-keyword{display:flex;align-items:center;gap:3px;margin:auto 6px 6px;font-size:10px;font-weight:700;color:var(--cat);text-transform:uppercase;letter-spacing:.4px}
.gcard-nft{position:absolute;top:32px;right:4px;font-size:8px;font-weight:800;padding:1px 4px;border-radius:3px;background:var(--ctp-mauve);color:var(--ctp-crust)}
.gcard-hand,.gcard-deck{width:88px;min-height:118px;flex:0 0 auto}
.gcard-deck{width:auto}
.gcard-board{width:100%;min-height:0;border-radius:7px;border-width:1px;flex-direction:row;align-items:center}
.gcard-board .gcard-art{width:22px;height:30px;flex:0 0 22px}
.gcard-board .gcard-art img{display:none}
.gcard-board .gcard-cost{display:none}
.gcard-board .gcard-power{position:static;margin:0 3px 0 auto;min-width:22px;height:22px;font-size:12px;flex:0 0 auto;box-shadow:none}
.gcard-board .gcard-title{font-size:10px;padding:2px 4px;min-height:0;-webkit-line-clamp:1;display:block;white-space:nowrap;text-overflow:ellipsis;flex:1 1 auto;min-width:0}
.gcard.is-selected{border-color:var(--theme-accent);box-shadow:0 0 0 2px var(--theme-accent);transform:translateY(-6px)}
.gcard-board.is-selected{transform:none;border-style:dashed;box-shadow:none;opacity:.85}
.gcard.is-dim{opacity:.45}
.gcard.is-fresh{animation:gcard-reveal .45s ease-out}
@keyframes gcard-reveal{0%{transform:scale(.6) rotateY(90deg);opacity:0}100%{transform:none;opacity:1}}
.gcard:focus-visible{outline:2px solid var(--theme-accent);outline-offset:2px}
/* Lobby */
.lobby-head{display:flex;justify-content:space-between;align-items:flex-start;gap:10px;flex-wrap:wrap}
.account-chip{display:flex;align-items:center;gap:8px;padding:6px 10px;border-radius:999px;background:var(--ctp-surface0);font-size:12px;color:var(--ctp-subtext1)}
.account-chip img{width:22px;height:22px;border-radius:50%}
.account-chip .text-button{font-size:11px;padding:4px 0;color:var(--theme-accent)}
.account-chip .text-button:disabled{color:var(--ctp-overlay1);cursor:default}
.lobby-label{font-size:12px;letter-spacing:1px;text-transform:uppercase;color:var(--ctp-subtext0);margin:20px 0 8px;display:flex;gap:8px;align-items:center}
.mode-list{display:grid;gap:8px}
.mode{display:flex;gap:12px;align-items:flex-start;text-align:left;padding:12px;border-radius:10px;border:1.5px solid var(--theme-border);background:var(--ctp-base);color:var(--ctp-text);min-height:56px}
.mode.selected{border-color:var(--theme-accent);background:color-mix(in srgb,var(--theme-accent) 10%,var(--ctp-base))}
.mode-icon{flex:0 0 36px;height:36px;border-radius:8px;display:flex;align-items:center;justify-content:center;background:var(--ctp-surface0);color:var(--theme-accent)}
.mode-copy{display:flex;flex-direction:column;gap:2px;min-width:0}
.mode-copy b{font-size:14px}.mode-copy small{font-size:12px;color:var(--ctp-subtext0);line-height:1.4}
.mode-copy .mode-host{color:var(--ctp-overlay2);font-size:11px}
.play-panel .category-tabs{display:flex;gap:6px;flex-wrap:wrap}
.play-panel .category-tabs button{font-size:13px;padding:10px 14px;min-height:40px;border:1px solid var(--theme-border)}
.deck-summary{width:100%;display:flex;align-items:center;gap:14px;padding:12px;border-radius:10px;border:1.5px solid var(--theme-border);background:var(--ctp-base);color:var(--ctp-text);text-align:left}
.deck-summary>span:nth-child(2){display:flex;flex-direction:column;flex:1;font-size:14px}
.deck-summary small{color:var(--ctp-subtext0);font-size:12px}
.deck-fan{display:flex;flex:0 0 auto}
.fan-chip{width:30px;height:42px;border-radius:6px;margin-left:-12px;display:flex;align-items:center;justify-content:center;border:1.5px solid var(--ctp-surface1);background:color-mix(in srgb,var(--cat) 30%,var(--ctp-surface0));color:var(--cat);transform:rotate(calc(var(--i,0)*4deg - 6deg));--cat:var(--ctp-overlay1)}
.fan-chip:first-child{margin-left:0}
.fan-chip.cat-space{--cat:var(--ctp-lavender)}.fan-chip.cat-nature{--cat:var(--ctp-green)}.fan-chip.cat-people{--cat:var(--ctp-peach)}.fan-chip.cat-science{--cat:var(--ctp-sky)}.fan-chip.cat-history{--cat:var(--ctp-yellow)}.fan-chip.cat-culture{--cat:var(--ctp-pink)}
.play-cta{font-size:15px!important}
.engine-note{text-align:center;padding-bottom:10px}
/* Deck builder */
.deck-curve{display:flex;gap:6px;align-items:flex-end;height:70px;margin:10px 0}
.deck-curve>div{flex:1;display:flex;flex-direction:column;align-items:center;height:100%;justify-content:flex-end;gap:2px;font-size:10px;color:var(--ctp-subtext0)}
.deck-curve span{width:100%;max-width:34px;background:var(--theme-accent);border-radius:4px 4px 0 0;min-height:2px;transition:height .2s}
.deck-strip{display:grid;grid-template-columns:repeat(auto-fill,minmax(104px,1fr));gap:5px;margin-bottom:14px}
.pool-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(96px,1fr));gap:10px;margin-top:12px}
.pool-grid .gcard.is-selected{transform:none}
/* Match */
.match{max-width:760px;margin:0 auto 24px;display:flex;flex-direction:column;border:1px solid var(--theme-border);border-radius:14px;background:var(--ctp-mantle);color:var(--ctp-text);position:relative}
.match-bar{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:8px 10px;border-bottom:1px solid var(--theme-border);font-size:12px;color:var(--ctp-subtext1)}
.match-bar>span{display:inline-flex;align-items:center;gap:5px}
.match-turn b{font-size:16px;color:var(--ctp-text)}
.turn-banner{position:absolute;top:56px;left:50%;transform:translateX(-50%);z-index:8;background:var(--theme-accent);color:var(--ctp-crust);padding:8px 18px;border-radius:999px;font-weight:800;font-size:14px;white-space:nowrap;animation:banner-in 1.4s ease both;pointer-events:none}
@keyframes banner-in{0%{opacity:0;transform:translate(-50%,-8px)}15%,80%{opacity:1;transform:translate(-50%,0)}100%{opacity:0}}
.lanes{display:grid;gap:6px;padding:8px}
.lane{display:flex;flex-direction:column;gap:4px;min-width:0;border-radius:10px;padding:4px;background:var(--ctp-base);border:1.5px solid transparent;transition:border-color .15s,background .15s}
.lane.is-target{border-color:var(--theme-accent);background:color-mix(in srgb,var(--theme-accent) 12%,var(--ctp-base))}
.lane.is-blocked{opacity:.6}
.lane-side{display:flex;flex-direction:column;gap:3px;min-height:120px}
.lane-side.theirs{justify-content:flex-end}
.lane-plate{display:grid;grid-template-columns:auto 1fr auto;align-items:center;gap:4px;padding:8px 4px;border-radius:8px;background:var(--ctp-surface0);color:var(--ctp-text);min-height:52px}
.lane-name{font-size:10px;line-height:1.2;text-align:center;color:var(--ctp-subtext1);overflow:hidden;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical}
.lane-score{font-weight:800;font-size:17px;min-width:24px;text-align:center}
.lane-score.theirs{color:var(--ctp-red)}.lane-score.mine{color:var(--ctp-green)}
.lane-plate.ahead{box-shadow:inset 0 -3px 0 var(--ctp-green)}.lane-plate.behind{box-shadow:inset 0 3px 0 var(--ctp-red)}
.lane-drop{border:1.5px dashed var(--theme-accent);border-radius:7px;color:var(--theme-accent);font-size:11px;font-weight:700;text-align:center;padding:6px 2px}
.match-dock{margin:0;border-radius:0 0 14px 14px;padding-inline:10px}
.hand{display:flex;gap:8px;overflow-x:auto;padding:8px 2px 6px;scroll-snap-type:x proximity;-webkit-overflow-scrolling:touch}
.hand .gcard{scroll-snap-align:start}
.dock-row{display:flex;align-items:center;gap:12px;margin-top:4px}
.energy{display:flex;align-items:center;gap:3px}
.energy i{width:10px;height:18px;border-radius:3px;background:var(--ctp-surface1)}
.energy i.on{background:var(--ctp-blue)}
.energy b{font-size:18px;margin-left:5px;color:var(--ctp-blue)}
.deck-count{display:inline-flex;gap:4px;align-items:center;font-size:12px;color:var(--ctp-subtext0)}
.end-turn{margin-left:auto;min-height:52px!important;min-width:132px;font-size:15px!important}
.end-turn:disabled{opacity:.55}
/* Bottom sheet (details instead of hover tooltips) */
.sheet-backdrop{position:fixed;inset:0;z-index:40;background:var(--theme-scrim,rgb(0 0 0/.5));display:flex;align-items:flex-end;justify-content:center}
.sheet{position:relative;width:100%;max-width:520px;background:var(--ctp-mantle);color:var(--ctp-text);border-radius:16px 16px 0 0;padding:22px 18px calc(18px + env(safe-area-inset-bottom));animation:sheet-up .18s ease-out;max-height:80vh;overflow:auto}
.sheet h3{font-size:20px;margin:6px 0}
.sheet p{font-size:14px;line-height:1.55}
.sheet-card{display:flex;justify-content:center}
.sheet-card .gcard{width:120px;min-height:150px}
@keyframes sheet-up{from{transform:translateY(40px);opacity:0}to{transform:none;opacity:1}}
/* Results */
.results{text-align:center}
.results h2{justify-content:center;font-size:34px}
.results .section-eyebrow{justify-content:center}
.result-mark{margin:8px auto 14px;width:64px;height:64px;border-radius:50%;display:flex;align-items:center;justify-content:center;background:var(--ctp-surface0);color:var(--ctp-overlay2)}
.results.win .result-mark{background:var(--ctp-yellow);color:var(--ctp-crust);animation:pop .4s ease-out}
.results.loss .result-mark{color:var(--ctp-red)}
@keyframes pop{0%{transform:scale(.4)}70%{transform:scale(1.1)}100%{transform:none}}
.result-lanes{list-style:none;padding:0;display:grid;grid-template-columns:repeat(3,1fr);gap:8px;margin:18px 0}
.result-lanes li{display:flex;flex-direction:column;gap:2px;padding:12px 4px;border-radius:10px;background:var(--ctp-base);border:1.5px solid var(--theme-border)}
.result-lanes li.won{border-color:var(--ctp-green)}.result-lanes li.lost{border-color:var(--ctp-red)}
.result-lanes b{font-size:20px}.result-lanes small,.result-lanes span{font-size:11px;color:var(--ctp-subtext0)}
/* Tutorial */
.tutorial p{font-size:14px;line-height:1.6}
.tutorial-visual{min-height:150px;display:flex;align-items:center;justify-content:center;margin:12px 0;padding:12px;border-radius:12px;background:var(--ctp-base)}
.tut-lanes{display:grid;grid-template-columns:repeat(3,1fr);gap:8px;width:100%}
.tut-lanes div{display:flex;flex-direction:column;align-items:center;padding:16px 4px;border-radius:8px;background:var(--ctp-surface0);font-size:12px}
.tut-lanes b{font-size:18px}.tut-lanes .won{box-shadow:inset 0 -3px 0 var(--ctp-green)}.tut-lanes .lost{box-shadow:inset 0 3px 0 var(--ctp-red)}
.tut-card{display:flex;align-items:center;gap:14px;flex-wrap:wrap;justify-content:center}
.tut-card ul{list-style:none;padding:0;margin:0;font-size:13px;line-height:1.9}
.tut-energy{display:flex;align-items:flex-end;gap:8px;height:90px}
.tut-energy span{width:26px;border-radius:4px 4px 0 0;background:var(--ctp-blue);color:var(--ctp-crust);font-weight:800;display:flex;justify-content:center;align-items:flex-start;font-size:12px}
.tut-lane-target{padding:22px 16px;border:2px dashed var(--theme-accent);border-radius:10px;color:var(--theme-accent);font-weight:700;display:flex;flex-direction:column;gap:4px;text-align:center}
.tut-lane-target small{font-weight:400;color:var(--ctp-subtext0)}
.tut-facedown{width:60px;height:84px;border-radius:8px;background:repeating-linear-gradient(45deg,var(--ctp-surface0) 0 6px,var(--ctp-surface1) 6px 12px);display:flex;align-items:center;justify-content:center;font-size:22px;font-weight:800;color:var(--ctp-overlay2)}
.tutorial .skip{display:block;margin:6px auto 12px}
@media(min-width:700px){
.gcard-hand{width:104px;min-height:136px}
.gcard-art{height:58px}
.lane-side{min-height:150px}
.gcard-board .gcard-title{font-size:11px}
.play-panel{padding:26px 26px 0}.play-dock{margin-inline:-26px;padding-inline:26px}
}
@media(max-width:400px){
.lanes{gap:4px;padding:6px 4px}
.lane{padding:3px}
.lane-score{font-size:15px;min-width:18px}
.gcard-board .gcard-art{display:none}
.end-turn{min-width:112px}
}
.gcard-board .gcard-power{order:3}
/* Phones: the match takes the whole screen so the board and the thumb dock both fit. */
@media(max-width:760px){
.match{position:fixed;inset:0;z-index:30;margin:0;max-width:none;border:0;border-radius:0;padding-top:env(safe-area-inset-top);overflow:hidden}
.match .lanes{flex:1 1 auto;overflow-y:auto;align-content:stretch}
.match .lane-side{flex:1 1 auto}
.match-dock{position:static;border-radius:0}
.lane-side{min-height:84px}
}
.deck-warning{color:var(--ctp-yellow)}
html.wd-in-match .auth-wrap,body:has(.match) .auth-wrap{display:none}
.gcard-home{position:absolute;top:30px;left:5px;z-index:2;display:flex;align-items:center;gap:1px;padding:2px 4px;border-radius:999px;background:var(--ctp-crust);color:var(--ctp-subtext1);font-size:10px}
.gcard-home .trend.up{color:var(--ctp-green)}.gcard-home .trend.down{color:var(--ctp-red)}
.gcard.is-on-topic .gcard-home{background:var(--ctp-green);color:var(--ctp-crust)}
.gcard-board .gcard-home{position:static;order:2;margin-left:2px;padding:2px 3px;flex:0 0 auto}
.lane-name{display:flex;flex-direction:column;align-items:center;gap:2px}
.lane-name small{font-size:9px;color:var(--ctp-overlay1)}
.lane-drop.on-topic{border-color:var(--ctp-green);color:var(--ctp-green);background:color-mix(in srgb,var(--ctp-green) 10%,transparent)}
.sheet h3{display:flex;align-items:center;gap:8px}
@media(max-width:400px){.gcard-board .gcard-home{display:none}.gcard-board.is-on-topic{box-shadow:inset 3px 0 0 var(--ctp-green)}}
.starter-picks{margin:8px 0 14px}
/* Review follow-ups: vertical lane plate (opponent total on top, yours below), rule line, tie reason */
.lane-plate{grid-template-columns:1fr;grid-template-rows:auto auto auto;justify-items:center;gap:2px;padding:4px 3px}
.lane-score{display:flex;align-items:baseline;gap:3px;line-height:1.1}
.lane-score small{font-size:8px;font-weight:600;color:var(--ctp-overlay1);text-transform:uppercase}
.lane-rule{font-size:9px!important;line-height:1.25;color:var(--ctp-subtext0)!important;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden}
.lane-tie{font-size:9px!important;color:var(--ctp-yellow)!important}
.gcard-keyword{text-transform:none;letter-spacing:0;font-size:10px;white-space:nowrap}
@media(max-width:480px){.hand{-webkit-mask-image:linear-gradient(to right,#000 82%,transparent);mask-image:linear-gradient(to right,#000 82%,transparent);padding-right:24px}}
/* Phones: on the Play route, hide the node/RPC chrome above the game so Play starts above the fold. */
@media(max-width:760px){html.wd-play .testnet-status,html.wd-play .error-banner,html.wd-play main>footer{display:none}}
@media(max-width:480px){html.wd-play:not(.wd-in-match) .play-dock{padding-right:62px}}
.leaderboards{margin:12px 0 0;padding:10px 12px;border:1px solid var(--theme-border);border-radius:10px;background:var(--ctp-base)}
.leaderboards summary{cursor:pointer;display:flex;align-items:center;gap:6px;font-weight:700;font-size:13px;min-height:32px}
.leaderboards h4{font-size:12px;margin:10px 0 6px;display:flex;align-items:center;gap:5px;color:var(--ctp-subtext1)}
.board-list{list-style:none;padding:0;margin:0;display:grid;gap:4px;counter-reset:rank}
.board-list li{display:grid;grid-template-columns:22px 1fr auto auto;gap:8px;align-items:baseline;font-size:13px;counter-increment:rank}
.board-list li::before{content:counter(rank);color:var(--ctp-overlay1);font-size:11px}
.board-list li span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
.board-list li small{color:var(--ctp-subtext0);font-size:11px}
.board-list li.self span{color:var(--theme-accent)}
@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}}
+40
View File
@@ -0,0 +1,40 @@
// Display names and one-line reminder text (DESIGN §10.2, §10.3). The engine registry wins when it
// has an entry; this table covers keywords and Portals whose registry entry hasn't landed yet.
import { KEYWORDS, PORTALS, type Ruleset, type Stat } from '../../shared/game/index.ts';
const KW: Record<string, [string, string]> = {
viral: ['Viral', 'On reveal: +{amount} power for each other card you revealed earlier this turn (max +{cap}).'],
rising: ['Rising', 'End of turn: +{amount} power (max +{cap} total).'],
local: ['Local', 'Ongoing: +{amount} power while on-topic.'],
encyclopedic: ['Encyclopedic', 'On reveal: +{amount} power if there are no other cards here.'],
nostalgic: ['Nostalgic', 'On reveal: +{amount} power if you are losing here.'],
translated: ['Translated', 'On reveal: +{amount} power to your most recent card in each other Topic.'],
edition: ['Edition', '+{amount} power for each other copy of this article on your side.'],
obscure: ['Obscure', 'Your opponent sees this face down until the match ends.'],
wildcard: ['Wildcard', 'On reveal: its home stat becomes this Topic’s stat.'],
};
const PORTAL: Record<string, [string, string]> = {
'main-page': ['Main Page', 'At scoring, each card here gets +1 power.'],
trending: ['Trending', 'Trend arrows count double here.'],
'featured-article': ['Featured Article', 'At scoring, whoever has the single strongest card here gets +2.'],
stub: ['Stub', 'Only 2 cards per player fit here.'],
interwiki: ['Interwiki', '+1 here if you have a card in all 3 Topics.'],
disambiguation: ['Disambiguation', 'Every card here counts as on-topic.'],
};
const fill = (text: string, params: Record<string, number> = {}) => text.replace(/\{(\w+)\}/g, (_, k) => String(params[k] ?? k));
export const STAT_LABEL: Record<Stat, string> = { attention: 'Attention', depth: 'Depth', reach: 'Reach' };
export const STAT_HINT: Record<Stat, string> = {
attention: 'how many people read it', depth: 'how long the article is', reach: 'how many languages it’s in',
};
export function keywordInfo(id: string | null, rules?: Ruleset) {
if (!id) return undefined;
const reg = KEYWORDS[id], fb = KW[id];
return { id, name: reg?.name ?? fb?.[0] ?? id, text: fill(reg?.text ?? fb?.[1] ?? '', rules?.keywordParams[id]) };
}
export function portalInfo(portalId: string | null, topicId: string, rules?: Ruleset) {
if (!portalId) return undefined;
const reg = PORTALS[portalId], fb = PORTAL[portalId];
return { name: reg?.name ?? fb?.[0] ?? portalId, text: fill(reg?.text ?? fb?.[1] ?? '', rules?.portalParams[topicId] ?? rules?.portalParams[portalId]) };
}
+90
View File
@@ -0,0 +1,90 @@
// 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.
import type { Action, GameCard, MatchResult, PlayerId, PlayerView, Ruleset, Stat } from '../../shared/game/index.ts';
export type PlayerIndex = PlayerId;
export type { Stat };
/** A card as the deck builder and match screen show it (DESIGN §1.9): cost, power, home icon, trend, one keyword. */
export type UICard = {
id: string; // engine cardId
pageId: number | null;
title: string;
category: string; // faction
image?: string;
cost: number;
power: number; // current lane power on the board, base power elsewhere
basePower: number;
home: Stat;
trend: -1 | 0 | 1;
onTopic?: boolean; // on the board: the Topic's stat matches home (or Disambiguation)
keyword?: { id: string; name: string; text: string };
source: 'starter' | 'nft';
tokenId?: string;
rarity?: string;
game: GameCard;
};
export type LaneView = {
index: number;
name: string; // Topic name
stat: Stat;
modifier?: { name: string; text: string }; // revealed Portal
portalNote?: string; // e.g. "Portal reveals on turn 3"
revealed: boolean;
mine: UICard[];
theirs: UICard[];
staged: UICard[]; // my queued plays this turn, not yet revealed
myPower: number;
theirPower: number;
leader: 'you' | 'opponent' | null;
capacity: number;
};
export type MatchView = {
me: PlayerIndex;
turn: number;
maxTurns: number;
energy: number; // left this turn
maxEnergy: number;
saved: number; // energy carried over from last turn (included in maxEnergy)
hand: UICard[];
deckCount: number;
oppHandCount: number;
oppDeckCount: number;
oppQueued: number;
lanes: LaneView[];
log: string[]; // newest last, this seat's events only
waitingForOpponent: boolean;
over: boolean;
/** For engine-level bots (ui-b): this seat's hidden-information view only (night-lead: never the full MatchState). */
engine?: { view: PlayerView; seat: PlayerId };
};
export type UIAction = (
| { type: 'play'; cardId: string; lane: number }
| { type: 'unstage'; cardId: string }
| { type: 'endTurn' }
| { type: 'concede' }
) & { engine?: Action };
/** Always from the viewer's side: 0 = you, 1 = your opponent, null = draw. */
export type ResultView = {
winner: PlayerIndex | null;
lanes: { name: string; myPower: number; theirPower: number; winner: PlayerIndex | null }[];
turns: number;
reason: MatchResult['reason'];
totalPower: [number, number];
};
export type GameMode = {
id: string;
/** The host's own mode id (for /api/game/modes/:id/...). */
remoteId?: string;
name: string;
description: string;
host: { kind: 'local' } | { kind: 'peer'; name: string; url: string; self: boolean };
ruleset: Ruleset;
players?: number;
matchesPlayed?: number;
};
+3
View File
@@ -0,0 +1,3 @@
// eom.dev login state from the SSO module (src/auth, #7).
import { useAccount as useAuthAccount } from '../auth/LoginButton.tsx';
export const useAccount = () => useAuthAccount();
+61
View File
@@ -0,0 +1,61 @@
import { useEffect, useState } from 'react';
import { DEFAULT_RULESET, parseRuleset, type Ruleset } from '../../shared/game/index.ts';
import { LOCAL_MODES } from './adapter.ts';
import type { GameMode } from './types.ts';
// Modes API (modes team, #6 / docs/game/HOSTING.md §3): GET /api/game/modes for this node and
// GET /api/game/network/modes for configured peers. Everything a peer sends is untrusted: strings are
// length-capped and rendered as React text only, and rules go through the engine's strict parseRuleset.
const str = (v: unknown, max = 120) => (typeof v === 'string' ? v.slice(0, max) : undefined);
const num = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? Math.floor(v) : undefined);
const obj = (v: unknown): Record<string, unknown> | undefined => (v && typeof v === 'object' && !Array.isArray(v) ? v as Record<string, unknown> : undefined);
function rulesFor(rules: unknown): Ruleset | undefined {
const overrides = obj(rules);
try { return parseRuleset({ ...DEFAULT_RULESET, ...(overrides ?? {}) }); } catch { return undefined; }
}
/** Parse a ModeList ({ host, modes: [{ mode, stats }] }). Malformed entries are skipped. */
export function parseModeList(data: unknown, where: { self: boolean; origin: string }): GameMode[] {
const list = obj(data);
const host = obj(list?.host);
const operator = str(host?.operator, 60) ?? str(host?.origin, 80) ?? (where.self ? 'this node' : where.origin);
const origin = str(host?.origin, 200) ?? where.origin;
const modes = Array.isArray(list?.modes) ? list!.modes as unknown[] : [];
return modes.slice(0, 16).flatMap((entry): GameMode[] => {
const e = obj(entry), m = obj(e?.mode), stats = obj(e?.stats);
const id = str(m?.id, 64), name = str(m?.name, 60);
const ruleset = rulesFor(m?.rules);
if (!id || !name || !ruleset) return [];
return [{ id: `${where.self ? 'self' : origin}:${id}`, remoteId: id, name, description: str(m?.description, 280) ?? '',
host: { kind: 'peer', name: operator, url: /^https?:\/\//.test(origin) ? origin : '', self: where.self },
ruleset, players: num(stats?.playersOnline), matchesPlayed: num(stats?.matchesPlayed) }];
});
}
export function useModes() {
const [remote, setRemote] = useState<GameMode[]>([]);
const [status, setStatus] = useState<'loading' | 'ok' | 'unavailable'>('loading');
useEffect(() => {
let active = true;
const get = (path: string) => fetch(path, { cache: 'no-store', signal: AbortSignal.timeout(8000) })
.then(r => (r.ok && r.headers.get('content-type')?.includes('json') ? r.json() : Promise.reject(new Error('unavailable'))));
Promise.allSettled([get('/api/game/modes'), get('/api/game/network/modes')]).then(([self, net]) => {
if (!active) return;
const found: GameMode[] = [];
if (self.status === 'fulfilled') found.push(...parseModeList(self.value, { self: true, origin: '' }));
if (net.status === 'fulfilled') {
const peers = obj(net.value)?.peers;
if (Array.isArray(peers)) for (const p of peers.slice(0, 16)) {
const peer = obj(p);
if (peer?.ok && peer.list) found.push(...parseModeList(peer.list, { self: false, origin: str(peer.origin, 200) ?? '' }));
}
}
const seen = new Set<string>();
setRemote(found.filter(m => !seen.has(m.id) && seen.add(m.id)));
setStatus(self.status === 'fulfilled' || net.status === 'fulfilled' ? 'ok' : 'unavailable');
});
return () => { active = false; };
}, []);
return { modes: [...LOCAL_MODES, ...remote], status };
}
+128
View File
@@ -0,0 +1,128 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { DEFAULT_RULESET } from '../shared/game/index.ts';
import { engine } from '../src/game/adapter.ts';
import { randomBot } from '../src/game/bots.ts';
import { cardFromBlock, loanerPool, opponentDeck, starterDeck } from '../src/game/cards.ts';
import { deckProblem, deckWarning } from '../src/game/DeckBuilder.tsx';
import { parseModeList } from '../src/game/useModes.ts';
import type { PlayerIndex } from '../src/game/types.ts';
import type { TestnetBlock } from '../shared/testnet.ts';
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. */
function playOut(seed: string) {
let s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck(seed)], seed);
const r = rand(seed.length * 7919 + 1);
for (let steps = 0; steps < 2000 && !engine.isOver(s); steps++) {
for (const p of [0, 1] as PlayerIndex[]) {
const legal = engine.legal(s, p).filter(a => a.type !== 'concede');
if (!legal.length) continue;
s = engine.apply(s, p, randomBot.choose(engine.view(s, p), legal, r));
}
}
return s;
}
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(opponentDeck('x'), DEFAULT_RULESET), '');
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', () => {
const pool = loanerPool();
const heavy = pool.filter(c => c.cost >= 3).slice(0, 12);
assert.match(deckWarning(heavy), /cost 2 or less/);
assert.equal(deckWarning(starterDeck()), '');
});
test('UI-driven random play always finishes within the turn cap and is deterministic', () => {
for (let i = 0; i < 40; i++) {
const a = playOut(`seed-${i}`), b = playOut(`seed-${i}`);
assert.ok(engine.isOver(a), `match ${i} finished`);
const ra = engine.result(a, 0);
assert.ok(ra.turns <= DEFAULT_RULESET.turns, `match ${i}: ${JSON.stringify(ra)}`);
assert.deepEqual(ra, engine.result(b, 0));
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.deepEqual(rb.totalPower, [ra.totalPower[1], ra.totalPower[0]]);
}
});
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).
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++)
s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck(`h${i}`)], `hidden-${i}`);
const play = engine.legal(s, 1).find(a => a.type === 'play');
assert.ok(play, 'some seed gives the opponent a turn-1 play');
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');
});
test('unstage refunds energy, and illegal plays are explained', () => {
let s = engine.createMatch(DEFAULT_RULESET, [starterDeck(), opponentDeck('e')], 'energy');
const v = engine.view(s, 0);
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 }));
const play = engine.legal(s, 0).find(a => a.type === 'play');
if (play?.type === 'play') {
s = engine.apply(s, 0, play);
assert.ok(engine.view(s, 0).energy < v.energy);
s = engine.apply(s, 0, { type: 'unstage', cardId: play.cardId });
assert.equal(engine.view(s, 0).energy, v.energy);
}
});
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 },
statsSnapshot: { stats: { attention: 100, depth: 100, reach: 100 } } } as unknown as TestnetBlock;
const card = cardFromBlock(block);
assert.equal(card.source, 'nft');
assert.ok(card.cost <= DEFAULT_RULESET.uncheckedCostCap, 'forged max stats are capped');
assert.equal(card.basePower, DEFAULT_RULESET.powerByCost[card.cost]);
const deck = [card, ...starterDeck().slice(1)];
assert.equal(deckProblem(deck, DEFAULT_RULESET), '');
});
test('peer mode lists are parsed defensively', () => {
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: 'bad', name: 'Bad rules', rules: { turns: 999 } } },
{ mode: { name: 'no id' } }, 'junk', null,
] }, { self: false, origin: 'http://192.168.1.32:3102' });
assert.equal(modes.length, 1);
const [m] = modes;
assert.equal(m.host.kind === 'peer' && m.host.name, 'node-b');
assert.equal(m.ruleset.turns, 5);
assert.ok(m.description.length <= 280);
assert.equal(m.players, 3);
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');
});
test('leaderboard parsers cap and sanitise host data', async () => {
const { parseHosts, parseLeaderboard } = await import('../src/game/Leaderboards.tsx');
const hosts = parseHosts({ hosts: [{ operator: 'x'.repeat(200), matchesHosted: 5, playersOnline: -3, self: true }, null, 'junk', ...Array(20).fill({ origin: 'http://n' })] });
assert.equal(hosts.length, 10);
assert.equal(hosts[0].operator.length, 60);
assert.equal(hosts[0].playersOnline, 0);
assert.equal(hosts[1].operator, 'http://n');
assert.deepEqual(parseLeaderboard({ entries: [{ name: '', wins: 2 }] }), [{ name: 'Anonymous', wins: 2, losses: 0, draws: 0, played: 0 }]);
assert.deepEqual(parseLeaderboard(42), []);
});