@johnmorrisdotca/domino 1.0.0

package/dist/mexicanTrain/trainComputer.js

@@ -0,0 +1,113 @@
+// Relative, like the rest of lib/party: the browser specs import this, and Playwright resolves no alias.
+import { endsOf, fits, isDouble, pipsOf } from "./dominoes.js";
+import { mexicanOf, openEnd, trainMoves } from "./mexicanTrain.js";
+/**
+ * A COMPUTER AT THE TABLE: the move a computer player makes, worked out in
+ * the browser from the game alone, the same move every time for the same
+ * game. It sees only what its seat may see — its own hand and the table —
+ * and never the boneyard's order or another hand.
+ *
+ * How it plays, the way a sensible player at a real table does:
+ *
+ *  - It PLANS ITS OWN TRAIN. From its train's open end it finds the longest
+ *    run its hand can lay there (`longestRun`), and keeps those tiles for its
+ *    own train, laying them one a turn, first to last.
+ *  - Everything not in that run it would rather lay somewhere else — the
+ *    Mexican Train, or a train left open — and the heavier the better, since
+ *    a tile laid is pips that cannot count against it.
+ *  - Its own marker out is a train anybody can block, so it lays at home
+ *    first when it can, and takes the marker in.
+ *  - A DOUBLE it lays only when it holds a tile to cover it with, so the
+ *    double is a free second tile rather than a turn spent drawing; when it
+ *    must cover somebody else's, it covers with a tile its run can spare.
+ *  - Going out wins the round, so a last tile is always laid.
+ */
+/** How many runs the planner looks at before settling for the longest found: enough for any hand, bounded for a huge one. */
+const PLAN_STEPS = 4000;
+/**
+ * The longest run of tiles from `hand` that can be laid one after another
+ * against `end`, in the order they would be laid. A depth-first search over
+ * the hand, bounded by `PLAN_STEPS`, preferring the heavier run of two the
+ * same length: pips laid are pips that do not count.
+ */
+export function longestRun(hand, end) {
+    let best = [];
+    let bestPips = -1;
+    let steps = 0;
+    const used = new Set();
+    const run = [];
+    const walk = (at, pips) => {
+        steps += 1;
+        if (run.length > best.length || (run.length === best.length && pips > bestPips)) {
+            best = [...run];
+            bestPips = pips;
+        }
+        if (steps > PLAN_STEPS)
+            return;
+        for (const tile of hand) {
+            if (used.has(tile) || !fits(tile, at))
+                continue;
+            const [low, high] = endsOf(tile);
+            used.add(tile);
+            run.push(tile);
+            walk(low === at ? high : low, pips + pipsOf(tile));
+            run.pop();
+            used.delete(tile);
+        }
+    };
+    walk(end, 0);
+    return best;
+}
+/** How good a lay looks to the computer: higher is better. */
+function scoreOf(game, move, plan) {
+    const seat = game.toPlay;
+    const hand = game.hands[seat];
+    const { tile, train } = move;
+    if (hand.length === 1)
+        return 10000;
+    const own = train === seat;
+    const planned = plan.indexOf(tile);
+    let score = pipsOf(tile);
+    if (own) {
+        if (planned === 0)
+            score += 40;
+        else if (planned > 0)
+            score -= 25;
+        else
+            score += 5;
+        if (game.trains[seat].open)
+            score += 30;
+    }
+    else {
+        score += planned >= 0 ? -30 : 12;
+        if (train === mexicanOf(game))
+            score += 2;
+    }
+    if (isDouble(tile)) {
+        const [value] = endsOf(tile);
+        const cover = hand.some((other) => other !== tile && fits(other, value));
+        score += cover ? 25 : -20;
+    }
+    return score;
+}
+/** The move the computer in the seat to move makes now: the best-scored lay, or the draw, pass or next round it must take. */
+export function computerMove(game) {
+    const offered = trainMoves(game);
+    if (offered.length === 0)
+        throw new Error("no move to make: the game is over");
+    const plays = offered.filter((move) => move.kind === "play");
+    if (plays.length === 0)
+        return offered[0];
+    const seat = game.toPlay;
+    const plan = longestRun(game.hands[seat], openEnd(game, seat));
+    let best = plays[0];
+    let bestScore = -Infinity;
+    for (const move of plays) {
+        const score = scoreOf(game, move, plan);
+        if (score > bestScore || (score === bestScore && (move.tile > best.tile || (move.tile === best.tile && move.train < best.train)))) {
+            best = move;
+            bestScore = score;
+        }
+    }
+    return best;
+}

