ChessModel

import java.util.ArrayList;
import java.util.Collections;

/*****************************************************************************
 * This class creates the chess game and is brains behind the GUI. every
 * decision is made in this class.
 * 
 * @author Nathan Kelderman and Matt Shampine
 * @version 1.0
 ***************************************************************************/
public class ChessModel implements IChessModel {

	/** a double array that stores all the pieces at their location on the 
	 * board */
	private IChessPiece[][] board;

	/** stores the current player */
	private Player player;

	/** sets board size to 8 */
	private final int BOARD_SIZE = 8;

	/** stores if it is the first click or not */
	private boolean firstClick;

	/** stores the number of moves the AI has done for random moves */
	private int numMoves;

	/** stores 8 moves for the AI to use randomly */
	private ArrayList<Move> randomMoves;

	/** stores the best move for the AI to use for the next move */
	private Move bestMove;

	/** stores a possibly best move for the AI which is used to check against 
	 * the current best move */
	private Move possibleMove;

	/** stores the last move the AI did so it doesn't move back to that 
	 * spot */
	private Move lastMove;

	/** used to copy the current board so it can be manipulated without 
	 * moving pieces on the actual board*/
	private IChessPiece[][] tempBoard;

	/** stores whether or not the AI is turned on or off */
	private boolean AIEnabled;

	/** stores all the dead white pieces */
	private ArrayList<IChessPiece> whitePieces;

	/** stores all the dead black pieces */
	private ArrayList<IChessPiece> blackPieces;

	/*************************************************************************
	 * The constructor resets the board to the default chess board and sets
	 * the AI to be on.
	 * 
	 ***********************************************************************/
	public ChessModel() {
		reset();
		setAIEnabled(true);
	}


	/*************************************************************************
	 * The reset method sets the board to a default board with all the pieces
	 * positions set to the normal spots on the board according to chess 
	 * rules. It also duplicates the board to the tempBoard in case a later
	 * method uses the tempBoard.
	 * 
	 ***********************************************************************/
	public void reset() {
		board = new IChessPiece[BOARD_SIZE][BOARD_SIZE];
		numMoves = 0;
		possibleMove = null;

		tempBoard = new IChessPiece[BOARD_SIZE][BOARD_SIZE];

		whitePieces = new ArrayList<IChessPiece>();
		blackPieces = new ArrayList<IChessPiece>();

		player = Player.BLACK; // setting the AI to black
		board[0][0] = new Rook(player);
		board[0][1] = new Knight(player);
		board[0][2] = new Bishop(player);
		board[0][3] = new Queen(player);
		board[0][4] = new King(player);
		board[0][5] = new Bishop(player);
		board[0][6] = new Knight(player);
		board[0][7] = new Rook(player);

		for (int col = 0; col < 8; col++)
			board[1][col] = new Pawn(player);

		player = Player.WHITE;
		board[7][0] = new Rook(player);
		board[7][1] = new Knight(player);
		board[7][2] = new Bishop(player);
		board[7][3] = new Queen(player);
		board[7][4] = new King(player);
		board[7][5] = new Bishop(player);
		board[7][6] = new Knight(player);
		board[7][7] = new Rook(player);

		for (int col = 0; col < 8; col++)
			board[6][col] = new Pawn(player);

		randomMoves = new ArrayList<Move>();
		randomMoves.add(new Move(0, 1, 2, 0));
		randomMoves.add(new Move(1, 1, 3, 1));
		randomMoves.add(new Move(1, 3, 2, 3));
		randomMoves.add(new Move(0, 6, 2, 5));
		randomMoves.add(new Move(1, 2, 3, 2));
		randomMoves.add(new Move(1, 4, 2, 4));
		randomMoves.add(new Move(1, 6, 2, 6));
		randomMoves.add(new Move(1, 7, 3, 7));
		Collections.shuffle(randomMoves);

		setFirstClick(true);
		duplicateBoard(board);
	}

	/*************************************************************************
	 * Checks to see if the spot on the cell if occupied.
	 * 
	 * @param temp stores a piece
	 * @return returns true if cell contains a piece and false if not
	 ************************************************************************/
	public boolean isCellOccupied(IChessPiece temp) {
		if (temp != null)
			return true;
		return false;
	}

	/*************************************************************************
	 * Getter for checking if it is the first click.
	 * 
	 * @return firstClick returns if it is the first click or not
	 ************************************************************************/
	public boolean isFirstClick() {
		return firstClick;
	}

	/*************************************************************************
	 * Setter for declaring if it is the first click or not.
	 * 
	 * @param firstClick 
	 ************************************************************************/
	public void setFirstClick(boolean firstClick) {
		this.firstClick = firstClick;
	}

