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

package/src/utils/board.ts

@@ -1,252 +0,0 @@
-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 const BOARD_SIZE = 8;
-
-export const oppositeColor = (color: CheckersColor): CheckersColor => (color === "white" ? "black" : "white");
-
-export const isDarkSquare = (row: number, column: number) => (row + column) % 2 === 1;
-
-export const inBounds = (row: number, column: number) => row >= 0 && row < BOARD_SIZE && column >= 0 && column < BOARD_SIZE;
-
-export const cloneBoard = (board: CheckersBoard): CheckersBoard => board.map((row) => row.map((cell) => (cell ? { ...cell } : null)));
-
-export const createInitialBoard = (): CheckersBoard => {
-  const board: CheckersBoard = 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 },
-] as const;
-
-const forwardRowDelta = (color: CheckersColor) => (color === "white" ? -1 : 1);
-
-const posKey = (pos: CheckersPos) => `${pos.row}:${pos.column}`;
-
-export const samePos = (a: CheckersPos, b: CheckersPos) => a.row === b.row && a.column === b.column;
-
-const getPiece = (board: CheckersBoard, pos: CheckersPos) => board[pos.row]?.[pos.column] ?? null;
-
-const setPiece = (board: CheckersBoard, pos: CheckersPos, piece: CheckersPiece | null) => {
-  board[pos.row]![pos.column] = piece;
-};
-
-const promoteIfNeeded = (piece: CheckersPiece, row: number): CheckersPiece => {
-  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: CheckersBoard, from: CheckersPos, piece: CheckersPiece): CheckersMove[] => {
-  const moves: CheckersMove[] = [];
-  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: CheckersBoard, from: CheckersPos, piece: CheckersPiece, capturedKeys: Set<string>): CheckersMove[] => {
-  const moves: CheckersMove[] = [];
-
-  for (const { dr, dc } of DIAGONALS) {
-    if (piece.king) {
-      let row = from.row + dr;
-      let column = from.column + dc;
-      let enemy: CheckersPos | null = 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: CheckersPos = { row: from.row + dr, column: from.column + dc };
-    const to: CheckersPos = { 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: CheckersBoard,
-  from: CheckersPos,
-  piece: CheckersPiece,
-  origin: CheckersPos,
-  capturedSoFar: CheckersPos[],
-  capturedKeys: Set<string>,
-): CheckersMove[] => {
-  const immediate = collectImmediateCaptures(board, from, piece, capturedKeys);
-  if (immediate.length === 0) {
-    return capturedSoFar.length > 0 ? [{ from: origin, to: from, captures: capturedSoFar }] : [];
-  }
-
-  const results: CheckersMove[] = [];
-
-  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: CheckersBoard, from: CheckersPos): CheckersMove[] => {
-  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: CheckersBoard, color: CheckersColor, onlyFrom?: CheckersPos): CheckersMove[] => {
-  const moves: CheckersMove[] = [];
-
-  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: CheckersBoard, move: CheckersMove): CheckersBoard => {
-  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: CheckersBoard, from: CheckersPos, to: CheckersPos, capture: CheckersPos): CheckersBoard => {
-  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: CheckersBoard) => {
-  const pieces: Array<CheckersPiece & CheckersPos> = [];
-
-  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: CheckersBoard, color: CheckersColor) => {
-  let count = 0;
-  for (const row of board) {
-    for (const cell of row) {
-      if (cell?.color === color) count++;
-    }
-  }
-  return count;
-};
-
-export const getWinner = (board: CheckersBoard, colorToMove: CheckersColor): CheckersColor | null => {
-  if (countPieces(board, colorToMove) === 0) return oppositeColor(colorToMove);
-  if (getAllMoves(board, colorToMove).length === 0) return oppositeColor(colorToMove);
-  return null;
-};
-
-export const findMove = (moves: CheckersMove[], from: CheckersPos, to: CheckersPos) => moves.find((move) => samePos(move.from, from) && samePos(move.to, to));