package/dist/random.d.ts

@@ -0,0 +1,17 @@
+/**
+ * SEEDED RANDOMNESS, the one thing every deal is made from.
+ *
+ * mulberry32: small, fast, and the same stream for the same seed in every
+ * browser and every Node. It decides every shuffle, so it must never change —
+ * a game kept as its seed and its moves is dealt again from it, and a changed
+ * stream would deal somebody a different hand from the one they were playing.
+ * `random.test.ts` pins its first numbers for that reason.
+ *
+ * Nothing here is a credential: it is for fair-looking deals, not secrets.
+ */
+/** A number in [0, 1), like `Math.random`, from a stream a seed fixes. */
+export type Random = () => number;
+/** A stream of numbers in [0, 1) fixed by a seed. */
+export declare function seededRandom(seed: number): Random;
+/** A copy of the list in a random order (Fisher–Yates); the list given is left alone. */
+export declare function shuffled<T>(items: readonly T[], random: Random): T[];

package/dist/random.js

@@ -0,0 +1,31 @@
+/**
+ * SEEDED RANDOMNESS, the one thing every deal is made from.
+ *
+ * mulberry32: small, fast, and the same stream for the same seed in every
+ * browser and every Node. It decides every shuffle, so it must never change —
+ * a game kept as its seed and its moves is dealt again from it, and a changed
+ * stream would deal somebody a different hand from the one they were playing.
+ * `random.test.ts` pins its first numbers for that reason.
+ *
+ * Nothing here is a credential: it is for fair-looking deals, not secrets.
+ */
+/** A stream of numbers in [0, 1) fixed by a seed. */
+export function seededRandom(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** A copy of the list in a random order (Fisher–Yates); the list given is left alone. */
+export function shuffled(items, random) {
+    const out = [...items];
+    for (let i = out.length - 1; i > 0; i -= 1) {
+        const j = Math.floor(random() * (i + 1));
+        [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** The package's version. */
+export declare const VERSION = "1.0.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+/** The package's version. */
+export const VERSION = "1.0.0";

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@johnmorrisdotca/domino",
+  "version": "1.0.0",
+  "description": "Dominoes for JavaScript and TypeScript: double-nine, double-twelve and double-fifteen sets, and the full rules of Mexican Train for two to eight players, with a computer player, seeded deals that replay exactly, and a compact saved-game format. Zero dependencies.",
+  "keywords": [
+    "dominoes",
+    "domino",
+    "mexican-train",
+    "mexican-train-dominoes",
+    "train-dominoes",
+    "double-twelve",
+    "double-nine",
+    "double-fifteen",
+    "domino-game",
+    "tile-game",
+    "board-game",
+    "game-engine",
+    "game-rules",
+    "rules-engine",
+    "computer-player",
+    "ai-player",
+    "bot",
+    "seeded",
+    "seeded-random",
+    "deterministic",
+    "replay",
+    "save-game",
+    "typescript",
+    "javascript",
+    "zero-dependencies",
+    "browser",
+    "node",
+    "party-game",
+    "family-game",
+    "itsutsu"
+  ],
+  "homepage": "https://github.com/johnmorrisdotca/domino#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johnmorrisdotca/domino.git"
+  },
+  "bugs": {
+    "url": "https://github.com/johnmorrisdotca/domino/issues"
+  },
+  "author": "John Morris",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "eslint .",
+    "typecheck": "tsc -p tsconfig.check.json",
+    "test": "vitest run",
+    "test:package": "pnpm build && node scripts/check-package.mjs",
+    "check": "pnpm lint && pnpm typecheck && pnpm test",
+    "prepublishOnly": "pnpm check && pnpm build"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "eslint": "^9.0.0",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^5.0.0"
+  },
+  "packageManager": "pnpm@10.11.0"
+}