	/*************************************************************************
	 * Getter for AIEnabled.
	 * 
	 * @return returns if AI is turned on or not
	 ************************************************************************/
	public boolean isAIEnabled() {
		return AIEnabled;
	}

	/*************************************************************************
	 * Setter for enabling or disabling the AI.
	 * 
	 * @param aIEnabled sets the AI to be enabled or disabled
	 ************************************************************************/
	public void setAIEnabled(boolean AIEnabled) {
		this.AIEnabled = AIEnabled;
	}

	/*************************************************************************
	 * Checks if the inputed move is a valid move.
	 * 
	 * @param move receives a move to check if it is valid
	 * @see IChessPiece#isValidMove(Move move)
	 ************************************************************************/
	public boolean isValidMove(Move move) {
		if (board[move.fromRow][move.fromColumn].player() != player) {
			throw new IllegalPlayer();
		}
		if (!castling(move)) {
			if (board[move.fromRow][move.fromColumn].isValidMove(move, board))
				return true;
			else
				throw new InvalidMove();
		} else
			return false;
	}

	/*************************************************************************
	 * Promotes a pawn to the highest value piece that is dead and removes 
	 * that piece from the dead pieces array.
	 * 
	 * @param move takes in a move so it can check if the fromRow and 
	 * fromColumn is a pawn and if it is White or Black
	 ************************************************************************/
	public void promotion(Move move) { 
		int y = 0;
		int z = 0;
		IChessPiece tempPiece = null;
		if (tempBoard[move.fromRow][move.fromColumn].player() ==
				Player.WHITE) { 
			//checks to see if piece reaching the end is a pawn
			if (tempBoard[move.fromRow][move.fromColumn].type().
					equals("Pawn")) { 
				//cycles through the dead pieces
				for (int x = 0; x < whitePieces.size(); x++) {
					if (whitePieces.get(x) != null && 
							!whitePieces.get(x).type().equals("Pawn")) {
					//sets temp piece to the next highest valued dead piece
						if (whitePieces.get(x).getPieceWorth() >= y) {
							y = whitePieces.get(x).getPieceWorth();
							tempPiece = whitePieces.get(x);
							z = x;
						}
					}
				}
			}
			//sets pawn to the highest dead piece
			board[move.toRow][move.toColumn] = tempPiece;
			//removes that dead piece from the arrayList
			if (whitePieces.size() != 0)
				whitePieces.remove(z);
		} else {
			tempPiece = null;
			if (tempBoard[move.fromRow][move.fromColumn].player() == 
					Player.BLACK) {
				//checks to see if piece reaching the end is a pawn
				if (tempBoard[move.fromRow][move.fromColumn].type().
						equals("Pawn")) {
					//cycles through the dead pieces
					for (int x = 0; x < blackPieces.size(); x++) {
						if (blackPieces.get(x) != null && !blackPieces.get(x).
								type().equals("Pawn")) {
					//sets temp piece to the next highest valued dead piece
							if (blackPieces.get(x).getPieceWorth() >= y) {
								y = blackPieces.get(x).getPieceWorth();
								tempPiece = blackPieces.get(x);
								z = x;
							}
						}
					}
				}
			}
			//sets pawn to the highest dead piece
			board[move.toRow][move.toColumn] = tempPiece;
			//removes that dead piece from the arrayList
			if (blackPieces.size() != 0)
				blackPieces.remove(z);
		}
	}

