Chess.java

package chess;

import java.util.ArrayList;

public class Chess {
	
	// Project completed by Dylan Abry and Chase Moskowitz

        enum Player { white, black }
        
        private static Board board;
        private static Player currentPlayer;
        
        private static char enPassantFile = '\0'; 
        private static int enPassantRank = -1; 
    
	/**
	 * Plays the next move for whichever player has the turn.
	 * 
	 * @param move String for next move, e.g. "a2 a3"
	 * 
	 * @return A ReturnPlay instance that contains the result of the move.
	 *         See the section "The Chess class" in the assignment description for details of
	 *         the contents of the returned ReturnPlay instance.
	 */
	public static ReturnPlay play(String move) {

		
		move = move.trim();
		ReturnPlay result = new ReturnPlay();
		
		// Handle resign and draw logic first before looking at coordinates!!!
		if (move.equalsIgnoreCase("resign")) {
			
			result.piecesOnBoard = board.returningPieces();
			result.message = (currentPlayer == Player.white
			        ? ReturnPlay.Message.RESIGN_BLACK_WINS
			        : ReturnPlay.Message.RESIGN_WHITE_WINS);
			start();
			return result;
		}
		
		// Set up the draw request logic (execute at the end of the turn)
		boolean drawRequest = move.endsWith("draw?");
		if (drawRequest) move = move.replace("draw?", "");
		
		// Begin breaking down the input into segments...
		
		String[] coordinates = move.split(" ");
		// Eliminate option of 0-1 inputs
		if (coordinates.length < 2) {
			result.piecesOnBoard = board.returningPieces();
			result.message = ReturnPlay.Message.ILLEGAL_MOVE;
			return result;
		}
		
		// Obtain starting and new ranks and values here...
		
		char startFile = coordinates[0].charAt(0);
		int startRank = Character.getNumericValue(coordinates[0].charAt(1));
		char newFile = coordinates[1].charAt(0);
		int newRank = Character.getNumericValue(coordinates[1].charAt(1));
		
		// Handle the promotion input from the player
		
		char promotionChoice = (coordinates.length == 3) ? coordinates[2].charAt(0) : 'Q';
		
		// Assign the piece that will be moved in turn
		Piece pieceToMove = board.getPiece(startFile, startRank);
		
		// Make sure the player is moving a piece of their own!! Don't mess this up!!!!
		if (pieceToMove == null || pieceToMove.isBlack != (currentPlayer == Player.black)) {
			
            result.piecesOnBoard = board.returningPieces();
            result.message = ReturnPlay.Message.ILLEGAL_MOVE;
            return result;
        }
		
		/* Another desperate approach at trying to handle an en passant move... it shouldn't allow
		 * the pawn move diagonal if the player is not executing an en passant move...
		 */
		boolean epAttempt = isEnPassantAttempt(pieceToMove, startFile, startRank, newFile, newRank, board);
		if (!epAttempt && !pieceToMove.canMove(startFile, startRank, newFile, newRank, board)) {
		    result.piecesOnBoard = board.returningPieces();
		    result.message = ReturnPlay.Message.ILLEGAL_MOVE;
		    return result;
		}
		
		// Simulate moves here to find more loop holes before executing the move...
		Board tempBoard = board.copy();
		Piece tempPiece = tempBoard.getPiece(startFile, startRank);

		tempBoard.setPiece(newFile, newRank, tempPiece);
		tempBoard.setPiece(startFile, startRank, null);
		
		// Simulate castling before it is done so we can ensure that nothing is in the way and the correct coordinates are entered...
		if (tempPiece instanceof King && Math.abs(newFile - startFile) == 2) {
		    if (newFile > startFile) {
		        Piece rook = tempBoard.getPiece('h', startRank);
		        tempBoard.setPiece((char)(newFile - 1), newRank, rook);
		        tempBoard.setPiece('h', startRank, null);
		    } else {
		    	
		        Piece rook = tempBoard.getPiece('a', startRank);
		        tempBoard.setPiece((char)(newFile + 1), newRank, rook);
		        tempBoard.setPiece('a', startRank, null);
		    }
		}
		
		// En passant simulation
		if (tempPiece instanceof Pawn &&
		    newFile == enPassantFile && newRank == enPassantRank) {
		    int direction = tempPiece.isBlack ? -1 : 1;
		    tempBoard.setPiece(newFile, newRank - direction, null);
		}
		
		// King in check simulation
		if (isKingInCheck(currentPlayer, tempBoard)) {
		    result.piecesOnBoard = board.returningPieces();
		    result.message = ReturnPlay.Message.ILLEGAL_MOVE;
		    return result;
		}
		
		// The transaction of moving the piece is now completed after all the initial checks pass!!!
		board.setPiece(newFile, newRank, pieceToMove);
		board.setPiece(startFile, startRank, null);
		
		// Flag castling if it happened
		if (pieceToMove instanceof King && Math.abs(newFile - startFile) == 2) {
		    if (newFile > startFile) {
		        Piece rook = board.getPiece('h', startRank);
		        board.setPiece((char)(newFile - 1), newRank, rook);
		        board.setPiece('h', startRank, null);
		        if (rook instanceof Rook) ((Rook) rook).rookOfficiallyMoved();
		    } else {
		        Piece rook = board.getPiece('a', startRank);
		        board.setPiece((char)(newFile + 1), newRank, rook);
		        board.setPiece('a', startRank, null);
		        if (rook instanceof Rook) ((Rook) rook).rookOfficiallyMoved();
		    }
		}
		
		// Flag en passant if it happened
		if (pieceToMove instanceof Pawn &&
		    newFile == enPassantFile && newRank == enPassantRank) {
		    int direction = pieceToMove.isBlack ? -1 : 1;
		    board.setPiece(newFile, newRank - direction, null);
		}
		
		// These two boolean methods will prevent the king and rook from attempting to castle again
		if (pieceToMove instanceof King) {
		    ((King) pieceToMove).officiallyMoved();
		}
		if (pieceToMove instanceof Rook) {
		    ((Rook) pieceToMove).rookOfficiallyMoved();
		}
		
		// Pawn promotion logic :)
		 if (pieceToMove instanceof Pawn && (newRank == 8 || newRank == 1)) {
		        Piece promotedPiece;
		        switch (promotionChoice) {
		        
		            case 'R': promotedPiece = new Rook(newFile, newRank, pieceToMove.isBlack); break;
		            case 'B': promotedPiece = new Bishop(newFile, newRank, pieceToMove.isBlack); break;
		            case 'N': promotedPiece = new Knight(newFile, newRank, pieceToMove.isBlack); break;
		            default: promotedPiece = new Queen(newFile, newRank, pieceToMove.isBlack);
		        }
		        
		        board.setPiece(newFile, newRank, promotedPiece);
		 }
		 
		 // Nullify values for en passant and reassign them
		 enPassantFile = '\0';
		 enPassantRank = -1;

		 if (pieceToMove instanceof Pawn && Math.abs(newRank - startRank) == 2) {
		     enPassantFile = newFile;
		     enPassantRank = (startRank + newRank) / 2;
		 }
		 
		 // Successful move with no draw, resign, check or checkmate
		
		result.piecesOnBoard = board.returningPieces();
        result.message = null;
        
        // Handle check/checkmate logic, try to add stalemate if time allows
        
        Player opponent = (currentPlayer == Player.white) ? Player.black : Player.white;
        if (isKingInCheck(opponent, board)) {
            if (!isAnyLegalMoves(opponent, board)) {
                result.message = (opponent == Player.white)
                        ? ReturnPlay.Message.CHECKMATE_BLACK_WINS
                        : ReturnPlay.Message.CHECKMATE_WHITE_WINS;
            } else {
                result.message = ReturnPlay.Message.CHECK;
            }
        } else if (!isAnyLegalMoves(opponent, board)) {
            result.message = ReturnPlay.Message.STALEMATE;
        }


        // Handle draw after move
        if (drawRequest) {
            result.message = ReturnPlay.Message.DRAW;
        }
        
        // The game should reset after one of these messages passes
        
        // Make sure the players know that white is going once the game resets, otherwise throw ILLEGAL_MOVE
        
        if (result.message == ReturnPlay.Message.CHECKMATE_BLACK_WINS ||
        	    result.message == ReturnPlay.Message.CHECKMATE_WHITE_WINS ||
        	    result.message == ReturnPlay.Message.STALEMATE ||
        	    result.message == ReturnPlay.Message.DRAW) {
        	    System.out.println("The game is over! The board is resetting and now it is white's turn!");
        	    start();
        	    return result;
        	}

        // Switch turns if game is still going
        currentPlayer = (currentPlayer == Player.white) ? Player.black : Player.white;

        return result;
	}
	
