Esempio n. 1
0
 private bool IsKingCanBeProtectWithCheckByPawn(ChessSquare[,] board, ChessSquare kingCheckedSquare, ChessSquare chessCheckSquare)
 {
     // Pawn can be cancel attack just by kill him
     // so don't need to check checking path
     Common.SquaresCheckingPath.Add(board[chessCheckSquare.Row, chessCheckSquare.Col]);
     return(IsSquareInPathCanBeProtect(board));
 }
Esempio n. 2
0
 public ChessSquare(ChessSquare a)
 {
     Chess = a.Chess;
     Image = a.Image;
     Row   = a.Row;
     Col   = a.Col;
 }
Esempio n. 3
0
        /// <summary>
        /// return true if checked team has a chess can be protect king
        /// else return false
        /// </summary>
        /// <param name="board"></param>
        /// <param name="kingCheckedSquare"></param>
        /// <param name="chessCheckSquare"></param>
        /// <returns></returns>
        public bool IsKingCanBeProtect(ChessSquare[,] board, ChessSquare kingCheckedSquare, ChessSquare chessCheckSquare)
        {
            if (kingCheckedSquare.Chess == null)
            {
                return(true);
            }
            if (chessCheckSquare.Chess == null)
            {
                return(true);
            }
            Chess chessCheck = chessCheckSquare.Chess;

            if (chessCheck.IsKnight)
            {
                return(IsKingCanBeProtectWithCheckByKnight(board, kingCheckedSquare, chessCheckSquare));
            }
            if (chessCheck.IsBishop)
            {
                return(IsKingCanBeProtectWithCheckByBishop(board, kingCheckedSquare, chessCheckSquare));
            }
            if (chessCheck.IsQueen)
            {
                return(IsKingCanBeProtectWithCheckByQueen(board, kingCheckedSquare, chessCheckSquare));
            }
            if (chessCheck.IsCastle)
            {
                return(IsKingCanBeProtectWithCheckByCastle(board, kingCheckedSquare, chessCheckSquare));
            }
            if (chessCheck.IsPawn)
            {
                return(IsKingCanBeProtectWithCheckByPawn(board, kingCheckedSquare, chessCheckSquare));
            }

            return(false);
        }
Esempio n. 4
0
        private void PhongHau(ref ChessSquare temp)
        {
            Chess newQueen = new Queen();

            if (temp.Chess.Team == 1) //white
            {
                newQueen.Team         = (int)ColorTeam.White;
                temp.Chess            = newQueen;
                temp.Image            = Image.FromFile(Constants.linkWhiteQueen);
                temp.Chess.Evaluation = 90;
            }
            else //black
            {
                newQueen.Team         = (int)ColorTeam.Black;
                temp.Chess            = newQueen;
                temp.Image            = Image.FromFile(Constants.linkBlackQueen);
                temp.Chess.Evaluation = -90;
            }
        }
Esempio n. 5
0
        private void KiemTraChieuVua()
        {
            bool        isCheck  = false;
            ChessSquare Kingtemp = new ChessSquare();

            this.Check(ref isCheck, ref Kingtemp);
            if (isCheck)
            {
                Checkmate(Kingtemp);
            }

            Common.CanBeEat.Clear();
            Common.CanBeMove.Clear();

            Common.BackChessBoard();
            if (Kingtemp.Chess != null && Kingtemp.Chess.IsKing == true)
            {
                Common.Board[Kingtemp.Row, Kingtemp.Col].BackColor = Color.BlueViolet;
            }
        }