	/*************************************************************************
	 * Moves the piece on the board to the new spot if all the requirements
	 * have been met and promotes the pawn if necessary and stores the
	 * piece taken out (if a piece is taken out) into the arrayList of dead
	 * pieces.
	 * 
	 * @param move is the move that is to be made
	 * @see IChessModel#move(Move)
	 ************************************************************************/
	public void move(Move move) {

		IChessPiece temp1 = board[move.toRow][move.toColumn];

		//adds killed piece to arrayList
		if (temp1 != null) {
			if (temp1.player() == Player.WHITE) {
				whitePieces.add(temp1);
			} else {
				blackPieces.add(temp1);
			}
		}
		
		//checks to see if the piece is a pawn and it is reaching the end
		//and if it is then it promotes it
		if (pieceAt(move.fromRow, move.fromColumn) != null
				&& pieceAt(move.fromRow, move.fromColumn).type().
				equals("Pawn") && ((move.toRow == 0 && 
				board[move.fromRow][move.fromColumn].player() == Player.WHITE)
				|| (move.toRow == 7 && board[move.fromRow][move.fromColumn].
				player() == Player.BLACK))
				&& player == pieceAt(move.fromRow, move.fromColumn).player()){
			promotion(move);
			board[move.fromRow][move.fromColumn] = null;
			//if the pawn isn't set to anything or just to another pawn then
			//it gets set to a queen
			if (pieceAt(move.toRow, move.toColumn) == null
					|| pieceAt(move.toRow, move.toColumn).
					type().equals("Pawn")) {
				board[move.toRow][move.toColumn] = new Queen(player);
				player = player.next(); 
				//checks if opposite player is in check after the promotion
				if ((player == Player.WHITE && inCheck(Player.WHITE))
						|| (player == Player.BLACK && 
						inCheck(Player.BLACK))) {
					if ((player == Player.WHITE && isComplete(Player.WHITE))
							|| (player == Player.BLACK && 
							isComplete(Player.BLACK))) {
						throw new NoDeadPiecesInCheckMate();
					} else
						throw new NoDeadPiecesInCheck();
				}
				throw new NoDeadPieces();
			}
			player = player.next();
			//checks if opposite player is in check after the promotion
			if ((player == Player.WHITE && inCheck(Player.WHITE))
					|| (player == Player.BLACK && inCheck(Player.BLACK))) {
				if ((player == Player.WHITE && isComplete(Player.WHITE))
						|| (player == Player.BLACK && 
						isComplete(Player.BLACK))) {
					throw new CheckMate();
				} else
					throw new Check();
			}
		} else {
			//if there is no promotion the it moves the piece 
			IChessPiece temp = board[move.fromRow][move.fromColumn];
			board[move.toRow][move.toColumn] = 
					board[move.fromRow][move.fromColumn];
			board[move.fromRow][move.fromColumn] = null;
			boolean black = inCheck(Player.BLACK);
			boolean white = inCheck(Player.WHITE);
			boolean blackCM = isComplete(Player.BLACK);
			boolean whiteCM = isComplete(Player.WHITE);
			//checks if either black or white is in checkmate after the move
			if (whiteCM || blackCM) {
				//if white is in checkmate and white is trying to move then 
				//don't allow the move
				if (player == Player.WHITE && whiteCM) {
					board[move.fromRow][move.fromColumn] = temp;
					board[move.toRow][move.toColumn] = temp1;
				}
				//if black is in checkmate and black is trying to move then 
				//don't allow the move
				if (player == Player.BLACK && blackCM) {
					board[move.fromRow][move.fromColumn] = temp;
					board[move.toRow][move.toColumn] = temp1;
				}
				//if white is moving and black is in checkmate then notify the 
				//players and allow the move
				if (player == Player.WHITE && blackCM) {
					board[move.fromRow][move.fromColumn] = null;
					board[move.toRow][move.toColumn] = temp;
					player = player.next();
					throw new CheckMate();
				}
				//if white is in checkmate and black is moving then notify the
				//players and allow the move
				if (player == Player.BLACK && whiteCM) {
					board[move.fromRow][move.fromColumn] = null;
					board[move.toRow][move.toColumn] = temp;
					player = player.next();
					throw new CheckMate();
				}
			}
			//if neither are in checkmate then check if they are in check 
			//after the move
			else {
				//if white is trying to move and white is in check then don't 
				//allow the move
				if (player == Player.WHITE && white) {
					board[move.fromRow][move.fromColumn] = temp;
					board[move.toRow][move.toColumn] = temp1;
				//if black is trying to move and black is in check then don't 
				//allow the move
				} else if (player == Player.BLACK && black) {
					board[move.fromRow][move.fromColumn] = temp;
					board[move.toRow][move.toColumn] = temp1;
				} else {
					//if white is trying to move and black is in check then 
					//notify the players and allow the move
					if (player == Player.WHITE && black) {
						board[move.fromRow][move.fromColumn] = null;
						board[move.toRow][move.toColumn] = temp;
						player = player.next();
						throw new Check();
					}
					//if black is trying to move and white is in check then 
					//notify the players and allow the move
					if (player == Player.BLACK && white) {
						board[move.fromRow][move.fromColumn] = null;
						board[move.toRow][move.toColumn] = temp;
						player = player.next();
						throw new Check();
					}
					//if neither players is in check or checkmate after the 
					//move then just allow it
					if (!black && !white) {
						board[move.toRow][move.toColumn] = temp;
						player = player.next();
					}
				}
			}
		}
	}

