コード例 #1
0
 private bool KingAI(PictureBox[][] board, int y, int x, bool turn, int movesCount, int movesLimit, int currentBoardState, AIResult finalResult)
 {
     // loop through all directions king can move by one square
     for (int i = -1; i <= 1; i++)
     {
         for (int j = -1; j <= 1; j++)
         {
             int Y = y + i;
             int X = x + j;
             if ((i == 0 && j == 0) || Y < 0 || Y > 7 || X < 0 || X > 7)
             {
                 continue;
             }
             PictureBox[][] newBoard = new PictureBox[8][];
             if (board[Y][X] == null) // if king moves to empty square
             {
                 setNewBoard(board, newBoard, y, x, Y, X);
                 if (IsValidMove(newBoard, turn))
                 {
                     continue;
                 }
                 AI  newAI          = new AI(movesCount + 1);
                 int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState, finalResult);
                 if (movesCount == 0)
                 {
                     CapturedSquares capture = new CapturedSquares();
                     setResult(turn, bestBoardState, y, x, Y, X, capture.CaptureCount(newBoard));
                 }
                 else
                 {
                     setResult(turn, bestBoardState, y, x, Y, X, 0);
                 }
                 continue;
             }
             int  value      = PieceValue(PieceDetails.selectedPiece(board[Y][X].Name));
             bool pieceColor = PieceDetails.IsPieceBlackorWhite(board[Y][X].Name);
             if (turn && !pieceColor)    // white king eats black piece
             {
                 if (value == kingvalue) // if king is eatten prune this path completely
                 {
                     return(true);
                 }
                 if (bestPath <= currentBoardState + value) // prune path that are smaller than the current board state
                 {
                     setNewBoard(board, newBoard, y, x, Y, X);
                     if (IsValidMove(newBoard, turn))
                     {
                         continue;
                     }
                     bestPath = currentBoardState + value;
                     AI  newAI          = new AI(movesCount + 1);
                     int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState + value, finalResult);
                     if (movesCount == 0)
                     {
                         CapturedSquares capture = new CapturedSquares();
                         setResult(turn, bestBoardState, y, x, Y, X, capture.CaptureCount(newBoard));
                     }
                     else
                     {
                         setResult(turn, bestBoardState, y, x, Y, X, 0);
                     }
                 }
             }
             else if (!turn && pieceColor) // black king eats white piece
             {
                 if (value == kingvalue)
                 {
                     return(true);
                 }
                 if (bestPath >= currentBoardState - value) // prune path that are larger than the current board state
                 {
                     setNewBoard(board, newBoard, y, x, Y, X);
                     if (IsValidMove(newBoard, turn))
                     {
                         continue;
                     }
                     bestPath = currentBoardState - value;
                     AI  newAI          = new AI(movesCount + 1);
                     int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState - value, finalResult);
                     if (movesCount == 0)
                     {
                         CapturedSquares capture = new CapturedSquares();
                         setResult(turn, bestBoardState, y, x, Y, X, capture.CaptureCount(newBoard));
                     }
                     else
                     {
                         setResult(turn, bestBoardState, y, x, Y, X, 0);
                     }
                 }
             }
         }
     }
     return(false);
 }