Esempio n. 6
0
        private void frmChessKing_Load(object sender, EventArgs e)
        {
            for (int row = 0; row < 8; row++)
            {
                for (int col = 0; col < 8; col++)
                {
                    ChessSquare temp = new ChessSquare();
                    if (row % 2 == 0)
                    {
                        if (col % 2 == 0)
                        {
                            temp.BackColor = Color.NavajoWhite;
                        }
                        else
                        {
                            temp.BackColor = Color.SaddleBrown;
                        }
                    }
                    else
                    {
                        if (col % 2 == 0)
                        {
                            temp.BackColor = Color.SaddleBrown;
                        }
                        else
                        {
                            temp.BackColor = Color.NavajoWhite;
                        }
                    }

                    temp.Location   = new Point((col + 1) * 60, (row + 1) * 60);
                    temp.Row        = row;
                    temp.Col        = col;
                    Board[row, col] = temp;

                    Board[row, col].findWayAction += new FindWayAction(OnAction);
                    this.Controls.Add(Board[row, col]);
                }
            }
        }
Esempio n. 7
0
 private void Check(ref bool isCheck, ref ChessSquare KingTemp)
 {
     // mặc định chưa bị chiếu tướng isCheck=false
     isCheck = false;
     Common.CanBeEatTemp.Clear();
     //check if King is danger
     for (int i = 0; i < 8; i++)
     {
         for (int j = 0; j < 8; j++)
         {
             if (Common.Board[i, j].Chess != null)
             {
                 Common.Board[i, j].Chess.FindSquaresCanEat(Common.Board, i, j);
                 for (int k = 0; k < Common.CanBeEatTemp.Count; k++)
                 {
                     if (Common.CanBeEatTemp[k].Chess.IsKing &&
                         Common.Board[i, j].Chess.Team != Common.CanBeEatTemp[k].Chess.Team)
                     {
                         isCheck  = true;
                         KingTemp = new ChessSquare(Common.CanBeEatTemp[k]);
                         if (isCheck)
                         {
                             // Set trạng thái đang bị check khiến không thể nhập thành
                             if (KingTemp.Chess.Team == (int)ColorTeam.White)
                             {
                                 Common.isWhiteKingChecked = true;
                             }
                             if (KingTemp.Chess.Team == (int)ColorTeam.Black)
                             {
                                 Common.isBlackKingChecked = true;
                             }
                         }
                     }
                 }
             }
             Common.CanBeEatTemp.Clear();
             Common.CanBeMoveTemp.Clear();
         }
     }
 }
Esempio n. 8
0
        /// <summary>
        /// - Check if king is available to move => check mate is false
        /// - Check if king is available to eat the attacker=> check mate is false
        /// - If king not avalable to move or eat-> check if teamate can eat the checker
        /// - Finally check if teamate can protect the checking path
        /// </summary>
        /// <param name="temp"></param>
        private void Checkmate(ChessSquare temp)
        {
            Common.CanBeEat.Clear();
            Common.CanBeMove.Clear();
            temp.Chess.FindWayAndAutoChangeSquareIfNeeded(Common.Board, temp.Row, temp.Col);
            bool isCheckmate = true;

            isCheckmate = !(temp.Chess as King).
                          IsKingCanBeProtect(Common.Board, temp,
                                             Common.Board[this.Row, this.Col]);
            if (Common.CanBeMove.Count > 0)
            {
                isCheckmate = false;
            }
            if (Common.CanBeEat.Count > 0)
            {
                isCheckmate = false;
            }

            if (isCheckmate)
            {
                if (temp.Chess.Team == (int)ColorTeam.White)
                {
                    MessageBox.Show("The Black Wins");
                }
                else
                {
                    MessageBox.Show("The White Wins");
                }

                Common.ClearMoveSuggestion();
                Common.IsPlaying = false;
                Common.Close     = true;
            }
            else
            {
                soundManager.PlayCheckSound();
            }
        }
