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

package/dist/board.d.ts

@@ -0,0 +1,387 @@
+import type { BaseRules, BoardGameId, Choices, GameOver, RoundResult, Scores, ScoreSheet, TableGame } from "./table.js";
+/** The colours a piece or a cell mark can take; the table decides what each looks like. */
+export type BoardTone = "light" | "dark" | "red" | "blue" | "gold" | "green";
+/** A piece on a cell or in a reserve. */
+export interface BoardPiece {
+    /** Whose it is (a seat), or null for something that is nobody's: a blocked cell, a hit, a miss. */
+    owner: number | null;
+    /** What it is, in the game's own words: "x", "man", "king", "pawn", "stone", "ship", "hit". */
+    kind: string;
+    /** What is drawn: "✕", "◯", "♛", "●". */
+    glyph: string;
+    /** What a screen reader says: "X", "white queen", "red king". */
+    label: string;
+    /** Its colour, when it isn't simply its owner's (seat 0 is the first tone, seat 1 the second…). */
+    tone?: BoardTone;
+    /**
+     * The same piece keeps the same id from move to move, so the table can slide it to where it went.
+     * Games where pieces never move (Tic-Tac-Toe) don't need one.
+     */
+    id?: string;
+    /** Drawn faintly: a piece just taken, a ship that has sunk. */
+    faded?: boolean;
+    /**
+     * A piece that covers several cells (a ship) is one of these per cell, all with the same `span`:
+     * the table joins them into one shape, and picking up any cell of it picks up the whole piece.
+     */
+    span?: string;
+    /**
+     * A stack: this many identical pieces on the one cell (backgammon's checkers on a point, stones in
+     * a pit). Left out for a piece on its own.
+     */
+    count?: number;
+    /**
+     * With `count`: an id for each piece in the stack, from the bottom up, so the table can follow the
+     * one that moves from stack to stack. (`id` is for a piece that is alone on its cell.)
+     */
+    ids?: string[];
+}
+/**
+ * A grid whose cells are places on a track and not squares of a field: pieces travel along it, any
+ * number can share a place (`count` on the piece), and some cells are places beside the track. It
+ * says what the board is, never how it is drawn; `rows` and `cols` still give a plain picture of it
+ * (backgammon is two rows of twelve points with the bar between and a tray at the end), and that is
+ * all a table that knows nothing about tracks needs.
+ */
+export interface BoardTrack {
+    /** What the places are: "points" are backgammon's long triangles. */
+    kind: "points";
+    /**
+     * The cells of the track in the order the first seat's pieces travel them, from the farthest from
+     * home to the last. The second seat travels them the other way. A table counts the places from
+     * whichever end the viewer is heading for ("your 6 point").
+     */
+    path: number[];
+    /** Where each seat's pieces wait once they've been knocked off the track, until they come back on: a cell per seat. */
+    bar?: number[];
+    /** Where each seat's pieces go when they have finished (borne off): a cell per seat. */
+    home?: number[];
+}
+/** How a cell is shaded, when it isn't plain: the two colours of a chessboard, water, a marked spot. */
+export type CellShade = "plain" | "light" | "dark" | "water" | "spot";
+/** Why a cell is highlighted. Several can apply to one cell. */
+export type CellMark = 
+/** Where the last move landed. */
+"last"
+/** Where the last move came from. */
+ | "from"
+/** Part of the winning line. */
+ | "win"
+/** In danger: a king in check, a ship just hit. */
+ | "threat"
+/** A piece that changed sides on the last move: a disc turned over in Reversi. */
+ | "flipped"
+/** A place you could move to, in a game that points them out. Only ever sent to the seat that can. */
+ | "hint"
+/** Has to move: a piece that must capture in checkers. */
+ | "must"
+/** Can't be played on just now, though it is empty: the ko point in Go. */
+ | "barred"
+/** Counted as a side's own at the end: territory in Go. The mark says whose (`owner`). */
+ | "claimed";
+export interface BoardGrid {
+    /** Names this grid in a move when a view has more than one: "board", "mine", "theirs". */
+    id: string;
+    /** For screen readers, and shown above the grid when there are two: "Board", "Your fleet". */
+    label: string;
+    /** A private grid: whose it is. Left out for the board everyone shares. */
+    owner?: number;
+    rows: number;
+    cols: number;
+    /** Row by row from the top left, rows × cols of them; null is an empty cell. */
+    cells: (BoardPiece | null)[];
+    /** Cell colours: "checker" for a chessboard, or a shade for every cell. Plain when left out. */
+    shade?: "checker" | CellShade[];
+    /** The cells are places along a track, each holding a stack (backgammon): see `BoardTrack`. */
+    track?: BoardTrack;
+    /** Pieces sit where the lines cross instead of in the squares (Go, Gomoku). */
+    points?: boolean;
+    /** The board stands on its edge, and a piece put in a column falls to where it lands (a drop game's rack). */
+    gravity?: boolean;
+    /** Names for the columns and rows ("a"–"h", "8"–"1"), drawn round the edge and read out. */
+    coords?: {
+        cols: string[];
+        rows: string[];
+    };
+    /** What each cell is called, when a row and a column don't say it well ("centre", "top left"). */
+    names?: string[];
+    /**
+     * The grid is made of equal blocks with heavier lines between them (Ultimate Tic-Tac-Toe's nine
+     * small boards). `states` has one entry per block, row by row.
+     */
+    blocks?: {
+        rows: number;
+        cols: number;
+        states: {
+            /** Who has taken this block, drawn over it; null for nobody (a drawn block is `closed`). */
+            owner?: number | null;
+            glyph?: string;
+            label?: string;
+            /** Where the next move has to go. */
+            active?: boolean;
+            /** Finished: nothing more can be played here. */
+            closed?: boolean;
+        }[];
+    };
+    /** `owner` is the seat a "claimed" cell belongs to. */
+    marks?: {
+        cell: number;
+        mark: CellMark;
+        owner?: number;
+    }[];
+    /**
+     * Draw the board turned half way round, so the last row is at the top and this seat's own pieces
+     * are nearest them (the second player in checkers or chess). Only the drawing turns: cells keep
+     * their numbers and their names. "rows" turns it over instead of round: the last row is at the top
+     * but left stays left, so both players of a track game run the same way across the screen and each
+     * has their home on the same hand (backgammon).
+     */
+    flip?: boolean | "rows";
+    /**
+     * Cells you can tap now. Tapping one sends { type, cell } (plus `grid` when the view has more
+     * than one). With `by: "col"` the whole column is the target and the move is { type, col }
+     * (a drop game: any cell of the column drops a piece into it).
+     */
+    tap?: {
+        type: string;
+        cells: number[];
+        by?: "cell" | "col";
+    } | null;
+    /**
+     * Things you can pick up now, and where each can go: `from` is a cell of this grid, or the
+     * `kind` of a piece in your reserve. Choosing one and then a destination sends { type, from, to }.
+     * `held` is a source that is already in hand (a checkers piece in the middle of a run of jumps):
+     * the table shows it picked up without being asked. `suggest` is a source the table picks up
+     * for you while you hold nothing else (the next ship to place), so one tap puts it down.
+     * With `quick`, a source that has only one place to go is played by tapping it (a table setting
+     * in backgammon); the table still shows where it went.
+     */
+    select?: {
+        type: string;
+        sources: {
+            from: number | string;
+            to: number[];
+        }[];
+        held?: number | string;
+        suggest?: number | string;
+        /**
+         * Moves that need one more thing said (what a pawn becomes on the far row): putting `from` down
+         * on `to` asks which of `options`, in a small chooser on that cell, the first being the usual
+         * one, and sends { type, from, to, [key]: the chosen piece's kind }.
+         */
+        choose?: {
+            from: number | string;
+            to: number;
+            key: string;
+            options: BoardPiece[];
+        }[];
+        /** Don't point out where a picked-up piece can go: the table lets it be put down anywhere and the engine says no. */
+        quiet?: boolean;
+        /** One tap moves (a table setting): a piece with one place to go is played by tapping it. */
+        quick?: boolean;
+    } | null;
+}
+/** Pieces off the board, per side: captured pieces, stones or discs left, ships still to place. */
+export interface BoardReserve {
+    owner: number;
+    /** "Captured", "Left to place". */
+    label: string;
+    pieces: {
+        piece: BoardPiece;
+        count: number;
+    }[];
+}
+/** One die on the table. `value` is null before it has been rolled. */
+export interface BoardDie {
+    /** The same die keeps the same id from throw to throw. */
+    id: number;
+    value: number | null;
+    /** Kept back from the next throw. */
+    held?: boolean;
+    /** Played already, or left over from the turn before: drawn dimmed. */
+    used?: boolean;
+    /** Whose die it is, when the dice on the table aren't all one player's. */
+    owner?: number | null;
+}
+/**
+ * The dice a seat sees. `roll` goes up by one with every throw, so the table knows to tumble them
+ * (the dice that aren't `held` are the ones that were thrown). `tap`, when set, makes each listed
+ * die a button that sends `{ type, die: id }` (hold or release a die).
+ */
+export interface BoardDice {
+    dice: BoardDie[];
+    roll: number;
+    /** How many faces a die has: six when left out. */
+    sides?: number;
+    tap?: {
+        type: string;
+        dice: number[];
+    } | null;
+    /**
+     * Dice only one seat can see (everyone rolling at once, each with their own): whose they are.
+     * Left out for dice the whole table sees. Like a private grid, they are only ever sent to that
+     * seat, and someone watching is shown none.
+     */
+    owner?: number;
+}
+/**
+ * A doubling cube: what the game is being played for, and who may turn it next. The table decides
+ * where it sits (in the middle while it is nobody's, on its owner's side after).
+ */
+export interface BoardCube {
+    /** What the game is worth now: 1 until it has been turned, then 2, 4, 8… */
+    value: number;
+    /** Whose side it is on (only they may double next), or null while it is in the middle. */
+    owner: number | null;
+    /** A double on offer, waiting to be taken or dropped: who offered it. `value` is still the old one. */
+    offered: number | null;
+    /** Out of play for this game (the Crawford game of a match): nobody may double. */
+    dead: boolean;
+}
+export interface BoardSeat {
+    /** A short line under the name: "2 wins", "12 discs". */
+    line: string;
+    /** What this seat plays as, shown beside the name (an X, a black stone). */
+    piece?: BoardPiece;
+    /** Partners: 0 or 1 (seats 0 and 2 are team 0). */
+    team?: 0 | 1;
+    /** Out of the game, or sitting this round out. */
+    out?: boolean;
+    /** A small badge: "Check", "Goes first". */
+    badge?: string;
+    /**
+     * This seat's clock, in a game that has one of its own (a chess clock): the time it had left
+     * when the last move was made, and whether it is the one running down now. The table counts
+     * the running one down from the time of that move.
+     */
+    clock?: {
+        ms: number;
+        running: boolean;
+    };
+}
+/** One piece going from a cell to another in a recorded move. Null for off the board: taken (`to`), or put on (`from`). */
+export interface BoardChange {
+    /** The piece's `id`. */
+    id: string;
+    from: number | null;
+    to: number | null;
+    /** The piece as it was before the move, when it left the board or changed (a pawn that was promoted). */
+    was?: BoardPiece;
+}
+/** A move in the game's record, in the game's own notation, with enough to put the board back as it was before it. */
+export interface BoardRecordMove {
+    /** "Nf3", "exd5", "O-O". */
+    label: string;
+    by: number;
+    /** The number it is written under: "1." for both White's first move and Black's. */
+    turn: number;
+    /** What moved, in the order it happened; the piece that made the move is last. */
+    changes: BoardChange[];
+    /** A cell left in danger by it: the king it checks. */
+    threat?: number;
+}
+/**
+ * The game so far, move by move, for a game that keeps a record (Chess): the table lists it, and
+ * steps back and forward through it on the first grid by undoing `changes`.
+ */
+export interface BoardRecord {
+    moves: BoardRecordMove[];
+    /** The whole record as text to copy: a PGN. Seats are named {0}, {1} as everywhere. */
+    export?: {
+        label: string;
+        text: string;
+    };
+}
+/** What a player can do besides move: give the game up, or ask the other player for something. */
+export type OfferKind = "resign" | "draw" | "takeback";
+/**
+ * Offers at a two-player board (see offers.ts): what is open, and what this seat may do about it.
+ * It is data, the same for every game, and the table says it in its own words. The moves are
+ * always the same four, and `offerMoves` lists the ones a view allows.
+ */
+export interface BoardOffers {
+    /** What this seat may send now: { type: "resign" }, or { type: "offer", offer: "draw" | "takeback" }. */
+    can: OfferKind[];
+    /** The offer waiting for an answer, and who made it. Everyone at the table sees this. */
+    open: {
+        kind: "draw" | "takeback";
+        by: number;
+    } | null;
+    /** It is this seat's to answer, with { type: "accept" } or { type: "decline" }. */
+    answer: boolean;
+    /**
+     * The last thing that happened with an offer, until play has moved on past it. "lapsed" is an
+     * offer that was played through instead of answered.
+     */
+    last: {
+        kind: OfferKind;
+        by: number;
+        outcome: "offered" | "accepted" | "declined" | "lapsed";
+    } | null;
+}
+export interface BoardView {
+    game: BoardGameId;
+    seats: number;
+    me: number;
+    teams: boolean;
+    phase: string;
+    /** Whose move it is, or null when everyone may move (both placing their ships, say). */
+    turn: number | null;
+    /** The boards, the main one first. A second is drawn smaller beside or under it. None for a game of dice and a sheet. */
+    grids: BoardGrid[];
+    reserves: BoardReserve[];
+    /** The dice on the table, for a game that has them. */
+    dice?: BoardDice | null;
+    /** The doubling cube, for a game that has one in play (backgammon). */
+    cube?: BoardCube | null;
+    /** A score sheet, for a game that is scored on one (Yacht's scorecard). */
+    sheet?: ScoreSheet | null;
+    /** Buttons: "Pass", "Offer a draw", a promotion, "Next game". */
+    choices: Choices | null;
+    players: BoardSeat[];
+    /** Small facts for the table: "Four in a row wins", "Game 2 of 3". */
+    info: string[];
+    /** What just happened, in words. */
+    narration: string | null;
+    scores: Scores;
+    /** After a round of a longer match, until everyone moves on. */
+    result: RoundResult | null;
+    /** `winners` is every seat when it's a draw. */
+    over: GameOver | null;
+    /** Resigning, draw offers and taking moves back, in a game that has them. */
+    offers?: BoardOffers;
+    /** The moves so far in notation, in a game that keeps a record. */
+    record?: BoardRecord;
+}
+/** A board game: an engine whose seats see a `BoardView`. */
+export interface BoardGame<R extends BaseRules = BaseRules, S = unknown, M = Record<string, unknown>> extends TableGame<R, S, M, BoardView> {
+    id: BoardGameId;
+}
+export declare const cellAt: (cols: number, row: number, col: number) => number;
+export declare const rowOf: (cols: number, cell: number) => number;
+export declare const colOf: (cols: number, cell: number) => number;
+/** The eight directions as [row, col] steps; the first four are enough to find lines through a cell. */
+export declare const DIRECTIONS: readonly (readonly [number, number])[];
+/** "a", "b", … for columns and "1", "2", … for rows counted from the bottom, as on a chessboard. */
+export declare function chessCoords(rows: number, cols: number): {
+    cols: string[];
+    rows: string[];
+};
+/** What a cell is called: its own name if the grid gives one, "b2" with coordinates, else "row 2, column 2". */
+export declare function cellName(grid: Pick<BoardGrid, "cols" | "coords" | "names">, cell: number): string;
+/**
+ * The longest unbroken line through `cell` of cells that `same` accepts, when it is at least
+ * `need` long: the cells of the line, or null. For every N-in-a-row game.
+ */
+export declare function lineThrough(rows: number, cols: number, cell: number, need: number, same: (cell: number) => boolean): number[] | null;
+/**
+ * A grid's cells as they stood after the first `count` moves of the record, worked back from how
+ * they stand now by undoing the moves since. Pieces keep their ids, so a table can slide them back.
+ */
+export declare function cellsAfter(cells: readonly (BoardPiece | null)[], record: BoardRecord, count: number): (BoardPiece | null)[];
+/**
+ * Everything a seat can send from a view, as moves: every tappable cell, every piece and each
+ * place it can go, every cell of the sheet it can choose, every die it can tap, every button. The table sends exactly these, and the shared tests check an
+ * engine accepts each one it offers.
+ */
+export declare function movesOffered(view: BoardView): Record<string, unknown>[];