	/************************************************************************
	 * Checks to see if Player p is in check. Cycles through all the enemy 
	 * pieces and if on of them can hit the friendly king then Player p is in
	 * check.
	 * 
	 * @param p is the player that is being checked if they are in check
	 * @return returns true if in check and false if not
	 * @see IChessModel#inCheck(Player)
	 ************************************************************************/
	public boolean inCheck(Player p) {

		duplicateBoard(board);
		//finds a spot on the board that is the opposite player of player 'p'
		for (int row = 0; row < BOARD_SIZE; row++)
			for (int col = 0; col < BOARD_SIZE; col++) {
				if (tempBoard[row][col] != null)
					if (tempBoard[row][col].player() != p) {
						//checks if that piece can move and hit the king of
						//player 'p'
						for (int r = 0; r < BOARD_SIZE; r++)
							for (int c = 0; c < BOARD_SIZE; c++) {
								Move temp = new Move(row, col, r, c);
								if (isValidMoveAI(temp) && board[r][c] != 
										null)
									//if it can then it returns true for king
									//being in check
									if (tempBoard[r][c].player() == p && 
									tempBoard[r][c].type().equals("King"))
										return true;
							}
					}
			}
		return false;
	}

	/*************************************************************************
	 * This inCheck method is used by the isComplete method which moves pieces
	 * on the tempBoard so we don't want to duplicate the board again like the
	 * other inCheck method does.
	 * 
	 * @param p is the player being checked if they are in check or not
	 * @return returns true if in check or false if not
	 ************************************************************************/
	public boolean tempBoardInCheck(Player p) {

		//same as inCheck except it doesn't duplicate the board
		for (int row = 0; row < BOARD_SIZE; row++)
			for (int col = 0; col < BOARD_SIZE; col++) {
				if (tempBoard[row][col] != null)
					if (tempBoard[row][col].player() != p) {
						for (int r = 0; r < BOARD_SIZE; r++)
							for (int c = 0; c < BOARD_SIZE; c++) {
								Move temp = new Move(row, col, r, c);
								if (isValidMoveAI(temp) && tempBoard[r][c] != 
										null)
									if (tempBoard[r][c].player() == p && 
									tempBoard[r][c].type().equals("King"))
										return true;
							}
					}
			}
		return false;
	}

	/*************************************************************************
	 * This method cycles through all of the Player p pieces and moves all of
	 * them to all of its possible move locations and checks if the king is 
	 * still in check. If the king is still in check after all pieces have
	 * been moved then the king is in checkmate otherwise if there is a 
	 * piece that can be moved to take the king out of check then the king
	 * is not in checkmate.
	 * 
	 * @param p is the player being checked if they are in check
	 * @return returns true if king is in checkmate and false if not
	 * @see IChessModel#isComplete(Player)
	 ************************************************************************/
	public boolean isComplete(Player p) {

		duplicateBoard(board);
		//finds a pieces on the board that is of type player 'p'
		for (int row = 0; row < BOARD_SIZE; row++)
			for (int col = 0; col < BOARD_SIZE; col++) {
				if (tempBoard[row][col] != null)
					if (tempBoard[row][col].player() == p) {
						//tries every possible move of that piece
						for (int r = 0; r < BOARD_SIZE; r++)
							for (int c = 0; c < BOARD_SIZE; c++) {
								Move temp = new Move(row, col, r, c);
								IChessPiece tempPiece = tempBoard[row][col];
								IChessPiece tempPiece1 = null;
								if (tempBoard[r][c] != null)
									tempPiece1 = tempBoard[r][c];
								if (isValidMoveAI(temp)) {
									tempBoard[row][col] = null;
									tempBoard[r][c] = tempPiece;
									//if that move takes the king out of 
									//check then that player is not in check
									if (!tempBoardInCheck(p)) {
										tempBoard[row][col] = tempPiece;
										tempBoard[r][c] = tempPiece1;
										return false;
									}
								}
								tempBoard[row][col] = tempPiece;
								tempBoard[r][c] = tempPiece1;
							}

					}
			}
		//if there are no pieces that can move and take the king out of check
		//then that means the king is in checkmate so it returns true;
		return true;
	}

