@vnejs/plugins.views.screens.checkers 0.2.1

package/dist/index.d.ts

@@ -0,0 +1 @@
+import "@vnejs/contracts.views.screens.checkers";

package/dist/index.js

@@ -0,0 +1,15 @@
+import "@vnejs/contracts.views.screens.checkers";
+import { regPlugin } from "@vnejs/shared";
+import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.screens.checkers";
+import { CheckersController } from "./modules/controller.js";
+import { CheckersControllerAccept } from "./modules/controller.accept.js";
+import { CheckersControllerGrid } from "./modules/controller.grid.js";
+import { Checkers } from "./modules/checkers.js";
+import { CheckersView } from "./modules/view.js";
+regPlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS }, [
+    CheckersController,
+    CheckersControllerGrid,
+    CheckersControllerAccept,
+    Checkers,
+    CheckersView,
+]);

package/dist/modules/checkers.d.ts

@@ -0,0 +1,9 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { LineExecHandlerArg } from "@vnejs/module.core";
+import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
+export declare class Checkers extends ModuleCore<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams> {
+    name: string;
+    postinject: () => void;
+    init: () => Promise<unknown[]> | undefined;
+    onLineExec: ({ line }?: LineExecHandlerArg) => Promise<unknown[]> | undefined;
+}

package/dist/modules/checkers.js

@@ -0,0 +1,37 @@
+import { tokenizeExecLine } from "@vnejs/helpers";
+import { ModuleCore } from "@vnejs/module.core";
+const AI_COLOR_VALUES = new Set(["white", "black"]);
+const AI_TYPE_VALUES = new Set(["player", "sacrifice", "random", "strong"]);
+export class Checkers extends ModuleCore {
+    name = "checkers";
+    postinject = () => {
+        this.shared.checkersAi ??= {
+            white: this.CONST.CHECKERS.AI_TYPES.PLAYER,
+            black: this.CONST.CHECKERS.AI_TYPES.PLAYER,
+        };
+        this.shared.checkersAiBusy ??= false;
+    };
+    init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: this.name, handler: this.onLineExec });
+    onLineExec = ({ line = "" } = {}) => {
+        const [action = "", colorRaw = "", typeRaw = ""] = tokenizeExecLine(line).map(String);
+        if (action === this.CONST.CHECKERS.EXEC_ACTIONS.SHOW) {
+            this.emitLog({ action });
+            return this.emit(this.EVENTS.CHECKERS.SHOW);
+        }
+        if (action !== this.CONST.CHECKERS.EXEC_ACTIONS.AI)
+            return;
+        if (!AI_COLOR_VALUES.has(colorRaw) || !AI_TYPE_VALUES.has(typeRaw)) {
+            this.emitLog({ action, color: colorRaw, type: typeRaw, error: "invalid_args" });
+            this.emitNext();
+            return;
+        }
+        const color = colorRaw;
+        const type = typeRaw;
+        this.shared.checkersAi = {
+            ...this.shared.checkersAi,
+            [color]: type,
+        };
+        this.emitLog({ action, color, type });
+        this.emitNext();
+    };
+}

package/dist/modules/controller.accept.d.ts