コード例 #2
0
 private bool KnightAI(PictureBox[][] board, int y, int x, bool turn, int movesCount, int movesLimit, int currentBoardState, AIResult finalResult)
 {
     foreach (int[] dir in PieceDetails.KnightDirection)
     {
         int Y = y + dir[0];
         int X = x + dir[1];
         if (Y < 0 || Y > 7 || X < 0 || X > 7)
         {
             continue;
         }
         PictureBox[][] newBoard = new PictureBox[8][];
         if (board[Y][X] == null)                      // knight moving to empty square
         {
             setNewBoard(board, newBoard, y, x, Y, X); // create new board object to be used as parameter to call minimax function
             if (IsValidMove(newBoard, turn))
             {
                 continue;
             }
             AI  newAI          = new AI(movesCount + 1);
             int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState, finalResult);
             if (movesCount == 0)
             {
                 CapturedSquares capture = new CapturedSquares();
                 setResult(turn, bestBoardState, y, x, Y, X, capture.CaptureCount(newBoard));
             }
             else
             {
                 setResult(turn, bestBoardState, y, x, Y, X, 0);
             }
             continue;
         }
         int  value      = PieceValue(PieceDetails.selectedPiece(board[Y][X].Name));
         bool pieceColor = PieceDetails.IsPieceBlackorWhite(board[Y][X].Name);
         if (turn && !pieceColor) // white knight eatting black piece
         {
             setNewBoard(board, newBoard, y, x, Y, X);
             if (value == kingvalue)  // if king is eatten prune this path completely
             {
                 return(true);
             }
             if (bestPath <= currentBoardState + value) // prune path that are smaller than the current board state
             {
                 if (IsValidMove(newBoard, turn))
                 {
                     continue;
                 }
                 bestPath = currentBoardState + value;
                 AI  newAI          = new AI(movesCount + 1);
                 int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState + value, finalResult);
                 if (movesCount == 0)
                 {
                     CapturedSquares capture = new CapturedSquares();
                     setResult(turn, bestBoardState, y, x, Y, X, capture.CaptureCount(newBoard));
                 }
                 else
                 {
                     setResult(turn, bestBoardState, y, x, Y, X, 0);
                 }
             }
         }
         else if (!turn && pieceColor) // black knight eatting white piece
         {
             setNewBoard(board, newBoard, y, x, Y, X);
             if (value == kingvalue)
             {
                 return(true);
             }
             if (bestPath >= currentBoardState - value) // prune path that are larger than the current board state
             {
                 if (IsValidMove(newBoard, turn))
                 {
                     continue;
                 }
                 bestPath = currentBoardState - value;
                 AI  newAI          = new AI(movesCount + 1);
                 int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState - value, finalResult);
                 if (movesCount == 0)
                 {
                     CapturedSquares capture = new CapturedSquares();
                     setResult(turn, bestBoardState, y, x, Y, X, capture.CaptureCount(newBoard));
                 }
                 else
                 {
                     setResult(turn, bestBoardState, y, x, Y, X, 0);
                 }
             }
         }
     }
     return(false);
 }
コード例 #3
0
        private bool QueenAI(PictureBox[][] board, int y, int x, bool turn, int movesCount, int movesLimit, int currentBoardState, AIResult finalResult)
        {
            bool[] pieceDirection = new bool[8]; // this array represents north, east, south, west, northeast, southeast, southwest, northwest and will reduce the processing time

            for (int i = 1; i < 8; i++)          // represents the distance to be moved
            {
                // queen cannot move anymore as it is either out of bound or there is another piece blocking it from its target
                if (PieceDetails.checkedAllDirections(pieceDirection))
                {
                    break;
                }
                for (int j = 0; j < PieceDetails.QueenDirection.Length; j++) // represents the array to define the direction of the move
                {
                    if (pieceDirection[j])
                    {
                        continue;
                    }
                    int Y = y + i * PieceDetails.QueenDirection[j][0];
                    int X = x + i * PieceDetails.QueenDirection[j][1];
                    if (Y >= 0 && Y < 8 && X >= 0 && X < 8)
                    {
                        PictureBox[][] newBoard = new PictureBox[8][];
                        if (board[Y][X] == null)                      // if queen moves to an empty square
                        {
                            setNewBoard(board, newBoard, y, x, Y, X); // create new board object to be used as parameter to call minimax function
                            if (IsValidMove(newBoard, turn))
                            {
                                continue;
                            }
                            AI  newAI          = new AI(movesCount + 1);
                            int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState, finalResult);
                            if (movesCount == 0)
                            {
                                CapturedSquares capture = new CapturedSquares();
                                setResult(turn, bestBoardState, y, x, Y, X, capture.CaptureCount(newBoard));
                            }
                            else
                            {
                                setResult(turn, bestBoardState, y, x, Y, X, 0);
                            }
                        }
                        else
                        {
                            bool pieceColor = PieceDetails.IsPieceBlackorWhite(board[Y][X].Name);
                            int  value      = PieceValue(PieceDetails.selectedPiece(board[Y][X].Name));
                            if (turn && !pieceColor)    // if white queen eats a black piece
                            {
                                if (value == kingvalue) // if king is eatten prune this path completely
                                {
                                    return(true);
                                }
                                if (bestPath <= currentBoardState + value) // prune path that are smaller than the current board state
                                {
                                    setNewBoard(board, newBoard, y, x, Y, X);
                                    if (IsValidMove(newBoard, turn))
                                    {
                                        pieceDirection[j] = true;
                                        continue;
                                    }
                                    bestPath = currentBoardState + value;
                                    AI  newAI          = new AI(movesCount + 1);
                                    int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState + value, finalResult);
                                    if (movesCount == 0)
                                    {
                                        CapturedSquares capture = new CapturedSquares();
                                        setResult(turn, bestBoardState, y, x, Y, X, capture.CaptureCount(newBoard));
                                    }
                                    else
                                    {
                                        setResult(turn, bestBoardState, y, x, Y, X, 0);
                                    }
                                }
                                pieceDirection[j] = true;
                            }
                            else if (!turn && pieceColor) // if black queen eats a white piece
                            {
                                if (value == kingvalue)
                                {
                                    return(true);
                                }
                                if (bestPath >= currentBoardState - value) // prune path that are larger than the current board state
                                {
                                    setNewBoard(board, newBoard, y, x, Y, X);
                                    if (IsValidMove(newBoard, turn))
                                    {
                                        pieceDirection[j] = true;
                                        continue;
                                    }
                                    bestPath = currentBoardState - value;
                                    AI  newAI          = new AI(movesCount + 1);
                                    int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState - value, finalResult);
                                    if (movesCount == 0)
                                    {
                                        CapturedSquares capture = new CapturedSquares();
                                        setResult(turn, bestBoardState, y, x, Y, X, capture.CaptureCount(newBoard));
                                    }
                                    else
                                    {
                                        setResult(turn, bestBoardState, y, x, Y, X, 0);
                                    }
                                }
                                pieceDirection[j] = true;
                            }
                            else
                            {
                                pieceDirection[j] = true; // if bishop lands on the its same color piece
                            }
                        }
                    }
                    else
                    {
                        pieceDirection[j] = true; // if bishop lands out of bounds
                    }
                }
            }
            return(false);
        }