	/*************************************************************************
	 * Creates a new board with the pieces at the same spot as the current 
	 * board so the program can manipulate the tempBoard without changing
	 * anything on the current board.
	 * 
	 * @param newBoard is the board that tempBoard is copying
	 ************************************************************************/
	public void duplicateBoard(IChessPiece[][] newBoard) {

		tempBoard = new IChessPiece[BOARD_SIZE][BOARD_SIZE];
		//cycles through the board and if there is a pieces there then it 
		//creates a new piece on the tempBoard at the same location as the 
		//one on board and sets the piece to be the exact same one as the one 
		//on board 
		for (int row = 0; row < BOARD_SIZE; row++)
			for (int col = 0; col < BOARD_SIZE; col++) {
				if (board[row][col] != null) {
					if (newBoard[row][col].type().equals("Pawn") && 
							newBoard[row][col].player() == Player.WHITE) {
						tempBoard[row][col] = new Pawn(Player.WHITE);
					} else if (newBoard[row][col].type().equals("Pawn"))
						tempBoard[row][col] = new Pawn(Player.BLACK);
					if (newBoard[row][col].type().equals("Rook") && 
							newBoard[row][col].player() == Player.WHITE) {
						tempBoard[row][col] = new Rook(Player.WHITE);
						if (!((Rook) board[row][col]).isCastlingValid())
							((Rook) tempBoard[row][col]).
							setCastlingValid(false);
					} else if (newBoard[row][col].type().equals("Rook")) {
						tempBoard[row][col] = new Rook(Player.BLACK);
						if (!((Rook) board[row][col]).isCastlingValid())
							((Rook) tempBoard[row][col]).
							setCastlingValid(false);
					}
					if (newBoard[row][col].type().equals("Bishop") && 
							newBoard[row][col].player() == Player.WHITE)
						tempBoard[row][col] = new Bishop(Player.WHITE);
					else if (newBoard[row][col].type().equals("Bishop"))
						tempBoard[row][col] = new Bishop(Player.BLACK);
					if (newBoard[row][col].type().equals("Knight") && 
							newBoard[row][col].player() == Player.WHITE)
						tempBoard[row][col] = new Knight(Player.WHITE);
					else if (newBoard[row][col].type().equals("Knight"))
						tempBoard[row][col] = new Knight(Player.BLACK);
					if (newBoard[row][col].type().equals("King") && 
							newBoard[row][col].player() == Player.WHITE) {
						tempBoard[row][col] = new King(Player.WHITE);
						if (!((King) board[row][col]).isCastlingValid())
							((King) tempBoard[row][col]).
							setCastlingValid(false);
					} else if (newBoard[row][col].type().equals("King")) {
						tempBoard[row][col] = new King(Player.BLACK);
						if (!((King) board[row][col]).isCastlingValid())
							((King) tempBoard[row][col]).
							setCastlingValid(false);
					}
					if (newBoard[row][col].type().equals("Queen") && 
							newBoard[row][col].player() == Player.WHITE)
						tempBoard[row][col] = new Queen(Player.WHITE);
					else if (newBoard[row][col].type().equals("Queen"))
						tempBoard[row][col] = new Queen(Player.BLACK);
				}
			}
	}

	/*************************************************************************
	 * @see IChessModel#currentPlayer()
	 ************************************************************************/
	public Player currentPlayer() {
		return player;
	}

	/*************************************************************************
	 * Getter for the number of rows on the board.
	 * 
	 * @return int returns the number of rows on the board
	 ************************************************************************/
	public int numRows() {
		return BOARD_SIZE;
	}

	/*************************************************************************
	 * Getter for the number of columns on the board.
	 * 
	 * @return int returns the number of columns on the board
	 ************************************************************************/
	public int numColumns() {
		return BOARD_SIZE;
	}

	/*************************************************************************
	 * Returns the piece at any given location on the board.
	 * @param row number of rows on the board
	 * @param col number of columns on the board
	 * @return IChessPiece returns the piece at the given row and column
	 ************************************************************************/
	public IChessPiece pieceAt(int row, int col) {
		return board[row][col];
	}

	/*************************************************************************
	 * Determines the best move for the AI to do without putting itself in 
	 * check and if it is in check then it gets itself out of check. First
	 * four moves are random unless the opponent puts the king in check before
	 * the 4 moves are done.
	 * 
	 * @return move returns the best move according to a point value that is
	 * given to each move
	 ************************************************************************/
	public Move chessAIMove() {
		if (Player.BLACK == player) {

			duplicateBoard(board);
			//sets initial move value to 0
			int moveValue = 0;
			//if king is in check then find a move that takes it out of check
			if (inCheck(Player.BLACK)) 
				return getOutOfCheck();
			//if it isn't in check then continue doing the random moves until
			//the AI is 4 moves in
			else {
				if (numMoves < 4) {
					for (int i = numMoves; i < randomMoves.size(); i++)
						if (isValidMoveAI(randomMoves.get(i))) {
							bestMove = randomMoves.get(i);
							lastMove = bestMove;
							numMoves++;
							return bestMove;
						}
				}
				//if the 4 random moves are done then it finds a black piece
				//on the board and sends that piece to chessAI to find the 
				//best move for that piece and the compares that to the 
				//previous best move and if its greater than or equal to the
				//previous best it assigns the new best move to the given move
				else {
					for (int row = 0; row < BOARD_SIZE; row++)
						for (int col = 0; col < BOARD_SIZE; col++) {
							if (tempBoard[row][col] != null)
								if (tempBoard[row][col].player() == 
								Player.BLACK) {
									int temp = chessAI(tempBoard[row][col]);
									if (temp >= moveValue) {
										moveValue = temp;
										//stores the last move and makes sure 
										//it doesn't keep moving back and 
										//forth
										if ( lastMove != possibleMove)
											bestMove = possibleMove;
									}
								}
						}
					lastMove = bestMove;
					return bestMove;
				}
			}
		}
		return null;
	}