Esempio n. 9
0
        protected double minimax(int depth, ref ChessSquare[,] root, double alpha, double beta, bool isMax)
        {
            if (depth == 0)
            {
                return(-this.BestValue(root));
            }
            ChessSquare[,] a = new ChessSquare[8, 8];
            double bestValue;
            int    team = 0;

            if (isMax == true)
            {
                team      = Common.Player2ColorTeam;
                bestValue = -9999;
            } //black
            else
            {
                team      = Common.Player1ColorTeam;
                bestValue = 9999;
            } //white

            //ke list can move from root
            //List<ChessSquare[,]> tempList = new List<ChessSquare[,]>();
            //createList(root, team, tempList);

            for (int i = 0; i < 8; i++)
            {
                for (int j = 0; j < 8; j++)
                {
                    int befRow = i;
                    int befCol = j;
                    if (!Common.IsEmptyChessSquare(root, befRow, befCol) &&
                        root[befRow, befCol].Chess.Team == team)
                    {
                        List <ChessSquare> RootTemp = new List <ChessSquare>();

                        root[befRow, befCol].Chess.FindWayAndAutoChangeSquareIfNeeded(root, befRow, befCol);

                        for (int k = 0; k < Common.CanBeMove.Count; k++)
                        {
                            RootTemp.Add(Common.CanBeMove[k]);
                        }
                        for (int k = 0; k < Common.CanBeEat.Count; k++)
                        {
                            RootTemp.Add(Common.CanBeEat[k]);
                        }
                        Common.CanBeMove.Clear();
                        Common.CanBeEat.Clear();
                        Chess tempChess = new Chess();
                        Image tempImage = null;

                        for (int k = 0; k < RootTemp.Count; k++)
                        {
                            tempChess = root[RootTemp[k].Row, RootTemp[k].Col].Chess;
                            tempImage = root[RootTemp[k].Row, RootTemp[k].Col].Image;

                            root[RootTemp[k].Row, RootTemp[k].Col].Chess = root[befRow, befCol].Chess;
                            root[RootTemp[k].Row, RootTemp[k].Col].Image = root[befRow, befCol].Image;
                            root[befRow, befCol].Chess = null;
                            root[befRow, befCol].Image = null;
                            if (team == Common.Player2ColorTeam)
                            {
                                bestValue = Math.Max(bestValue, minimax(depth - 1, ref root, alpha, beta, !isMax));
                                alpha     = Math.Max(alpha, bestValue);
                                if (beta <= alpha)
                                {
                                    root[RootTemp[k].Row, RootTemp[k].Col].Undo(ref root, befRow, befCol, tempChess, tempImage);
                                    return(bestValue);
                                }
                            }
                            else
                            {
                                bestValue = Math.Min(bestValue, minimax(depth - 1, ref root, alpha, beta, !isMax));
                                beta      = Math.Min(beta, bestValue);
                                if (beta <= alpha)
                                {
                                    root[RootTemp[k].Row, RootTemp[k].Col].Undo(ref root, befRow, befCol, tempChess, tempImage);
                                    return(bestValue);
                                }
                            }
                            root[RootTemp[k].Row, RootTemp[k].Col].Undo(ref root, befRow, befCol, tempChess, tempImage);
                        }
                        RootTemp.Clear();
                    }
                }
            }
            return(bestValue);
        }
