public int CaptureCount(PictureBox[][] board)
{
for (int i = 0; i < board.Length; i++)
{
for (int j = 0; j < board[i].Length; j++)
{
if (board[i][j] == null)
{
continue;
}
bool turn = PieceDetails.IsPieceBlackorWhite(board[i][j].Name);
ChessBoard.pieceName selected = PieceDetails.selectedPiece(board[i][j].Name);
switch (selected)
{
case ChessBoard.pieceName.Pawn:
PawnSquaresTaken(i, j, board, turn);
break;
case ChessBoard.pieceName.Rook:
RookSquaresTaken(i, j, board, turn);
break;
case ChessBoard.pieceName.Knight:
KnightSquaresTaken(i, j, board, turn);
break;
case ChessBoard.pieceName.Bishop:
BishopSquaresTaken(i, j, board, turn);
break;
case ChessBoard.pieceName.Queen:
QueenSquaresTaken(i, j, board, turn);
break;
default:
KingSquaresTaken(i, j, board, turn);
break;
}
}
}
return(capturedBoard);
}
private void AIMove() // determine how the AI will move and swap back to players turn after AI makes its move
{
if (PvE && (currentState == gameState.Normal || currentState == gameState.Check) && ((turn && AIColor) || (!turn && !AIColor)))
{
int currentBoardState = 0;
AIResult aiResult = new AIResult();
AI ai = new AI(0);
for (int y = 0; y < board.Length; y++)
{
for (int x = 0; x < board[y].Length; x++)
{
if (board[y][x] == null)
{
continue;
}
if (PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
currentBoardState += ai.PieceValue(PieceDetails.selectedPiece(board[y][x].Name));
}
else
{
currentBoardState -= ai.PieceValue(PieceDetails.selectedPiece(board[y][x].Name));
}
}
}
ai.MiniMax(board, turn, AIComplexity, currentBoardState, aiResult);
selectedpiece = board[aiResult.SourceY][aiResult.SourceX];
if (!IsValidMove(PieceDetails.selectedPiece(board[aiResult.SourceY][aiResult.SourceX].Name), aiResult.DestinationY, aiResult.DestinationX))
{
MessageBox.Show("AI ERROR");
undo();
return;
}
completeTurn();
}
}
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);
}
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);
}
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);
}