// Method to determine of the SelectedPiece is attacking the other players king public bool attackingKing(ref ChessBoardState chessBoardState) { // Switch Condition to test which piece is selected. switch (chessBoardState.SelectedPiece.piece) { // return if the piece is attacking the other players king. case Pieces.bb: return(BishopMoves.attackingKing(ref chessBoardState)); case Pieces.bk: return(KingMoves.attackingKing(ref chessBoardState)); case Pieces.bn: return(KnightMoves.attakingKing(ref chessBoardState)); case Pieces.bp: return(PawnMoves.attakingKing(ref chessBoardState)); case Pieces.bq: return(QueenMoves.attackingKing(ref chessBoardState)); case Pieces.br: return(RookMoves.attackingKing(ref chessBoardState)); case Pieces.wb: return(BishopMoves.attackingKing(ref chessBoardState)); case Pieces.wk: return(KingMoves.attackingKing(ref chessBoardState)); case Pieces.wn: return(KnightMoves.attakingKing(ref chessBoardState)); case Pieces.wp: return(PawnMoves.attakingKing(ref chessBoardState)); case Pieces.wq: return(QueenMoves.attackingKing(ref chessBoardState)); case Pieces.wr: return(RookMoves.attackingKing(ref chessBoardState)); } return(false); }
//Method to test if the other player is in check. public bool Check(ref ChessBoardState chessBoardState) { List <ChessPiece> playersPieces = chessBoardState.WhitesMove ? chessBoardState.WhitePieces : chessBoardState.BlackPieces; //Square otherKingSquare = chessBoardState.WhitesMove ? chessBoardState.BlackKingSquare : chessBoardState.WhiteKingSquare; ChessPiece selectedPiece = chessBoardState.SelectedPiece; for (int i = 0; i < playersPieces.Count; i++) { chessBoardState.SelectedPiece = playersPieces[i]; //Console.Write($" {chessBoardState.SelectedPiece.piece.ToString()}"); /*List<Square> playerPotentialMoves = getPotentialMoves(ref chessBoardState); * for (int j = 0; j < playerPotentialMoves.Count; j++) * { * if (playerPotentialMoves[j].Equals(otherKingSquare)) * { * chessBoardState.SelectedPiece = selectedPiece; * return true; * } * }*/ if (attackingKing(ref chessBoardState)) { chessBoardState.SelectedPiece = selectedPiece; return(true); } } chessBoardState.SelectedPiece = selectedPiece; return(false); }
// Method to return the valid moves of the selected piece. public List <Square> getValidMoves(ref ChessBoardState chessBoardState) { List <Square> validMoves = new List <Square>(); ChessBoardState cBoard = cloneChessBoardState(ref chessBoardState); List <Square> potentialMoves = getPotentialMoves(ref cBoard); //Console.WriteLine(potentialMoves.Count); for (int i = 0; i < potentialMoves.Count; i++) { //Console.WriteLine($"{potentialMoves[i].row}, {potentialMoves[i].column}"); movePiece(ref cBoard, potentialMoves[i]); if (!Check(ref cBoard)) { validMoves.Add(potentialMoves[i]); } cBoard = cloneChessBoardState(ref chessBoardState); // TODO undo move instead. } backGroundChanges = new List <ChessPiece>(); if (chessBoardState.SelectedPiece.piece == Pieces.wk || chessBoardState.SelectedPiece.piece == Pieces.bk) { validCastling(ref chessBoardState, ref validMoves);; } //validMoves = potentialMoves; return(validMoves); }
// Method to test if a rook is being moved. private void RookMove(ref ChessBoardState chessBoardState) { // Condition to test if the Selected Piece is a rook. if (chessBoardState.SelectedPiece.piece == Pieces.wr || chessBoardState.SelectedPiece.piece == Pieces.br) { // Condition to test if it is WhitesMove if (chessBoardState.WhitesMove) { // White King rook if (chessBoardState.WhiteRooksMoved[0] == false && chessBoardState.SelectedPiece.square.Equals(new Square(7, 7))) { chessBoardState.WhiteRooksMoved[0] = true; } // White Queen rook if (chessBoardState.WhiteRooksMoved[1] == false && chessBoardState.SelectedPiece.square.Equals(new Square(7, 0))) { chessBoardState.WhiteRooksMoved[1] = true; } return; } // Black King rook if (chessBoardState.BlackRooksMoved[0] == false && chessBoardState.SelectedPiece.square.Equals(new Square(0, 7))) { chessBoardState.BlackRooksMoved[0] = true; } // Black Queen rook if (chessBoardState.BlackRooksMoved[1] == false && chessBoardState.SelectedPiece.square.Equals(new Square(0, 0))) { chessBoardState.BlackRooksMoved[1] = true; } } }
public List <Square> getPotentialMoves(ref ChessBoardState chessBoardState) { List <Square> potentialMoves = new List <Square>(); // Get the potential moves for the selected Piece Pieces piece = chessBoardState.SelectedPiece.piece; switch (piece) { case Pieces.bb: potentialMoves = BishopMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.bk: potentialMoves = KingMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.bn: potentialMoves = KnightMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.bp: potentialMoves = PawnMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.bq: potentialMoves = QueenMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.br: potentialMoves = RookMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.wb: potentialMoves = BishopMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.wk: potentialMoves = KingMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.wn: potentialMoves = KnightMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.wp: potentialMoves = PawnMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.wq: potentialMoves = QueenMoves.getPotentialMoves(ref chessBoardState); break; case Pieces.wr: potentialMoves = RookMoves.getPotentialMoves(ref chessBoardState); break; } return(potentialMoves); }
public void GetMoves_Rook(ChessColor color) { var board = new ChessBoardState(); board.Clear(); board.SetSideToMove(color); board.SetSpot(4, 5, color == ChessColor.White ? ChessPiece.WhiteRook : ChessPiece.BlackRook); var expectedMoves = new List <string> { "Rd5-d1", "Rd5-d2", "Rd5-d3", "Rd5-d4", "Rd5-a5", "Rd5-b5", "Rd5-c5", "Rd5-e5", "Rd5-f5", "Rd5-g5", "Rd5-h5", "Rd5-d6", "Rd5-d7", "Rd5-d8" }; CheckPossibleMoves(board, expectedMoves); }
public void GetMoves_WhiteCanDeliverCheck() { var board = new ChessBoardState(); board.Clear(); board.SetSpot(1, 1, ChessPiece.WhiteRook); board.SetSpot(5, 1, ChessPiece.WhiteKing); board.SetSpot(5, 8, ChessPiece.BlackKing); board.SetSpot(1, 8, ChessPiece.BlackRook); var expectedMoves = new List <string> { "Ra1-b1", "Ra1-c1", "Ra1-d1", "Ra1-a2", "Ra1-a3", "Ra1-a4", "Ra1-a5", "Ra1-a6", "Ra1-a7", "Ra1xa8", "Ke1-d1", "Ke1-f1", "Ke1-d2", "Ke1-e2", "Ke1-f2", }; CheckPossibleMoves(board, expectedMoves); }
public void GetMoves_BlackPawn_PromotionCapture_Blockers() { var board = new ChessBoardState(); board.Clear(); board.SetSideToMove(ChessColor.Black); board.SetSpot(4, 2, ChessPiece.BlackPawn); board.SetSpot(3, 1, ChessPiece.WhiteKnight); board.SetSpot(5, 1, ChessPiece.BlackKnight); var expectedMoves = new List <string> { // Knight moves (don't forget!) "Ne1-c2", "Ne1-g2", "Ne1-d3", "Ne1-f3", "Pd2xc1=b", "Pd2xc1=n", "Pd2xc1=q", "Pd2xc1=r", "Pd2-d1=b", "Pd2-d1=n", "Pd2-d1=q", "Pd2-d1=r", }; CheckPossibleMoves(board, expectedMoves); }
public ChessBoardState GetBoardState() { ChessBoardState state = ChessBoardState.Normal; GetBoardThreats( out var ownKingUnderThreat, CurrentPlayer == PiecePlayer.White ? PiecePlayer.Black : PiecePlayer.White); int movesAvailable = GetAllAvailableMoves().Count(); if (ownKingUnderThreat == true) { if (movesAvailable == 0) { state = ChessBoardState.CheckMate; } else { state = ChessBoardState.Check; } } else if (movesAvailable == 0) { state = ChessBoardState.StaleMate; } return(state); }
public void GetMoves_BlackPawn_PromotionCapture() { var board = new ChessBoardState(); board.Clear(); board.SetSideToMove(ChessColor.Black); board.SetSpot(4, 2, ChessPiece.BlackPawn); board.SetSpot(3, 1, ChessPiece.WhiteKnight); board.SetSpot(5, 1, ChessPiece.WhiteKnight); var expectedMoves = new List <string> { "Pd2xc1=b", "Pd2xc1=n", "Pd2xc1=q", "Pd2xc1=r", "Pd2-d1=b", "Pd2-d1=n", "Pd2-d1=q", "Pd2-d1=r", "Pd2xe1=b", "Pd2xe1=n", "Pd2xe1=q", "Pd2xe1=r", }; CheckPossibleMoves(board, expectedMoves); }
public void GetPossibleFirstMovesForBlack() { var board = new ChessBoardState(); board.TryMakeMove(5); // White moves a pawn. var expectedMoves = new List <string> { "Pa7-a5", "Pa7-a6", "Pb7-b5", "Pb7-b6", "Pc7-c5", "Pc7-c6", "Pd7-d5", "Pd7-d6", "Pe7-e5", "Pe7-e6", "Pf7-f5", "Pf7-f6", "Pg7-g5", "Pg7-g6", "Ph7-h5", "Ph7-h6", "Nb8-a6", "Nb8-c6", "Ng8-f6", "Ng8-h6" }; CheckPossibleMoves(board, expectedMoves); }
public void GetMoves_WhitePawn_PromotionCapture() { var board = new ChessBoardState(); board.Clear(); board.SetSpot(4, 7, ChessPiece.WhitePawn); board.SetSpot(3, 8, ChessPiece.BlackKnight); board.SetSpot(5, 8, ChessPiece.BlackKnight); var expectedMoves = new List <string> { "Pd7xc8=b", "Pd7xc8=n", "Pd7xc8=q", "Pd7xc8=r", "Pd7-d8=b", "Pd7-d8=n", "Pd7-d8=q", "Pd7-d8=r", "Pd7xe8=b", "Pd7xe8=n", "Pd7xe8=q", "Pd7xe8=r", }; CheckPossibleMoves(board, expectedMoves); }
public void GetMoves_WhitePawn_PromotionCapture_Blockers() { var board = new ChessBoardState(); board.Clear(); board.SetSpot(4, 7, ChessPiece.WhitePawn); board.SetSpot(3, 8, ChessPiece.BlackKnight); board.SetSpot(5, 8, ChessPiece.WhiteKnight); var expectedMoves = new List <string> { "Pd7xc8=b", "Pd7xc8=n", "Pd7xc8=q", "Pd7xc8=r", "Pd7-d8=b", "Pd7-d8=n", "Pd7-d8=q", "Pd7-d8=r", // Knight moves (don't forget!) "Ne8-d6", "Ne8-f6", "Ne8-c7", "Ne8-g7" }; CheckPossibleMoves(board, expectedMoves); }
public void GetDefaultFEN() { var board = new ChessBoardState(); var boardFEN = board.GetFEN(); Assert.AreEqual("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", boardFEN); }
public void GetPossibleFirstMovesForWhite() { var board = new ChessBoardState(); var expectedMoves = new List <string> { "Nb1-a3", "Nb1-c3", "Ng1-f3", "Ng1-h3", "Pa2-a3", "Pa2-a4", "Pb2-b3", "Pb2-b4", "Pc2-c3", "Pc2-c4", "Pd2-d3", "Pd2-d4", "Pe2-e3", "Pe2-e4", "Pf2-f3", "Pf2-f4", "Pg2-g3", "Pg2-g4", "Ph2-h3", "Ph2-h4" }; CheckPossibleMoves(board, expectedMoves); }
public void GetMoves_WhiteKing_CanCastleBothSides() { var board = new ChessBoardState(); board.Clear(); board.SetSpot(5, 1, ChessPiece.WhiteKing); board.SetSpot(1, 1, ChessPiece.WhiteRook); board.SetSpot(8, 1, ChessPiece.WhiteRook); board.SetSpot(1, 2, ChessPiece.BlackRook); board.SetSpot(8, 2, ChessPiece.BlackRook); board.SetWhiteCanCastleKingside(true); board.SetWhiteCanCastleQueenside(true); var expectedMoves = new List <string> { // A1 Rook "Ra1-b1", "Ra1-c1", "Ra1-d1", "Ra1xa2", // King "O-O-O", "Ke1-d1", "Ke1-f1", "O-O", // H1 Rook "Rh1-f1", "Rh1-g1", "Rh1xh2" }; CheckPossibleMoves(board, expectedMoves); }
private void PawnPromotion(ref ChessBoardState chessBoardState, Square square) { // Condition to test if the SelectedPiece is a pawn. if (chessBoardState.SelectedPiece.piece == Pieces.wp || chessBoardState.SelectedPiece.piece == Pieces.bp) { // Initialize backRank to be the row of the other players backRank. int backRank = chessBoardState.WhitesMove ? 0 : 7; // Condtion to test if the row the pawn is being moved to is the backRank. if (square.row == backRank) { // Condition to test if it is WhitesMove and to queen. if (chessBoardState.WhitesMove && chessBoardState.WhiteAlwaysQueen) { chessBoardState.SelectedPiece.piece = Pieces.wq; return; } // Condition to test if it is BlacksMove and to queen. if (!chessBoardState.WhitesMove && chessBoardState.BlackAlwaysQueen) { chessBoardState.SelectedPiece.piece = Pieces.bq; return; } chessBoardState.promotePawn = true; //Console.WriteLine("promote!"); } } }
private void GetMoves_Bishop(ChessColor color) { var board = new ChessBoardState(); board.Clear(); board.SetSideToMove(color); board.SetSpot(4, 5, color == ChessColor.White ? ChessPiece.WhiteBishop : ChessPiece.BlackBishop); var expectedMoves = new List <string> { "Bd5-h1", "Bd5-a2", "Bd5-g2", "Bd5-b3", "Bd5-f3", "Bd5-c4", "Bd5-e4", "Bd5-c6", "Bd5-e6", "Bd5-b7", "Bd5-f7", "Bd5-a8", "Bd5-g8" }; CheckPossibleMoves(board, expectedMoves); }
internal bool attackingKing(ref ChessBoardState chessBoardState) { // Declare otherKingSquare to be the square the other players king is on. Square otherKingSquare = chessBoardState.WhitesMove ? chessBoardState.BlackKingSquare : chessBoardState.WhiteKingSquare; // Condition to test if the king is one square from the other king. if (Math.Abs(chessBoardState.SelectedPiece.square.row - otherKingSquare.row) <= 1 && Math.Abs(chessBoardState.SelectedPiece.square.column - otherKingSquare.column) <= 1) { return(true); } return(false); }
//Method to test if the selected pawn is attaking the other players king. internal bool attakingKing(ref ChessBoardState chessBoardState) { // Declare otherKingSquare to be the square the other players king is on. Square otherKingSquare = chessBoardState.WhitesMove ? chessBoardState.BlackKingSquare : chessBoardState.WhiteKingSquare; int pawnOffset = chessBoardState.WhitesMove ? -1 : 1; if ((chessBoardState.SelectedPiece.square.row + pawnOffset == otherKingSquare.row) && ((chessBoardState.SelectedPiece.square.column + 1 == otherKingSquare.column) || (chessBoardState.SelectedPiece.square.column - 1 == otherKingSquare.column))) { return(true); } return(false); }