forked from WikiDeck/wikideck
Overnight build by 17 Claude agents (2026-11-16 22:45 → 01:30 EST), coordinated in [claude/wikideck milestone 63](https://gitea.eom.dev/claude/wikideck/milestone/63). **For Eric's review. Do not merge without it.** The full write-up is in `docs/night/REPORT.md`. **What's in it** (38 reviewed PRs, squash-merged into `night/2026-11-16`): - **Edit War:** - a 3-lane, 6-turn card game built on what WikiDeck cards actually hold - a pure, deterministic, off-chain rules engine (`shared/game/`, with the API in `docs/game/ENGINE_API.md`); rules are data and v1.1 is the default - a mobile-first Play UI with a lobby, deck builder, four loaner starter decks, a match against the AI, results and a tutorial - a landing page (fixes #3) - **Design and balance:** `docs/game/DESIGN.md`, `CARD_DATA.md` (236 sampled articles) and `BALANCE.md` (bot simulations). Starter pairings went from 23–77% on v1 to roughly even on v1.1. - **eom.dev accounts:** Dex OIDC with PKCE, plus off-chain wallet linking, where the client builds the message it signs (`server/account/`, `src/auth/`). - **Peer-hosted game modes:** modes are JSON data, never code. Node API at `/api/game/*`, with host credit and leaderboards. Three example modes (`shared/game/modes.ts`, `server/game/`, `docs/game/HOSTING.md`). - **Mobile:** Capacitor 7 Android app (a debug APK played a full match against the AI in the emulator), and an iOS project waiting on Xcode (`docs/night/ANDROID.md`, `docs/night/IOS.md`). - **Testnet tooling:** `deploy/night/` (LAN-only, 3 nodes) and an optional `WIKIDECK_USER_AGENT` (the default is unchanged). **Not touched:** consensus and protocol (`server/chain.ts`, `shared/protocol.ts`, `server/testnet/{consensus,ledger,…}.ts`, `native/`), the live deployment and mainnet. Matches run off-chain and never move or burn NFTs. **Checks:** the final integration gate passed in `node:24-alpine`: `npm test` 241/242 with 0 fail (1 skipped), and `npm run build` passes. The repo needs Node 24, because Node 20 fails 12 tests falsely. **Decisions for Eric** (see REPORT.md, Known issues and Next steps): 1. whether the live node should set `WIKIDECK_USER_AGENT` 2. the Xcode licence, which you should accept yourself 3. #49 in the fork, a bot change held after the freeze 4. on-chain host rewards (proposal only, in HOSTING.md) 🤖 Generated with [Claude Code](https://claude.com/claude-code)Reviewed-on: WikiDeck/wikideck#22 Co-authored-by: Claude <claude@eom.dev>
80 lines
4.2 KiB
TypeScript
80 lines
4.2 KiB
TypeScript
/** Binds the mode host to the real engine through its public API (shared/game/index.ts). */
|
||
import { DEFAULT_RULESET, parseRuleset, starterDeck, previewPool as engineLoaners, validateDeck, createMatch,
|
||
legalActions, applyAction, isOver, result, viewFor, Rng,
|
||
type Action, type GameCard, type MatchState, type Ruleset } from '../../shared/game/index.ts';
|
||
import type { EnginePort, Seat } from './engine-port.ts';
|
||
|
||
/**
|
||
* Deterministic pool of loaner (non-NFT) cards for draft modes: seeded shuffles of the engine's
|
||
* frozen loaner cards (`previewPool(rules)`, derived with the mode's rules), one copy per round,
|
||
* never exceeding the ruleset's per-page copy limit. Copies get distinct cardIds.
|
||
*/
|
||
export function previewPool(rules: Ruleset, seed: string, size: number): GameCard[] {
|
||
const rng = Rng.fromSeed(`draft-pool:${seed}`);
|
||
const loaners = engineLoaners(rules);
|
||
const pool: GameCard[] = [];
|
||
for (let copy = 0; pool.length < size && copy < rules.maxCopiesPerPage; copy++) {
|
||
for (const card of rng.shuffle(loaners)) {
|
||
if (pool.length >= size) break;
|
||
pool.push({ ...card, cardId: `${card.cardId}:${copy}` });
|
||
}
|
||
}
|
||
return pool;
|
||
}
|
||
|
||
/**
|
||
* The engine's strict parseRuleset, plus host-side checks that keep a hosted mode playable
|
||
* (requested in review on #6). Anything that fails is rejected at startup, never passed on.
|
||
*/
|
||
export const UNSAFE_KEYWORDS: readonly string[] = ['obscure'];
|
||
|
||
export function parseModeRuleset(value: unknown): Ruleset {
|
||
const rules = parseRuleset(value);
|
||
const problems: string[] = [];
|
||
if (rules.distinctStats && rules.topicCount !== 3) problems.push('distinctStats requires topicCount 3');
|
||
if (rules.portalReveal.some(turn => turn > rules.turns)) problems.push('every portalReveal turn must be ≤ turns');
|
||
if (rules.energyByTurn.length < rules.turns) problems.push('energyByTurn needs one entry per turn');
|
||
if (rules.turns * rules.turnSeconds > 240) problems.push('turns × turnSeconds must be ≤ 240');
|
||
if (rules.powerByCost.length !== 7) problems.push('powerByCost needs 7 entries');
|
||
// Keywords whose hidden information viewFor doesn't mask yet would leak cards to the opponent (#6, #27).
|
||
for (const id of UNSAFE_KEYWORDS) if ((rules.keywordsEnabled as readonly string[]).includes(id)) problems.push(`keyword "${id}" is not hostable yet (viewFor does not mask it)`);
|
||
if (problems.length) throw new Error(`Invalid mode rules: ${problems.join('; ')}`);
|
||
return rules;
|
||
}
|
||
|
||
export const engineBinding: EnginePort<Ruleset, GameCard, MatchState, Action> = {
|
||
defaultRuleset: DEFAULT_RULESET,
|
||
parseRuleset: parseModeRuleset,
|
||
deckSize: rules => rules.deckSize,
|
||
starterDeck: (_rules, seed) => starterDeck(seed),
|
||
previewPool,
|
||
validateDeck: (rules, cards) => {
|
||
const problems = validateDeck(rules, cards);
|
||
if (problems.length) throw new Error(problems.slice(0, 3).join('; '));
|
||
},
|
||
cardPower: card => card.power,
|
||
withPower: (card, power) => ({ ...card, power: Math.min(30, Math.max(0, power)) }),
|
||
cardPageId: card => card.pageId,
|
||
cardSummary: card => ({ cardId: card.cardId, title: card.title, pageId: card.pageId, faction: card.faction,
|
||
cost: card.cost, power: card.power, home: card.home, trend: card.trend, keyword: card.keyword }),
|
||
createMatch: (rules, decks, seed) => createMatch(rules, decks, seed),
|
||
legalActions: (state, seat) => legalActions(state, seat),
|
||
applyAction: (state, seat: Seat, action) => {
|
||
if (action.player !== seat) throw new Error('Action for the wrong seat');
|
||
return applyAction(state, action);
|
||
},
|
||
concedeAction: seat => ({ type: 'concede', player: seat }),
|
||
timeoutAction: seat => ({ type: 'timeout', player: seat }),
|
||
turnSeconds: rules => rules.turnSeconds,
|
||
turnOf: state => state.turn,
|
||
// DESIGN §1.6: the live trend arrow, frozen at match start, using the ruleset's thresholds.
|
||
applyLive: (rules, card, live) => {
|
||
const t = live.trendPercent;
|
||
const trend = t === null || !Number.isFinite(t) ? 0 : t >= rules.trendUp ? 1 : t <= rules.trendDown ? -1 : 0;
|
||
return { ...card, trend };
|
||
},
|
||
isOver,
|
||
result: state => { const r = result(state); return { winner: r?.winner ?? null, reason: r?.reason ?? 'complete' }; },
|
||
viewFor: (state, seat) => viewFor(state, seat),
|
||
};
|