chesspal 0.0.1 → 0.1.0

package/dist/core/moods.js

@@ -0,0 +1,45 @@
+/** The moods of the AI, which the Torretta shows. */
+export const moods = ["neutral", "happy", "surprised", "worried", "thoughtful", "sad"];
+/** How many of the AI's moves each mood lasts, the one it comes with included: a surprise is a flash (Julián, round of T-107). */
+export const moodMoves = { neutral: 0, happy: 3, surprised: 1, worried: 3, thoughtful: 3, sad: 3 };
+/** The mood as a move's comment carries it. */
+export function moodTag(mood) {
+    return `[%mood ${mood}]`;
+}
+/** The mood a move's comment carries, if it carries one. */
+export function moodOf(comment) {
+    const found = moodPattern.exec(comment ?? "")?.[1];
+    return moods.find((mood) => mood === found);
+}
+/** Gives the AI's mood on the last move of a game that has ended, in place of the one it had: the face the game ends with. A game without moves keeps none. */
+export function endWithMood(game, mood) {
+    const plies = game.record.moves.length;
+    const comment = game.record.moves[plies - 1]?.comment?.replace(moodPattern, "");
+    if (plies > 0) {
+        game.annotate(plies, { comment: comment === undefined || comment === "" ? moodTag(mood) : `${comment} ${moodTag(mood)}` });
+    }
+}
+/** The AI's mood after the first `plies` moves of a record: the last it gave, while it lasts, else neutral. A mood on the player's move is the one the game ended with. */
+export function moodAt(record, ai, plies = record.moves.length) {
+    // The ply count from white's move of the first move number: 1 when black moves first.
+    const offset = record.tags.FEN?.split(" ")[1] === "b" ? 1 : 0;
+    const aiMoves = (index) => ((index + offset) % 2 === 0 ? "white" : "black") === ai;
+    let since = 0;
+    for (let index = Math.min(plies, record.moves.length) - 1; index >= 0; index--) {
+        const mood = moodOf(record.moves[index]?.comment);
+        if (mood !== undefined) {
+            const left = moodMoves[mood] - 1 - since;
+            return mood === "neutral" || left < 0 ? neutral : { mood, left };
+        }
+        if (aiMoves(index)) {
+            since++;
+        }
+    }
+    return neutral;
+}
+/** The record without moods: another game's are not the AI's. */
+export function withoutMoods(record) {
+    return { ...record, moves: record.moves.map((move) => ({ ...move, comment: move.comment?.replace(moodPattern, "") })) };
+}
+const neutral = { mood: "neutral", left: 0 };
+const moodPattern = /\s*\[%mood ([a-z]+)\]/;

package/dist/core/openings.d.ts

@@ -0,0 +1,37 @@
+import type { GameRecord } from "./record.ts";
+/** The openings by position: the position's key (its FEN without the move counters) to its ECO code and name. */
+export type OpeningIndex = Readonly<Record<string, readonly [eco: string, name: string]>>;
+/** The opening a game is in, or the last one it was in: its ECO code, its name split in family and variation, and the ply that reached it. */
+export interface Opening {
+    readonly eco: string;
+    /** The whole name, as Lichess writes it: Sicilian Defense: Najdorf Variation, English Attack. */
+    readonly name: string;
+    /** The name before the colon: Sicilian Defense. */
+    readonly family: string;
+    /** The name after the colon, when there is one: Najdorf Variation, English Attack. */
+    readonly variation?: string;
+    /** How many plies the game had when it reached the opening's position. */
+    readonly ply: number;
+    /** Whether the game's position now is a named one; when not, it left the book at the ply after `ply`. */
+    readonly inBook: boolean;
+}
+/** No line of the book is longer: past it, no position is looked up. */
+export declare const bookDepth = 40;
+/** The book's moves: each position on a line of Lichess's files to the moves its lines play from it, the theory the AI knows at the master level (D-15, D-60). */
+export type OpeningBook = Readonly<Record<string, readonly string[]>>;
+/** The index of the openings in Lichess's TSV files (eco, name, pgn), each line keyed by the position its moves reach. */
+export declare function indexOpenings(tsv: string): Record<string, [string, string]>;
+/**
+ * The book of Lichess's TSV files: every position on their lines, keyed as the index keys them, to the moves the lines play from it, the move most lines go
+ * through first: how much theory a move has, never how good it is. A move under one line in fifty from its position is left out; one whose lines are all named
+ * traps carries the trap's name, as the files write it: Nxe5 (Mortimer Trap).
+ */
+export declare function indexBook(tsv: string): Record<string, string[]>;
+/** The moves the book knows from a position, in SAN; none out of the book. */
+export declare function bookMoves(fen: string, book: OpeningBook): readonly string[];
+/** Whether a line of the book reaches a position, by any order of moves: one its lines play on from, or one an opening is named after. */
+export declare function inOpenings(fen: string, index: OpeningIndex, book: OpeningBook): boolean;
+/** The opening of a game from the standard position, the last named one its moves reached; none before the first, or from another position. */
+export declare function openingOf(record: GameRecord, index: OpeningIndex): Opening | undefined;
+/** The move number at which a game that reached an opening at `ply` left the book. */
+export declare function outOfBookMove(opening: Opening): number;