	/*************************************************************************
	 * This cycles through all of the board pieces and when it finds a black
	 * piece then it moves it to all of the possible spots on the board and 
	 * gives that move a point value and if it is greater than the previous
	 * move's point value then it sets the new one the be the best up to this 
	 * point.
	 * 
	 * @param AIBoard a specific piece on the board to try moves on
	 * @return int returns the highest moves point value and stores the move 
	 * into a temporary 'best' variable
	 ************************************************************************/
	public int chessAI(IChessPiece AIBoard) {

		int moveValue = 0;
		int tempValue = 0;
		//finds the given black piece on the board
		for (int row = 0; row < BOARD_SIZE; row++) {
			for (int col = 0; col < BOARD_SIZE; col++) {
				if (tempBoard[row][col] == AIBoard)
					//cycles through each move that piece can move
					for (int r = 0; r < BOARD_SIZE; r++) {
						for (int c = 0; c < BOARD_SIZE; c++) {
							//makes sure the move isn't back to the spot it 
							//was last turn
//							if (r == lastMove.fromRow && c == 
//									lastMove.fromColumn) 
//								break;
							Move tempMove = new Move(row, col, r, c);
							if (isValidMoveAI(tempMove)) {
								IChessPiece temp = tempBoard[row][col];
								IChessPiece temp1 = tempBoard[r][c];
								//moves the piece if it is a valid move
								tempBoard[r][c] = tempBoard[row][col];
								tempBoard[row][col] = null;
								//makes sure that move doesn't put it in 
								//check
								if (!tempBoardInCheck(Player.BLACK)) {
									tempBoard[r][c] = temp1;
									tempBoard[row][col] = temp;
									//if a pawn takes out a pawn the move
									//value is set to 7
									if (tempBoard[r][c] != null && 
											tempBoard[r][c].type().
											equals("Pawn") && 
											tempBoard[row][col].type().
											equals("Pawn"))
										moveValue = 7;
									//if a piece take out a piece of the same
									//type then the piece worths are
									//multiplied together
									else if (tempBoard[r][c] != null
											&& tempBoard[r][c].type().
											equals(tempBoard[row][col].
													type()))
										moveValue = AIBoard.getPieceWorth() 
																		* 2;
									//adds piece worths together if it is 2
									//random pieces taking e each other out
									else if (tempBoard[r][c] != null)
										moveValue = AIBoard.getPieceWorth() + 
										tempBoard[r][c].getPieceWorth(); 
									else
										//sets move value to 1 if moving to 
										//empty cell
										moveValue = 1; 
									//compares move values
									if (moveValue > tempValue)
									{
										tempValue = moveValue;
										possibleMove = 
												tempMove;
									}
									//checks white moves 
									for (int rowW = 0; rowW < BOARD_SIZE; 
											rowW++) {
										for (int colW = 0; colW < BOARD_SIZE; 
												colW++) {
											if (tempBoard[rowW][colW] != null 
													&& tempBoard[rowW][colW].
													player() == Player.WHITE){
												Move tempW = new Move(rowW, 
														colW, r, c);
												if (isValidMoveAI(tempW)) {
								   //if AI queen is taken out the divide by 2
													if (tempBoard[row][col].
															type().equals
															("Queen")) 
														moveValue = moveValue
																		  /2;
								//if white takes out the same piece as black 
								//moved then subtract the AI's piece worth
													else if (tempBoard[row]
															[col].type().
															equals(tempBoard
															[rowW][colW].
															type()))
														moveValue = moveValue 
															- AIBoard.
															getPieceWorth(); 
													else if (tempBoard[row]
															[col] != null)
								//subtracts the AI's piece worth and the 
								//white's piece worth if none of the above 
								//happens
														moveValue = moveValue 
															- (AIBoard.
															getPieceWorth() + 
															tempBoard[rowW]
															[colW].
															getPieceWorth());
													//compares move values
													if (moveValue > tempValue)
													{
														tempValue = moveValue;
														possibleMove = 
																tempMove;
													}
												}
											}
										}

									}
								}
								//resets the board
								tempBoard[r][c] = temp1;
								tempBoard[row][col] = temp;
							}
						}
					}
			}
		}
		return tempValue;
	}