@@ -0,0 +1,30 @@
+import { ModuleControllerAccept } from "@vnejs/module.controller.accept";
+import type { CheckersAiType } from "@vnejs/contracts.views.screens.checkers";
+import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
+import { type CheckersPos } from "../utils/board.js";
+import { type CheckersCellClickPayload, type CheckersPluginState } from "../utils/checkers.js";
+export declare class CheckersControllerAccept extends ModuleControllerAccept<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams, CheckersPluginState> {
+    name: string;
+    EVENT_SHOW: "vne:checkers:show";
+    EVENT_HIDE: "vne:checkers:hide";
+    EVENT_ACCEPT: "vne:checkers:accept";
+    EVENT_STATE_UPDATE: "vne:checkers:state_update";
+    CONTROLS_ZINDEX: number;
+    subscribe: () => void;
+    onShow: () => undefined;
+    onShowAndMaybeAi: () => Promise<void>;
+    onHide: () => Promise<unknown[]> | undefined;
+    controllerFor: (turn: NonNullable<CheckersPluginState["turn"]>) => CheckersAiType;
+    isHumanTurn: () => boolean;
+    onCellClick: ({ row, column }?: CheckersCellClickPayload) => Promise<void>;
+    onAccept: () => Promise<void>;
+    onAiTurn: () => Promise<void>;
+    playMove: (from: CheckersPos, to: CheckersPos, { scheduleAi }?: {
+        scheduleAi?: boolean;
+    }) => Promise<boolean>;
+    emitBoardState: (patch: Partial<CheckersPluginState> & {
+        board?: CheckersPluginState["board"];
+        selected?: CheckersPluginState["selected"];
+        legalMoves?: CheckersPluginState["legalMoves"];
+    }) => Promise<void>;
+}

package/dist/modules/controller.accept.js

