428 lines
13 KiB
TypeScript
428 lines
13 KiB
TypeScript
import { type ChessPiece, PieceType, PieceColor, type Position, type MoveResult, GameMode } from "./chess-types"
|
|
import { cloneBoard, findKingPosition } from "./chess-utils"
|
|
|
|
// Check if a move is valid for a specific piece
|
|
export function isValidMove(
|
|
board: (ChessPiece | null)[][],
|
|
from: Position,
|
|
to: Position,
|
|
currentPlayer: PieceColor,
|
|
gameMode: GameMode = GameMode.CLASSIC,
|
|
): boolean {
|
|
// Cannot move to the same position
|
|
if (from.row === to.row && from.col === to.col) {
|
|
return false
|
|
}
|
|
|
|
const piece = board[from.row][from.col]
|
|
|
|
// No piece at the starting position or wrong player's piece
|
|
if (!piece || piece.color !== currentPlayer) {
|
|
return false
|
|
}
|
|
|
|
const targetPiece = board[to.row][to.col]
|
|
|
|
// Cannot capture own piece
|
|
if (targetPiece && targetPiece.color === piece.color) {
|
|
return false
|
|
}
|
|
|
|
// Check piece-specific movement rules
|
|
let validPieceMove = false
|
|
|
|
switch (piece.type) {
|
|
case PieceType.PAWN:
|
|
validPieceMove = isValidPawnMove(board, from, to)
|
|
break
|
|
case PieceType.ROOK:
|
|
validPieceMove = isValidRookMove(board, from, to)
|
|
break
|
|
case PieceType.KNIGHT:
|
|
validPieceMove = isValidKnightMove(from, to)
|
|
break
|
|
case PieceType.BISHOP:
|
|
validPieceMove = isValidBishopMove(board, from, to)
|
|
break
|
|
case PieceType.QUEEN:
|
|
validPieceMove = isValidQueenMove(board, from, to)
|
|
break
|
|
case PieceType.KING:
|
|
validPieceMove = isValidKingMove(board, from, to)
|
|
break
|
|
}
|
|
|
|
if (!validPieceMove) {
|
|
return false
|
|
}
|
|
|
|
// In ghost chess, forced captures take priority
|
|
if (gameMode === GameMode.GHOST) {
|
|
const captureMoves = getCaptureMoves(board, currentPlayer)
|
|
const isCapture = targetPiece !== null
|
|
|
|
// If there are capture moves available and this isn't a capture, it's invalid
|
|
if (captureMoves.length > 0 && !isCapture) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Check if the move would put or leave the king in check (only in classic mode)
|
|
if (gameMode === GameMode.CLASSIC) {
|
|
const newBoard = cloneBoard(board)
|
|
newBoard[to.row][to.col] = newBoard[from.row][from.col]
|
|
newBoard[from.row][from.col] = null
|
|
|
|
return !isKingInCheck(newBoard, piece.color)
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// Make a move and return the new board state
|
|
export function makeMove(board: (ChessPiece | null)[][], from: Position, to: Position): MoveResult {
|
|
const newBoard = cloneBoard(board)
|
|
const piece = newBoard[from.row][from.col]
|
|
const capturedPiece = newBoard[to.row][to.col]
|
|
|
|
if (!piece) {
|
|
return { newBoard, capturedPiece: null }
|
|
}
|
|
|
|
// Update hasMoved property for pawns, kings, and rooks (for castling)
|
|
if (piece.type === PieceType.PAWN || piece.type === PieceType.KING || piece.type === PieceType.ROOK) {
|
|
piece.hasMoved = true
|
|
}
|
|
|
|
// Handle pawn promotion
|
|
if (piece.type === PieceType.PAWN && (to.row === 0 || to.row === 7)) {
|
|
piece.type = PieceType.QUEEN // Auto-promote to queen for simplicity
|
|
}
|
|
|
|
// Handle castling
|
|
if (piece.type === PieceType.KING && Math.abs(from.col - to.col) === 2) {
|
|
const isKingSide = to.col > from.col
|
|
const rookCol = isKingSide ? 7 : 0
|
|
const newRookCol = isKingSide ? from.col + 1 : from.col - 1
|
|
|
|
// Move the rook
|
|
newBoard[from.row][newRookCol] = newBoard[from.row][rookCol]
|
|
newBoard[from.row][rookCol] = null
|
|
|
|
if (newBoard[from.row][newRookCol]) {
|
|
newBoard[from.row][newRookCol].hasMoved = true
|
|
}
|
|
}
|
|
|
|
// Make the move
|
|
newBoard[to.row][to.col] = piece
|
|
newBoard[from.row][from.col] = null
|
|
|
|
return { newBoard, capturedPiece }
|
|
}
|
|
|
|
// Check if the king of the given color is in check
|
|
export function isCheck(board: (ChessPiece | null)[][], color: PieceColor): boolean {
|
|
return isKingInCheck(board, color)
|
|
}
|
|
|
|
// Check if the king of the given color is in checkmate
|
|
export function isCheckmate(board: (ChessPiece | null)[][], color: PieceColor, gameMode: GameMode = GameMode.CLASSIC): boolean {
|
|
// Ghost chess doesn't have checkmate
|
|
if (gameMode === GameMode.GHOST) {
|
|
return false
|
|
}
|
|
|
|
// If the king is not in check, it's not checkmate
|
|
if (!isKingInCheck(board, color)) {
|
|
return false
|
|
}
|
|
|
|
// Check if any move can get the king out of check
|
|
return !hasLegalMoves(board, color, gameMode)
|
|
}
|
|
|
|
// Check if the position is a stalemate
|
|
export function isStalemate(board: (ChessPiece | null)[][], color: PieceColor, gameMode: GameMode = GameMode.CLASSIC): boolean {
|
|
// Ghost chess doesn't have stalemate
|
|
if (gameMode === GameMode.GHOST) {
|
|
return false
|
|
}
|
|
|
|
// If the king is in check, it's not stalemate
|
|
if (isKingInCheck(board, color)) {
|
|
return false
|
|
}
|
|
|
|
// If the player has no legal moves, it's stalemate
|
|
return !hasLegalMoves(board, color, gameMode)
|
|
}
|
|
|
|
// Helper function to check if a player has any legal moves
|
|
function hasLegalMoves(board: (ChessPiece | null)[][], color: PieceColor, gameMode: GameMode = GameMode.CLASSIC): boolean {
|
|
for (let fromRow = 0; fromRow < 8; fromRow++) {
|
|
for (let fromCol = 0; fromCol < 8; fromCol++) {
|
|
const piece = board[fromRow][fromCol]
|
|
if (piece && piece.color === color) {
|
|
for (let toRow = 0; toRow < 8; toRow++) {
|
|
for (let toCol = 0; toCol < 8; toCol++) {
|
|
if (isValidMove(board, { row: fromRow, col: fromCol }, { row: toRow, col: toCol }, color, gameMode)) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Helper function to check if the king is in check
|
|
function isKingInCheck(board: (ChessPiece | null)[][], kingColor: PieceColor): boolean {
|
|
const kingPosition = findKingPosition(board, kingColor)
|
|
if (!kingPosition) return false
|
|
|
|
const opponentColor = kingColor === PieceColor.WHITE ? PieceColor.BLACK : PieceColor.WHITE
|
|
|
|
// Check if any opponent piece can capture the king
|
|
for (let row = 0; row < 8; row++) {
|
|
for (let col = 0; col < 8; col++) {
|
|
const piece = board[row][col]
|
|
if (piece && piece.color === opponentColor) {
|
|
// Use a simplified version of isValidMove that doesn't check for check
|
|
// to avoid infinite recursion
|
|
if (canPieceMove(board, { row, col }, kingPosition)) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// Simplified version of isValidMove that doesn't check for check
|
|
function canPieceMove(board: (ChessPiece | null)[][], from: Position, to: Position): boolean {
|
|
const piece = board[from.row][from.col]
|
|
if (!piece) return false
|
|
|
|
const targetPiece = board[to.row][to.col]
|
|
if (targetPiece && targetPiece.color === piece.color) return false
|
|
|
|
switch (piece.type) {
|
|
case PieceType.PAWN:
|
|
return isValidPawnMove(board, from, to)
|
|
case PieceType.ROOK:
|
|
return isValidRookMove(board, from, to)
|
|
case PieceType.KNIGHT:
|
|
return isValidKnightMove(from, to)
|
|
case PieceType.BISHOP:
|
|
return isValidBishopMove(board, from, to)
|
|
case PieceType.QUEEN:
|
|
return isValidQueenMove(board, from, to)
|
|
case PieceType.KING:
|
|
return isValidKingMove(board, from, to)
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Check if a pawn move is valid
|
|
function isValidPawnMove(board: (ChessPiece | null)[][], from: Position, to: Position): boolean {
|
|
const piece = board[from.row][from.col]
|
|
if (!piece || piece.type !== PieceType.PAWN) return false
|
|
|
|
const direction = piece.color === PieceColor.WHITE ? -1 : 1
|
|
const startRow = piece.color === PieceColor.WHITE ? 6 : 1
|
|
|
|
// Moving forward one square
|
|
if (from.col === to.col && from.row + direction === to.row && !board[to.row][to.col]) {
|
|
return true
|
|
}
|
|
|
|
// Moving forward two squares from starting position
|
|
if (
|
|
from.col === to.col &&
|
|
from.row === startRow &&
|
|
from.row + 2 * direction === to.row &&
|
|
!board[from.row + direction][from.col] &&
|
|
!board[to.row][to.col]
|
|
) {
|
|
return true
|
|
}
|
|
|
|
// Capturing diagonally
|
|
if ((from.col + 1 === to.col || from.col - 1 === to.col) && from.row + direction === to.row) {
|
|
return board[to.row][to.col] !== null
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// Check if a rook move is valid
|
|
function isValidRookMove(board: (ChessPiece | null)[][], from: Position, to: Position): boolean {
|
|
// Rooks move horizontally or vertically
|
|
if (from.row !== to.row && from.col !== to.col) {
|
|
return false
|
|
}
|
|
|
|
// Check if the path is clear
|
|
if (from.row === to.row) {
|
|
// Horizontal movement
|
|
const start = Math.min(from.col, to.col)
|
|
const end = Math.max(from.col, to.col)
|
|
|
|
for (let col = start + 1; col < end; col++) {
|
|
if (board[from.row][col] !== null) {
|
|
return false
|
|
}
|
|
}
|
|
} else {
|
|
// Vertical movement
|
|
const start = Math.min(from.row, to.row)
|
|
const end = Math.max(from.row, to.row)
|
|
|
|
for (let row = start + 1; row < end; row++) {
|
|
if (board[row][from.col] !== null) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// Check if a knight move is valid
|
|
function isValidKnightMove(from: Position, to: Position): boolean {
|
|
const rowDiff = Math.abs(from.row - to.row)
|
|
const colDiff = Math.abs(from.col - to.col)
|
|
|
|
// Knights move in an L-shape: 2 squares in one direction and 1 square perpendicular
|
|
return (rowDiff === 2 && colDiff === 1) || (rowDiff === 1 && colDiff === 2)
|
|
}
|
|
|
|
// Check if a bishop move is valid
|
|
function isValidBishopMove(board: (ChessPiece | null)[][], from: Position, to: Position): boolean {
|
|
const rowDiff = Math.abs(from.row - to.row)
|
|
const colDiff = Math.abs(from.col - to.col)
|
|
|
|
// Bishops move diagonally
|
|
if (rowDiff !== colDiff) {
|
|
return false
|
|
}
|
|
|
|
// Check if the path is clear
|
|
const rowDirection = from.row < to.row ? 1 : -1
|
|
const colDirection = from.col < to.col ? 1 : -1
|
|
|
|
for (let i = 1; i < rowDiff; i++) {
|
|
if (board[from.row + i * rowDirection][from.col + i * colDirection] !== null) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// Check if a queen move is valid
|
|
function isValidQueenMove(board: (ChessPiece | null)[][], from: Position, to: Position): boolean {
|
|
// Queens can move like rooks or bishops
|
|
return isValidRookMove(board, from, to) || isValidBishopMove(board, from, to)
|
|
}
|
|
|
|
// Check if a king move is valid
|
|
function isValidKingMove(board: (ChessPiece | null)[][], from: Position, to: Position): boolean {
|
|
const rowDiff = Math.abs(from.row - to.row)
|
|
const colDiff = Math.abs(from.col - to.col)
|
|
|
|
// Kings move one square in any direction
|
|
if (rowDiff <= 1 && colDiff <= 1) {
|
|
return true
|
|
}
|
|
|
|
// Check for castling
|
|
const piece = board[from.row][from.col]
|
|
if (piece && piece.type === PieceType.KING && !piece.hasMoved && rowDiff === 0 && colDiff === 2) {
|
|
// Determine if it's kingside or queenside castling
|
|
const isKingSide = to.col > from.col
|
|
const rookCol = isKingSide ? 7 : 0
|
|
|
|
// Check if the rook is in place and hasn't moved
|
|
const rook = board[from.row][rookCol]
|
|
if (!rook || rook.type !== PieceType.ROOK || rook.color !== piece.color || rook.hasMoved) {
|
|
return false
|
|
}
|
|
|
|
// Check if the path is clear
|
|
const start = isKingSide ? from.col + 1 : rookCol + 1
|
|
const end = isKingSide ? rookCol : from.col
|
|
|
|
for (let col = start; col < end; col++) {
|
|
if (board[from.row][col] !== null) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Check if the king is in check or would pass through check
|
|
const tempBoard = cloneBoard(board)
|
|
tempBoard[from.row][from.col] = null
|
|
|
|
// Check if the king is in check
|
|
if (isKingInCheck(tempBoard, piece.color)) {
|
|
return false
|
|
}
|
|
|
|
// Check if the king would pass through check
|
|
tempBoard[from.row][isKingSide ? from.col + 1 : from.col - 1] = piece
|
|
if (isKingInCheck(tempBoard, piece.color)) {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// Get all possible capture moves for a player (for ghost chess)
|
|
export function getCaptureMoves(board: (ChessPiece | null)[][], color: PieceColor): { from: Position; to: Position }[] {
|
|
const captureMoves: { from: Position; to: Position }[] = []
|
|
|
|
for (let fromRow = 0; fromRow < 8; fromRow++) {
|
|
for (let fromCol = 0; fromCol < 8; fromCol++) {
|
|
const piece = board[fromRow][fromCol]
|
|
if (piece && piece.color === color) {
|
|
for (let toRow = 0; toRow < 8; toRow++) {
|
|
for (let toCol = 0; toCol < 8; toCol++) {
|
|
const targetPiece = board[toRow][toCol]
|
|
if (targetPiece && targetPiece.color !== color) {
|
|
// Check if this piece can capture the target
|
|
if (canPieceMove(board, { row: fromRow, col: fromCol }, { row: toRow, col: toCol })) {
|
|
captureMoves.push({
|
|
from: { row: fromRow, col: fromCol },
|
|
to: { row: toRow, col: toCol }
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return captureMoves
|
|
}
|
|
|
|
// Check if a player has lost all their pieces (ghost chess win condition)
|
|
export function hasLostAllPieces(board: (ChessPiece | null)[][], color: PieceColor): boolean {
|
|
for (let row = 0; row < 8; row++) {
|
|
for (let col = 0; col < 8; col++) {
|
|
const piece = board[row][col]
|
|
if (piece && piece.color === color) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|