@journey-to-code/games 0.0.0-stage → 0.1.0

package/dist/table.d.ts

@@ -0,0 +1,284 @@
+import { type PlayStyle } from "@journey-to-code/rules";
+/** The games that are played with cards. */
+export type CardGameId = "hearts" | "ohhell" | "euchre" | "crazy8" | "gin" | "pinochle" | "canasta" | "gofish" | "oldmaid" | "war" | "whist" | "golf" | "rummy500" | "president" | "klondike" | "freecell" | "handfoot" | "cribbage" | "fivedraw" | "holdem" | "bluff" | "liarspoker" | "switch" | "thirtyone" | "kingscorner" | "blackjack" | "spite" | "pitch" | "fivehundred" | "durak" | "bridge" | "fruitsalad" | "slapjack" | "speed" | "memory" | "sevens" | "cuckoo" | "contractrummy" | "spider" | "pyramid" | "ridethebus" | "kingscup" | "horserace" | "drinkingpyramid";
+/** The games that are played on a board. */
+export type BoardGameId = "tictactoe" | "dropfour" | "combat" | "reversi" | "checkers" | "go" | "chess" | "yacht" | "backgammon";
+/** The games that are played by striking a ball across a table. */
+export type SportGameId = "minigolf";
+/** Every game on the kit. (Rooms, houses and saved rules have always called these "kit" games.) */
+export type KitGameId = CardGameId | BoardGameId | SportGameId;
+/** A move that isn't allowed. The message is shown to the player as is. */
+export declare class GameError extends Error {
+}
+export declare function shuffled<T>(items: readonly T[], rand: () => number): T[];
+/** A seeded random source that survives being stored in a state (a number, advanced each use). */
+export declare function nextRandom(state: {
+    rng: number;
+}): () => number;
+/** One choice a player can make with a button. `move` is sent as is. */
+export interface Choice {
+    label: string;
+    move: Record<string, unknown>;
+    /** The main choice: drawn as the big gold button. */
+    primary?: boolean;
+    hint?: string;
+    /** A question to put before it is sent ("Pass your turn?"): for a button that is easy to press and hard to undo. */
+    confirm?: string;
+}
+/** Buttons a seat can press now: a bid, a trump call, "Next hand". */
+export interface Choices {
+    prompt: string;
+    options: Choice[];
+    layout?: "grid" | "row" | "list";
+}
+/** One line of a hand summary table: a label and a value per side (team or player). */
+export interface SummaryRow {
+    label: string;
+    values: string[];
+    tone?: "score" | "total";
+}
+/** The scoreboard: one entry per side (team or player): the seats on that side and its score. */
+export type Scores = {
+    seats: number[];
+    value: number;
+}[];
+/** After a hand or a round: what it scored, a column per side (the seats on it), until everyone moves on. */
+export interface RoundResult {
+    key: string;
+    title: string;
+    sides: number[][];
+    rows: SummaryRow[];
+}
+export interface GameOver {
+    winners: number[];
+    title: string;
+}
+/**
+ * A score sheet: a column per thing that is scored (a hole, a frame, a category of dice) and a row
+ * per player. Mini Golf's scorecard and Yacht's sheet are both one of these; how it is laid out
+ * (holes across the page, categories down it) is the table's business.
+ */
+export interface ScoreSheet {
+    title: string;
+    columns: SheetColumn[];
+    /** The column being played, if any. */
+    current: number | null;
+    rows: SheetRow[];
+    /** What `total` and `note` are, for the headings: "Total", "To par". */
+    totalLabel: string;
+    noteLabel?: string;
+    /** The cell filled in last, so the table can point at it. */
+    last?: {
+        seat: number;
+        column: number;
+    } | null;
+    /**
+     * Cells of this seat's own row that it can choose now (score this roll as a full house). Each
+     * says what it would score; tapping one sends `{ type, cell }` with the column's `id`. Only ever
+     * sent to the seat that can choose.
+     */
+    pick?: {
+        type: string;
+        cells: {
+            column: number;
+            would: string;
+        }[];
+    } | null;
+}
+export interface SheetColumn {
+    label: string;
+    /** A second line under the label: a hole's par, what a category scores. */
+    sub?: string;
+    /** Names this column in a move. Needed only where a cell can be chosen. */
+    id?: string;
+    /** A column nobody fills in: it is worked out from the others (a bonus). */
+    kind?: "sum";
+}
+export interface SheetRow {
+    seat: number;
+    /** One per column; "" for a cell not filled in yet. */
+    cells: string[];
+    total: string;
+    note?: string;
+}
+/** A finished or running game, in a few words, for lobbies, houses, leaderboards and tournaments. */
+export interface KitSummary {
+    game: KitGameId;
+    rules: string;
+    phase: string;
+    over: boolean;
+    /** Which hand (or round) it's on, from 1. */
+    hand: number;
+    /** "120 to 85", "Ann 34 · Bo 51 · …". */
+    scoreLine: string;
+    /** Seats best to worst once it's over (partners together); null while playing. */
+    order: number[] | null;
+    winners: number[] | null;
+    teams: boolean;
+    seats: number;
+}
+export declare const who: (seat: number) => string;
+export interface BaseRules {
+    id: string;
+    name: string;
+}
+/** One house rule, described so the rules editor can draw it. */
+export type RuleField<R> = {
+    key: keyof R & string;
+    label: string;
+    hint?: string;
+    kind: "toggle";
+} | {
+    key: keyof R & string;
+    label: string;
+    hint?: string;
+    kind: "choice";
+    options: [string | number, string][];
+} | {
+    key: keyof R & string;
+    label: string;
+    hint?: string;
+    kind: "number";
+    min: number;
+    max: number;
+    step?: number;
+};
+/**
+ * A clock of the game's own: a shot clock, a chess clock, a window for claiming a discard. The
+ * table keeps the time (the server for a family table, the browser in practice) and makes `move`
+ * as `seat` if nothing else happens first.
+ */
+export interface GameDeadline<M = Record<string, unknown>> {
+    /** How long the seat has, in ms, counted from the last move anyone made (or the deal). */
+    after: number;
+    /** Whose clock it is: the table counts down on this seat. */
+    seat: number;
+    /** The move made as that seat when time runs out. It goes through `apply` like any other. */
+    move: M;
+    /**
+     * The clock holds whoever is in the seat, a computer player too (a chess clock: the time is
+     * part of the game, and a bot that thinks too long loses on it like anyone). Without it a
+     * computer player's seat has no clock, and the table only keeps it moving inside the time.
+     */
+    strict?: boolean;
+}
+/**
+ * How long a computer player may think, when the table says. A game that searches (Chess, Go) can
+ * look until the time is nearly gone and play the best move it has; the table gives up on a think
+ * that runs far past it and plays a quick move instead (see `TableGame.bot`).
+ */
+export interface ThinkBudget {
+    /** Ms this think may take. A handful means "answer at once": the first sensible move will do. */
+    ms: number;
+}
+/** The style a computer player is asked in when its real think was given up on: no skill wanted, just a legal move, now. */
+export declare const QUICK_STYLE: PlayStyle;
+/** And the budget that goes with it. */
+export declare const QUICK_BUDGET: ThinkBudget;
+/**
+ * When a move was made, as the table that keeps the time tells it (a room on the server, the
+ * browser in practice). Only a game that keeps time in its state needs it, and a table that keeps
+ * no time leaves it out.
+ */
+export interface MoveTime {
+    /** Ms since the move before it (or since the game began). */
+    elapsed: number;
+}
+/**
+ * A game, apart from what its table looks like: `View` is what one seat sees (a `KitView` for a
+ * card game, a `BoardView` for a board game, a `SportView` for a table sport).
+ */
+export interface TableGame<R extends BaseRules = BaseRules, S = unknown, M = Record<string, unknown>, View = unknown> {
+    id: KitGameId;
+    name: string;
+    emoji: string;
+    /** For the game picker. */
+    blurb: string;
+    /** For the setup screen's heading. */
+    tagline: string;
+    seats: {
+        min: number;
+        max: number;
+        default: number;
+    };
+    /** Partners across the table (needs four seats). */
+    teams: boolean;
+    presets: R[];
+    fields: RuleField<R>[];
+    /** Rules from storage or a page: anything missing comes from the first preset. */
+    normalize(rules: unknown): R;
+    validate(rules: R): string[];
+    /** The rules in plain sentences, for the rules sheet and summaries. */
+    describe(rules: R): string[];
+    newGame(rules: R, seats: number, seed: number): S;
+    /** Apply a seat's move; throws GameError when it isn't allowed. Never changes the given state. */
+    apply(state: S, seat: number, move: M, time?: MoveTime): S;
+    view(state: S, seat: number): View;
+    /**
+     * The move a computer player makes now, or null when it has nothing to do. Whether there is a move
+     * at all must not depend on the style.
+     *
+     * `rand` is where a bot that rolls dice gets them (default `Math.random`); tests pass a seeded one.
+     *
+     * `budget` is how long the think may take, when the table says. The bots here ignore it: they
+     * ration themselves by work done (so many positions, so many putts), which gives the same move on
+     * a fast machine and a slow one. A game that wants to use the time may, and must then keep to it:
+     * a think that runs far past its budget is abandoned by the table, and the seat is asked again
+     * with `QUICK_STYLE` and `QUICK_BUDGET`, on the table's own thread, so that answer has to come at
+     * once whatever the position.
+     */
+    bot(state: S, seat: number, style: PlayStyle, rand?: () => number, budget?: ThinkBudget): M | null;
+    /**
+     * Whether working out this seat's move here is slow enough (a few ms or more) that the table
+     * should do it off its main thread: a search, a simulation. It must answer at once, from the state
+     * alone, and say no when the seat has nothing to do or its move is obvious ("Next hand"). A game
+     * without it always thinks on the table's own thread, which is right for anything quick: handing a
+     * think to another thread costs a little too.
+     */
+    heavy?(state: S, seat: number): boolean;
+    /**
+     * The computer player's move on the board alone, when `bot` may do something else first (answer
+     * an offer: see offers.ts). The turn timer plays this for a person who has run out of time; a
+     * game without it is played `bot`'s move.
+     */
+    play?(state: S, seat: number, style: PlayStyle, rand?: () => number, budget?: ThinkBudget): M | null;
+    /** How long a person would think here, in ms (before the persona's own pace). */
+    thinkingTime(state: S, seat: number): number;
+    /**
+     * For a race (a slap in Slapjack): how long this computer player takes to react, in ms. When it
+     * gives a number, it's used as is, whatever pace the table is set to, so a person can win the race.
+     */
+    reactionTime?(state: S, seat: number, style: PlayStyle): number | null;
+    /**
+     * The game's own clock in this state, if one is running: null (or no `deadline` at all) when the
+     * game waits as long as it takes. Asked again after every move, so it describes this state only,
+     * and like everything else here it must be worked out from the state alone, never from the time
+     * of day. The table's turn timer is separate; when both are running, the sooner one counts. A
+     * computer player in the seat is never held to it (and never takes longer than it).
+     */
+    deadline?(state: S): GameDeadline<M> | null;
+    /**
+     * Ms of the wait for the next move on the board that have already gone by, over moves that
+     * aren't one (an offer and its answer). The table's clocks count from the last move of any kind,
+     * so the turn timer takes this off; a game's own `deadline` has already allowed for it.
+     */
+    spent?(state: S): number;
+    summary(state: S): KitSummary;
+}
+export declare const clone: <T>(value: T) => T;
+/** Order sides best-first by score (higher better unless `lowWins`), then flatten to seats. */
+export declare function rankSeats(sides: {
+    seats: number[];
+    score: number;
+}[], lowWins?: boolean): number[];
+export declare const teamOfSeat: (seat: number) => 0 | 1;
+export declare const teamSeats: (team: 0 | 1) => number[];
+/** A "Next hand" button for each person who hasn't moved on yet; bots move on at once. */
+export declare function nextHandChoices(ready: boolean[], seat: number, last: boolean, next?: string): Choices | null;
+/** Moving on after a hand: marks the seat ready; returns true once everyone is. */
+export declare function markReady(ready: boolean[], seat: number): boolean;
+/** How long to think: a beat plus a little per option, longer when it matters. */
+export declare function thinkFor(options: number, weight?: number): number;
+/** The persona's sharpness: careless players sometimes pick a random option. */
+export declare function careless(style: PlayStyle, rand?: () => number): boolean;
+export declare function pickRandom<T>(items: T[], rand?: () => number): T;