@@ -0,0 +1,165 @@
+import { ModuleControllerAccept } from "@vnejs/module.controller.accept";
+import { applyMove, findMove, getAllMoves, getWinner, oppositeColor, samePos } from "../utils/board.js";
+import { pickMove } from "../utils/ai.js";
+import { buildGridItems, statusForTurn } from "../utils/checkers.js";
+export class CheckersControllerAccept extends ModuleControllerAccept {
+    name = "checkers.controller.accept";
+    EVENT_SHOW = this.EVENTS.CHECKERS.SHOW;
+    EVENT_HIDE = this.EVENTS.CHECKERS.HIDE;
+    EVENT_ACCEPT = this.EVENTS.CHECKERS.ACCEPT;
+    EVENT_STATE_UPDATE = this.EVENTS.CHECKERS.STATE_UPDATE;
+    CONTROLS_ZINDEX = this.PARAMS.CHECKERS.ZINDEX;
+    subscribe = () => {
+        this.on(this.EVENT_SHOW, this.onShow);
+        this.on(this.EVENT_HIDE, this.onHide);
+        this.on(this.EVENT_ACCEPT, this.onAccept);
+        if (this.EVENT_STATE_UPDATE)
+            this.on(this.EVENT_STATE_UPDATE, this.updateState);
+        this.on(this.EVENTS.CHECKERS.CELL_CLICK, this.onCellClick);
+        this.on(this.EVENTS.CHECKERS.AI_TURN, this.onAiTurn);
+    };
+    onShow = () => void this.onShowAndMaybeAi();
+    onShowAndMaybeAi = async () => {
+        await this.emit(this.EVENTS.CONTROLS.PUSH, {
+            key: this.name,
+            controls: this.CONTROLS,
+            index: this.CONTROLS_ZINDEX + 1,
+            checkNext: true,
+        });
+        // SHOW handlers run in parallel with controller.beforeShow — wait for board.
+        await this.waitCheck(() => Boolean(this.state.board && this.state.turn));
+        await this.onAiTurn();
+    };
+    onHide = () => {
+        this.shared.checkersAiBusy = false;
+        this.setDefaultState();
+        return this.emit(this.EVENTS.CONTROLS.POP, { key: this.name });
+    };
+    controllerFor = (turn) => (this.state.ai?.[turn] ?? this.shared.checkersAi?.[turn] ?? this.CONST.CHECKERS.AI_TYPES.PLAYER);
+    isHumanTurn = () => {
+        const turn = this.state.turn;
+        if (!turn)
+            return false;
+        return this.controllerFor(turn) === this.CONST.CHECKERS.AI_TYPES.PLAYER;
+    };
+    onCellClick = async ({ row, column } = {}) => {
+        if (this.shared.checkersAiBusy || !this.isHumanTurn())
+            return;
+        if (row == null || column == null)
+            return;
+        await this.emit(this.EVENTS.CHECKERS.STATE_UPDATE, {
+            gridRow: row,
+            gridColumn: column,
+        });
+        await this.emit(this.EVENTS.CHECKERS.UPDATE_FAST);
+        await this.onAccept();
+    };
+    onAccept = async () => {
+        if (this.shared.checkersAiBusy)
+            return;
+        if (this.state.winner) {
+            await this.emit(this.EVENTS.CHECKERS.FINISH);
+            return;
+        }
+        if (!this.isHumanTurn())
+            return;
+        const { gridRow, gridColumn, board, turn, selected } = this.state;
+        if (gridRow == null || gridColumn == null || !board || !turn)
+            return;
+        const focus = { row: gridRow, column: gridColumn };
+        const piece = board[focus.row]?.[focus.column] ?? null;
+        if (selected && findMove(this.state.legalMoves ?? [], selected, focus)) {
+            await this.playMove(selected, focus);
+            return;
+        }
+        if (piece && piece.color === turn) {
+            const all = getAllMoves(board, turn);
+            const legalMoves = all.filter((move) => samePos(move.from, focus));
+            if (legalMoves.length === 0)
+                return;
+            const nextSelected = selected && samePos(selected, focus) ? null : focus;
+            const nextLegal = nextSelected ? legalMoves : [];
+            await this.emitBoardState({
+                selected: nextSelected,
+                legalMoves: nextLegal,
+            });
+            return;
+        }
+        if (selected) {
+            await this.emitBoardState({ selected: null, legalMoves: [] });
+        }
+    };
+    onAiTurn = async () => {
+        if (this.state.winner || !this.state.board || !this.state.turn)
+            return;
+        if (this.isHumanTurn())
+            return;
+        if (this.shared.checkersAiBusy)
+            return;
+        this.shared.checkersAiBusy = true;
+        try {
+            while (!this.state.winner && this.state.board && this.state.turn && !this.isHumanTurn()) {
+                await this.waitTimeout(this.PARAMS.CHECKERS.AI_DELAY);
+                const { board, turn } = this.state;
+                if (!board || !turn || this.state.winner)
+                    break;
+                const move = pickMove(board, turn, this.controllerFor(turn));
+                if (!move)
+                    break;
+                const played = await this.playMove(move.from, move.to, { scheduleAi: false });
+                if (!played)
+                    break;
+            }
+        }
+        finally {
+            this.shared.checkersAiBusy = false;
+        }
+    };
+    playMove = async (from, to, { scheduleAi = true } = {}) => {
+        const { board, turn } = this.state;
+        if (!board || !turn)
+            return false;
+        // Always resolve against current legal moves — `legalMoves: []` after a move is truthy and must not win over getAllMoves.
+        const move = findMove(getAllMoves(board, turn), from, to);
+        if (!move)
+            return false;
+        const nextBoard = applyMove(board, move);
+        const nextTurn = oppositeColor(turn);
+        const winner = getWinner(nextBoard, nextTurn);
+        await this.emitBoardState({
+            board: nextBoard,
+            turn: nextTurn,
+            selected: null,
+            legalMoves: [],
+            winner,
+            statusText: statusForTurn(nextTurn, winner),
+        });
+        if (winner) {
+            await this.waitTimeout(this.PARAMS.CHECKERS.TRANSITION);
+            await this.emit(this.EVENTS.CHECKERS.FINISH);
+            return true;
+        }
+        if (scheduleAi)
+            await this.onAiTurn();
+        return true;
+    };
+    emitBoardState = async (patch) => {
+        const board = patch.board ?? this.state.board;
+        if (!board)
+            return;
+        const selected = patch.selected !== undefined ? patch.selected : this.state.selected;
+        const legalMoves = patch.legalMoves !== undefined ? patch.legalMoves : this.state.legalMoves;
+        const gridItems = buildGridItems({
+            board,
+            selected: selected ?? null,
+            legalMoves: legalMoves ?? [],
+            gridRow: this.state.gridRow ?? null,
+            gridColumn: this.state.gridColumn ?? null,
+        });
+        await this.emit(this.EVENTS.CHECKERS.STATE_UPDATE, {
+            ...patch,
+            gridItems,
+        });
+        await this.emit(this.EVENTS.CHECKERS.UPDATE_FAST);
+    };
+}

