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

package/dist/minigolf.d.ts

@@ -0,0 +1,104 @@
+import { type Point } from "@journey-to-code/physics";
+import { type GolfHole, type PlacedBall } from "./minigolfcourse.js";
+import { type ShotMove, type SportGame, type SportShot } from "./sport.js";
+import { type BaseRules } from "./table.js";
+export interface MiniGolfRules extends BaseRules {
+    /** Which course (see COURSES). */
+    course: string;
+    /** How many of its holes to play, from the first. */
+    holes: number;
+    /** In turn, or everyone at once. */
+    order: "turns" | "together";
+    /** Strokes allowed on a hole. Not in by then: pick up, and write down one more than this. */
+    limit: number;
+    /** Strokes added for a ball in the water or off the course. It is played again from where it was struck. */
+    penalty: number;
+    /** In turn: balls knock into each other. (Everyone at once, they never do.) */
+    collide: boolean;
+    /** A ball knocked into the cup by someone else's counts as holed. Off: it is put back where it lay. */
+    knockIn: boolean;
+}
+export declare const nineHoles: MiniGolfRules;
+export declare const nineTogether: MiniGolfRules;
+export declare const quickThree: MiniGolfRules;
+export declare const quickTogether: MiniGolfRules;
+/** The gentlest and hardest a ball may be struck. A putt of nothing would be a stroke that moves nothing. */
+export declare const MIN_POWER = 20;
+export declare const MAX_POWER = 1000;
+export interface GolfBall {
+    x: number;
+    y: number;
+    /** Strokes on this hole so far, penalties included. */
+    strokes: number;
+    /** Has left the tee on this hole. */
+    teed: boolean;
+    done: "holed" | "pickup" | null;
+}
+export interface MiniGolfState {
+    game: "minigolf";
+    rules: MiniGolfRules;
+    seats: number;
+    rng: number;
+    /** The physics that plays this table's shots. */
+    physics: number;
+    /** Which hole, from 0. */
+    hole: number;
+    /** Who tees off first on this hole. */
+    first: number;
+    /** In turn: whose shot it is. Everyone at once: always null. */
+    turn: number | null;
+    balls: GolfBall[];
+    /** What each seat wrote down for each hole: card[seat][hole]; null until the hole is finished. */
+    card: (number | null)[][];
+    /** Shots taken in the whole round. */
+    shots: number;
+    /** Each seat's last shot on this hole. */
+    lasts: (SportShot | null)[];
+    phase: "playing" | "holed" | "finished";
+    ready: boolean[];
+    narration: string | null;
+}
+export type MiniGolfMove = ShotMove | {
+    type: "next";
+};
+export declare const ballId: (seat: number) => string;
+/** Whether this table's balls knock into each other: in turn, unless the house says no. */
+export declare const ballsCollide: (rules: MiniGolfRules) => boolean;
+/** A ball lying this close to the tee (centre to centre) is lifted while someone tees off. */
+export declare const TEE_CLEAR: number;
+export declare function newMiniGolf(rules: MiniGolfRules, seats: number, seed: number): MiniGolfState;
+/** What golfers call a score on a hole. */
+export declare function scoreName(strokes: number, par: number): string;
+interface Field {
+    x: number;
+    y: number;
+    cols: number;
+    rows: number;
+    /** Distance to the cup along the green from each cell, in world units; Infinity where no ball can be. */
+    dist: Float64Array;
+    /** The pieces of the hole's ledges. */
+    ledges: [Point, Point][];
+}
+/** How far each spot on a hole is from the cup by the shortest way a ball could roll there. */
+export declare function greenDistances(h: GolfHole): Field;
+/** How far a ball lying here is from the cup, along the green. */
+export declare function distanceToCup(h: GolfHole, x: number, y: number): number;
+export interface Putt {
+    angle: number;
+    power: number;
+    /** What the search made of it: under zero means it expects to hole out. */
+    score: number;
+    /** How many putts were simulated to find it. */
+    tried: number;
+}
+/**
+ * The best putt from here that a search can find: what a player with a perfect stroke would hit.
+ * The work is bounded (at most 286 simulated putts) and remembered, since a table asks more than once.
+ * `others` are the balls lying on the hole that this one can knock into.
+ */
+export declare function bestPutt(h: GolfHole, x: number, y: number, penalty?: number, others?: PlacedBall[]): Putt;
+/** The most a computer player's aim (hundredths of a degree) and strength (a share of it) can be off: at full skill, and how much more at none. */
+export declare const AIM_SLIP: readonly [300, 1100];
+export declare const POWER_SLIP: readonly [0.2, 0.45];
+export declare const miniGolf: SportGame<MiniGolfRules, MiniGolfState, MiniGolfMove>;
+export {};