package/dist/board.js

@@ -0,0 +1,105 @@
+// ---- Helpers for engines ------------------------------------------------------------------------
+export const cellAt = (cols, row, col) => row * cols + col;
+export const rowOf = (cols, cell) => Math.floor(cell / cols);
+export const colOf = (cols, cell) => cell % cols;
+/** The eight directions as [row, col] steps; the first four are enough to find lines through a cell. */
+export const DIRECTIONS = [[0, 1], [1, 0], [1, 1], [1, -1], [0, -1], [-1, 0], [-1, -1], [-1, 1]];
+/** "a", "b", … for columns and "1", "2", … for rows counted from the bottom, as on a chessboard. */
+export function chessCoords(rows, cols) {
+    return { cols: Array.from({ length: cols }, (_, c) => String.fromCharCode(97 + c)), rows: Array.from({ length: rows }, (_, r) => String(rows - r)) };
+}
+/** What a cell is called: its own name if the grid gives one, "b2" with coordinates, else "row 2, column 2". */
+export function cellName(grid, cell) {
+    if (grid.names?.[cell])
+        return grid.names[cell];
+    const r = rowOf(grid.cols, cell);
+    const c = colOf(grid.cols, cell);
+    return grid.coords ? `${grid.coords.cols[c] ?? c + 1}${grid.coords.rows[r] ?? r + 1}` : `row ${r + 1}, column ${c + 1}`;
+}
+/**
+ * The longest unbroken line through `cell` of cells that `same` accepts, when it is at least
+ * `need` long: the cells of the line, or null. For every N-in-a-row game.
+ */
+export function lineThrough(rows, cols, cell, need, same) {
+    const r0 = rowOf(cols, cell);
+    const c0 = colOf(cols, cell);
+    let best = null;
+    for (const [dr, dc] of DIRECTIONS.slice(0, 4)) {
+        const line = [cell];
+        for (const sign of [1, -1]) {
+            for (let r = r0 + dr * sign, c = c0 + dc * sign; r >= 0 && r < rows && c >= 0 && c < cols && same(cellAt(cols, r, c)); r += dr * sign, c += dc * sign) {
+                if (sign === 1)
+                    line.push(cellAt(cols, r, c));
+                else
+                    line.unshift(cellAt(cols, r, c));
+            }
+        }
+        if (line.length >= need && (!best || line.length > best.length))
+            best = line;
+    }
+    return best;
+}
+/**
+ * A grid's cells as they stood after the first `count` moves of the record, worked back from how
+ * they stand now by undoing the moves since. Pieces keep their ids, so a table can slide them back.
+ */
+export function cellsAfter(cells, record, count) {
+    const out = cells.slice();
+    for (let i = record.moves.length - 1; i >= Math.max(0, count); i--) {
+        const changes = record.moves[i].changes;
+        // Everything that moved is lifted before anything is put back: in a castling move one piece
+        // may have landed where the other stood.
+        const lifted = new Map();
+        for (const c of changes) {
+            if (c.to === null || out[c.to]?.id !== c.id)
+                continue;
+            lifted.set(c.id, out[c.to]);
+            out[c.to] = null;
+        }
+        for (const c of changes) {
+            const piece = c.was ?? lifted.get(c.id);
+            if (c.from !== null && piece)
+                out[c.from] = piece;
+        }
+    }
+    return out;
+}
+/**
+ * Everything a seat can send from a view, as moves: every tappable cell, every piece and each
+ * place it can go, every cell of the sheet it can choose, every die it can tap, every button. The table sends exactly these, and the shared tests check an
+ * engine accepts each one it offers.
+ */
+export function movesOffered(view) {
+    const out = [];
+    const many = view.grids.length > 1;
+    for (const g of view.grids) {
+        const grid = many ? { grid: g.id } : {};
+        if (g.tap) {
+            if (g.tap.by === "col")
+                for (const col of new Set(g.tap.cells.map((c) => colOf(g.cols, c))))
+                    out.push({ type: g.tap.type, col, ...grid });
+            else
+                for (const cell of g.tap.cells)
+                    out.push({ type: g.tap.type, cell, ...grid });
+        }
+        for (const s of g.select?.sources ?? []) {
+            for (const to of s.to) {
+                // A move that asks a question first is one move for each answer.
+                const ask = g.select.choose?.find((c) => c.from === s.from && c.to === to);
+                if (ask)
+                    for (const option of ask.options)
+                        out.push({ type: g.select.type, from: s.from, to, [ask.key]: option.kind, ...grid });
+                else
+                    out.push({ type: g.select.type, from: s.from, to, ...grid });
+            }
+        }
+    }
+    for (const c of view.sheet?.pick?.cells ?? [])
+        out.push({ type: view.sheet.pick.type, cell: view.sheet.columns[c.column]?.id });
+    for (const die of view.dice?.tap?.dice ?? [])
+        out.push({ type: view.dice.tap.type, die });
+    for (const o of view.choices?.options ?? [])
+        out.push(o.move);
+    return out;
+}
+//# sourceMappingURL=board.js.map