package/dist/modules/controller.d.ts

@@ -0,0 +1,13 @@
+import { ModuleController } from "@vnejs/module.components";
+import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
+import { type CheckersPluginState } from "../utils/checkers.js";
+export declare class CheckersController extends ModuleController<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams, CheckersPluginState> {
+    name: string;
+    EVENT_UPDATE_VIEW: "vne:checkers:update";
+    CONTROLS: {};
+    CONTROLS_INDEX: number;
+    subscribe: () => void;
+    beforeShow: () => Promise<void>;
+    afterHide: () => void;
+    onFinish: () => Promise<void>;
+}

package/dist/modules/controller.grid.d.ts

@@ -0,0 +1,20 @@
+import { ModuleControllerArrowsGrid } from "@vnejs/module.controller.arrows.grid";
+import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
+import { type CheckersPluginState } from "../utils/checkers.js";
+export declare class CheckersControllerGrid extends ModuleControllerArrowsGrid<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams, CheckersPluginState> {
+    name: string;
+    EVENT_SHOW: "vne:checkers:show";
+    EVENT_HIDE: "vne:checkers:hide";
+    EVENT_STATE_UPDATE: "vne:checkers:state_update";
+    EVENT_UPDATE_FAST: "vne:checkers:update_fast";
+    EVENT_GRID_NEXT: "vne:checkers:grid_next";
+    EVENT_GRID_PREV: "vne:checkers:grid_prev";
+    EVENT_GRID_CLEAR: "vne:checkers:grid_clear";
+    EVENT_GRID_UPDATE_ITEMS: "vne:checkers:grid_update_items";
+    CONTROLS_ZINDEX: number;
+    isDisableGridChangeHorizontal: boolean;
+    isDisableGridChangeVertical: boolean;
+    getMaxRows: () => number;
+    getMaxColumns: () => number;
+    getGridItems: () => Promise<import("../utils/checkers.js").CheckersGridItem[]>;
+}

package/dist/modules/controller.grid.js

@@ -0,0 +1,29 @@
+import { ModuleControllerArrowsGrid } from "@vnejs/module.controller.arrows.grid";
+import { buildGridItems } from "../utils/checkers.js";
+import { createInitialBoard } from "../utils/board.js";
+export class CheckersControllerGrid extends ModuleControllerArrowsGrid {
+    name = "checkers.controller.grid";
+    EVENT_SHOW = this.EVENTS.CHECKERS.SHOW;
+    EVENT_HIDE = this.EVENTS.CHECKERS.HIDE;
+    EVENT_STATE_UPDATE = this.EVENTS.CHECKERS.STATE_UPDATE;
+    EVENT_UPDATE_FAST = this.EVENTS.CHECKERS.UPDATE_FAST;
+    EVENT_GRID_NEXT = this.EVENTS.CHECKERS.GRID_NEXT;
+    EVENT_GRID_PREV = this.EVENTS.CHECKERS.GRID_PREV;
+    EVENT_GRID_CLEAR = this.EVENTS.CHECKERS.GRID_CLEAR;
+    EVENT_GRID_UPDATE_ITEMS = this.EVENTS.CHECKERS.GRID_UPDATE_ITEMS;
+    CONTROLS_ZINDEX = this.PARAMS.CHECKERS.ZINDEX;
+    isDisableGridChangeHorizontal = true;
+    isDisableGridChangeVertical = true;
+    getMaxRows = () => this.PARAMS.CHECKERS.ROWS;
+    getMaxColumns = () => this.PARAMS.CHECKERS.COLUMNS;
+    getGridItems = async () => {
+        const board = this.state.board ?? createInitialBoard();
+        return buildGridItems({
+            board,
+            selected: this.state.selected ?? null,
+            legalMoves: this.state.legalMoves ?? [],
+            gridRow: this.state.gridRow ?? null,
+            gridColumn: this.state.gridColumn ?? null,
+        });
+    };
+}

package/dist/modules/controller.js