Esempio n. 10
0
        protected void minimaxRoot()
        {
            int    depth = Common.Depth;
            double bestValue = -9999;
            double value = 0;
            double alpha = -10000, beta = 10000;
            bool   isMax = true;

            ChessSquare[,] board    = new ChessSquare[8, 8];
            ChessSquare[,] bestMove = new ChessSquare[8, 8];
            board = Common.Board;

            bool isComputerKingInDefault = false;
            int  defaultRowComputerKing  = 0;

            // Kiểm tra xem ô vua may mặc định lúc thực hiện thuật toán có vua đen không?
            if (Common.Player2ColorTeam == (int)ColorTeam.Black)
            {
                defaultRowComputerKing = 0;
            }
            else
            {
                defaultRowComputerKing = 7;
            }
            if (board[defaultRowComputerKing, 4].Chess != null)
            {
                isComputerKingInDefault = board[defaultRowComputerKing, 4].Chess.IsKing &&
                                          board[defaultRowComputerKing, 4].Chess.Team == Common.Player2ColorTeam;
            }

            for (int i = 0; i < 8; i++)
            {
                for (int j = 0; j < 8; j++)
                {
                    if (board[i, j].Chess != null && board[i, j].Chess.Team == Common.Player2ColorTeam)
                    {
                        List <ChessSquare> RootTemp = new List <ChessSquare>();

                        int befRow = i;
                        int befCol = j;
                        board[befRow, befCol].Chess.FindWayAndAutoChangeSquareIfNeeded(board, befRow, befCol);

                        for (int k = 0; k < Common.CanBeMove.Count; k++)
                        {
                            RootTemp.Add(Common.CanBeMove[k]);
                        }
                        for (int k = 0; k < Common.CanBeEat.Count; k++)
                        {
                            RootTemp.Add(Common.CanBeEat[k]);
                        }
                        Common.CanBeMove.Clear();
                        Common.CanBeEat.Clear();

                        Chess tempChess = new Chess();
                        Image tempImage = null;

                        // Giả định lần lượt các nước đi quân cờ nếu nó có thể di chuyển
                        //được để tìm được giá trị tốt nhất cho nước đi
                        for (int k = 0; k < RootTemp.Count; k++)
                        {
                            tempChess = board[RootTemp[k].Row, RootTemp[k].Col].Chess;
                            tempImage = board[RootTemp[k].Row, RootTemp[k].Col].Image;

                            board[RootTemp[k].Row, RootTemp[k].Col].Chess = board[befRow, befCol].Chess;
                            board[RootTemp[k].Row, RootTemp[k].Col].Image = board[befRow, befCol].Image;

                            board[befRow, befCol].Chess = null;
                            board[befRow, befCol].Image = null;


                            value = minimax(depth - 1, ref board, alpha, beta, !isMax);
                            if (value >= bestValue)
                            {
                                for (int m = 0; m < 8; m++)
                                {
                                    for (int n = 0; n < 8; n++)
                                    {
                                        bestMove[m, n] = new ChessSquare(board[m, n]);
                                    }
                                }
                                bestValue = value;
                            }

                            //phục hồi lại trạng thái ban đầu quân cờ sau khi giả định
                            board[RootTemp[k].Row, RootTemp[k].Col].Undo(ref board, befRow, befCol, tempChess, tempImage);
                        }
                        RootTemp.Clear();
                    }
                }
            }

            for (int k = 0; k < 8; k++)
            {
                for (int l = 0; l < 8; l++)
                {
                    Common.Board[k, l].Row   = bestMove[k, l].Row;
                    Common.Board[k, l].Col   = bestMove[k, l].Col;
                    Common.Board[k, l].Chess = bestMove[k, l].Chess;
                    Common.Board[k, l].Image = bestMove[k, l].Image;
                }
            }


            // Nếu ban đầu vị trí mặc định có vua đen, Kiểm tra xem
            // Vua đen có đi vào 2 vị trí nhập thành ngắn và dài không
            if (isComputerKingInDefault)
            {
                // Vua đã đi khỏi vị trí default => vị trí default không có cờ
                if (board[defaultRowComputerKing, 4].Chess == null)
                {
                    //colRightBishop =5
                    //colRightKnight =6
                    //colRightCastle = 7

                    // Kiểm tra king side castle
                    if (board[defaultRowComputerKing, 6].Chess != null)
                    {
                        if (board[defaultRowComputerKing, 6].Chess.IsKing)
                        {
                            Common.Board[defaultRowComputerKing, 5].Image     = Common.Board[defaultRowComputerKing, 7].Image;
                            Common.Board[defaultRowComputerKing, 7].Image     = null;
                            Common.Board[defaultRowComputerKing, 7].BackColor = Common.OldBackGround;
                            Common.Board[defaultRowComputerKing, 5].Chess     = Common.Board[defaultRowComputerKing, 7].Chess;
                            Common.Board[defaultRowComputerKing, 7].Chess     = null;
                            //Thêm trạng thái đã castle để không thể castle lần 2
                            if (Common.Player2ColorTeam == (int)ColorTeam.Black)
                            {
                                Common.isBlackKingMoved = true;
                            }
                            else
                            {
                                Common.isWhiteKingMoved = true;
                            }
                        }
                    }
                    // Kiểm tra queen side castle
                    //colQueen = 3;
                    //colLeftBishop = 2;
                    //colLeftCastle = 0;
                    if (board[defaultRowComputerKing, 2].Chess != null)
                    {
                        if (board[defaultRowComputerKing, 2].Chess.IsKing)
                        {
                            Common.Board[defaultRowComputerKing, 3].Image     = Common.Board[defaultRowComputerKing, 0].Image;
                            Common.Board[defaultRowComputerKing, 0].Image     = null;
                            Common.Board[defaultRowComputerKing, 0].BackColor = Common.OldBackGround;
                            Common.Board[defaultRowComputerKing, 3].Chess     = Common.Board[defaultRowComputerKing, 0].Chess;
                            Common.Board[defaultRowComputerKing, 0].Chess     = null;

                            //Thêm trạng thái đã castle để không thể castle lần 2
                            if (Common.Player2ColorTeam == (int)ColorTeam.Black)
                            {
                                Common.isBlackKingMoved = true;
                            }
                            else
                            {
                                Common.isWhiteKingMoved = true;
                            }
                        }
                    }
                }
            }

            //Kiểm tra xem máy có di chuyển vua chưa, phục vụ cho mục đích xét nhập thành
            KiemTraVuaDaDiChuyen();
            KiemTraCastleDaDiChuyen();
            Common.IsTurn++;
            Common.ClearMoveSuggestion();
        }