	// The isKingInCheck method scans all of the opponent's pieces on the board to ensure that the king isn't vulnerable for checkmate
	public static boolean isKingInCheck(Player player, Board board) {
		
		 	Piece king = board.locateKing(player);
		 
		    if (king == null) return false;

		    char kingFile = king.getFile();
		    int kingRank = king.getRank();

		    // look at all opponent pieces
		    for (Piece piece : board.getAllPieces()) {
		        if (piece.isBlack != (player == Player.black)) {
		            if (piece.canMove(piece.getFile(), piece.getRank(), kingFile, kingRank, board)) {
		                return true;
		            }
		        }
		    }
		    return false;
	}
	
	// Check if the square of destination is currently occupied
	public static boolean isSquareUnderAttack(char file, int rank, boolean isBlack, Board board) {
	    for (Piece piece : board.getAllPieces()) {
	        
	        if (piece.isBlack != isBlack) {
	            // Special handling for pawns since they can only attack diagonal but move forward otherwise
	        	
	            if (piece instanceof Pawn) {
	                int pawnDirection = piece.isBlack ? -1 : 1;
	                
	                if ((file == piece.getFile() + 1 || file == piece.getFile() - 1) &&
	                    rank - piece.getRank() == pawnDirection) {
	                    return true;
	                }
	            } 
	            
	            // All other pieces
	            else {
	                if (piece.canMove(piece.getFile(), piece.getRank(), file, rank, board)) {
	                    return true;
	                }
	            }
	        }
	    }
	    return false;
	}
	