@@ -0,0 +1,34 @@
+import { ModuleController } from "@vnejs/module.components";
+import { createInitialCheckersState } from "../utils/checkers.js";
+export class CheckersController extends ModuleController {
+    name = "checkers.controller";
+    EVENT_UPDATE_VIEW = this.EVENTS.CHECKERS.UPDATE;
+    CONTROLS = {};
+    CONTROLS_INDEX = this.PARAMS.CHECKERS.ZINDEX;
+    subscribe = () => {
+        this.on(this.EVENTS.CHECKERS.SHOW, this.onShow);
+        this.on(this.EVENTS.CHECKERS.HIDE, this.onHide);
+        this.on(this.EVENTS.CHECKERS.STATE_UPDATE, this.updateState);
+        this.on(this.EVENTS.CHECKERS.UPDATE_FAST, this.updateViewFast);
+        this.on(this.EVENTS.CHECKERS.FINISH, this.onFinish);
+    };
+    beforeShow = async () => {
+        this.shared.checkersAiBusy = false;
+        const initial = createInitialCheckersState();
+        const ai = {
+            white: this.shared.checkersAi?.white ?? this.CONST.CHECKERS.AI_TYPES.PLAYER,
+            black: this.shared.checkersAi?.black ?? this.CONST.CHECKERS.AI_TYPES.PLAYER,
+        };
+        await this.emit(this.EVENTS.CHECKERS.STATE_UPDATE, { ...initial, ai });
+        await this.emit(this.EVENTS.CHECKERS.GRID_UPDATE_ITEMS);
+    };
+    afterHide = () => {
+        this.shared.checkersAiBusy = false;
+        this.setDefaultState();
+    };
+    onFinish = async () => {
+        this.shared.checkersAiBusy = false;
+        await this.emit(this.EVENTS.CHECKERS.HIDE);
+        this.emitNext();
+    };
+}

package/dist/modules/view.d.ts

@@ -0,0 +1,10 @@
+import { ModuleView } from "@vnejs/module.components";
+import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
+import type { CheckersPluginState } from "../utils/checkers.js";
+export declare class CheckersView extends ModuleView<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams, CheckersPluginState> {
+    name: string;
+    EVENT_UPDATE_VIEW: "vne:checkers:update";
+    LOC_LABEL: null;
+    TRANSITION: number;
+    renderFunc: import("@vnejs/module.components").ViewRenderFunc<CheckersPluginState>;
+}

package/dist/modules/view.js

@@ -0,0 +1,9 @@
+import { ModuleView } from "@vnejs/module.components";
+import { render } from "../view/index.js";
+export class CheckersView extends ModuleView {
+    name = "checkers.view";
+    EVENT_UPDATE_VIEW = this.EVENTS.CHECKERS.UPDATE;
+    LOC_LABEL = null;
+    TRANSITION = this.PARAMS.CHECKERS.TRANSITION;
+    renderFunc = render;
+}

package/dist/types.d.ts

@@ -0,0 +1,9 @@
+import type { ModuleComponentsConstants, ModuleComponentsEvents, ModuleComponentsParams, ModuleComponentsSettings } from "@vnejs/module.components";
+import type { Constants as ControlsConstants, PluginName as ControlsPluginName } from "@vnejs/contracts.controls";
+import type { Constants as ScenarioConstants, PluginName as ScenarioPluginName, SubscribeEvents as ScenarioSubscribeEvents } from "@vnejs/contracts.core.scenario";
+import type { PluginName as LogsPluginName, SubscribeEvents as LogsSubscribeEvents } from "@vnejs/contracts.core.logs";
+import type { Constants, Params, PluginName, SubscribeEvents } from "@vnejs/contracts.views.screens.checkers";
+export type CheckersPluginEvents = ModuleComponentsEvents & Record<PluginName, SubscribeEvents> & Record<ScenarioPluginName, ScenarioSubscribeEvents> & Record<LogsPluginName, LogsSubscribeEvents>;
+export type CheckersPluginConstants = ModuleComponentsConstants & Record<PluginName, Constants> & Record<ControlsPluginName, ControlsConstants> & Record<ScenarioPluginName, ScenarioConstants>;
+export type CheckersPluginSettings = ModuleComponentsSettings;
+export type CheckersPluginParams = ModuleComponentsParams & Record<PluginName, Params>;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ai.d.ts

