chesspal 0.0.1 → 0.2.0

package/dist/core/levels.js

@@ -0,0 +1,33 @@
+/** The AI's levels, the weakest first. */
+export const aiLevels = ["beginner", "club", "strong", "master"];
+/** The layers of facts: the board as the player sees it (D-59), the tactical view (D-26), the positional profile, the opening book's moves (D-15). */
+const layers = ["board", "tactics", "strategy", "theory"];
+/** The PGN tag that keeps a game's level, so the archive keeps it too. */
+export const levelTag = "AILevel";
+/** The level of the games played before levels came: the AI saw the board, the tactical view and the positional profile. */
+const formerLevel = "strong";
+/** The level to suggest by how the player says they play (D-23), a step below their strength: strong only when they choose it. */
+export const levelForPlayer = { learning: "beginner", casual: "beginner", regular: "club", tournament: "master" };
+/** The level of a new game the player does not choose: the game before's, else the one that suits how the player says they play, else the former one. */
+export function suggestedLevel(before, playerLevel) {
+    if (before !== undefined) {
+        return levelOf(before);
+    }
+    return playerLevel !== undefined && Object.hasOwn(levelForPlayer, playerLevel) ? levelForPlayer[playerLevel] : formerLevel;
+}
+/** The layers a level sees, the board first. */
+export function layersOf(level) {
+    return layers.slice(0, aiLevels.indexOf(level) + 1);
+}
+/** Whether a level sees a layer. */
+export function sees(level, layer) {
+    return layers.indexOf(layer) <= aiLevels.indexOf(level);
+}
+/** The level a game is played at, by its tag; a game without one was played before levels came. */
+export function levelOf(record) {
+    const tag = record.tags[levelTag];
+    return isLevel(tag) ? tag : formerLevel;
+}
+function isLevel(text) {
+    return aiLevels.includes(text);
+}

package/dist/core/material.d.ts

@@ -0,0 +1,9 @@
+import type { PieceLetter } from "./facts.ts";
+import type { Side } from "./game.ts";
+/** What each side has taken, the most valuable first, and the material balance in pawns: above zero when White is ahead. */
+export interface Material {
+    readonly taken: Readonly<Record<Side, readonly PieceLetter[]>>;
+    readonly balance: number;
+}
+/** The material of a FEN: the pieces each side took, from what the other has left against a full set, and the balance at 1, 3, 3, 5 and 9 pawns. */
+export declare function materialOf(fen: string): Material;

package/dist/core/material.js

@@ -0,0 +1,12 @@
+/** The material of a FEN: the pieces each side took, from what the other has left against a full set, and the balance at 1, 3, 3, 5 and 9 pawns. */
+export function materialOf(fen) {
+    const placement = fen.split(" ")[0] ?? "";
+    const count = (letter) => placement.split(letter).length - 1;
+    const takenFrom = (side) => pieces.flatMap((piece) => Array(Math.max(0, fullSet[piece] - count(side === "white" ? piece : piece.toLowerCase()))).fill(piece));
+    const balance = pieces.reduce((sum, piece) => sum + values[piece] * (count(piece) - count(piece.toLowerCase())), 0);
+    return Object.freeze({ taken: Object.freeze({ white: Object.freeze(takenFrom("black")), black: Object.freeze(takenFrom("white")) }), balance });
+}
+// The pieces that can be taken, the most valuable first, with how many each side starts with and their usual value in pawns.
+const pieces = ["Q", "R", "B", "N", "P"];
+const fullSet = { Q: 1, R: 2, B: 2, N: 2, P: 8 };
+const values = { Q: 9, R: 5, B: 3, N: 3, P: 1 };

package/dist/core/moods.d.ts

@@ -0,0 +1,21 @@
+import type { Game, Side } from "./game.ts";
+import type { GameRecord } from "./record.ts";
+/** The moods of the AI, which the Torretta shows. */
+export declare const moods: readonly ["neutral", "happy", "surprised", "worried", "thoughtful", "sad"];
+/** A mood of the AI. */
+export type Mood = (typeof moods)[number];
+/** The AI's mood at a point of a game, and how many more of its moves keep it before it fades: 0 when its next move ends it. */
+export interface MoodNow {
+    readonly mood: Mood;
+    readonly left: number;
+}
+/** The mood as a move's comment carries it. */
+export declare function moodTag(mood: Mood): string;
+/** The mood a move's comment carries, if it carries one. */
+export declare function moodOf(comment: string | undefined): Mood | undefined;
+/** 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 declare function endWithMood(game: Game, mood: Mood): void;
+/** 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 declare function moodAt(record: GameRecord, ai: Side, plies?: number): MoodNow;
+/** The record without moods: another game's are not the AI's. */
+export declare function withoutMoods(record: GameRecord): GameRecord;

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). */
+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,35 @@
+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;
+}
+/** 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. */
+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(" ");
+}