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

package/dist/yacht.d.ts

@@ -0,0 +1,96 @@
+import type { BoardGame } from "./board.js";
+import { type Tally } from "./drinks.js";
+import { type BaseRules } from "./table.js";
+export interface YachtRules extends BaseRules {
+    /** Which scorecard. */
+    sheet: "classic" | "yatzy" | "quick";
+    /**
+     * Extra Yachts (Classic and Quick): once the Yacht box is filled, another five of a kind is a
+     * joker, and worth a bonus of 100 if the box was filled with 50.
+     */
+    bonus: boolean;
+    /** Who rolls when: one player at a time, or everyone at once with dice of their own. */
+    order: "turns" | "together";
+    /** Drinking mode: the table is Shotzee. */
+    drinking: boolean;
+}
+export declare const classicYacht: YachtRules;
+export declare const yatzyYacht: YachtRules;
+export declare const quickYacht: YachtRules;
+export declare const shotzee: YachtRules;
+export declare const YACHT_DICE = 5;
+export declare const YACHT_ROLLS = 3;
+/** What an extra Yacht is worth, when the Yacht box holds 50. */
+export declare const YACHT_BONUS = 100;
+/** The boxes of a sheet, in the order they are written down. */
+export declare const yachtBoxes: (rules: Pick<YachtRules, "sheet">) => readonly {
+    id: string;
+    label: string;
+    face?: number;
+}[];
+/** What five dice score in a box, by the plain rules of the sheet (no joker). */
+export declare function yachtScore(rules: Pick<YachtRules, "sheet">, box: string, dice: readonly number[]): number;
+/** Five dice in someone's hand: what they show (0 before the first roll), and which are kept back. */
+export interface YachtHand {
+    dice: number[];
+    held: boolean[];
+    /** Rolls made this turn: 0 to 3. At 0 the dice are whatever was scored last. */
+    rolls: number;
+    /** Every throw of these dice since the game began: what the table watches to know they were thrown. */
+    throws: number;
+    /** Everyone at once: this seat has scored this round and is waiting for the others. */
+    done: boolean;
+}
+export interface YachtState {
+    game: "yacht";
+    rules: YachtRules;
+    seats: number;
+    rng: number;
+    /** Which round, from 1: there is one for every box on the sheet. */
+    round: number;
+    /** In turn: who rolls first each round, and whose turn it is. */
+    first: number;
+    turn: number;
+    /** In turn, one set of dice that goes round the table; everyone at once, a set per seat. */
+    hands: YachtHand[];
+    /** Per seat, a score for each box of the sheet, or null while it is empty. */
+    sheets: (number | null)[][];
+    /** Extra Yachts that earned the bonus, per seat. */
+    extra: number[];
+    tally: Tally;
+    /** The box filled in last. */
+    last: {
+        seat: number;
+        box: number;
+    } | null;
+    phase: "playing" | "finished";
+    narration: string | null;
+}
+export type YachtMove = {
+    type: "roll";
+} | {
+    type: "hold";
+    die: number;
+} | {
+    type: "score";
+    cell: string;
+};
+export declare function newYacht(rules: YachtRules, seats: number, seed: number): YachtState;
+/** A seat's total: every box, the top half's bonus, and the extra Yachts. */
+export declare function yachtTotal(s: YachtState, seat: number): number;
+/** The boxes a seat can score in now, by id, with what each would give. Empty until it has rolled. */
+export declare function yachtOptions(s: YachtState, seat: number): {
+    box: string;
+    score: number;
+}[];
+export interface YachtPlan {
+    /** Score now, in this box… */
+    box: string | null;
+    /** …or roll again, keeping this many of each face (`keep[3]` threes). */
+    keep: number[] | null;
+    /** What the turn is expected to be worth from here, in the computer player's own terms. */
+    value: number;
+}
+/** What the sharpest player would do with a seat's dice now: the box to score, or the dice to keep and roll again. */
+export declare function yachtPlan(s: YachtState, seat: number): YachtPlan | null;
+export declare const yacht: BoardGame<YachtRules, YachtState, YachtMove>;