@@ -0,0 +1,4 @@
+import { type CheckersBoard, type CheckersColor, type CheckersMove } from "./board.js";
+export type CheckersAiType = "player" | "sacrifice" | "random" | "strong";
+export declare const isHangingMove: (board: CheckersBoard, move: CheckersMove, color: CheckersColor) => boolean;
+export declare const pickMove: (board: CheckersBoard, color: CheckersColor, type: CheckersAiType) => CheckersMove | null;

package/dist/utils/ai.js

@@ -0,0 +1,27 @@
+import { applyMove, getAllMoves, oppositeColor } from "./board.js";
+export const isHangingMove = (board, move, color) => {
+    const nextBoard = applyMove(board, move);
+    const opponentMoves = getAllMoves(nextBoard, oppositeColor(color));
+    return opponentMoves.some((candidate) => candidate.captures.length > 0);
+};
+const pickRandom = (items) => {
+    if (items.length === 0)
+        return null;
+    return items[Math.floor(Math.random() * items.length)] ?? null;
+};
+export const pickMove = (board, color, type) => {
+    if (type === "player")
+        return null;
+    const moves = getAllMoves(board, color);
+    if (moves.length === 0)
+        return null;
+    if (type === "random")
+        return pickRandom(moves);
+    const hanging = moves.filter((move) => isHangingMove(board, move, color));
+    const safe = moves.filter((move) => !isHangingMove(board, move, color));
+    if (type === "sacrifice")
+        return pickRandom(hanging.length > 0 ? hanging : moves);
+    if (type === "strong")
+        return pickRandom(safe.length > 0 ? safe : hanging.length > 0 ? hanging : moves);
+    return pickRandom(moves);
+};

package/dist/utils/board.d.ts

@@ -0,0 +1,32 @@
+export type CheckersColor = "white" | "black";
+export type CheckersPiece = {
+    id: string;
+    color: CheckersColor;
+    king: boolean;
+};
+export type CheckersPos = {
+    row: number;
+    column: number;
+};
+export type CheckersMove = {
+    from: CheckersPos;
+    to: CheckersPos;
+    captures: CheckersPos[];
+};
+export type CheckersBoard = (CheckersPiece | null)[][];
+export declare const BOARD_SIZE = 8;
+export declare const oppositeColor: (color: CheckersColor) => CheckersColor;
+export declare const isDarkSquare: (row: number, column: number) => boolean;
+export declare const inBounds: (row: number, column: number) => boolean;
+export declare const cloneBoard: (board: CheckersBoard) => CheckersBoard;
+export declare const createInitialBoard: () => CheckersBoard;
+export declare const samePos: (a: CheckersPos, b: CheckersPos) => boolean;
+export declare const getMovesFrom: (board: CheckersBoard, from: CheckersPos) => CheckersMove[];
+export declare const getAllMoves: (board: CheckersBoard, color: CheckersColor, onlyFrom?: CheckersPos) => CheckersMove[];
+export declare const applyMove: (board: CheckersBoard, move: CheckersMove) => CheckersBoard;
+/** Apply one hop of a multi-capture chain (first capture only). */
+export declare const applyCaptureStep: (board: CheckersBoard, from: CheckersPos, to: CheckersPos, capture: CheckersPos) => CheckersBoard;
+export declare const listBoardPieces: (board: CheckersBoard) => (CheckersPiece & CheckersPos)[];
+export declare const countPieces: (board: CheckersBoard, color: CheckersColor) => number;
+export declare const getWinner: (board: CheckersBoard, colorToMove: CheckersColor) => CheckersColor | null;
+export declare const findMove: (moves: CheckersMove[], from: CheckersPos, to: CheckersPos) => CheckersMove | undefined;

