internal static bool CanCastle(ChessBoard board, SquareCoordinates coord, Player p) { ChessPiece piece = board.GetPiece(coord); if (piece != null && piece.IsA(PieceType.ROOK) && piece.IsFriendly(p.White) && piece.HasNotMoved()) { SquareCoordinates kingSq = p.White ? new SquareCoordinates("E1") : new SquareCoordinates("E8"); piece = board.GetPiece(kingSq); if (piece != null && piece.IsA(PieceType.KING) && piece.IsFriendly(p.White) && piece.HasNotMoved() && !KingInCheck(board, p)) { if (coord.File == 0) { if (!board.WillPlaceKingInCheck(p, new SquareCoordinates[] { new SquareCoordinates(4, coord.Rank), new SquareCoordinates(0, coord.Rank) }, new SquareCoordinates[] { new SquareCoordinates(2, coord.Rank), new SquareCoordinates(3, coord.Rank) })) { for (int file = 1, rank = coord.Rank; file < 4; file++) if (board.GetPiece(coord = new SquareCoordinates(file, rank)) != null || Attackers(board, coord, p.White, true).Length > 0) return false; return true; } } else if (coord.File == 7) { if (!board.WillPlaceKingInCheck(p, new SquareCoordinates[] { new SquareCoordinates(4, coord.Rank), new SquareCoordinates(7, coord.Rank) }, new SquareCoordinates[] { new SquareCoordinates(6, coord.Rank), new SquareCoordinates(5, coord.Rank) })) { for (int file = 5, rank = coord.Rank; file < 7; file++) if (board.GetPiece(coord = new SquareCoordinates(file, rank)) != null || Attackers(board, coord, p.White, true).Length > 0) return false; return true; } } } } return false; }
internal static KingStatus KingConcern(ChessBoard board, Player p) { MoveSet moves = KingMoves(board, p.Material.KingSquare, p); SquareCoordinates[] attackingPieces = Attackers(board, p.Material.KingSquare, p.White, true); if (attackingPieces.Length != 0) { if (moves.LegalMoves.Length != 0) return KingStatus.CHECK; foreach (SquareCoordinates coord in attackingPieces) if (Attackers(board, coord, !p.White, true).Length == 0 && !CanInterpose(board, coord, p.Material.KingSquare, p)) return KingStatus.CHECKMATE; //there is one opponent piece that can reach our king and is unable to be captured or blocked return KingStatus.CHECK; } else { if (moves.LegalMoves.Length != 0) return KingStatus.NO_IMMEDIATE_CONCERN; foreach (SquareCoordinates coord in p.Material.Pieces) if (MoveSet(board, coord, p).LegalMoves.Length != 0) return KingStatus.NO_IMMEDIATE_CONCERN; //there is one friendly piece we can move return KingStatus.STALEMATE; } }
private static MoveSet RookMoves(ChessBoard board, SquareCoordinates coord, Player p) { List<Move> allowedMoves = new List<Move>(); List<SquareCoordinates> movesWithCheck = new List<SquareCoordinates>(); List<SquareCoordinates> blockedMoves = new List<SquareCoordinates>(); bool boardOrientation = board.WhiteOnBottom; bool white = p.White; SquareCoordinates nextSquare/*, opponentEnPassantPawn*/; Move m; int nextFile, nextRank; ProcessSquare linearProc = delegate(SquareCoordinates to) { /*if ((opponentEnPassantPawn = EnPassant(board, to, p.White)).File != -1 && opponentEnPassantPawn.Rank != -1) if (!board.WillPlaceKingInCheck(p, coord, m = new Move(to, opponentEnPassantPawn))) allowedMoves.Add(m); else movesWithCheck.Add(to); else*/ if (!board.WillPlaceKingInCheck(p, coord, m = new Move(to))) allowedMoves.Add(m); else movesWithCheck.Add(to); }; ProcessSquare blockingPieceProc = delegate(SquareCoordinates to) { if (!board.GetPiece(to).IsFriendly(white)) if (!board.WillPlaceKingInCheck(p, coord, m = new Move(to, to))) allowedMoves.Add(m); else movesWithCheck.Add(to); else blockedMoves.Add(to); }; nextFile = coord.File; nextRank = coord.Rank; while (++nextFile < 8 && board.GetPiece(nextSquare = new SquareCoordinates(nextFile, nextRank)) == null) linearProc(nextSquare); //we stop the loop if we encounter any piece, or if we start going out of bounds off the board. //if we did not stop at the edge of the board, check to see if the piece we stopped at is an opponent piece. if it is, we can move there as well if (nextFile < 8) blockingPieceProc(new SquareCoordinates(nextFile, nextRank)); nextFile = coord.File; nextRank = coord.Rank; while (++nextRank < 8 && board.GetPiece(nextSquare = new SquareCoordinates(nextFile, nextRank)) == null) linearProc(nextSquare); //we stop the loop if we encounter any piece, or if we start going out of bounds off the board. //if we did not stop at the edge of the board, check to see if the piece we stopped at is an opponent piece. if it is, we can move there as well if (nextRank < 8) blockingPieceProc(new SquareCoordinates(nextFile, nextRank)); nextFile = coord.File; nextRank = coord.Rank; while (--nextFile >= 0 && board.GetPiece(nextSquare = new SquareCoordinates(nextFile, nextRank)) == null) linearProc(nextSquare); //we stop the loop if we encounter any piece, or if we start going out of bounds off the board. //if we did not stop at the edge of the board, check to see if the piece we stopped at is an opponent piece. if it is, we can move there as well if (nextFile >= 0) blockingPieceProc(new SquareCoordinates(nextFile, nextRank)); nextFile = coord.File; nextRank = coord.Rank; while (--nextRank >= 0 && board.GetPiece(nextSquare = new SquareCoordinates(nextFile, nextRank)) == null) linearProc(nextSquare); //we stop the loop if we encounter any piece, or if we start going out of bounds off the board. //if we did not stop at the edge of the board, check to see if the piece we stopped at is an opponent piece. if it is, we can move there as well if (nextRank >= 0) blockingPieceProc(new SquareCoordinates(nextFile, nextRank)); return new MoveSet(allowedMoves, movesWithCheck, blockedMoves); }
private static MoveSet QueenMoves(ChessBoard board, SquareCoordinates coord, Player p) { //Queen's allowed moves are basically a combination of those of rook (diagonals) and bishop (vertical/horizontal) //so just call the methods to get rook and bishop moves and return a union of them return new MoveSet(RookMoves(board, coord, p), BishopMoves(board, coord, p)); }
//TODO: promotion (pawn reaching opponent's end of board -> any piece) private static MoveSet PawnMoves(ChessBoard board, SquareCoordinates coord, Player p) { List<Move> allowedMoves = new List<Move>(); List<SquareCoordinates> movesWithCheck = new List<SquareCoordinates>(); List<SquareCoordinates> blockedMoves = new List<SquareCoordinates>(); bool boardOrientation = board.WhiteOnBottom; bool white = p.White; SquareCoordinates nextSquare; ChessPiece existingPiece; Move m; int nextRank, nextFile; //check if piece would go out of bounds if (white && (nextRank = coord.Rank + 1) < 8 || !white && (nextRank = coord.Rank - 1) >= 0) { nextSquare = new SquareCoordinates(coord.File, nextRank); existingPiece = board.GetPiece(nextSquare); if (existingPiece == null) //move up 1 if no piece is in that space if (!board.WillPlaceKingInCheck(p, coord, m = new Move(nextSquare))) allowedMoves.Add(m); else movesWithCheck.Add(nextSquare); else blockedMoves.Add(nextSquare); //diagonal take SquareCoordinates opponentEnPassantPawn; ProcessSquare diagonalProc = delegate(SquareCoordinates to) { if ((existingPiece = board.GetPiece(to)) != null) { if (!existingPiece.IsFriendly(white)) if (!board.WillPlaceKingInCheck(p, coord, m = new Move(to, to))) allowedMoves.Add(m); else movesWithCheck.Add(to); } else if ((opponentEnPassantPawn = EnPassant(board, to, p.White)).File != -1 && opponentEnPassantPawn.Rank != -1) { if (!board.WillPlaceKingInCheck(p, coord, m = new Move(to, opponentEnPassantPawn))) allowedMoves.Add(m); else movesWithCheck.Add(nextSquare); } }; nextFile = coord.File + 1; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextFile < 8) diagonalProc(new SquareCoordinates(nextFile, nextRank)); //move diagonally up right if an opponent piece is in that space nextFile = coord.File - 1; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextFile >= 0) diagonalProc(new SquareCoordinates(nextFile, nextRank)); //move diagonally up left if an opponent piece is in that space } //check if we are still in the home position if (white && (nextRank = coord.Rank + 2) == 3 || !white && (nextRank = coord.Rank - 2) == 4) { nextSquare = new SquareCoordinates(coord.File, nextRank); SquareCoordinates betweenSquare = new SquareCoordinates(coord.File, (nextRank + coord.Rank) / 2); existingPiece = board.GetPiece(nextSquare); ChessPiece betweenPiece = board.GetPiece(betweenSquare); if (existingPiece == null && betweenPiece == null) //move up 2 spaces if no piece is at that space and no piece is in between if (!board.WillPlaceKingInCheck(p, coord, m = new Move(nextSquare))) allowedMoves.Add(m); else movesWithCheck.Add(nextSquare); else blockedMoves.Add(nextSquare); } return new MoveSet(allowedMoves, movesWithCheck, blockedMoves); }
private static MoveSet KnightMoves(ChessBoard board, SquareCoordinates coord, Player p) { List<Move> allowedMoves = new List<Move>(); List<SquareCoordinates> movesWithCheck = new List<SquareCoordinates>(); List<SquareCoordinates> blockedMoves = new List<SquareCoordinates>(); bool boardOrientation = board.WhiteOnBottom; bool white = p.White; //SquareCoordinates opponentEnPassantPawn; ChessPiece existingPiece; Move m; int nextFile, nextRank; ProcessSquare proc = delegate(SquareCoordinates to) { if ((existingPiece = board.GetPiece(to)) == null) /*if ((opponentEnPassantPawn = EnPassant(board, to, p.White)).File != -1 && opponentEnPassantPawn.Rank != -1) if (!board.WillPlaceKingInCheck(p, coord, m = new Move(to, opponentEnPassantPawn))) allowedMoves.Add(m); else movesWithCheck.Add(to); else*/ if (!board.WillPlaceKingInCheck(p, coord, m = new Move(to))) allowedMoves.Add(m); else movesWithCheck.Add(to); else if (!existingPiece.IsFriendly(p.White)) if (!board.WillPlaceKingInCheck(p, coord, m = new Move(to, to))) allowedMoves.Add(m); else movesWithCheck.Add(to); else blockedMoves.Add(to); }; nextFile = coord.File + 1; if (nextFile < 8) { nextRank = coord.Rank + 2; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextRank < 8) proc(new SquareCoordinates(nextFile, nextRank)); //right 1 up 2 nextRank = coord.Rank - 2; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextRank >= 0) proc(new SquareCoordinates(nextFile, nextRank)); //right 1 down 2 } nextFile = coord.File + 2; if (nextFile < 8) { nextRank = coord.Rank + 1; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextRank < 8) proc(new SquareCoordinates(nextFile, nextRank)); //right 2 up 1 nextRank = coord.Rank - 1; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextRank >= 0) proc(new SquareCoordinates(nextFile, nextRank)); //right 2 down 1 } nextFile = coord.File - 1; if (nextFile >= 0) { nextRank = coord.Rank + 2; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextRank < 8) proc(new SquareCoordinates(nextFile, nextRank)); //left 1 up 2 nextRank = coord.Rank - 2; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextRank >= 0) proc(new SquareCoordinates(nextFile, nextRank)); //left 1 down 2 } nextFile = coord.File - 2; if (nextFile >= 0) { nextRank = coord.Rank + 1; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextRank < 8) proc(new SquareCoordinates(nextFile, nextRank)); //left 2 up 1 nextRank = coord.Rank - 1; //check if we are in bounds and that either no piece exists there, or the piece is not a friendly if (nextRank >= 0) proc(new SquareCoordinates(nextFile, nextRank)); //left 2 down 1 } return new MoveSet(allowedMoves, movesWithCheck, blockedMoves); }
private static bool CanInterpose(ChessBoard board, SquareCoordinates from, SquareCoordinates to, Player p) { switch (board.GetPiece(from).Type) { case PieceType.PAWN: return false; //if pawns cannot be captured, they cannot be blocked by friendly pieces! case PieceType.KNIGHT: return false; //if knights cannot be captured, they cannot be blocked by friendly pieces! case PieceType.BISHOP: if (from.File - to.File == from.Rank - to.Rank) { for (int file = Math.Min(from.File, to.File) + 1, rank = Math.Min(from.Rank, to.Rank) + 1; file < Math.Max(from.File, to.File); file++, rank++) if (Attackers(board, new SquareCoordinates(file, rank), !p.White, false).Length > 0) return true; } else if (from.File - to.File == -(from.Rank - to.Rank)) { for (int file = Math.Min(from.File, to.File) + 1, rank = Math.Max(from.Rank, to.Rank) + 1; file < Math.Max(from.File, to.File) && rank < 8; file++, rank--) if (Attackers(board, new SquareCoordinates(file, rank), !p.White, false).Length > 0) return true; } return false; case PieceType.ROOK: if (from.File == to.File) { for (int file = from.File, rank = Math.Min(from.Rank, to.Rank) + 1; rank < Math.Max(from.Rank, to.Rank); rank++) if (Attackers(board, new SquareCoordinates(file, rank), !p.White, false).Length > 0) return true; } else if (from.Rank == to.Rank) { for (int file = Math.Min(from.File, to.File) + 1, rank = from.Rank; file < Math.Max(from.File, to.File); file++) if (Attackers(board, new SquareCoordinates(file, rank), !p.White, false).Length > 0) return true; } return false; case PieceType.QUEEN: if (from.File == to.File || from.Rank == to.Rank) goto case PieceType.ROOK; else if (Math.Abs(from.File - to.File) == Math.Abs(from.Rank - to.Rank)) goto case PieceType.BISHOP; return false; default: return false; } }
internal static MoveSet MoveSet(ChessBoard board, SquareCoordinates coord, Player p) { switch (board.GetPiece(coord).Type) { case PieceType.PAWN: return PawnMoves(board, coord, p); case PieceType.KNIGHT: return KnightMoves(board, coord, p); case PieceType.BISHOP: return BishopMoves(board, coord, p); case PieceType.ROOK: return RookMoves(board, coord, p); case PieceType.QUEEN: return QueenMoves(board, coord, p); case PieceType.KING: return KingMoves(board, coord, p); default: return new MoveSet(); } }
internal static bool KingInCheck(ChessBoard board, Player p) { return KingInCheck(board, p.Material.KingSquare, p.White); }