package/dist/board.js.map

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

package/dist/bridge.d.ts

@@ -0,0 +1,86 @@
+import { type BaseRules, type CardGame, type KCard } from "./kit.js";
+import { type Play } from "./tricks.js";
+export interface BridgeRules extends BaseRules {
+    /** Rounds of four deals. */
+    chukkers: number;
+}
+export declare const chicagoBridge: BridgeRules;
+export declare const longBridge: BridgeRules;
+export type Strain = "clubs" | "diamonds" | "hearts" | "spades" | "nt";
+export interface Contract {
+    level: number;
+    strain: Strain;
+}
+export type Call = {
+    type: "bid";
+    level: number;
+    strain: Strain;
+} | {
+    type: "pass";
+} | {
+    type: "double";
+} | {
+    type: "redouble";
+};
+export interface BridgeState {
+    game: "bridge";
+    rules: BridgeRules;
+    seats: 4;
+    rng: number;
+    /** Deals played so far. */
+    hand: number;
+    dealer: number;
+    phase: "bidding" | "playing" | "scored" | "finished";
+    hands: KCard[][];
+    auction: {
+        seat: number;
+        call: Call;
+    }[];
+    contract: (Contract & {
+        by: number;
+        doubled: 0 | 1 | 2;
+    }) | null;
+    declarer: number | null;
+    trick: Play[];
+    lastTrick: {
+        plays: Play[];
+        winner: number;
+    } | null;
+    turn: number;
+    tricksWon: number[];
+    scores: [number, number];
+    lastHand: {
+        contract: (Contract & {
+            doubled: 0 | 1 | 2;
+        }) | null;
+        declarer: number | null;
+        tricks: [number, number];
+        points: [number, number];
+        made: boolean;
+    } | null;
+    ready: boolean[];
+    narration: string | null;
+}
+export declare const strainName: (s: Strain) => string;
+export declare const contractName: (c: Contract & {
+    doubled?: number;
+}) => string;
+/** Chicago vulnerability: none, dealer's side, dealer's side, both. */
+export declare function vulnerable(s: BridgeState, team: 0 | 1): boolean;
+export declare function newBridge(rules: BridgeRules, _seats: number, seed: number): BridgeState;
+/** The calls this seat may make: pass, a higher bid, double their bid, redouble our doubled bid. */
+export declare function callsFor(s: BridgeState, seat: number): Call[];
+export declare function bridgeLegal(s: BridgeState, seat: number): KCard[];
+type Move = Call | {
+    type: "play";
+    card: string;
+} | {
+    type: "next";
+};
+/** Points for the declaring side (positive) or the defenders (negative), Chicago style. */
+export declare function bridgeScore(c: Contract & {
+    doubled: 0 | 1 | 2;
+}, tricks: number, vul: boolean): number;
+export declare const hcp: (hand: KCard[]) => number;
+export declare const bridge: CardGame<BridgeRules, BridgeState, Move>;
+export {};