Esempio n. 11
0
        private void frmChessKing_Load(object sender, EventArgs e)
        {
            for (int row = 0; row < 8; row++)
            {
                for (int col = 0; col < 8; col++)
                {
                    ChessSquare temp = new ChessSquare();
                    if (row % 2 == 0)
                    {
                        if (col % 2 == 0)
                        {
                            temp.BackColor = Color.LavenderBlush;
                        }
                        else
                        {
                            temp.BackColor = Color.DarkSlateGray;
                        }
                    }
                    else
                    {
                        if (col % 2 == 0)
                        {
                            temp.BackColor = Color.DarkSlateGray;
                        }
                        else
                        {
                            temp.BackColor = Color.LavenderBlush;
                        }
                    }

                    temp.Location = new Point((col + 1) * 60, (row + 1) * 60);
                    temp.Row      = row;
                    temp.Col      = col;

                    Board[row, col] = temp;
                    Board[row, col].findWayDisplayAction += new FindWayDisplayAction(OnAction);

                    this.Controls.Add(Board[row, col]);
                }
            }

            for (int row = 0; row < 8; row++)
            {
                for (int col = 0; col < 8; col++)
                {
                    ChessSquare temp = new ChessSquare();
                    if (row % 2 == 0)
                    {
                        if (col % 2 == 0)
                        {
                            temp.BackColor = Color.LavenderBlush;
                        }
                        else
                        {
                            temp.BackColor = Color.DarkSlateGray;
                        }
                    }
                    else
                    {
                        if (col % 2 == 0)
                        {
                            temp.BackColor = Color.DarkSlateGray;
                        }
                        else
                        {
                            temp.BackColor = Color.LavenderBlush;
                        }
                    }

                    temp.Location = new Point((col + 1) * 60, (row + 1) * 60);
                    temp.Row      = row;
                    temp.Col      = col;

                    Common.VirtualBoard[row, col]         = temp;
                    Board[row, col].findWayDisplayAction += new FindWayDisplayAction(OnAction);
                }
            }
        }
