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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mikey Nichols
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/backgammon.d.ts

@@ -0,0 +1,146 @@
+import type { BoardGame } from "./board.js";
+import { type BaseRules } from "./table.js";
+export interface BackgammonRules extends BaseRules {
+    /** A match to this many points; 0 is a single game. */
+    match: number;
+    /** The doubling cube is in play. */
+    cube: boolean;
+    /** In a match: no doubling in the first game after a player comes within a point of winning. */
+    crawford: boolean;
+    /** In a single game with the cube: gammons and backgammons only count once the cube has been turned. */
+    jacoby: boolean;
+    /** In a single game with the cube: a tied opening roll doubles the stakes (once). */
+    autoDoubles: boolean;
+    /** Where the checkers start: the standard position, or Nackgammon's (two more checkers back). */
+    start: "standard" | "nack";
+    /** A turn isn't over until its player says so, and can be taken back until then. */
+    confirm: boolean;
+    /** Tapping a checker that has only one place to go plays it at once. */
+    quick: boolean;
+}
+export declare const friendlyBackgammon: BackgammonRules;
+export declare const moneyBackgammon: BackgammonRules;
+export declare const match3Backgammon: BackgammonRules;
+export declare const match5Backgammon: BackgammonRules;
+export declare const match7Backgammon: BackgammonRules;
+export declare const nackgammon: BackgammonRules;
+/** One checker moved by one die, as the state remembers it (so it can be taken back). */
+export interface BackgammonStep {
+    seat: number;
+    /** Where from and where to, as places of `stacks`; `to` is null for a checker borne off. */
+    from: number;
+    to: number | null;
+    /** Which of the dice was used. */
+    die: number;
+    /** A blot was hit and sent to the bar. */
+    hit: boolean;
+}
+export interface BackgammonResult {
+    winner: number;
+    kind: "single" | "gammon" | "backgammon";
+    /** The other player turned down a double. */
+    dropped: boolean;
+    /** A gammon that didn't count: the Jacoby rule, and the cube was never turned. */
+    jacoby: boolean;
+    points: number;
+}
+export interface BackgammonState {
+    game: "backgammon";
+    rules: BackgammonRules;
+    seats: number;
+    rng: number;
+    /** Which game of the match, from 1. */
+    round: number;
+    /**
+     * Who is where: 26 places, each a pile of checkers from the bottom up. 1 to 24 are the points as
+     * the first seat counts them (it travels from 24 down to 1, the second seat from 1 up to 24); 25
+     * is the first seat's bar and 0 the second's. Checkers 0 to 14 are the first seat's, 15 to 29 the
+     * second's, and each keeps its number all game.
+     */
+    stacks: number[][];
+    /** The checkers each seat has borne off. */
+    home: number[][];
+    /**
+     * "opening": each rolls a die to see who starts. "roll": `turn` is to roll (or double first).
+     * "offer": `turn` has offered a double and the other seat must take or drop. "move": `turn` is
+     * playing its dice.
+     */
+    phase: "opening" | "roll" | "offer" | "move" | "scored" | "finished";
+    turn: number;
+    /** The opening roll: what each seat has thrown so far. */
+    opening: (number | null)[];
+    /** The dice on the table (four of them for a double), which have been played, and who threw each. */
+    dice: number[];
+    used: boolean[];
+    thrower: number[];
+    /** How many throws there have been, so the table knows when to tumble the dice. */
+    rolls: number;
+    /** The moves made so far this turn. */
+    steps: BackgammonStep[];
+    /** The turn before, for marking where it went. */
+    last: BackgammonStep[];
+    cube: {
+        value: number;
+        owner: number | null;
+        turned: boolean;
+    };
+    /** Tied opening rolls that have doubled the stakes this game. */
+    autos: number;
+    /** This is the Crawford game; and whether the match has had one. */
+    crawford: boolean;
+    crawfordDone: boolean;
+    /** Points won so far (in a single game, what it was won for). */
+    score: number[];
+    result: BackgammonResult | null;
+    ready: boolean[];
+    narration: string | null;
+}
+export type BackgammonMove = {
+    type: "roll";
+} | {
+    type: "move";
+    from: number;
+    to: number;
+} | {
+    type: "undo";
+} | {
+    type: "confirm";
+} | {
+    type: "double";
+} | {
+    type: "take";
+} | {
+    type: "drop";
+} | {
+    type: "next";
+};
+/** A step the seat to move may make now, as the table and `apply` name it. */
+export interface BackgammonOption {
+    /** Cells of the board. */
+    from: number;
+    to: number;
+    /** The die it uses (its place among the dice on the table). */
+    die: number;
+}
+/**
+ * What the player to move may do next: one checker by one die, each as the cell it leaves and the
+ * cell it lands in (the tray for a checker borne off). Two dice that would do the same thing are
+ * one option: the one that fits exactly is used, and failing that the bigger.
+ */
+export declare function backgammonSteps(s: BackgammonState): BackgammonOption[];
+/** A whole turn as the player to move could play it: each step as cells, and how many of them hit. */
+export interface BackgammonTurn {
+    steps: {
+        from: number;
+        to: number;
+        die: number;
+    }[];
+}
+/** Every whole turn the player to move could play with the dice still to play: one for each position it could leave. */
+export declare function backgammonTurns(s: BackgammonState): BackgammonTurn[];
+/** How far a seat still has to go: every checker's distance to being off, added up. */
+export declare function backgammonPips(s: Pick<BackgammonState, "stacks" | "home">, seat: number): number;
+export declare function newBackgammon(rules: BackgammonRules, _seats: number, seed: number): BackgammonState;
+/** How much looking the computer players have done so far: for measuring what a move costs. */
+export declare const backgammonWork: () => number;
+export declare const backgammon: BoardGame<BackgammonRules, BackgammonState, BackgammonMove>;