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

package/dist/sport.d.ts

@@ -0,0 +1,266 @@
+import type { Body, Point, Shape, Shot, World } from "@journey-to-code/physics";
+import type { BaseRules, Choices, GameOver, RoundResult, Scores, ScoreSheet, SportGameId, TableGame } from "./table.js";
+/**
+ * Lengths in a sport's world are tenths of a millimetre, as in the physics core's examples, so a
+ * table can say "1.2 m from the cup" to someone who can't see it.
+ */
+export declare const UNITS_PER_METRE = 10000;
+/** What a patch of the table is, for drawing: the table screen decides what each looks like. */
+export type SportSurface = "green" | "rough" | "sand" | "water" | "slope" | "felt" | "wood" | "lane" | "lawn" | "gravel" | "paving" | "soil" | "deck";
+/** What a rail, a block or a ledge is made of. */
+export type SportMaterial = "timber" | "brick" | "stone";
+/** A patch of ground: scenery round the table or the surface that is played on. */
+export interface SportGround {
+    shape: Shape;
+    surface: SportSurface;
+    /**
+     * How far above the ground round the table this patch stands (a terrace, a raised bed), in world
+     * units. Left out: it lies on whatever was laid under it, and if it is water or sand, the
+     * screen may sink it a little.
+     */
+    level?: number;
+}
+/**
+ * A wall of the world that is a rail: a border with thickness, standing beside the line a ball
+ * stops at. `side` is where the rail's body lies as you walk along the wall's points (with y down
+ * the screen): to the left of the line, to the right, or astride it.
+ */
+export interface SportRail {
+    wall: string;
+    material: SportMaterial;
+    side: "left" | "right" | "both";
+    /** Across, and how high it stands, in world units. */
+    width: number;
+    height: number;
+}
+/** A closed wall of the world that is a solid thing standing on the table. */
+export interface SportBlock {
+    wall: string;
+    kind: "rock" | "brick" | "timber" | "planter" | "pot" | "stone" | "castle" | "crate";
+    /** How high it stands, in world units. */
+    height: number;
+}
+/** A one-way wall of the world that is a step down: the ground on its open side is `drop` higher. */
+export interface SportLedge {
+    wall: string;
+    drop: number;
+    material: SportMaterial;
+}
+/** A tunnel of the world: what it is, and where its pipe runs if any of it shows. */
+export interface SportTunnel {
+    id: string;
+    /** A pipe with open ends, a garden hose, or a burrow: a hole in the ground and a mound where it comes up. */
+    kind: "pipe" | "hose" | "burrow";
+    /** The way a ball rolls into the mouth, in hundredths of a degree: which way the opening faces. */
+    enter: number;
+    /** Where the pipe can be seen lying between its two ends. Left out when it runs underground or through something. */
+    path?: Point[];
+    /** Where the far opening is, when that isn't quite where the ball is let go (a pipe's end set in a rock face). */
+    out?: Point;
+}
+/** The colours a ball can take. */
+export type SportTone = "white" | "red" | "blue" | "gold" | "green" | "purple" | "orange" | "pink" | "maroon" | "black";
+/** How one body is drawn and who it belongs to. Bodies without an entry are drawn plain. */
+export interface SportBody {
+    /** The body's id in the world (or a ghost's own id). */
+    id: string;
+    /** Whose it is (a seat), or null for something that is nobody's: an object ball, a pin, a bumper. */
+    owner: number | null;
+    /** What it is, in the game's own words: "ball", "cue", "striker", "pin", "toadstool". */
+    kind: string;
+    tone: SportTone;
+    /** What a screen reader says: "your ball", "the 8 ball". */
+    label: string;
+    /** Drawn on it: a pool ball's number, a player's initial. */
+    mark?: string;
+    /** A striped pool ball. */
+    striped?: boolean;
+    /** How high it stands, in world units, for something that isn't a ball. */
+    height?: number;
+}
+/**
+ * Something drawn on the table that the physics of this view knows nothing about: in mini golf
+ * played all at once, the other players' balls (which never collide with yours), and in turn, a
+ * ball lifted out of the way of the one about to be struck. It can't be struck or hit.
+ */
+export interface SportGhost extends SportBody {
+    x: number;
+    y: number;
+    r: number;
+}
+/** Scenery, in world units. None of it touches the ball. */
+export interface SportDecor {
+    kind: "tee" | "flag" | "bush" | "flowers" | "rock" | "tree" | "gnome" | "flowerpot" | "wateringcan" | "wheelbarrow" | "steppingstone" | "lilypad" | "fish" | "reeds" | "duck" | "bucket" | "spade" | "bricks" | "bench" | "birdbath" | "molehill" | "poolring" | "doormat" | "hosereel" | "plank" | "shell";
+    x: number;
+    y: number;
+    /** Size, for the things that have one. */
+    r?: number;
+    /** Which way it faces, in hundredths of a degree (0 along +x), for the things that face a way. */
+    angle?: number;
+    /** A length, for the things that are longer than they are wide (a plank, a bench). */
+    length?: number;
+    /** How high it stands, in world units. Left out: as high as such a thing usually is. */
+    height?: number;
+    tone?: SportTone;
+}
+/** How the world is drawn. The world says where things are; this says what they are. */
+export interface SportLook {
+    /** The rectangle the screen fits and centres: the table and a margin round it. */
+    frame: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    /** What lies under and around everything else, as far as the screen goes. */
+    base: SportSurface;
+    /** Patches of ground, laid in order: the scenery first, then what is played on (the green of a hole, the cloth of a pool table). */
+    ground: SportGround[];
+    /**
+     * What each region of the world is drawn as, in drawing order. A region left out is not drawn.
+     * `rise` is for a slope: how much higher its top is than its foot, in world units.
+     */
+    regions: {
+        id: string;
+        surface: SportSurface;
+        rise?: number;
+    }[];
+    /** The walls that are rails. A wall named nowhere in the look is not drawn. */
+    rails: SportRail[];
+    /** Closed walls that are solid things standing on the table (a rock, a planter). */
+    blocks: SportBlock[];
+    ledges: SportLedge[];
+    tunnels: SportTunnel[];
+    /** Pockets are drawn as golf cups (with a flag) or as the pockets of a pool table. */
+    pockets: "cup" | "pocket";
+    decor: SportDecor[];
+}
+/** What a seat may strike now. Later additions sit beside these: `place` for a ball in hand, `spin`. */
+export interface SportShoot {
+    /** The body to strike. */
+    body: string;
+    /** The power may be anything from here… */
+    minPower: number;
+    /** …to here (1000 is the world's full shot speed). */
+    maxPower: number;
+}
+/** Where one body stopped when the physics came to rest, before the game's rules moved anything. */
+export interface SportRest {
+    id: string;
+    x: number;
+    y: number;
+    pocketed?: string;
+    out?: string;
+}
+/**
+ * The shot just taken, enough for a browser to play it again: put `from` in place of the bodies
+ * of the view's world (see `worldBefore`), run the shot, and it ends at `rest`. After that the
+ * screen shows the view's world as it is, which is `rest` with the game's rules applied (in mini
+ * golf, a ball that went in the water is back where it was struck from).
+ */
+export interface SportShot {
+    /** Counts the shots of a game from 1, so each is animated once. */
+    n: number;
+    seat: number;
+    shot: Shot;
+    /** The bodies as they were when the shot was struck. */
+    from: Body[];
+    rest: SportRest[];
+    /** How many steps of the world's tick the shot took. */
+    ticks: number;
+    /** The PHYSICS_VERSION that played it. A browser on another version shows the result without stepping. */
+    physics: number;
+}
+/**
+ * A score sheet with a column per hole (or frame, or rack) and a row per player. It is the kit-wide
+ * `ScoreSheet` (table.ts), which the board kit uses too.
+ */
+export type SportCard = ScoreSheet;
+export interface SportSeat {
+    /** A short line under the name: "2 strokes", "Holed in 3". */
+    line: string;
+    /** What this seat plays with, shown beside the name. */
+    body?: SportBody;
+    /** Partners: 0 or 1 (seats 0 and 2 are team 0). */
+    team?: 0 | 1;
+    /** Finished with this table for now: holed out, or picked up. */
+    done?: boolean;
+    badge?: string;
+}
+export interface SportView {
+    game: SportGameId;
+    seats: number;
+    me: number;
+    teams: boolean;
+    phase: string;
+    /** Whose shot it is, or null when everyone may shoot (each at their own ball) or nobody may. */
+    turn: number | null;
+    table: {
+        /** Changes when the table is a different one (the next hole), so the screen fits it afresh. */
+        key: string;
+        /** "Hole 3: The Elbow". */
+        name: string;
+        /** The table at rest, as this seat's next shot would find it. */
+        world: World;
+        look: SportLook;
+        /** How the world's bodies are drawn, by id. */
+        bodies: SportBody[];
+        ghosts: SportGhost[];
+    };
+    /** What this seat may strike now, or null. */
+    shoot: SportShoot | null;
+    /** The last shot on this table that this seat should see played, or null. */
+    last: SportShot | null;
+    card: SportCard | null;
+    /** Buttons: "Next hole", "Rack them up". */
+    choices: Choices | null;
+    players: SportSeat[];
+    /** Small facts for the table: "Par 3", "Stroke 2". */
+    info: string[];
+    /** What just happened, in words. */
+    narration: string | null;
+    scores: Scores;
+    /** After a hole or a frame, until everyone moves on; and with `over`, the final summary. */
+    result: RoundResult | null;
+    /** `winners` is every seat when it's a tie. */
+    over: GameOver | null;
+}
+/** A table sport: an engine whose seats see a `SportView`, and whose moves are shots and buttons. */
+export interface SportGame<R extends BaseRules = BaseRules, S = unknown, M = Record<string, unknown>> extends TableGame<R, S, M, SportView> {
+    id: SportGameId;
+    /**
+     * Work worth doing once before the first table opens. A JavaScript engine runs the simulation
+     * slowly until it has seen it a few hundred times, and a game may keep maps of its tables; a
+     * server calls this as it starts, so the first shot of the day isn't the slow one.
+     */
+    warmUp?(): void;
+}
+/** A shot as a move. The numbers are the physics core's: whole, and checked again by the engine. */
+export interface ShotMove {
+    type: "shot";
+    body: string;
+    /** Whole hundredths of a degree, 0 to 35999. 0 is along +x, 9000 along +y (down the screen). */
+    angle: number;
+    /** A whole number within the view's `shoot` range. */
+    power: number;
+}
+/** The world as it was when the view's last shot was struck: what a browser simulates from. */
+export declare function worldBefore(view: Pick<SportView, "table" | "last">): World | null;
+/** Where the bodies of a resting world are, in the short form a view carries. */
+export declare function restOf(world: World): SportRest[];
+/** Whether a locally stepped world ended exactly where the server said it would. */
+export declare function sameRest(world: World, rest: SportRest[]): boolean;
+/** The angle (in the physics core's hundredths of a degree) from one point towards another. */
+export declare function angleTo(from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}): number;
+/**
+ * Some of what a seat can send from a view, as moves: every button, and when it may shoot, a
+ * spread of shots across the range it is offered. (There are 36 million shots; the shared tests
+ * play from these.)
+ */
+export declare function sportMovesOffered(view: SportView): Record<string, unknown>[];

