private void clickBlack(object sender, EventArgs e)
{
if (currentState != gameState.Checkmate && currentState != gameState.Stalemate && (PvP || PvE))
{
if (alreadySelected && turn) // when white piece eats black piece
{
if (MovePiece((PictureBox)sender))
{
panel.Refresh();
selectedpiece.BackColor = Color.Transparent;
foreach (PictureBox p in PossiblePieceToTake)
{
p.BackColor = Color.Transparent;
}
PossiblePieceToTake = new List <PictureBox>();
completeTurn();
AIMove();
}
else
{
MessageBox.Show("Invalid Move, please try again.");
}
}
else if (!turn && selectedpiece != (PictureBox)sender) // selecting black piece
{
resetHighlightedPieces();
selectedpiece = (PictureBox)sender;
selectedpiece.BackColor = Color.FromArgb(220, 13, 86, 212);
alreadySelected = true;
pieceName sourcePieceType = PieceDetails.selectedBlackPiece(selectedpiece.Name);
int Y = PieceDetails.FindCoordinate(selectedpiece.Location.Y);
int X = PieceDetails.FindCoordinate(selectedpiece.Location.X);
DisplayPossibleMoves dpm = new DisplayPossibleMoves(panel.CreateGraphics(), Color.FromArgb(125, 48, 118, 240));
dpm.DisplayMoves(Y, X, board, PossiblePieceToTake, turn, sourcePieceType);
}
}
}
public bool BlockMultipleTargets(PictureBox[][] board, bool turn, Dictionary <int, HashSet <int> > reach)
{
// loop through board to look for whether a piece can block the piece checking the king represented as reach (hashset)
for (int y = 0; y < board.Length; y++)
{
for (int x = 0; x < board[y].Length; x++)
{
if (board[y][x] == null)
{
continue;
}
ChessBoard.pieceName selected;
if (turn && PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
selected = PieceDetails.selectedWhitePiece(board[y][x].Name);
}
else if (!turn && !PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
selected = PieceDetails.selectedBlackPiece(board[y][x].Name);
}
else
{
continue;
}
// determine if selected piece can block the piece checking the king
switch (selected)
{
case ChessBoard.pieceName.Pawn:
if (PawnBlock(board, y, x, turn, reach))
{
return(true);
}
break;
case ChessBoard.pieceName.Rook:
if (RookBlock(board, y, x, reach))
{
return(true);
}
break;
case ChessBoard.pieceName.Knight:
if (KnightBlock(y, x, reach))
{
return(true);
}
break;
case ChessBoard.pieceName.Bishop:
if (BishopBlock(board, y, x, reach))
{
return(true);
}
break;
case ChessBoard.pieceName.Queen:
if (QueenBlock(board, y, x, reach))
{
return(true);
}
break;
}
}
}
return(false);
}
public ChessBoard.gameState TurnResult(PictureBox[][] board, bool turn) // turn will be represented as the current player that is making the move
{
Dictionary <int, HashSet <int> > targets = new Dictionary <int, HashSet <int> >(); // different places king can move are stored in a hash table
int[] kingCoord = PieceDetails.FindKing(board, !turn); // represent the opposite king to determine status of game through "!turn"
for (int i = -1; i <= 1; i++) // look for all the different places the king can move
{
for (int j = -1; j <= 1; j++)
{
int y = kingCoord[0] + i;
int x = kingCoord[1] + j;
if ((i == 0 && j == 0) || y >= 8 || y < 0 || x >= 8 || x < 0)
{
continue;
}
// check if selected king in the kingCoord can move to empty square or eat the opposite piece
if (board[y][x] == null || (turn && PieceDetails.IsPieceBlackorWhite(board[y][x].Name)) ||
(!turn && !PieceDetails.IsPieceBlackorWhite(board[y][x].Name)))
{
if (!targets.ContainsKey(y))
{
targets.Add(y, new HashSet <int>());
}
targets[y].Add(x);
}
}
}
PictureBox originalPosition = board[kingCoord[0]][kingCoord[1]];
board[kingCoord[0]][kingCoord[1]] = null;
for (int y = 0; y < board.Length; y++) // determine if the king can move at any of these places without being checked by removing all invalid moves in target array
{
if (targets.Count == 0) // break out if no targets are left
{
break;
}
for (int x = 0; x < board[y].Length; x++)
{
if (targets.Count == 0) // break out if no targets are left
{
break;
}
if (board[y][x] == null)
{
continue;
}
ChessBoard.pieceName selected = ChessBoard.pieceName.None;
// piece being selected must be based on the current turn piece
if (turn && PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
selected = PieceDetails.selectedWhitePiece(board[y][x].Name);
}
else if (!turn && !PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
selected = PieceDetails.selectedBlackPiece(board[y][x].Name);
}
else
{
continue;
}
switch (selected)
{
case ChessBoard.pieceName.Pawn:
PawnCheck(y, x, turn, targets);
break;
case ChessBoard.pieceName.Rook:
RookCheck(board, y, x, targets);
break;
case ChessBoard.pieceName.Knight:
KnightCheck(y, x, targets);
break;
case ChessBoard.pieceName.Bishop:
BishopCheck(board, y, x, targets);
break;
case ChessBoard.pieceName.Queen:
QueenCheck(board, y, x, targets);
break;
case ChessBoard.pieceName.King:
KingCheck(y, x, targets);
break;
}
}
}
board[kingCoord[0]][kingCoord[1]] = originalPosition;
List <int[]> checks = new List <int[]>(); // determine how many pieces are checking king
Check IsChecked = new Check();
IsChecked.CheckForMultipleChecks(board, kingCoord[0], kingCoord[1], turn, checks); // determine if king is checked
/*
* Checkmate Conditions:
* 1. King must be checked
* 2. King cannot move to any other squares without being checked again or an ally piece blocking it
* 3. The piece checking the king cannot be blocked or eatten by another piece
*
* Stalemate Conditions:
* 1. King must not be checked
* 2. King cannot move to any other squares without being checked again or an ally piece blocking it
* 3. No piece cannot be moved due to being checked if moved or blocked
*
* Check Conditions:
* 1. King must be checked
* 2. a) King can move to any other squares without being checked again or an ally piece blocking it
* b) The piece checking the king can be blocked or eatten by another piece
*
* Normal Conditions:
* 1. King must not be checked
* 2. a) King can move to other squares without being checked or blocked
* b) Other pieces can be moved without being blocked or king being checked
*/
if (checks.Count > 1 && targets.Count == 0) // this is checkmate
{
return(ChessBoard.gameState.Checkmate);
}
else if (checks.Count == 0 && targets.Count == 0) // determine if stalemate
{
// determine if any other pieces can move aside from the king
Movable canMove = new Movable();
Check IsCheck = new Check();
// determine if opposite player can move any piece to determine if its stalemate (for example, if it is currently the white's turn look for all the black pieces)
for (int y = 0; y < board.Length; y++)
{
for (int x = 0; x < board[y].Length; x++)
{
if (board[y][x] == null)
{
continue;
}
ChessBoard.pieceName piece = ChessBoard.pieceName.None;
if (!turn && PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
piece = PieceDetails.selectedWhitePiece(board[y][x].Name);
}
else if (turn && !PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
piece = PieceDetails.selectedBlackPiece(board[y][x].Name);
}
else
{
continue;
}
switch (piece) // if opposite piece can be moved than it is not a stalemate without being checked
{
case ChessBoard.pieceName.Pawn:
if (canMove.PawnMove(board, y, x, !turn, kingCoord[0], kingCoord[1]))
{
return(ChessBoard.gameState.Normal);
}
break;
case ChessBoard.pieceName.Rook:
if (canMove.RookMove(board, y, x, !turn, kingCoord[0], kingCoord[1]))
{
return(ChessBoard.gameState.Normal);
}
break;
case ChessBoard.pieceName.Knight:
if (canMove.KnightMove(board, y, x, !turn, kingCoord[0], kingCoord[1]))
{
return(ChessBoard.gameState.Normal);
}
break;
case ChessBoard.pieceName.Bishop:
if (canMove.BishopMove(board, y, x, !turn, kingCoord[0], kingCoord[1]))
{
return(ChessBoard.gameState.Normal);
}
break;
case ChessBoard.pieceName.Queen:
if (canMove.QueenMove(board, y, x, !turn, kingCoord[0], kingCoord[1]))
{
return(ChessBoard.gameState.Normal);
}
break;
default:
break;
}
}
}
return(ChessBoard.gameState.Stalemate);
}
else if (checks.Count == 1 && targets.Count == 0) // determine if checkmate
{
// check.Count must be 1 and not larger than 1 as two piece cannot be blocked at the same time to protect the king
int Y = checks[0][0];
int X = checks[0][1];
PieceReach maxReach = new PieceReach();
Dictionary <int, HashSet <int> > reach = new Dictionary <int, HashSet <int> >(); // the reach will determine how many different squares can be blocked to protect the king
ChessBoard.pieceName selected = ChessBoard.pieceName.None;
if (turn && PieceDetails.IsPieceBlackorWhite(board[Y][X].Name))
{
selected = PieceDetails.selectedWhitePiece(board[Y][X].Name);
}
else if (!turn && !PieceDetails.IsPieceBlackorWhite(board[Y][X].Name))
{
selected = PieceDetails.selectedBlackPiece(board[Y][X].Name);
}
reach.Add(Y, new HashSet <int>());
reach[Y].Add(X); // this represents that piece being eaten rather than blocked
switch (selected)
{
case ChessBoard.pieceName.Rook:
maxReach.RookReach(Y, X, kingCoord[0], kingCoord[1], turn, reach);
break;
case ChessBoard.pieceName.Bishop:
maxReach.BishopReach(Y, X, kingCoord[0], kingCoord[1], turn, reach);
break;
case ChessBoard.pieceName.Queen:
maxReach.QueenReach(Y, X, kingCoord[0], kingCoord[1], turn, reach);
break;
}
BlockPiece block = new BlockPiece();
if (!block.BlockMultipleTargets(board, !turn, reach)) // determine if piece checking king can be blocked or eaten
{
return(ChessBoard.gameState.Checkmate);
}
}
return(checks.Count > 0 ? ChessBoard.gameState.Check : ChessBoard.gameState.Normal);
}
public bool IsChecked(PictureBox[][] board, int targetY, int targetX, bool turn) // Determine if king is checked
{
for (int y = 0; y < board.Length; y++) // loop board to determine if move is valid
{
for (int x = 0; x < board[y].Length; x++)
{
// only select pieces based on black or white's turn
if (board[y][x] == null || (y == targetY && x == targetX))
{
continue;
}
ChessBoard.pieceName selected;
if (turn && PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
selected = PieceDetails.selectedWhitePiece(board[y][x].Name);
}
else if (!turn && !PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
selected = PieceDetails.selectedBlackPiece(board[y][x].Name);
}
else
{
continue;
}
switch (selected) // select a piece that will be moved that may result in a check
{
case ChessBoard.pieceName.Pawn:
if (PawnCheck(y, x, turn, targetY, targetX))
{
return(true);
}
break;
case ChessBoard.pieceName.Rook:
if (RookCheck(board, y, x, targetY, targetX))
{
return(true);
}
break;
case ChessBoard.pieceName.Knight:
if (KnightCheck(y, x, targetY, targetX))
{
return(true);
}
break;
case ChessBoard.pieceName.Bishop:
if (BishopCheck(board, y, x, targetY, targetX))
{
return(true);
}
break;
case ChessBoard.pieceName.Queen:
if (QueenCheck(board, y, x, targetY, targetX))
{
return(true);
}
break;
case ChessBoard.pieceName.King:
if (KingCheck(y, x, targetY, targetX))
{
return(true);
}
break;
}
}
}
return(false);
}
// store all the possible ways king can be checked in the current board
public void CheckForMultipleChecks(PictureBox[][] board, int targetY, int targetX, bool turn, List <int[]> checks)
{
// loop through board to look if king has being checked
for (int y = 0; y < board.Length; y++)
{
for (int x = 0; x < board[y].Length; x++)
{
if (checks.Count > 1)
{
return;
}
if (board[y][x] == null)
{
continue;
}
ChessBoard.pieceName selected;
if (turn && PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
selected = PieceDetails.selectedWhitePiece(board[y][x].Name);
}
else if (!turn && !PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
selected = PieceDetails.selectedBlackPiece(board[y][x].Name);
}
else
{
continue;
}
switch (selected) // select a piece that will be moved that may result in a check where results are stored as coordinates in an array
{
case ChessBoard.pieceName.Pawn:
if (PawnCheck(y, x, turn, targetY, targetX))
{
checks.Add(new int[] { y, x });
}
break;
case ChessBoard.pieceName.Rook:
if (RookCheck(board, y, x, targetY, targetX))
{
checks.Add(new int[] { y, x });
}
break;
case ChessBoard.pieceName.Knight:
if (KnightCheck(y, x, targetY, targetX))
{
checks.Add(new int[] { y, x });
}
break;
case ChessBoard.pieceName.Bishop:
if (BishopCheck(board, y, x, targetY, targetX))
{
checks.Add(new int[] { y, x });
}
break;
case ChessBoard.pieceName.Queen:
if (QueenCheck(board, y, x, targetY, targetX))
{
checks.Add(new int[] { y, x });
}
break;
case ChessBoard.pieceName.King:
if (KingCheck(y, x, targetY, targetX))
{
checks.Add(new int[] { y, x });
}
break;
}
}
}
}
private bool MovePiece(int destinationY, int destinationX) // moving a piece to an empty square
{
pieceName sourcePieceType = turn ? PieceDetails.selectedWhitePiece(selectedpiece.Name) : PieceDetails.selectedBlackPiece(selectedpiece.Name);
return(IsValidMove(sourcePieceType, destinationY, destinationX));
}
private bool MovePiece(PictureBox destination) // moving a piece to eat another piece
{
pieceName sourcePieceType = turn ? PieceDetails.selectedWhitePiece(selectedpiece.Name) : PieceDetails.selectedBlackPiece(selectedpiece.Name);
int destinationY = PieceDetails.FindCoordinate(destination.Location.Y);
int destinationX = PieceDetails.FindCoordinate(destination.Location.X);
return(IsValidMove(sourcePieceType, destinationY, destinationX));
}
// if it is currently at white's turn, it will try to look for the maximum boardstate value but if it is at black's turn, it will look for the minimum boardstate
public int MiniMax(PictureBox[][] board, bool turn, int movesLimit, int currentBoardState, AIResult finalResult)
{
if (movesCount == movesLimit) // this will be the base case which is an end point where this end value will be compared with other end values
{
return(currentBoardState);
}
BoardState = turn ? int.MinValue : int.MaxValue; // boardstate looks at the materials represented in the current board (white looks for the maximum board state and black looks for the minimum board state)
squareCount = turn ? int.MinValue : int.MaxValue; // squarecount looks at the number of spaces that can be moved represented in the current board (white looks for the maximum squarecount and black looks for the minimum squarecount - only compares when movecount is 0)
bestPath = currentBoardState;
for (int y = 0; y < board.Length; y++)
{
for (int x = 0; x < board[y].Length; x++)
{
if (board[y][x] == null)
{
continue;
}
ChessBoard.pieceName name = ChessBoard.pieceName.None;
// look for the piece that corresponds with its own selected piece (black must select a black piece and white must select a white piece)
if (turn && PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
name = PieceDetails.selectedWhitePiece(board[y][x].Name);
}
else if (!turn && !PieceDetails.IsPieceBlackorWhite(board[y][x].Name))
{
name = PieceDetails.selectedBlackPiece(board[y][x].Name);
}
else
{
continue;
}
switch (name)
{
case ChessBoard.pieceName.Pawn:
if (PawnAI(board, y, x, turn, movesCount, movesLimit, currentBoardState, finalResult)) // if these return true than stop perform best path calculation and break out of this path
{
return(turn ? int.MaxValue : int.MinValue);
}
break;
case ChessBoard.pieceName.Rook:
if (RookAI(board, y, x, turn, movesCount, movesLimit, currentBoardState, finalResult))
{
return(turn ? int.MaxValue : int.MinValue);
}
break;
case ChessBoard.pieceName.Knight:
if (KnightAI(board, y, x, turn, movesCount, movesLimit, currentBoardState, finalResult))
{
return(turn ? int.MaxValue : int.MinValue);
}
break;
case ChessBoard.pieceName.Bishop:
if (BishopAI(board, y, x, turn, movesCount, movesLimit, currentBoardState, finalResult))
{
return(turn ? int.MaxValue : int.MinValue);
}
break;
case ChessBoard.pieceName.Queen:
if (QueenAI(board, y, x, turn, movesCount, movesLimit, currentBoardState, finalResult))
{
return(turn ? int.MaxValue : int.MinValue);
}
break;
case ChessBoard.pieceName.King:
if (KingAI(board, y, x, turn, movesCount, movesLimit, currentBoardState, finalResult))
{
return(turn ? int.MaxValue : int.MinValue);
}
break;
}
}
}
if (movesCount == 0) // this will store the beginning point of the best path which will allow AI to make that specific move
{
finalResult.SourceY = SourceY;
finalResult.SourceX = SourceX;
finalResult.DestinationY = DestinationY;
finalResult.DestinationX = DestinationX;
}
return(BoardState);
}
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);
}