コード例 #4
0
 private bool PawnAI(PictureBox[][] board, int y, int x, bool turn, int movesCount, int movesLimit, int currentBoardState, AIResult finalResult)
 {
     if (turn) // white pawn move
     {
         if (y - 1 >= 0)
         {
             if (board[y - 1][x] == null) // white pawn moving 1 square north to empty square
             {
                 PictureBox[][] newBoard = new PictureBox[8][];
                 setNewBoard(board, newBoard, y, x, y - 1, x); // create new board object to be used as parameter to call minimax function
                 if (!IsValidMove(newBoard, turn))
                 {
                     AI  newAI          = new AI(movesCount + 1);
                     int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState, finalResult); // find best path
                     if (movesCount == 0)
                     {
                         CapturedSquares capture = new CapturedSquares();
                         setResult(turn, bestBoardState, y, x, y - 1, x, capture.CaptureCount(newBoard));
                     }
                     else
                     {
                         setResult(turn, bestBoardState, y, x, y - 1, x, 0);
                     }
                 }
             }
             if (x - 1 >= 0 && board[y - 1][x - 1] != null && !PieceDetails.IsPieceBlackorWhite(board[y - 1][x - 1].Name)) // white pawn eat black piece at north-west
             {
                 int value = PieceValue(PieceDetails.selectedBlackPiece(board[y - 1][x - 1].Name));
                 if (value == kingvalue) // if king is eatten prune this path completely
                 {
                     return(true);
                 }
                 if (bestPath <= currentBoardState + value) // prune path that are smaller than the current board state
                 {
                     PictureBox[][] newBoard = new PictureBox[8][];
                     setNewBoard(board, newBoard, y, x, y - 1, x - 1);
                     if (!IsValidMove(newBoard, turn))
                     {
                         bestPath = currentBoardState + value;
                         AI  newAI          = new AI(movesCount + 1);
                         int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState + value, finalResult);
                         if (movesCount == 0)
                         {
                             CapturedSquares capture = new CapturedSquares();
                             setResult(turn, bestBoardState, y, x, y - 1, x - 1, capture.CaptureCount(newBoard));
                         }
                         else
                         {
                             setResult(turn, bestBoardState, y, x, y - 1, x - 1, 0);
                         }
                     }
                 }
             }
             if (x + 1 < 8 && board[y - 1][x + 1] != null && !PieceDetails.IsPieceBlackorWhite(board[y - 1][x + 1].Name)) // white pawn eat black piece at north-east
             {
                 int value = PieceValue(PieceDetails.selectedBlackPiece(board[y - 1][x + 1].Name));
                 if (value == kingvalue)
                 {
                     return(true);
                 }
                 if (bestPath <= currentBoardState + value)
                 {
                     PictureBox[][] newBoard = new PictureBox[8][];
                     setNewBoard(board, newBoard, y, x, y - 1, x + 1);
                     if (!IsValidMove(newBoard, turn))
                     {
                         bestPath = currentBoardState + value;
                         AI  newAI          = new AI(movesCount + 1);
                         int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState + value, finalResult);
                         if (movesCount == 0)
                         {
                             CapturedSquares capture = new CapturedSquares();
                             setResult(turn, bestBoardState, y, x, y - 1, x + 1, capture.CaptureCount(newBoard));
                         }
                         else
                         {
                             setResult(turn, bestBoardState, y, x, y - 1, x + 1, 0);
                         }
                     }
                 }
             }
         }
         if (y - 2 >= 0 && y == 6 && board[y - 1][x] == null && board[y - 2][x] == null) // white pawn moves 2 squares north to empty square
         {
             PictureBox[][] newBoard = new PictureBox[8][];
             setNewBoard(board, newBoard, y, x, y - 2, x);
             if (!IsValidMove(newBoard, turn))
             {
                 AI  newAI          = new AI(movesCount + 1);
                 int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState, finalResult);
                 if (movesCount == 0)
                 {
                     CapturedSquares capture = new CapturedSquares();
                     setResult(turn, bestBoardState, y, x, y - 2, x, capture.CaptureCount(newBoard));
                 }
                 else
                 {
                     setResult(turn, bestBoardState, y, x, y - 2, x, 0);
                 }
             }
         }
     }
     else // black pawn move
     {
         if (y + 1 < 8)
         {
             if (board[y + 1][x] == null) // black pawn moving 1 square south to empty square
             {
                 PictureBox[][] newBoard = new PictureBox[8][];
                 setNewBoard(board, newBoard, y, x, y + 1, x); // create new board object to be used as parameter to call minimax function
                 if (!IsValidMove(newBoard, turn))
                 {
                     AI  newAI          = new AI(movesCount + 1);
                     int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState, finalResult);
                     if (movesCount == 0)
                     {
                         CapturedSquares capture = new CapturedSquares();
                         setResult(turn, bestBoardState, y, x, y + 1, x, capture.CaptureCount(newBoard));
                     }
                     else
                     {
                         setResult(turn, bestBoardState, y, x, y + 1, x, 0);
                     }
                 }
             }
             if (x - 1 >= 0 && board[y + 1][x - 1] != null && PieceDetails.IsPieceBlackorWhite(board[y + 1][x - 1].Name)) // black pawn eat white piece at south-west
             {
                 int value = PieceValue(PieceDetails.selectedWhitePiece(board[y + 1][x - 1].Name));
                 if (value == kingvalue) // if king is eatten prune this path completely
                 {
                     return(true);
                 }
                 if (bestPath >= currentBoardState - value) // prune path that are larger than the current board state
                 {
                     PictureBox[][] newBoard = new PictureBox[8][];
                     setNewBoard(board, newBoard, y, x, y + 1, x - 1);
                     if (!IsValidMove(newBoard, turn))
                     {
                         bestPath = currentBoardState - value;
                         AI  newAI          = new AI(movesCount + 1);
                         int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState - value, finalResult);
                         if (movesCount == 0)
                         {
                             CapturedSquares capture = new CapturedSquares();
                             setResult(turn, bestBoardState, y, x, y + 1, x - 1, capture.CaptureCount(newBoard));
                         }
                         else
                         {
                             setResult(turn, bestBoardState, y, x, y + 1, x - 1, 0);
                         }
                     }
                 }
             }
             if (x + 1 < 8 && board[y + 1][x + 1] != null && PieceDetails.IsPieceBlackorWhite(board[y + 1][x + 1].Name)) // black pawn eat white piece at south-east
             {
                 int value = PieceValue(PieceDetails.selectedWhitePiece(board[y + 1][x + 1].Name));
                 if (value == kingvalue)
                 {
                     return(true);
                 }
                 if (bestPath >= currentBoardState - value)
                 {
                     PictureBox[][] newBoard = new PictureBox[8][];
                     setNewBoard(board, newBoard, y, x, y + 1, x + 1);
                     if (!IsValidMove(newBoard, turn))
                     {
                         bestPath = currentBoardState - value;
                         AI  newAI          = new AI(movesCount + 1);
                         int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState - value, finalResult);
                         if (movesCount == 0)
                         {
                             CapturedSquares capture = new CapturedSquares();
                             setResult(turn, bestBoardState, y, x, y + 1, x + 1, capture.CaptureCount(newBoard));
                         }
                         else
                         {
                             setResult(turn, bestBoardState, y, x, y + 1, x + 1, 0);
                         }
                     }
                 }
             }
         }
         if (y + 2 < 8 && y == 1 && board[y + 1][x] == null && board[y + 2][x] == null) // white pawn moves 2 squares south to empty square
         {
             PictureBox[][] newBoard = new PictureBox[8][];
             setNewBoard(board, newBoard, y, x, y + 2, x);
             if (!IsValidMove(newBoard, turn))
             {
                 AI  newAI          = new AI(movesCount + 1);
                 int bestBoardState = newAI.MiniMax(newBoard, !turn, movesLimit, currentBoardState, finalResult);
                 if (movesCount == 0)
                 {
                     CapturedSquares capture = new CapturedSquares();
                     setResult(turn, bestBoardState, y, x, y + 2, x, capture.CaptureCount(newBoard));
                 }
                 else
                 {
                     setResult(turn, bestBoardState, y, x, y + 2, x, 0);
                 }
             }
         }
     }
     return(false);
 }