package/dist/core/openings.js

@@ -0,0 +1,98 @@
+// The openings by position (D-15, D-16): Lichess's names, indexed by the position each line reaches, so transpositions find them too.
+import { Chess } from "chess.js";
+/** No line of the book is longer: past it, no position is looked up. */
+export const bookDepth = 40;
+/** The index of the openings in Lichess's TSV files (eco, name, pgn), each line keyed by the position its moves reach. */
+export function indexOpenings(tsv) {
+    const index = {};
+    for (const { eco, name, moves } of linesOf(tsv)) {
+        const chess = new Chess();
+        moves.forEach((move) => chess.move(move));
+        index[positionKey(chess.fen())] = [eco, name];
+    }
+    return index;
+}
+/**
+ * The book of Lichess's TSV files: every position on their lines, keyed as the index keys them, to the moves the lines play from it, the move most lines go
+ * through first: how much theory a move has, never how good it is. A move under one line in fifty from its position is left out; one whose lines are all named
+ * traps carries the trap's name, as the files write it: Nxe5 (Mortimer Trap).
+ */
+export function indexBook(tsv) {
+    const lines = new Map();
+    for (const { name, moves } of linesOf(tsv)) {
+        const trap = name.split(/[:,]/).map((part) => part.trim()).find((part) => /\bTrap\b/.test(part));
+        const chess = new Chess();
+        for (const move of moves) {
+            const key = positionKey(chess.fen());
+            const san = chess.move(move).san;
+            const counts = lines.get(key) ?? new Map();
+            const count = counts.get(san) ?? { lines: 0, traps: [] };
+            counts.set(san, { lines: count.lines + 1, traps: trap === undefined ? count.traps : [...count.traps, trap] });
+            lines.set(key, counts);
+        }
+    }
+    return Object.fromEntries([...lines].map(([key, counts]) => [key, bookOf(counts)]));
+}
+/** The moves the book knows from a position, in SAN; none out of the book. */
+export function bookMoves(fen, book) {
+    return book[positionKey(fen)] ?? [];
+}
+/** Whether a line of the book reaches a position, by any order of moves: one its lines play on from, or one an opening is named after. */
+export function inOpenings(fen, index, book) {
+    const key = positionKey(fen);
+    return book[key] !== undefined || index[key] !== undefined;
+}
+/** The opening of a game from the standard position, the last named one its moves reached; none before the first, or from another position. */
+export function openingOf(record, index) {
+    if (record.tags.FEN !== undefined && record.tags.FEN !== new Chess().fen()) {
+        return undefined;
+    }
+    const chess = new Chess();
+    const plies = Math.min(record.moves.length, bookDepth);
+    let found;
+    for (let ply = 1; ply <= plies; ply++) {
+        chess.move(record.moves[ply - 1].san);
+        const named = index[positionKey(chess.fen())];
+        if (named !== undefined) {
+            found = { named, ply };
+        }
+    }
+    if (found === undefined) {
+        return undefined;
+    }
+    const [eco, name] = found.named;
+    const colon = name.indexOf(":");
+    const family = colon < 0 ? name : name.slice(0, colon);
+    const opening = { eco, name, family, ply: found.ply, inBook: found.ply === record.moves.length };
+    return colon < 0 ? opening : { ...opening, variation: name.slice(colon + 1).trim() };
+}
+/** The move number at which a game that reached an opening at `ply` left the book. */
+export function outOfBookMove(opening) {
+    return Math.floor(opening.ply / 2) + 1;
+}
+/** The moves from a position that at least one line in fifty plays, the most played first, with the trap's name when all their lines are traps. */
+function bookOf(counts) {
+    const total = [...counts.values()].reduce((sum, count) => sum + count.lines, 0);
+    return [...counts]
+        .filter(([, count]) => count.lines * 50 >= total)
+        .sort(([, one], [, other]) => other.lines - one.lines)
+        .map(([san, count]) => count.traps.length === count.lines ? `${san} (${[...new Set(count.traps)].join(" / ")})` : san);
+}
+/** The lines of Lichess's TSV files, their moves in SAN; one past the book's depth throws. */
+function linesOf(tsv) {
+    return tsv.split(/\r?\n/).flatMap((line) => {
+        const [eco, name, pgn] = line.split("\t");
+        if (eco === undefined || name === undefined || pgn === undefined || eco === "eco") {
+            return [];
+        }
+        const moves = pgn.split(/\s+/).filter((token) => token !== "" && !/^\d+\.+$/.test(token));
+        if (moves.length > bookDepth) {
+            throw new Error(`The opening ${eco} ${name} is ${moves.length} plies long, past the book's depth of ${bookDepth}: raise bookDepth.`);
+        }
+        return [{ eco, name, moves }];
+    });
+}
+/** A position without its move counters: the same position reached in another order is the same key. */
+function positionKey(fen) {
+    return fen.split(" ").slice(0, 4).join(" ");
+}