	/*************************************************************************
	 * Determines if castling is valid. 
	 * 
	 * @param move is the move that is a possible castle
	 * @return boolean returns true if castling is valid and false if it isn't
	 ************************************************************************/
	public boolean castling(Move move) {

		duplicateBoard(board);

		//king cannot be in check when castling
		if (!tempBoardInCheck(player)) { 
			if (player == Player.WHITE) {
				//makes sure they clicked on a king
				if (tempBoard[move.fromRow][move.fromColumn].type().
						equals("King"))
					//makes sure king hasn't moved yet
					if (((King) tempBoard[move.fromRow][move.fromColumn]).
							isCastlingValid())
						//checks if the spot they clicked on was 2 to the 
						//left and that the rook is still in the corner
						if (move.toColumn == 2 && tempBoard[7][0] 
								instanceof Rook) {
							//checks if rook hasn't moved yet
							if (((Rook) tempBoard[7][0]).isCastlingValid())
								//checks the spots between the rook and king
								//to make sure they are empty
								if (tempBoard[7][1] == null && tempBoard[7][2]
										== null && tempBoard[7][3] == null) {
									Move temp = new Move(7, 4, 7, 3);
									if (isValidMoveAI(temp)) {
										tempBoard[7][3] = tempBoard[7][4];
										tempBoard[7][4] = null;
										//makes sure the king isn't in check
										//in the middle spot
										if (!tempBoardInCheck(Player.WHITE)) {
											Move temp1 = new Move(7, 3, 7, 2);
											if (isValidMoveAI(temp1)) {
												tempBoard[7][2] = 
														tempBoard[7][3];
												tempBoard[7][3] = null;
												//checks if the king is in
												//check in the ending 
												//position
												if (!tempBoardInCheck(Player.
														WHITE)) {
													board[7][3] = 
															tempBoard[7][0];
													board[7][2] = 
															tempBoard[7][2];
													board[7][0] = null; 
													board[7][4] = null; 
													player = player.next();
													return true;
												}
											}
										}
										tempBoard[7][4] = tempBoard[7][2];
										tempBoard[7][2] = null;
										tempBoard[7][0] = tempBoard[7][3];
										tempBoard[7][3] = null;
									}
								}
							//same as previous except on left side of white 
							//player
						} else if (move.toColumn == 6 && tempBoard[7][7] 
								instanceof Rook) {
							if (((Rook) tempBoard[7][7]).isCastlingValid())
								if (tempBoard[7][5] == null && tempBoard[7][6]
										== null) {
									Move temp = new Move(7, 4, 7, 5);
									if (isValidMoveAI(temp)) {
										tempBoard[7][5] = tempBoard[7][4];
										tempBoard[7][4] = null;
										if (!tempBoardInCheck(Player.WHITE)) {
											Move temp1 = new Move(7, 5, 7, 6);
											if (isValidMoveAI(temp1)) {
												tempBoard[7][6] = 
														tempBoard[7][5];
												tempBoard[7][5] = null;
												if (!tempBoardInCheck(Player.
														WHITE)) {

													board[7][5] = 
															tempBoard[7][7];
													board[7][6] = 
															tempBoard[7][6];
													board[7][7] = null; 
													board[7][4] = null; 
													player = player.next();
													return true;
												}

											}
										}
										tempBoard[7][4] = tempBoard[7][6];
										tempBoard[7][6] = null;
										tempBoard[7][7] = board[7][5];
										tempBoard[7][5] = null;
									}
								}
						}
				//same as previous except for black player
			} else if (tempBoard[move.fromRow][move.fromColumn].type().
					equals("King"))
				if (((King) tempBoard[move.fromRow][move.fromColumn]).
						isCastlingValid())
					if (move.toColumn == 2 && tempBoard[0][0] instanceof Rook)
					{
						if (((Rook) tempBoard[0][0]).isCastlingValid())
							if (tempBoard[0][1] == null && tempBoard[0][2] ==
							null && tempBoard[0][3] == null) {

								Move temp = new Move(0, 4, 0, 3);
								isValidMoveAI(temp);

								tempBoard[0][3] = tempBoard[0][4];
								tempBoard[0][4] = null;

								if (!tempBoardInCheck(Player.BLACK)) {

									Move temp1 = new Move(0, 3, 0, 2);
									isValidMoveAI(temp1);

									tempBoard[0][2] = tempBoard[0][3];
									tempBoard[0][3] = null;

									if (!tempBoardInCheck(Player.BLACK)) {

										board[0][3] = tempBoard[0][0];
										board[0][2] = tempBoard[0][2];
										board[0][0] = null; 
										board[0][4] = null; 
										player = player.next();
										return true;
									}

								}
							}
						tempBoard[0][4] = tempBoard[0][2];
						tempBoard[0][2] = null;
						tempBoard[0][0] = board[0][3];
						tempBoard[0][3] = null;
					} else if (move.toColumn == 6 && tempBoard[0][7] 
							instanceof Rook) {
						if (((Rook) tempBoard[0][7]).isCastlingValid())
							if (tempBoard[0][5] == null && tempBoard[0][6] == 
							null) {

								Move temp = new Move(0, 4, 0, 5);
								isValidMoveAI(temp);

								tempBoard[0][5] = tempBoard[0][4];
								tempBoard[0][4] = null;

								if (!tempBoardInCheck(Player.BLACK)) {

									Move temp1 = new Move(0, 5, 0, 6);
									isValidMoveAI(temp1);

									tempBoard[0][6] = tempBoard[0][5];
									tempBoard[0][5] = null;

									if (!tempBoardInCheck(Player.BLACK)) {

										board[0][5] = tempBoard[0][7];
										board[0][6] = tempBoard[0][6];
										board[0][7] = null; 
										board[0][4] = null; 
										player = player.next();
										return true;
									}
								}
							}
						tempBoard[0][4] = tempBoard[0][6];
						tempBoard[0][6] = null;
						tempBoard[0][7] = board[0][5];
						tempBoard[0][5] = null;
					}
		}

		return false;
	}