package/dist/sport.js

@@ -0,0 +1,48 @@
+/**
+ * Lengths in a sport's world are tenths of a millimetre, as in the physics core's examples, so a
+ * table can say "1.2 m from the cup" to someone who can't see it.
+ */
+export const UNITS_PER_METRE = 10000;
+// ---- Helpers for engines, tables and tests ------------------------------------------------------
+/** The world as it was when the view's last shot was struck: what a browser simulates from. */
+export function worldBefore(view) {
+    return view.last ? { ...view.table.world, bodies: view.last.from } : null;
+}
+/** Where the bodies of a resting world are, in the short form a view carries. */
+export function restOf(world) {
+    return world.bodies.map((b) => ({ id: b.id, x: b.x, y: b.y, ...(b.pocketed !== undefined ? { pocketed: b.pocketed } : {}), ...(b.out !== undefined ? { out: b.out } : {}) }));
+}
+/** Whether a locally stepped world ended exactly where the server said it would. */
+export function sameRest(world, rest) {
+    if (world.bodies.length !== rest.length)
+        return false;
+    return world.bodies.every((b, i) => {
+        const r = rest[i];
+        return b.id === r.id && b.x === r.x && b.y === r.y && b.pocketed === r.pocketed && b.out === r.out;
+    });
+}
+/** The angle (in the physics core's hundredths of a degree) from one point towards another. */
+export function angleTo(from, to) {
+    // Aiming is free to use any maths: only the rounded whole number is ever sent or simulated.
+    const a = Math.round((Math.atan2(to.y - from.y, to.x - from.x) * 18000) / Math.PI);
+    return ((a % 36000) + 36000) % 36000;
+}
+/**
+ * Some of what a seat can send from a view, as moves: every button, and when it may shoot, a
+ * spread of shots across the range it is offered. (There are 36 million shots; the shared tests
+ * play from these.)
+ */
+export function sportMovesOffered(view) {
+    const out = [];
+    if (view.shoot) {
+        const { body, minPower, maxPower } = view.shoot;
+        const mid = Math.round((minPower + maxPower) / 2);
+        for (const angle of [0, 4500, 9000, 13500, 18000, 22500, 27000, 31500, 35999])
+            for (const power of [minPower, mid, maxPower])
+                out.push({ type: "shot", body, angle, power });
+    }
+    for (const o of view.choices?.options ?? [])
+        out.push(o.move);
+    return out;
+}
+//# sourceMappingURL=sport.js.map