package/dist/utils/board.js

@@ -0,0 +1,199 @@
+export const BOARD_SIZE = 8;
+export const oppositeColor = (color) => (color === "white" ? "black" : "white");
+export const isDarkSquare = (row, column) => (row + column) % 2 === 1;
+export const inBounds = (row, column) => row >= 0 && row < BOARD_SIZE && column >= 0 && column < BOARD_SIZE;
+export const cloneBoard = (board) => board.map((row) => row.map((cell) => (cell ? { ...cell } : null)));
+export const createInitialBoard = () => {
+    const board = Array.from({ length: BOARD_SIZE }, () => Array.from({ length: BOARD_SIZE }, () => null));
+    let nextId = 0;
+    for (let row = 0; row < BOARD_SIZE; row++) {
+        for (let column = 0; column < BOARD_SIZE; column++) {
+            if (!isDarkSquare(row, column))
+                continue;
+            if (row <= 2)
+                board[row][column] = { id: `piece-${nextId++}`, color: "black", king: false };
+            if (row >= 5)
+                board[row][column] = { id: `piece-${nextId++}`, color: "white", king: false };
+        }
+    }
+    return board;
+};
+const DIAGONALS = [
+    { dr: -1, dc: -1 },
+    { dr: -1, dc: 1 },
+    { dr: 1, dc: -1 },
+    { dr: 1, dc: 1 },
+];
+const forwardRowDelta = (color) => (color === "white" ? -1 : 1);
+const posKey = (pos) => `${pos.row}:${pos.column}`;
+export const samePos = (a, b) => a.row === b.row && a.column === b.column;
+const getPiece = (board, pos) => board[pos.row]?.[pos.column] ?? null;
+const setPiece = (board, pos, piece) => {
+    board[pos.row][pos.column] = piece;
+};
+const promoteIfNeeded = (piece, row) => {
+    if (piece.king)
+        return piece;
+    if (piece.color === "white" && row === 0)
+        return { ...piece, king: true };
+    if (piece.color === "black" && row === BOARD_SIZE - 1)
+        return { ...piece, king: true };
+    return piece;
+};
+const collectSimpleMoves = (board, from, piece) => {
+    const moves = [];
+    const deltas = piece.king ? DIAGONALS : DIAGONALS.filter(({ dr }) => dr === forwardRowDelta(piece.color));
+    for (const { dr, dc } of deltas) {
+        if (piece.king) {
+            let row = from.row + dr;
+            let column = from.column + dc;
+            while (inBounds(row, column) && !getPiece(board, { row, column })) {
+                moves.push({ from, to: { row, column }, captures: [] });
+                row += dr;
+                column += dc;
+            }
+            continue;
+        }
+        const row = from.row + dr;
+        const column = from.column + dc;
+        if (!inBounds(row, column) || getPiece(board, { row, column }))
+            continue;
+        moves.push({ from, to: { row, column }, captures: [] });
+    }
+    return moves;
+};
+const collectImmediateCaptures = (board, from, piece, capturedKeys) => {
+    const moves = [];
+    for (const { dr, dc } of DIAGONALS) {
+        if (piece.king) {
+            let row = from.row + dr;
+            let column = from.column + dc;
+            let enemy = null;
+            while (inBounds(row, column)) {
+                const occupant = getPiece(board, { row, column });
+                if (!occupant) {
+                    if (enemy) {
+                        moves.push({ from, to: { row, column }, captures: [enemy] });
+                    }
+                    row += dr;
+                    column += dc;
+                    continue;
+                }
+                if (enemy)
+                    break;
+                if (occupant.color === piece.color || capturedKeys.has(posKey({ row, column })))
+                    break;
+                enemy = { row, column };
+                row += dr;
+                column += dc;
+            }
+            continue;
+        }
+        const mid = { row: from.row + dr, column: from.column + dc };
+        const to = { row: from.row + 2 * dr, column: from.column + 2 * dc };
+        if (!inBounds(to.row, to.column) || getPiece(board, to))
+            continue;
+        const victim = getPiece(board, mid);
+        if (!victim || victim.color === piece.color || capturedKeys.has(posKey(mid)))
+            continue;
+        moves.push({ from, to, captures: [mid] });
+    }
+    return moves;
+};
+const expandCaptureChains = (board, from, piece, origin, capturedSoFar, capturedKeys) => {
+    const immediate = collectImmediateCaptures(board, from, piece, capturedKeys);
+    if (immediate.length === 0) {
+        return capturedSoFar.length > 0 ? [{ from: origin, to: from, captures: capturedSoFar }] : [];
+    }
+    const results = [];
+    for (const step of immediate) {
+        const nextBoard = cloneBoard(board);
+        setPiece(nextBoard, from, null);
+        for (const capture of step.captures)
+            setPiece(nextBoard, capture, null);
+        const nextPiece = promoteIfNeeded(piece, step.to.row);
+        setPiece(nextBoard, step.to, nextPiece);
+        const nextCaptures = [...capturedSoFar, ...step.captures];
+        const nextKeys = new Set(capturedKeys);
+        for (const capture of step.captures)
+            nextKeys.add(posKey(capture));
+        results.push(...expandCaptureChains(nextBoard, step.to, nextPiece, origin, nextCaptures, nextKeys));
+    }
+    return results;
+};
+export const getMovesFrom = (board, from) => {
+    const piece = getPiece(board, from);
+    if (!piece)
+        return [];
+    const captures = expandCaptureChains(board, from, piece, from, [], new Set());
+    if (captures.length > 0)
+        return captures;
+    return collectSimpleMoves(board, from, piece);
+};
+export const getAllMoves = (board, color, onlyFrom) => {
+    const moves = [];
+    for (let row = 0; row < BOARD_SIZE; row++) {
+        for (let column = 0; column < BOARD_SIZE; column++) {
+            if (onlyFrom && !samePos(onlyFrom, { row, column }))
+                continue;
+            const piece = board[row]?.[column];
+            if (!piece || piece.color !== color)
+                continue;
+            moves.push(...getMovesFrom(board, { row, column }));
+        }
+    }
+    const hasCapture = moves.some((move) => move.captures.length > 0);
+    return hasCapture ? moves.filter((move) => move.captures.length > 0) : moves;
+};
+export const applyMove = (board, move) => {
+    const next = cloneBoard(board);
+    const piece = getPiece(next, move.from);
+    if (!piece)
+        return next;
+    setPiece(next, move.from, null);
+    for (const capture of move.captures)
+        setPiece(next, capture, null);
+    setPiece(next, move.to, promoteIfNeeded(piece, move.to.row));
+    return next;
+};
+/** Apply one hop of a multi-capture chain (first capture only). */
+export const applyCaptureStep = (board, from, to, capture) => {
+    const next = cloneBoard(board);
+    const piece = getPiece(next, from);
+    if (!piece)
+        return next;
+    setPiece(next, from, null);
+    setPiece(next, capture, null);
+    setPiece(next, to, promoteIfNeeded(piece, to.row));
+    return next;
+};
+export const listBoardPieces = (board) => {
+    const pieces = [];
+    for (let row = 0; row < BOARD_SIZE; row++) {
+        for (let column = 0; column < BOARD_SIZE; column++) {
+            const piece = board[row]?.[column];
+            if (!piece)
+                continue;
+            pieces.push({ ...piece, row, column });
+        }
+    }
+    return pieces;
+};
+export const countPieces = (board, color) => {
+    let count = 0;
+    for (const row of board) {
+        for (const cell of row) {
+            if (cell?.color === color)
+                count++;
+        }
+    }
+    return count;
+};
+export const getWinner = (board, colorToMove) => {
+    if (countPieces(board, colorToMove) === 0)
+        return oppositeColor(colorToMove);
+    if (getAllMoves(board, colorToMove).length === 0)
+        return oppositeColor(colorToMove);
+    return null;
+};
+export const findMove = (moves, from, to) => moves.find((move) => samePos(move.from, from) && samePos(move.to, to));