@vnejs/plugins.views.screens.checkers 0.2.2 → 0.2.3

package/dist/utils/board.js

@@ -1,199 +0,0 @@
-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));

package/src/modules/checkers.ts

@@ -1,52 +0,0 @@
-import { tokenizeExecLine } from "@vnejs/helpers";
-import { ModuleCore } from "@vnejs/module.core";
-
-import type { LineExecHandlerArg } from "@vnejs/module.core";
-import type { CheckersAiColor, CheckersAiType } from "@vnejs/contracts.views.screens.checkers";
-
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-
-const AI_COLOR_VALUES = new Set<string>(["white", "black"]);
-const AI_TYPE_VALUES = new Set<string>(["player", "sacrifice", "random", "strong"]);
-
-export class Checkers extends ModuleCore<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams> {
-  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 = "" }: LineExecHandlerArg = {}) => {
-    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 as CheckersAiColor;
-    const type = typeRaw as CheckersAiType;
-
-    this.shared.checkersAi = {
-      ...this.shared.checkersAi,
-      [color]: type,
-    };
-
-    this.emitLog({ action, color, type });
-    this.emitNext();
-  };
-}

package/src/tests/ai.test.ts

@@ -1,61 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { BOARD_SIZE, type CheckersBoard, type CheckersPiece } from "../utils/board.js";
-import { isHangingMove, pickMove } from "../utils/ai.js";
-
-const emptyBoard = (): CheckersBoard => Array.from({ length: BOARD_SIZE }, () => Array.from({ length: BOARD_SIZE }, () => null));
-
-const piece = (id: string, color: CheckersPiece["color"]): CheckersPiece => ({ id, color, king: false });
-
-/** White at (5,2): (4,1) hangs to black at (3,0); (4,3) is safe. */
-const hangingScenarioBoard = (): CheckersBoard => {
-  const board = emptyBoard();
-  board[5]![2] = piece("w1", "white");
-  board[3]![0] = piece("b1", "black");
-  return board;
-};
-
-describe("checkers ai", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("isHangingMove is true when opponent gets a capture", () => {
-    const board = hangingScenarioBoard();
-    const hanging = { from: { row: 5, column: 2 }, to: { row: 4, column: 1 }, captures: [] };
-    const safe = { from: { row: 5, column: 2 }, to: { row: 4, column: 3 }, captures: [] };
-
-    expect(isHangingMove(board, hanging, "white")).toBe(true);
-    expect(isHangingMove(board, safe, "white")).toBe(false);
-  });
-
-  it("pickMove sacrifice prefers hanging moves", () => {
-    vi.spyOn(Math, "random").mockReturnValue(0);
-    const board = hangingScenarioBoard();
-    const move = pickMove(board, "white", "sacrifice");
-
-    expect(move).toEqual({ from: { row: 5, column: 2 }, to: { row: 4, column: 1 }, captures: [] });
-  });
-
-  it("pickMove strong prefers safe moves", () => {
-    vi.spyOn(Math, "random").mockReturnValue(0);
-    const board = hangingScenarioBoard();
-    const move = pickMove(board, "white", "strong");
-
-    expect(move).toEqual({ from: { row: 5, column: 2 }, to: { row: 4, column: 3 }, captures: [] });
-  });
-
-  it("pickMove random returns a legal move", () => {
-    vi.spyOn(Math, "random").mockReturnValue(0);
-    const board = hangingScenarioBoard();
-    const move = pickMove(board, "white", "random");
-
-    expect(move).not.toBeNull();
-    expect(move?.from).toEqual({ row: 5, column: 2 });
-  });
-
-  it("pickMove player returns null", () => {
-    const board = hangingScenarioBoard();
-    expect(pickMove(board, "white", "player")).toBeNull();
-  });
-});