Esempio n. 12
0
        private bool IsKingCanBeProtectWithCheckByBishop(ChessSquare[,] board, ChessSquare kingCheckedSquare, ChessSquare chessCheckSquare)
        {
            Common.SquaresCheckingPath.Add(board[chessCheckSquare.Row, chessCheckSquare.Col]);
            // Bishop in south east king
            if (kingCheckedSquare.Row < chessCheckSquare.Row &&
                kingCheckedSquare.Col < chessCheckSquare.Col)
            {
                // Get squares in check path to king
                int j = chessCheckSquare.Col - 1;
                for (int i = chessCheckSquare.Row - 1; i >= Constants.firstRowOfTable; i--)
                {
                    // Kiểm tra điều kiện, nếu ngoài bàn cờ ( col <0) thì xong việc xét chéo trái lên
                    if (j < Constants.firstColOfTable)
                    {
                        break;
                    }
                    // Ô trong checking path từ bishop tới king
                    if (kingCheckedSquare.Row < i && kingCheckedSquare.Col < j)
                    {
                        if (Common.IsEmptyChessSquare(board, i, j))
                        {
                            Common.SquaresCheckingPath.Add(board[i, j]);
                        }
                    }
                    // nếu có ô ngay sau king trên đường checking path,
                    // loại bỏ ô đó khỏi list can move hoac eat của king
                    else if (kingCheckedSquare.Row - 1 == i && kingCheckedSquare.Col - 1 == j)
                    {
                        RemoveElementCanBeMoveOrEatAfterKingInCheckPath(board, j, i);
                    }

                    j--;
                }
                return(IsSquareInPathCanBeProtect(board));
            }

            //Bishop in south west king
            if (kingCheckedSquare.Row < chessCheckSquare.Row &&
                kingCheckedSquare.Col > chessCheckSquare.Col)
            {
                int j = chessCheckSquare.Col + 1;
                for (int i = chessCheckSquare.Row - 1; i >= Constants.firstRowOfTable; i--)
                {
                    if (j > Constants.lastColOfTable)
                    {
                        break;
                    }
                    if (kingCheckedSquare.Row < i && kingCheckedSquare.Col > j)
                    {
                        if (Common.IsEmptyChessSquare(board, i, j))
                        {
                            Common.SquaresCheckingPath.Add(board[i, j]);
                        }
                    }
                    else if (kingCheckedSquare.Row - 1 == i && kingCheckedSquare.Col + 1 == j)
                    {
                        RemoveElementCanBeMoveOrEatAfterKingInCheckPath(board, i, j);
                    }
                    j++;
                }
                return(IsSquareInPathCanBeProtect(board));
            }

            //Bishop in north east king
            if (kingCheckedSquare.Row > chessCheckSquare.Row &&
                kingCheckedSquare.Col < chessCheckSquare.Col)
            {
                int j = chessCheckSquare.Col - 1;
                for (int i = chessCheckSquare.Row + 1; i <= Constants.lastRowOfTable; i++)
                {
                    if (j < Constants.firstColOfTable)
                    {
                        break;
                    }
                    if (kingCheckedSquare.Row > i && kingCheckedSquare.Col < j)
                    {
                        if (Common.IsEmptyChessSquare(board, i, j))
                        {
                            Common.SquaresCheckingPath.Add(board[i, j]);
                        }
                    }
                    else if (i == kingCheckedSquare.Row + 1 && j == kingCheckedSquare.Col - 1)
                    {
                        RemoveElementCanBeMoveOrEatAfterKingInCheckPath(board, i, j);
                    }

                    j--;
                }
                return(IsSquareInPathCanBeProtect(board));
            }

            //Bishop in north west king
            if (kingCheckedSquare.Row > chessCheckSquare.Row &&
                kingCheckedSquare.Col > chessCheckSquare.Col)
            {
                int j;
                j = chessCheckSquare.Col + 1;
                for (int i = chessCheckSquare.Row + 1; i <= Constants.lastRowOfTable; i++)
                {
                    if (j > Constants.lastColOfTable)
                    {
                        break;
                    }
                    if (kingCheckedSquare.Row > i && kingCheckedSquare.Col > j)
                    {
                        if (Common.IsEmptyChessSquare(board, i, j))
                        {
                            Common.SquaresCheckingPath.Add(board[i, j]);
                        }
                    }
                    else if (i == kingCheckedSquare.Row + 1 && j == kingCheckedSquare.Col + 1)
                    {
                        RemoveElementCanBeMoveOrEatAfterKingInCheckPath(board, i, j);
                    }
                    j++;
                }
                return(IsSquareInPathCanBeProtect(board));
            }
            return(false);
        }