	// The leavesKingInCheck method will check if the king is left in check after the move and warn the player before the turn switches
	private static boolean leavesKingInCheck(Piece piece, char newFile, int newRank, Board board) {
	    Board tempBoard = board.copy();
	    
	    // Simulate move
	    tempBoard.setPiece(newFile, newRank, piece.clone());
	    tempBoard.setPiece(piece.getFile(), piece.getRank(), null);

	    // Check safety of king
	    Player player = piece.isBlack ? Player.black : Player.white;
	    return isKingInCheck(player, tempBoard);
	}
	
	// Check for an en passant attempt, which should be handled before ILLEGAL_MOVE is thrown!!
	private static boolean isEnPassantAttempt(Piece p, char sf, int sr, char nf, int nr, Board b) {
	    if (!(p instanceof Pawn)) return false;

	    int dir = p.isBlack ? -1 : 1;
	    // Must be a diagonal step of exactly 1 rank in the pawn's forward direction!!!
	    
	    if (Math.abs(nf - sf) != 1 || (nr - sr) != dir) return false;
    
	    if (!b.isEmpty(nf, nr)) return false;
	    return (nf == enPassantFile && nr == enPassantRank);
	}
	
	// The isAnyLegalMoves method completes a final check of moves the player can do. If this returns false, CHECKMATE!!!!
	public static boolean isAnyLegalMoves(Player player, Board board) {
	    for (Piece piece : board.getAllPieces()) {
	        if (piece.isBlack == (player == Player.black)) {
	            char startFile = piece.getFile();
	            int startRank = piece.getRank();

	            for (char f = 'a'; f <= 'h'; f++) {
	                for (int r = 1; r <= 8; r++) {

	                    boolean epassTry = isEnPassantAttempt(piece, startFile, startRank, f, r, board);
	                    if (!epassTry && !piece.canMove(startFile, startRank, f, r, board)) {
	                        continue;
	                    }

	                    Board testBoard = board.copy();
	                    Piece testPiece = testBoard.getPiece(startFile, startRank);
	                    testBoard.setPiece(f, r, testPiece);
	                    testBoard.setPiece(startFile, startRank, null);

	                    if (epassTry) {
	                        int direction = testPiece.isBlack ? -1 : 1;
	                        testBoard.setPiece(f, r - direction, null);
	                    }

	                    if (!isKingInCheck(player, testBoard)) {
	                        return true;
	                    }
	                }
	            }
	        }
	    }
	    return false;
	}
	
	
	/**
	 * This method should reset the game, and start from scratch.
	 */
	public static void start() {
		
		board = new Board();
        board.setBeginningPositions();
        currentPlayer = Player.white;
        
        enPassantFile = '\0';
        enPassantRank = -1;
		
	}
}