	/*************************************************************************
	 * This method only checks if the move is valid for the AI so it doesn't 
	 * throw exceptions for every false move because it will run into many
	 * of them.
	 * 
	 * @param move takes in the move that the AI wants to do
	 * @return boolean returns true if the move is valid and false if it isn't
	 ************************************************************************/
	public boolean isValidMoveAI(Move move) {

		if ((tempBoard[move.fromRow][move.fromColumn] != null))
			if (tempBoard[move.fromRow][move.fromColumn].isValidMove(move, 
					tempBoard))
				return true;

		return false;
	}

	/*************************************************************************
	 * This returns true of the spot on the board is a valid move and then the
	 * GUI in turn highlights that spot green.
	 * 
	 * @param move takes in the move that is requested
	 * @return boolean returns true if it is a valid move and false if it 
	 * isn't
	 ************************************************************************/
	public boolean highlight(Move move) {

		duplicateBoard(board);

		if ((tempBoard[move.fromRow][move.fromColumn] != null))
			if (tempBoard[move.fromRow][move.fromColumn].isValidMove(move, 
					tempBoard))
				return true;

		return false;
	}

	/*************************************************************************
	 * Checks to see if the move will put the current players piece in danger
	 * and the GUI in turn highlights it red if it is in danger.
	 * @param move takes the move that is requested 
	 * @return boolean returns true if the spot the piece is moving to is in
	 * danger and false if it isn't
	 ************************************************************************/
	public boolean highlightRed(Move move) {

		duplicateBoard(board);

		tempBoard[move.toRow][move.toColumn] = 
				tempBoard[move.fromRow][move.fromColumn];
		tempBoard[move.fromRow][move.fromColumn] = null;

		for (int r = 0; r < BOARD_SIZE; r++)
			for (int c = 0; c < BOARD_SIZE; c++) {
				if (tempBoard[r][c] != null && tempBoard[r][c].player() != 
						currentPlayer()) {
					Move move1 = new Move(r, c, move.toRow, move.toColumn);
					if (isValidMoveAI(move1)) {
						return true;
					}
				}
			}
		return false;
	}

	/*************************************************************************
	 * This method is for the AI to find a black piece that, when moved, takes
	 * the king out of check. 
	 * 
	 * @return move returns the move that gets the king out of check
	 ************************************************************************/
	public Move getOutOfCheck() {

		for (int row = 0; row < BOARD_SIZE; row++)
			for (int col = 0; col < BOARD_SIZE; col++) {
				if (tempBoard[row][col] != null)
					if (tempBoard[row][col].player() == Player.BLACK){
						for (int r = 0; r < BOARD_SIZE; r++)
							for (int c = 0; c < BOARD_SIZE; c++) {
								Move temp = new Move(row, col, r, c);
								IChessPiece tempPiece = 
										tempBoard[row][col];
								IChessPiece tempPiece1 = null;
								if (tempBoard[r][c] != null)
									tempPiece1 = tempBoard[r][c];
								if (isValidMoveAI(temp)) {
									tempBoard[r][c] = tempPiece;
									tempBoard[row][col] = null;
									if (!tempBoardInCheck(
											Player.BLACK)) {
										tempBoard[row][col] = tempPiece;
										tempBoard[r][c] = tempPiece1;
										//returns the move that makes the 
										//king not in check anymore
										return temp;
									}
								}
								tempBoard[row][col] = tempPiece;
								tempBoard[r][c] = tempPiece1;
							}
					}
			}
		return null;
	}

}