package/dist/table.js

@@ -0,0 +1,67 @@
+// What every game here has in common, whatever is on the table. A game is a pure, deterministic
+// engine (the same seed and moves always give the same game, so a room can replay its log): its
+// house rules, how a game starts, what a move does, what each seat may see, what a computer player
+// does, and a summary for lobbies and leaderboards. What a seat sees is the one part that differs:
+// card games describe hands, tricks and piles (a `KitView`, in kit.ts) and board games a grid and
+// its pieces (a `BoardView`, in board.ts), and table sports a physics world and whose shot it is
+// (a `SportView`, in sport.ts). Everything else (the room on the server, the setup
+// screen, the rules editor, houses, challenges, tournaments, practice) only needs this file.
+import { mulberry32 } from "@journey-to-code/rules";
+/** A move that isn't allowed. The message is shown to the player as is. */
+export class GameError extends Error {
+}
+export function shuffled(items, rand) {
+    const out = [...items];
+    for (let i = out.length - 1; i > 0; i--) {
+        const j = Math.floor(rand() * (i + 1));
+        [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+}
+/** A seeded random source that survives being stored in a state (a number, advanced each use). */
+export function nextRandom(state) {
+    return () => {
+        const r = mulberry32(state.rng)();
+        state.rng = (state.rng + 0x9e3779b9) >>> 0;
+        return r;
+    };
+}
+// Text from engines names seats as {0}, {1}…; the table puts the players' names in.
+export const who = (seat) => `{${seat}}`;
+/** The style a computer player is asked in when its real think was given up on: no skill wanted, just a legal move, now. */
+export const QUICK_STYLE = { skill: 0, sloppy: 0 };
+/** And the budget that goes with it. */
+export const QUICK_BUDGET = { ms: 10 };
+// ---- Helpers for engines ------------------------------------------------------------------------
+export const clone = (value) => structuredClone(value);
+/** Order sides best-first by score (higher better unless `lowWins`), then flatten to seats. */
+export function rankSeats(sides, lowWins = false) {
+    return [...sides].sort((a, b) => (lowWins ? a.score - b.score : b.score - a.score)).flatMap((s) => s.seats);
+}
+export const teamOfSeat = (seat) => (seat % 2);
+export const teamSeats = (team) => [team, team + 2];
+/** A "Next hand" button for each person who hasn't moved on yet; bots move on at once. */
+export function nextHandChoices(ready, seat, last, next = "Deal the next hand") {
+    if (ready[seat])
+        return null;
+    return { prompt: "", options: [{ label: last ? "See the final score" : next, move: { type: "next" }, primary: true }] };
+}
+/** Moving on after a hand: marks the seat ready; returns true once everyone is. */
+export function markReady(ready, seat) {
+    if (ready[seat])
+        throw new GameError("Waiting for the others.");
+    ready[seat] = true;
+    return ready.every(Boolean);
+}
+/** How long to think: a beat plus a little per option, longer when it matters. */
+export function thinkFor(options, weight = 1) {
+    return Math.round((700 + Math.min(options, 10) * 120) * weight);
+}
+/** The persona's sharpness: careless players sometimes pick a random option. */
+export function careless(style, rand = Math.random) {
+    return rand() < (style.sloppy ?? 0) + (1 - (style.skill ?? 1)) * 0.25;
+}
+export function pickRandom(items, rand = Math.random) {
+    return items[Math.floor(rand() * items.length)];
+}
+//# sourceMappingURL=table.js.map

package/dist/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sourceRoot":"","sources":["../src/table.ts"],"names":[],"mappings":"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"}

package/dist/talk.d.ts

@@ -0,0 +1,17 @@
+import type { KitGameId, KitSummary } from "./kit.js";
+export interface KitRemark {
+    seat: number;
+    text: string;
+    delay: number;
+}
+type Cast = {
+    bots: {
+        seat: number;
+        name: string;
+    }[];
+};
+type Rand = () => number;
+export declare function kitGreet(cast: Cast, rand?: Rand, game?: KitGameId): KitRemark[];
+/** When a game has just ended: the winners cheer, the rest congratulate. */
+export declare function reactToKit(before: KitSummary, after: KitSummary, cast: Cast, rand?: Rand): KitRemark[];
+export {};

package/dist/talk.js

@@ -0,0 +1,44 @@
+// Table talk for the kit games: the same cast, in their own voices, saying hello and reacting
+// when a game ends. (Answers to people's chat come from the shared reply lines.)
+import { personaFor } from "@journey-to-code/rules";
+import { isBoardGame, isSportGame } from "./registry.js";
+const LINES = {
+    warm: { hello: ["Hi everybody! Good luck 🍀", "Ooh, a new game. Be nice to me 😊"], won: ["I won?! Good game everybody ❤️"], lost: ["Good game! I'll get you next time 😅"], someoneWon: ["Congrats! 🎉", "Well played 👏"] },
+    dry: { hello: ["Deal 'em.", "Let's go."], won: ["GG.", "That's how it's done."], lost: ["Yeah, yeah. GG."], someoneWon: ["GG.", "Not bad."] },
+    goofy: { hello: ["Card party! 🎉", "Who's ready to lose to me? 😂"], won: ["WINNER WINNER 🍗😂", "Woohoo! 🎉🤪"], lost: ["I meant to do that 😂"], someoneWon: ["🎉🎉", "Bow down! 👑😂"] },
+    sharp: { hello: ["Good luck. You'll need it 😏"], won: ["As expected 😏", "🏆"], lost: ["Rematch. Now. 😤"], someoneWon: ["Well played. Rematch?"] },
+    quiet: { hello: ["👋"], won: ["GG 🙂"], lost: ["GG"], someoneWon: ["👏"] },
+    nervous: { hello: ["Oh gosh, okay, here we go 😬"], won: ["Wait, I won?? 😳🎉"], lost: ["I knew it 😩"], someoneWon: ["Congrats! You earned it 👏"] },
+    dramatic: { hello: ["Let the games BEGIN 🎭"], won: ["VICTORY IS MINE 🏆✨"], lost: ["Betrayed by the cards 😩"], someoneWon: ["A worthy champion 👑"] },
+};
+/** At a board or on a green there are no cards to deal or blame: these stand in for the lines that mention them. */
+const BOARD_LINES = {
+    dry: { hello: ["Your move.", "Let's go."] },
+    goofy: { hello: ["Game time! 🎉", "Who's ready to lose to me? 😂"] },
+    dramatic: { lost: ["Outplayed. For now 😩"] },
+};
+function line(seat, name, event, weight, rand, delay, game) {
+    const persona = personaFor(name);
+    const voice = persona.voice ?? "warm";
+    const options = (isBoardGame(game) || isSportGame(game) ? BOARD_LINES[voice]?.[event] : undefined) ?? LINES[voice][event] ?? LINES.warm[event];
+    if (!options?.length || rand() > persona.chatty * weight)
+        return null;
+    return { seat, text: options[Math.floor(rand() * options.length)], delay: delay[0] + rand() * (delay[1] - delay[0]) };
+}
+export function kitGreet(cast, rand = Math.random, game) {
+    return cast.bots
+        .map((b) => line(b.seat, b.name, "hello", 0.8, rand, [800, 2500], game))
+        .filter((r) => r !== null)
+        .slice(0, 2)
+        .map((r, i) => ({ ...r, delay: r.delay + i * 1100 }));
+}
+/** When a game has just ended: the winners cheer, the rest congratulate. */
+export function reactToKit(before, after, cast, rand = Math.random) {
+    if (!after.over || before.over)
+        return [];
+    const out = cast.bots
+        .map((b) => line(b.seat, b.name, after.winners?.includes(b.seat) ? "won" : after.order?.at(-1) === b.seat ? "lost" : "someoneWon", 2, rand, [500, 2400], after.game))
+        .filter((r) => r !== null);
+    return out.slice(0, 3).map((r, i) => ({ ...r, delay: r.delay + i * 900 }));
+}
+//# sourceMappingURL=talk.js.map

package/dist/talk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"talk.js","sourceRoot":"","sources":["../src/talk.ts"],"names":[],"mappings":"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"}

package/dist/thirtyone.d.ts

@@ -0,0 +1,66 @@
+import { type BaseRules, type CardGame, type KCard } from "./kit.js";
+export interface ThirtyOneRules extends BaseRules {
+    lives: number;
+    /** Three of a kind counts 30½. */
+    trips: boolean;
+    /** A knocker with the lowest hand loses two lives. */
+    knockerPays: boolean;
+    /** A house rule: suits don't matter, all three cards count together. Missing on older saved rules: off. */
+    anySuit?: boolean;
+    /** Drinking mode, a house rule: see the game's describe(). */
+    drinking?: boolean;
+}
+export declare const classicThirtyOne: ThirtyOneRules;
+export declare const longThirtyOne: ThirtyOneRules;
+export declare const plainThirtyOne: ThirtyOneRules;
+export declare const noSuitsThirtyOne: ThirtyOneRules;
+export interface ThirtyOneState {
+    game: "thirtyone";
+    rules: ThirtyOneRules;
+    seats: number;
+    rng: number;
+    hand: number;
+    dealer: number;
+    lives: number[];
+    /** The hand number each seat went out on, for the final order. */
+    outAt: (number | null)[];
+    hands: KCard[][];
+    stock: KCard[];
+    discard: KCard[];
+    turn: number;
+    phase: "draw" | "discard" | "reveal" | "finished";
+    /** The card just taken from the discards: it can't go straight back. */
+    taken: string | null;
+    knocker: number | null;
+    /** Turns played this round, so computer players knock sooner as it drags on. */
+    turns: number;
+    /** Who lost lives at the last showdown, and how many. */
+    lost: number[];
+    ready: boolean[];
+    narration: string | null;
+}
+/**
+ * The hand's score: the best suit total, or 30½ for three of a kind. Only cards of one suit count
+ * together, unless the house plays `anySuit`: then every card counts.
+ */
+export declare function score31(cards: KCard[], trips?: boolean, anySuit?: boolean): number;
+/**
+ * A hand's score in words, saying which cards made it: "20 in ♦ (A♥ doesn't count)". The number alone
+ * leaves a player with A♥ 10♦ Q♦ wondering why it isn't 31.
+ */
+export declare function explain31(cards: KCard[], trips?: boolean, anySuit?: boolean): string;
+export declare function newThirtyOne(rules: ThirtyOneRules, seats: number, seed: number): ThirtyOneState;
+type Move = {
+    type: "draw";
+} | {
+    type: "take";
+} | {
+    type: "knock";
+} | {
+    type: "discard";
+    card: string;
+} | {
+    type: "next";
+};
+export declare const thirtyOne: CardGame<ThirtyOneRules, ThirtyOneState, Move>;
+export {};