Esempio n. 13
0
        private bool IsKingCanBeProtectWithCheckByCastle(ChessSquare[,] board, ChessSquare kingCheckedSquare, ChessSquare chessCheckSquare)
        {
            Common.SquaresCheckingPath.Add(board[chessCheckSquare.Row, chessCheckSquare.Col]);
            //Castle is in bottom side ofking
            if (kingCheckedSquare.Row < chessCheckSquare.Row)
            {
                for (int i = chessCheckSquare.Row - 1; i >= 0; i--)
                {
                    if (kingCheckedSquare.Row < i)
                    {
                        if (Common.IsEmptyChessSquare(board, i, chessCheckSquare.Col))
                        {
                            Common.SquaresCheckingPath.Add(board[i, chessCheckSquare.Col]);
                        }
                    }
                    else if (kingCheckedSquare.Row - 1 == i)
                    {
                        RemoveElementCanBeMoveOrEatAfterKingInCheckPath(board, chessCheckSquare.Col, i);
                    }
                }
                return(IsSquareInPathCanBeProtect(board));
            }

            //Castle is in the top side of the king
            if (kingCheckedSquare.Row > chessCheckSquare.Row)
            {
                for (int i = chessCheckSquare.Row + 1; i <= 7; i++)
                {
                    if (kingCheckedSquare.Row > i)
                    {
                        if (Common.IsEmptyChessSquare(board, i, chessCheckSquare.Col))
                        {
                            Common.SquaresCheckingPath.Add(board[i, chessCheckSquare.Col]);
                        }
                    }
                    else if (kingCheckedSquare.Row + 1 == i)
                    {
                        RemoveElementCanBeMoveOrEatAfterKingInCheckPath(board, chessCheckSquare.Col, i);
                    }
                }
                return(IsSquareInPathCanBeProtect(board));
            }

            //Castle is in the right side of theking
            if (kingCheckedSquare.Col < chessCheckSquare.Col)
            {
                for (int i = chessCheckSquare.Col - 1; i >= 0; i--)
                {
                    if (kingCheckedSquare.Col < i)
                    {
                        if (Common.IsEmptyChessSquare(board, chessCheckSquare.Row, i))
                        {
                            Common.SquaresCheckingPath.Add(board[chessCheckSquare.Row, i]);
                        }
                    }
                    else if (kingCheckedSquare.Col - 1 == i)
                    {
                        RemoveElementCanBeMoveOrEatAfterKingInCheckPath(board, i, chessCheckSquare.Col);
                    }
                }
                return(IsSquareInPathCanBeProtect(board));
            }

            //Castle is in left side of the king
            if (kingCheckedSquare.Col > chessCheckSquare.Col)
            {
                for (int i = chessCheckSquare.Col + 1; i <= 7; i++)
                {
                    if (kingCheckedSquare.Col > i)
                    {
                        if (Common.IsEmptyChessSquare(board, chessCheckSquare.Row, i))
                        {
                            Common.SquaresCheckingPath.Add(board[chessCheckSquare.Row, i]);
                        }
                    }
                    else if (kingCheckedSquare.Col + 1 == i)
                    {
                        RemoveElementCanBeMoveOrEatAfterKingInCheckPath(board, i, chessCheckSquare.Row);
                    }
                }
            }
            return(false);
        }