package/dist/sport.js.map

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

package/dist/switch.d.ts

@@ -0,0 +1,69 @@
+import type { Suit } from "@journey-to-code/rules";
+import { type BaseRules, type CardGame, type KCard } from "./kit.js";
+export interface SwitchRules extends BaseRules {
+    /** Draw one and pass, or draw until you can play. */
+    draw: "until" | "one";
+    /** One hand (first out wins) or points: the winner scores what's left in everyone's hands. */
+    scoring: "single" | "points";
+    playTo: number;
+    /** You must call "Last card!" before going down to one card, or pick up two. */
+    lastCard: boolean;
+}
+export declare const classicSwitch: SwitchRules;
+export declare const pointsSwitch: SwitchRules;
+export declare const easySwitch: SwitchRules;
+type Phase = "playing" | "suit" | "scored" | "finished";
+export interface SwitchState {
+    game: "switch";
+    rules: SwitchRules;
+    seats: number;
+    rng: number;
+    hand: number;
+    dealer: number;
+    phase: Phase;
+    hands: KCard[][];
+    stock: KCard[];
+    discard: KCard[];
+    /** The suit to match: the top card's, or the one named with an eight. */
+    suit: Suit;
+    turn: number;
+    direction: 1 | -1;
+    /** Cards the next player must draw (from 2s). */
+    owed: number;
+    /** This turn's player has drawn (under draw-one they may then pass). */
+    drew: boolean;
+    /** Turns in a row where nobody could play or draw anything: a full round ends the hand. */
+    stuck: number;
+    /** How often the discards have been shuffled into a new stock this hand (at most twice). */
+    reshuffles: number;
+    /** Who has called "Last card!" (and still holds two or fewer). */
+    called: boolean[];
+    scores: number[];
+    lastHand: {
+        winner: number;
+        points: number;
+        left: number[];
+    } | null;
+    ready: boolean[];
+    narration: string | null;
+}
+export declare function newSwitch(rules: SwitchRules, seats: number, seed: number): SwitchState;
+/** Cards this seat may play now: matching suit or rank, or an ace. Facing twos, only another two. */
+export declare function switchLegal(s: SwitchState, seat: number): KCard[];
+type Move = {
+    type: "play";
+    card: string;
+} | {
+    type: "suit";
+    suit: Suit;
+} | {
+    type: "draw";
+} | {
+    type: "pass";
+} | {
+    type: "last";
+} | {
+    type: "next";
+};
+export declare const switchGame: CardGame<SwitchRules, SwitchState, Move>;
+export {};