package/src/tests/board.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { applyMove, createInitialBoard, getAllMoves, getWinner, countPieces } from "../utils/board.js";
-
-describe("checkers board", () => {
-  it("creates initial setup with 12 pieces each", () => {
-    const board = createInitialBoard();
-
-    expect(countPieces(board, "white")).toBe(12);
-    expect(countPieces(board, "black")).toBe(12);
-  });
-
-  it("white has simple opening moves", () => {
-    const board = createInitialBoard();
-    const moves = getAllMoves(board, "white");
-
-    expect(moves.length).toBeGreaterThan(0);
-    expect(moves.every((move) => move.captures.length === 0)).toBe(true);
-  });
-
-  it("detects win when side has no pieces", () => {
-    const board = createInitialBoard();
-    for (let row = 0; row < 8; row++) {
-      for (let column = 0; column < 8; column++) {
-        if (board[row]?.[column]?.color === "black") board[row]![column] = null;
-      }
-    }
-
-    expect(getWinner(board, "black")).toBe("white");
-  });
-
-  it("applies a simple move", () => {
-    const board = createInitialBoard();
-    const moves = getAllMoves(board, "white");
-    const move = moves[0]!;
-    const pieceId = board[move.from.row]![move.from.column]!.id;
-    const next = applyMove(board, move);
-
-    expect(next[move.from.row]![move.from.column]).toBeNull();
-    expect(next[move.to.row]![move.to.column]?.color).toBe("white");
-    expect(next[move.to.row]![move.to.column]?.id).toBe(pieceId);
-  });
-});

package/src/tests/checkers.test.ts

@@ -1,58 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import { spyEvent } from "@vnejs/test-utils";
-
-import { Checkers } from "../modules/checkers.js";
-import { createCheckersTestModule, registerCheckersPluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
-
-describe("Checkers", () => {
-  beforeEach(() => {
-    registerCheckersPluginVne();
-  });
-
-  it("line exec show emits SHOW", async () => {
-    const { module, observer } = createCheckersTestModule(Checkers, { subscribe: false });
-    const show = spyEvent(observer, SUBSCRIBE_EVENTS.SHOW);
-
-    await (module as Checkers).init();
-    await (module as Checkers).onLineExec({ line: "show" });
-
-    expect(show).toHaveBeenCalledOnce();
-  });
-
-  it("line exec ignores unknown action", async () => {
-    const { module, observer } = createCheckersTestModule(Checkers, { subscribe: false });
-    const show = spyEvent(observer, SUBSCRIBE_EVENTS.SHOW);
-
-    await (module as Checkers).init();
-    await (module as Checkers).onLineExec({ line: "open" });
-
-    expect(show).not.toHaveBeenCalled();
-  });
-
-  it("line exec ai sets shared.checkersAi and emits next", async () => {
-    const { module } = createCheckersTestModule(Checkers, { subscribe: false });
-    const checkers = module as Checkers;
-    const emitNext = vi.spyOn(checkers, "emitNext");
-
-    await checkers.postinject();
-    await checkers.init();
-    await checkers.onLineExec({ line: "ai black strong" });
-
-    expect(checkers.shared.checkersAi).toEqual({ white: "player", black: "strong" });
-    expect(emitNext).toHaveBeenCalledOnce();
-  });
-
-  it("line exec ai with invalid args still emits next", async () => {
-    const { module } = createCheckersTestModule(Checkers, { subscribe: false });
-    const checkers = module as Checkers;
-    const emitNext = vi.spyOn(checkers, "emitNext");
-
-    await checkers.postinject();
-    await checkers.init();
-    await checkers.onLineExec({ line: "ai red random" });
-
-    expect(checkers.shared.checkersAi).toEqual({ white: "player", black: "player" });
-    expect(emitNext).toHaveBeenCalledOnce();
-  });
-});

package/src/utils/ai.ts

@@ -1,31 +0,0 @@
-import { applyMove, getAllMoves, oppositeColor, type CheckersBoard, type CheckersColor, type CheckersMove } from "./board.js";
-
-export type CheckersAiType = "player" | "sacrifice" | "random" | "strong";
-
-export const isHangingMove = (board: CheckersBoard, move: CheckersMove, color: CheckersColor) => {
-  const nextBoard = applyMove(board, move);
-  const opponentMoves = getAllMoves(nextBoard, oppositeColor(color));
-  return opponentMoves.some((candidate) => candidate.captures.length > 0);
-};
-
-const pickRandom = <T>(items: T[]): T | null => {
-  if (items.length === 0) return null;
-  return items[Math.floor(Math.random() * items.length)] ?? null;
-};
-
-export const pickMove = (board: CheckersBoard, color: CheckersColor, type: CheckersAiType): CheckersMove | null => {
-  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);
-};