Chess.cpp

/*
 * README:
 * Author: Blake Walker
 * Description: 
 *  A fully functional chess game played in the terminal
 *  Where each move is played by entering it in standard
 *  Chess notation. Includes edge case rules such as draw
 *  by stalemate and the 50 move rule, as well as allowing
 *  The players to agree to a draw. The program also prints 
 *  the game summary in chess notation at the end of a game.
 *  The only weird thing is that the game does not end at
 *  checkmate unless there are no legal moves, so a player's king
 *  must be captured or stalemated for the game to end.
 * Note:
 *  I am pretty sure this would be much easier using classes, but I am not
 *  confident with OOP concepts. Maybe I will come back and recreate with classes later.
 * Date Completed: 5/27/2025
*/

// Setup
#include <iostream>
#include <string>

#define NUM_ROW 8
#define NUM_COL 8
#define MAX_NUM_MOVES 17697

#ifdef _WIN32
#include <windows.h>
#endif

std::string game_summary[MAX_NUM_MOVES]; 
/* Fun fact: 
In casual play, a game of chess can go on forever if neither player claims a draw by 50 moves rule or 3-fold repetition.
However, in 2014, FIDE introduced rules that require a game to be declared a draw in the event of 
75 moves with no pawn moves or captures, and repeating the same position 5 times consecutively.
Considering these rules, the longest possible game of chess is 8848.5 moves (17697 half-moves).
These rules were not implemented in this program, however, so dont play more than 8848 moves you rascal!
Bonus fun fact: using the more typical rules of either side being able to claim a draw by 50 move rule or 3-fold repetition,
the longest possible game would be 5898.5 moves (11797 half-moves), but I'll go with the bigger one.
*/

int move_num = 0; // stores the number of half-moves that have elapsed
int moves_since_pawn_move_or_capture = 0;

// boolean variable initialization
short int white_king_moved = 0;
short int white_kingside_rook_moved = 0;
short int white_queenside_rook_moved = 0;
short int black_king_moved = 0;
short int black_kingside_rook_moved = 0;
short int black_queenside_rook_moved = 0;
short int white_to_move = 1;
short int white_pawns_en_passantable[8];
short int black_pawns_en_passantable[8];

// 1D constant array initialization
const int white_unicode[6] = {
    0x2654, // white king
    0x2655, // white queen
    0x2656, // white rook
    0x2657, // white bishop
    0x2658, // white knight
    0x2659 // white pawn
};
const int black_unicode[6] = {
    0x265A, // black king
    0x265B, // black queen
    0x265C, // black rook
    0x265D, // black bishop
    0x265E, // black knight
    0x265F // black pawn
};
const char wrappertop[NUM_COL+1] = {' ','a','b','c','d','e','f','g','h'};
const char wrapperside[NUM_ROW] = {'8','7','6','5','4','3','2','1'};

// 2D array initialization
int board[NUM_ROW][NUM_COL] = {
    {black_unicode[2],black_unicode[4],black_unicode[3],black_unicode[1],black_unicode[0],black_unicode[3],black_unicode[4],black_unicode[2]},
    {black_unicode[5],black_unicode[5],black_unicode[5],black_unicode[5],black_unicode[5],black_unicode[5],black_unicode[5],black_unicode[5]},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {white_unicode[5],white_unicode[5],white_unicode[5],white_unicode[5],white_unicode[5],white_unicode[5],white_unicode[5],white_unicode[5]},
    {white_unicode[2],white_unicode[4],white_unicode[3],white_unicode[1],white_unicode[0],white_unicode[3],white_unicode[4],white_unicode[2]}
    };
short int legal_moves[NUM_ROW][NUM_COL] = {
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0}
};
short int white_protected_squares[NUM_ROW][NUM_COL] = {
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0}
};
short int black_protected_squares[NUM_ROW][NUM_COL] = {
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0}
};

// Simple boolean function declarations
short int IsLowercase(char input){
    int num = (int)input;
    if(num >= 97 && num <= 122){return 1;}
    else{return 0;}
}
short int IsUppercase(char input){
    int num = (int)input;
    if(num >= 65 && num <= 90){return 1;}
    else{return 0;}
}
short int IsDigit(char input){
    int num = (int)input;
    if(num >= 48 && num <= 57){return 1;}
    else{return 0;}
}
short int IsWhitePiece(int piece){
    for(int i = 0; i < 6; i++){
        if(white_unicode[i] == piece){return 1;}
    }
    return 0;
}
short int IsBlackPiece(int piece){
    for(int i = 0; i < 6; i++){
        if(black_unicode[i] == piece){return 1;}
    }
    return 0;
}

// Converts integer unicode values into a form that can be printed to the terminal
std::string unicode_to_utf8(int code_point) {
    std::string utf8;
    
    if (code_point <= 0x7F) { // 1 byte
        utf8.push_back(static_cast<char>(code_point));
    }
    else if (code_point <= 0x7FF) { // 2 bytes
        utf8.push_back(static_cast<char>(0xC0 | ((code_point >> 6) & 0x1F)));
        utf8.push_back(static_cast<char>(0x80 | (code_point & 0x3F)));
    }
    else if (code_point <= 0xFFFF) { // 3 bytes
        utf8.push_back(static_cast<char>(0xE0 | ((code_point >> 12) & 0x0F)));
        utf8.push_back(static_cast<char>(0x80 | ((code_point >> 6) & 0x3F)));
        utf8.push_back(static_cast<char>(0x80 | (code_point & 0x3F)));
    }
    else if (code_point <= 0x10FFFF) { // 4 bytes
        utf8.push_back(static_cast<char>(0xF0 | ((code_point >> 18) & 0x07)));
        utf8.push_back(static_cast<char>(0x80 | ((code_point >> 12) & 0x3F)));
        utf8.push_back(static_cast<char>(0x80 | ((code_point >> 6) & 0x3F)));
        utf8.push_back(static_cast<char>(0x80 | (code_point & 0x3F)));
    }
    // Invalid code points will return empty string
    return utf8;
}

// Displays the current board state with the ranks and files labelled
void PrintBoard(){
    for(int i = 0; i < NUM_COL+1; i++){
        std::cout << wrappertop[i] << "|"; // prints the column letters at the top
    }
    std::cout << std::endl;
    for(int i = 0; i < NUM_ROW; i++){
        std::cout << wrapperside[i] << '|'; // prints the row numbers on the side
        for(int j = 0;j < NUM_COL; j++){
            if(board[i][j] == 0)
                std::cout << " |";
            else{
                std::cout << unicode_to_utf8(board[i][j]) << '|';
            }
            
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;   
}

// Updates the white_protected_squares array to find the legal black king moves
void FindWhiteProtectedSquares(){
    //clear
    for(int i = 0; i < NUM_ROW; i++){
        for(int j = 0; j < NUM_COL; j++){
            white_protected_squares[i][j] = 0;
        }
    }  
    for(int row = 0; row < NUM_ROW; row++){
        for(int col = 0; col < NUM_COL; col++){
            //pawns
            if(row < 6 && row >= 0){
                if(col-1 >= 0){
                    if(board[row+1][col-1] == white_unicode[5]){
                        white_protected_squares[row][col] = 1;
                        continue;
                    } 
                }
                if(col+1 < NUM_COL){
                    if(board[row+1][col+1] == white_unicode[5]){
                        white_protected_squares[row][col] = 1;
                        continue;
                    }      
                }
                
            }

            //knights
            if(row+1 < NUM_ROW && col+2 < NUM_COL && board[row+1][col+2] == white_unicode[4]){
                white_protected_squares[row][col] = 1;
                continue;
            }
            else if(row+2 < NUM_ROW && col+1 < NUM_COL && board[row+2][col+1] == white_unicode[4]){
                white_protected_squares[row][col] = 1;
                continue;
            }
            else if(row-1 >= 0 && col+2 < NUM_COL && board[row-1][col+2] == white_unicode[4]){
                white_protected_squares[row][col] = 1;
                continue;
            }
            if(row-2 >= 0 && col+1 < NUM_COL && board[row-2][col+1] == white_unicode[4]){
                white_protected_squares[row][col] = 1;
                continue;
            }
            if(row+1 < NUM_ROW && col-2 >= 0 && board[row+1][col-2] == white_unicode[4]){
                white_protected_squares[row][col] = 1;
                continue;
            }
            if(row+2 < NUM_ROW && col-1 >= 0 && board[row+2][col-1] == white_unicode[4]){
                white_protected_squares[row][col] = 1;
                continue;
            }
            if(row-1 >= 0 && col-2 >= 0 && board[row-1][col-2] == white_unicode[4]){
                white_protected_squares[row][col] = 1;
                continue;
            }
            if(row-2 >= 0 && col-1 >= 0 && board[row-2][col-1] == white_unicode[4]){
                white_protected_squares[row][col] = 1;
                continue;
            }
            
            //king
            if(row-1 >= 0){
                if(board[row-1][col] == white_unicode[0]){ // up
                    white_protected_squares[row][col] = 1;
                    continue;
                }
                if(col-1 >= 0){ // up left
                    if(board[row-1][col-1] == white_unicode[0]){
                        white_protected_squares[row][col] = 1;
                        continue;
                    }
                }
                if(col+1 < NUM_COL){ // up right
                    if(board[row-1][col+1] == white_unicode[0]){
                        white_protected_squares[row][col] = 1;
                        continue;
                    }
                }
            }
            if(col-1 >= 0){
                if(board[row][col-1] == white_unicode[0]){ // left
                    white_protected_squares[row][col] = 1;
                    continue;
                }
            }
            if(col+1 < NUM_COL){
                if(board[row][col+1] == white_unicode[0]){ // right
                    white_protected_squares[row][col] = 1;
                    continue;
                }
            }
            if(row+1 < NUM_ROW){
                if(board[row+1][col] == white_unicode[0]){ // down
                    white_protected_squares[row][col] = 1;
                    continue;
                }
                if(col-1 >= 0){ // down left
                    if(board[row+1][col-1] == white_unicode[0]){
                        white_protected_squares[row][col] = 1;
                        continue;
                    }
                }
                if(col+1 < NUM_COL){ // down right
                    if(board[row+1][col+1] == white_unicode[0]){
                        white_protected_squares[row][col] = 1;
                        continue;
                    }
                }
            }
            
           //bishop
           int i = 1;
           short int bishop_found = 0;
            //searching on the down right diagonal
            while(row+i < NUM_ROW && col+i < NUM_COL){
                if(IsWhitePiece(board[row+i][col+i])){
                    if(board[row+i][col+i] == white_unicode[3]){
                        white_protected_squares[row][col] = 1;
                        bishop_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col+i] == 0 || board[row+i][col+i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(bishop_found){continue;}
            i = 1;
            //searching on the down left diagonal
            while(row+i < NUM_ROW && col-i >= 0){
                if(IsWhitePiece(board[row+i][col-i])){
                    if(board[row+i][col-i] == white_unicode[3]){
                        white_protected_squares[row][col] = 1;
                        bishop_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col-i] == 0 || board[row+i][col-i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(bishop_found){continue;}
            i = 1;
            //searching on the up right diagonal
            while(row-i >= 0 && col+i < NUM_COL){
                if(IsWhitePiece(board[row-i][col+i])){
                    if(board[row-i][col+i] == white_unicode[3]){
                        white_protected_squares[row][col] = 1;
                        bishop_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col+i] == 0 || board[row-i][col+i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(bishop_found){continue;}
            i = 1;
            //searching on the up left diagonal
            while(row-i >= 0 && col-i >= 0){
                if(IsWhitePiece(board[row-i][col-i])){
                    if(board[row-i][col-i] == white_unicode[3]){
                        white_protected_squares[row][col] = 1;
                        bishop_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col-i] == 0 || board[row-i][col-i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            i = 1;
            
            //rook
            short int rook_found = 0;
            //searching down
            while(row+i < NUM_ROW){
                if(IsWhitePiece(board[row+i][col])){
                    if(board[row+i][col] == white_unicode[2]){
                        white_protected_squares[row][col] = 1;
                        rook_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col] == 0 || board[row+i][col] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(rook_found){continue;}
            i = 1;
            //searching up
            while(row-i >= 0){
                if(IsWhitePiece(board[row-i][col])){
                    if(board[row-i][col] == white_unicode[2]){
                        white_protected_squares[row][col] = 1;
                        rook_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col] == 0 || board[row-i][col] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(rook_found){continue;}
            i = 1;
            //searching left
            while(col-i >= 0){
                if(IsWhitePiece(board[row][col-i])){
                    if(board[row][col-i] == white_unicode[2]){
                        white_protected_squares[row][col] = 1;
                        rook_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row][col-i] == 0 || board[row][col-i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(rook_found){continue;}
            i = 1;
            //searching right
            while(col+i < NUM_COL){
                if(IsWhitePiece(board[row][col+i])){
                    if(board[row][col+i] == white_unicode[2]){
                        white_protected_squares[row][col] = 1;
                        rook_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row][col+i] == 0 || board[row][col+i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            i = 1;

            //queen
            short int queen_found = 0;
            //searching on the down right diagonal
            while(row+i < NUM_ROW && col+i < NUM_COL){
                if(IsWhitePiece(board[row+i][col+i])){
                    if(board[row+i][col+i] == white_unicode[1]){
                        white_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col+i] == 0 || board[row+i][col+i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching on the down left diagonal
            while(row+i < NUM_ROW && col-i >= 0){
                if(IsWhitePiece(board[row+i][col-i])){
                    if(board[row+i][col-i] == white_unicode[1]){
                        white_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col-i] == 0 || board[row+i][col-i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching on the up right diagonal
            while(row-i >= 0 && col+i < NUM_COL){
                if(IsWhitePiece(board[row-i][col+i])){
                    if(board[row-i][col+i] == white_unicode[1]){
                        white_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col+i] == 0 || board[row-i][col+i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching on the up left diagonal
            while(row-i >= 0 && col-i >= 0){
                if(IsWhitePiece(board[row-i][col-i])){
                    if(board[row-i][col-i] == white_unicode[1]){
                        white_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col-i] == 0 || board[row-i][col-i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            i = 1;
            //searching down
            while(row+i < NUM_ROW){
                if(IsWhitePiece(board[row+i][col])){
                    if(board[row+i][col] == white_unicode[1]){
                        white_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col] == 0 || board[row+i][col] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching up
            while(row-i >= 0){
                if(IsWhitePiece(board[row-i][col])){
                    if(board[row-i][col] == white_unicode[1]){
                        white_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col] == 0 || board[row-i][col] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching left
            while(col-i >= 0){
                if(IsWhitePiece(board[row][col-i])){
                    if(board[row][col-i] == white_unicode[1]){
                        white_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row][col-i] == 0 || board[row][col-i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching right
            while(col+i < NUM_COL){
                if(IsWhitePiece(board[row][col+i])){
                    if(board[row][col+i] == white_unicode[1]){
                        white_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row][col+i] == 0 || board[row][col+i] == black_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
        }
    }
}

// Updates the black_protected_squares array to find the legal white king moves
void FindBlackProtectedSquares(){
    //clear
    for(int i = 0; i < NUM_ROW; i++){
        for(int j = 0; j < NUM_COL; j++){
            black_protected_squares[i][j] = 0;
        }
    }  
    for(int row = 0; row < NUM_ROW; row++){
        for(int col = 0; col < NUM_COL; col++){
            //pawns
            if(row > 1 && row < NUM_ROW){
                if(col-1 >= 0){
                    if(board[row-1][col-1] == black_unicode[5]){
                        black_protected_squares[row][col] = 1;
                        continue;
                    } 
                }
                if(col+1 < NUM_COL){
                    if(board[row-1][col+1] == black_unicode[5]){
                        black_protected_squares[row][col] = 1;
                        continue;
                    }      
                }
                
            }

            //knights
            if(row+1 < NUM_ROW && col+2 < NUM_COL && board[row+1][col+2] == black_unicode[4]){
                black_protected_squares[row][col] = 1;
                continue;
            }
            if(row+2 < NUM_ROW && col+1 < NUM_COL && board[row+2][col+1] == black_unicode[4]){
                black_protected_squares[row][col] = 1;
                continue;
            }
            if(row-1 >= 0 && col+2 < NUM_COL && board[row-1][col+2] == black_unicode[4]){
                black_protected_squares[row][col] = 1;
                continue;
            }
            if(row-2 >= 0 && col+1 < NUM_COL && board[row-2][col+1] == black_unicode[4]){
                black_protected_squares[row][col] = 1;
                continue;
            }
            if(row+1 < NUM_ROW && col-2 >= 0 && board[row+1][col-2] == black_unicode[4]){
                black_protected_squares[row][col] = 1;
                continue;
            }
            if(row+2 < NUM_ROW && col-1 >= 0 && board[row+2][col-1] == black_unicode[4]){
                black_protected_squares[row][col] = 1;
                continue;
            }
            if(row-1 >= 0 && col-2 >= 0 && board[row-1][col-2] == black_unicode[4]){
                black_protected_squares[row][col] = 1;
                continue;
            }
            if(row-2 >= 0 && col-1 >= 0 && board[row-2][col-1] == black_unicode[4]){
                black_protected_squares[row][col] = 1;
                continue;
            }

            //king
            if(row-1 >= 0){
                if(board[row-1][col] == black_unicode[0]){ // up
                    black_protected_squares[row][col] = 1;
                    continue;
                }
                if(col-1 >= 0){ // up left
                    if(board[row-1][col-1] == black_unicode[0]){
                        black_protected_squares[row][col] = 1;
                        continue;
                    }
                }
                if(col+1 < NUM_COL){ // up right
                    if(board[row-1][col+1] == black_unicode[0]){
                        black_protected_squares[row][col] = 1;
                        continue;
                    }
                }
            }
            if(col-1 >= 0){
                if(board[row][col-1] == black_unicode[0]){ // left
                    black_protected_squares[row][col] = 1;
                    continue;
                }
            }
            if(col+1 < NUM_COL){
                if(board[row][col+1] == black_unicode[0]){ // right
                    black_protected_squares[row][col] = 1;
                    continue;
                }
            }
            if(row+1 < NUM_ROW){
                if(board[row+1][col] == black_unicode[0]){ // down
                    black_protected_squares[row][col] = 1;
                    continue;
                }
                if(col-1 >= 0){ // down left
                    if(board[row+1][col-1] == black_unicode[0]){
                        black_protected_squares[row][col] = 1;
                        continue;
                    }
                }
                if(col+1 < NUM_COL){ // down right
                    if(board[row+1][col+1] == black_unicode[0]){
                        black_protected_squares[row][col] = 1;
                        continue;
                    }
                }
            }
            
            //bishop
            int i = 1;
            short int bishop_found = 0;
            //searching on the down right diagonal
            while(row+i < NUM_ROW && col+i < NUM_COL){
                if(IsBlackPiece(board[row+i][col+i])){
                    if(board[row+i][col+i] == black_unicode[3]){
                        black_protected_squares[row][col] = 1;
                        bishop_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col+i] == 0 || board[row+i][col+i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(bishop_found){continue;}
            i = 1;
            //searching on the down left diagonal
            while(row+i < NUM_ROW && col-i >= 0){
                if(IsBlackPiece(board[row+i][col-i])){
                    if(board[row+i][col-i] == black_unicode[3]){
                        black_protected_squares[row][col] = 1;
                        bishop_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col-i] == 0 || board[row+i][col-i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(bishop_found){continue;}
            i = 1;
            //searching on the up right diagonal
            while(row-i >= 0 && col+i < NUM_COL){
                if(IsBlackPiece(board[row-i][col+i])){
                    if(board[row-i][col+i] == black_unicode[3]){
                        black_protected_squares[row][col] = 1;
                        bishop_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col+i] == 0 || board[row-i][col+i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(bishop_found){continue;}
            i = 1;
            //searching on the up left diagonal
            while(row-i >= 0 && col-i >= 0){
                if(IsBlackPiece(board[row-i][col-i])){
                    if(board[row-i][col-i] == black_unicode[3]){
                        black_protected_squares[row][col] = 1;
                        bishop_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col-i] == 0 || board[row-i][col-i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            i = 1;

            //rook
            short int rook_found = 0;
            //searching down
            while(row+i < NUM_ROW){
                if(IsBlackPiece(board[row+i][col])){
                    if(board[row+i][col] == black_unicode[2]){
                        black_protected_squares[row][col] = 1;
                        rook_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col] == 0 || board[row+i][col] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(rook_found){continue;}
            i = 1;
            //searching up
            while(row-i >= 0){
                if(IsBlackPiece(board[row-i][col])){
                    if(board[row-i][col] == black_unicode[2]){
                        black_protected_squares[row][col] = 1;
                        rook_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col] == 0 || board[row-i][col] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(rook_found){continue;}
            i = 1;
            //searching left
            while(col-i >= 0){
                if(IsBlackPiece(board[row][col-i])){
                    if(board[row][col-i] == black_unicode[2]){
                        black_protected_squares[row][col] = 1;
                        rook_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row][col-i] == 0 || board[row][col-i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(rook_found){continue;}
            i = 1;
            //searching right
            while(col+i < NUM_COL){
                if(IsBlackPiece(board[row][col+i])){
                    if(board[row][col+i] == black_unicode[2]){
                        black_protected_squares[row][col] = 1;
                        rook_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row][col+i] == 0 || board[row][col+i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            i = 1;

            //queen
            short int queen_found = 0;
            //searching on the down right diagonal
            while(row+i < NUM_ROW && col+i < NUM_COL){
                if(IsBlackPiece(board[row+i][col+i])){
                    if(board[row+i][col+i] == black_unicode[1]){
                        black_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col+i] == 0 || board[row+i][col+i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching on the down left diagonal
            while(row+i < NUM_ROW && col-i >= 0){
                if(IsBlackPiece(board[row+i][col-i])){
                    if(board[row+i][col-i] == black_unicode[1]){
                        black_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col-i] == 0 || board[row+i][col-i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching on the up right diagonal
            while(row-i >= 0 && col+i < NUM_COL){
                if(IsBlackPiece(board[row-i][col+i])){
                    if(board[row-i][col+i] == black_unicode[1]){
                        black_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col+i] == 0 || board[row-i][col+i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching on the up left diagonal
            while(row-i >= 0 && col-i >= 0){
                if(IsBlackPiece(board[row-i][col-i])){
                    if(board[row-i][col-i] == black_unicode[1]){
                        black_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col-i] == 0 || board[row-i][col-i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            i = 1;
            //searching down
            while(row+i < NUM_ROW){
                if(IsBlackPiece(board[row+i][col])){
                    if(board[row+i][col] == black_unicode[1]){
                        black_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row+i][col] == 0 || board[row+i][col] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching up
            while(row-i >= 0){
                if(IsBlackPiece(board[row-i][col])){
                    if(board[row-i][col] == black_unicode[1]){
                        black_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row-i][col] == 0 || board[row-i][col] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching left
            while(col-i >= 0){
                if(IsBlackPiece(board[row][col-i])){
                    if(board[row][col-i] == black_unicode[1]){
                        black_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row][col-i] == 0 || board[row][col-i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
            if(queen_found){continue;}
            i = 1;
            //searching right
            while(col+i < NUM_COL){
                if(IsBlackPiece(board[row][col+i])){
                    if(board[row][col+i] == black_unicode[1]){
                        black_protected_squares[row][col] = 1;
                        queen_found = 1;
                        break;
                    }
                    else{
                        break;
                    }
                }
                else if(board[row][col+i] == 0 || board[row][col+i] == white_unicode[0]){
                    i++;
                }
                else{
                    break;
                }
            }
        }
    }
}

// Fills the legal_moves array with the legal moves of a pawn on a given square
void PawnLegalMoves(int row, int col){
    if(white_to_move){ 
        // first move condition
        if(row == 6 && board[5][col] == 0 && board[4][col] == 0)
        {legal_moves[4][col] = 1;}
        // moving forward
        if(board[row-1][col] == 0)
        {legal_moves[row-1][col] = 1;}
        //capture right
        if(col+1 < NUM_COL && board[row-1][col+1] != 0)
        {legal_moves[row-1][col+1] = 1;}
        //capture left
        if(col-1 >=0 && board[row-1][col-1] != 0)
        {legal_moves[row-1][col-1] = 1;}
        //en passant
        if(col-1 >=0 && board[row][col-1] == black_unicode[5] && black_pawns_en_passantable[col-1] == 1)
        {legal_moves[row-1][col-1] = 1;}
        if(col+1 < NUM_COL && board[row][col+1] == black_unicode[5] && black_pawns_en_passantable[col+1] == 1)
        {legal_moves[row-1][col+1] = 1;}
    }
    else{
        // first move condition
        if(row == 1 && board[2][col] == 0 && board[3][col] == 0)
        {legal_moves[3][col] = 1;}
        // moving forward
        if(board[row+1][col] == 0)
        {legal_moves[row+1][col] = 1;}
        //capture right
        if(col+1 < NUM_COL && board[row+1][col+1] != 0)
        {legal_moves[row+1][col+1] = 1;}
        //capture left
        if(col-1 >=0 && board[row+1][col-1] != 0)
        {legal_moves[row+1][col-1] = 1;}
        //en passant
        if(col-1 >=0 && board[row][col-1] == white_unicode[5] && white_pawns_en_passantable[col-1] == 1)
        {legal_moves[row+1][col-1] = 1;}
        if(col+1 < NUM_COL && board[row][col+1] == white_unicode[5] && white_pawns_en_passantable[col+1] == 1)
        {legal_moves[row+1][col+1] = 1;}
    }
}

// Fills the legal_moves array with the legal moves of a knight on a given square
void KnightLegalMoves(int row, int col){
    if(white_to_move){
        if(row+1 < NUM_ROW && col+2 < NUM_COL && !IsWhitePiece(board[row+1][col+2]))
        {legal_moves[row+1][col+2] = 1;}
        if(row+2 < NUM_ROW && col+1 < NUM_COL && !IsWhitePiece(board[row+2][col+1]))
        {legal_moves[row+2][col+1] = 1;}
        if(row-1 >= 0 && col+2 < NUM_COL && !IsWhitePiece(board[row-1][col+2]))
        {legal_moves[row-1][col+2] = 1;}
        if(row-2 >= 0 && col+1 < NUM_COL && !IsWhitePiece(board[row-2][col+1]))
        {legal_moves[row-2][col+1] = 1;}
        if(row+1 < NUM_ROW && col-2 >= 0 && !IsWhitePiece(board[row+1][col-2]))
        {legal_moves[row+1][col-2] = 1;}
        if(row+2 < NUM_ROW && col-1 >= 0 && !IsWhitePiece(board[row+2][col-1]))
        {legal_moves[row+2][col-1] = 1;}
        if(row-1 >= 0 && col-2 >= 0 && !IsWhitePiece(board[row-1][col-2]))
        {legal_moves[row-1][col-2] = 1;}
        if(row-2 >= 0 && col-1 >= 0 && !IsWhitePiece(board[row-2][col-1]))
        {legal_moves[row-2][col-1] = 1;}
    }
    else{
        if(row+1 < NUM_ROW && col+2 < NUM_COL && !IsBlackPiece(board[row+1][col+2]))
        {legal_moves[row+1][col+2] = 1;}
        if(row+2 < NUM_ROW && col+1 < NUM_COL && !IsBlackPiece(board[row+2][col+1]))
        {legal_moves[row+2][col+1] = 1;}
        if(row-1 >= 0 && col+2 < NUM_COL && !IsBlackPiece(board[row-1][col+2]))
        {legal_moves[row-1][col+2] = 1;}
        if(row-2 >= 0 && col+1 < NUM_COL && !IsBlackPiece(board[row-2][col+1]))
        {legal_moves[row-2][col+1] = 1;}
        if(row+1 < NUM_ROW && col-2 >= 0 && !IsBlackPiece(board[row+1][col-2]))
        {legal_moves[row+1][col-2] = 1;}
        if(row+2 < NUM_ROW && col-1 >= 0 && !IsBlackPiece(board[row+2][col-1]))
        {legal_moves[row+2][col-1] = 1;}
        if(row-1 >= 0 && col-2 >= 0 && !IsBlackPiece(board[row-1][col-2]))
        {legal_moves[row-1][col-2] = 1;}
        if(row-2 >= 0 && col-1 >= 0 && !IsBlackPiece(board[row-2][col-1]))
        {legal_moves[row-2][col-1] = 1;}
    }
}

// Fills the legal_moves array with the legal moves of a bishop on a given square
void BishopLegalMoves(int row, int col){
    if(white_to_move){
        int i = 1;
        //down right diagonal
        while(row+i < NUM_ROW && col+i < NUM_COL){
            if(board[row+i][col+i] == 0){
                legal_moves[row+i][col+i] = 1;
                i++;
            }
            else if(IsBlackPiece(board[row+i][col+i])){
                legal_moves[row+i][col+i] = 1;
                break;
            }
            else if(IsWhitePiece(board[row+i][col+i])){
                break;
            }
        }
        i = 1;
        //down left diagonal
        while(row+i < NUM_ROW && col-i >= 0){
            if(board[row+i][col-i] == 0){
                legal_moves[row+i][col-i] = 1;
                i++;
            }
            else if(IsBlackPiece(board[row+i][col-i])){
                legal_moves[row+i][col-i] = 1;
                break;
            }
            else if(IsWhitePiece(board[row+i][col-i])){
                break;
            }
        }
        i = 1;
        //up right diagonal
        while(row-i >= 0 && col+i < NUM_COL){
            if(board[row-i][col+i] == 0){
                legal_moves[row-i][col+i] = 1;
                i++;
            }
            else if(IsBlackPiece(board[row-i][col+i])){
                legal_moves[row-i][col+i] = 1;
                break;
            }
            else if(IsWhitePiece(board[row-i][col+i])){
                break;
            }
        }
        i = 1;
        //up left diagonal
        while(row-i >= 0 && col-i >= 0){
            if(board[row-i][col-i] == 0){
                legal_moves[row-i][col-i] = 1;
                i++;
            }
            else if(IsBlackPiece(board[row-i][col-i])){
                legal_moves[row-i][col-i] = 1;
                break;
            }
            else if(IsWhitePiece(board[row-i][col-i])){
                break;
            }
        }
    }
    else{
        int i = 1;
        //down right diagonal
        while(row+i < NUM_ROW && col+i < NUM_COL){
            if(board[row+i][col+i] == 0){
                legal_moves[row+i][col+i] = 1;
                i++;
            }
            else if(IsWhitePiece(board[row+i][col+i])){
                legal_moves[row+i][col+i] = 1;
                break;
            }
            else if(IsBlackPiece(board[row+i][col+i])){
                break;
            }
        }
        i = 1;
        //down left diagonal
        while(row+i < NUM_ROW && col-i >= 0){
            if(board[row+i][col-i] == 0){
                legal_moves[row+i][col-i] = 1;
                i++;
            }
            else if(IsWhitePiece(board[row+i][col-i])){
                legal_moves[row+i][col-i] = 1;
                break;
            }
            else if(IsBlackPiece(board[row+i][col-i])){
                break;
            }
        }
        i = 1;
        //up right diagonal
        while(row-i >= 0 && col+i < NUM_COL){
            if(board[row-i][col+i] == 0){
                legal_moves[row-i][col+i] = 1;
                i++;
            }
            else if(IsWhitePiece(board[row-i][col+i])){
                legal_moves[row-i][col+i] = 1;
                break;
            }
            else if(IsBlackPiece(board[row-i][col+i])){
                break;
            }
        }
        i = 1;
        //up left diagonal
        while(row-i >= 0 && col-i >= 0){
            if(board[row-i][col-i] == 0){
                legal_moves[row-i][col-i] = 1;
                i++;
            }
            else if(IsWhitePiece(board[row-i][col-i])){
                legal_moves[row-i][col-i] = 1;
                break;
            }
            else if(IsBlackPiece(board[row-i][col-i])){
                break;
            }
        }
    }
}

// Fills the legal_moves array with the legal moves of a rook on a given square
void RookLegalMoves(int row, int col){
    if(white_to_move){
        int i = 1;
        while(row+i < NUM_ROW){ // down
            if(board[row+i][col] == 0){
                legal_moves[row+i][col] = 1;
                i++;
            }
            else if(IsBlackPiece(board[row+i][col])){
                legal_moves[row+i][col] = 1;
                break;
            }
            else if(IsWhitePiece(board[row+i][col])){
                break;
            }
        }
        i = 1;
        while(row-i >= 0){ // up
            if(board[row-i][col] == 0){
                legal_moves[row-i][col] = 1;
                i++;
            }
            else if(IsBlackPiece(board[row-i][col])){
                legal_moves[row-i][col] = 1;
                break;
            }
            else if(IsWhitePiece(board[row-i][col])){
                break;
            }
        }
        i = 1;
        while(col+i < NUM_COL){ // right
            if(board[row][col+i] == 0){
                legal_moves[row][col+i] = 1;
                i++;
            }
            else if(IsBlackPiece(board[row][col+i])){
                legal_moves[row][col+i] = 1;
                break;
            }
            else if(IsWhitePiece(board[row][col+i])){
                break;
            }
        }
        i = 1;
        while(col-i >= 0){ // left
            if(board[row][col-i] == 0){
                legal_moves[row][col-i] = 1;
                i++;
            }
            else if(IsBlackPiece(board[row][col-i])){
                legal_moves[row][col-i] = 1;
                break;
            }
            else if(IsWhitePiece(board[row][col-i])){
                break;
            }
        }
    }
    else{
        int i = 1;
        while(row+i < NUM_ROW){ // down
            if(board[row+i][col] == 0){
                legal_moves[row+i][col] = 1;
                i++;
            }
            else if(IsWhitePiece(board[row+i][col])){
                legal_moves[row+i][col] = 1;
                break;
            }
            else if(IsBlackPiece(board[row+i][col])){
                break;
            }
        }
        i = 1;
        while(row-i >= 0){ // up
            if(board[row-i][col] == 0){
                legal_moves[row-i][col] = 1;
                i++;
            }
            else if(IsWhitePiece(board[row-i][col])){
                legal_moves[row-i][col] = 1;
                break;
            }
            else if(IsBlackPiece(board[row-i][col])){
                break;
            }
        }
        i = 1;
        while(col+i < NUM_COL){ // right
            if(board[row][col+i] == 0){
                legal_moves[row][col+i] = 1;
                i++;
            }
            else if(IsWhitePiece(board[row][col+i])){
                legal_moves[row][col+i] = 1;
                break;
            }
            else if(IsBlackPiece(board[row][col+i])){
                break;
            }
        }
        i = 1;
        while(col-i >= 0){ // left
            if(board[row][col-i] == 0){
                legal_moves[row][col-i] = 1;
                i++;
            }
            else if(IsWhitePiece(board[row][col-i])){
                legal_moves[row][col-i] = 1;
                break;
            }
            else if(IsBlackPiece(board[row][col-i])){
                break;
            }
        }
    }
}

// Fills the legal_moves array with the legal moves of a queen on a given square
void QueenLegalMoves(int row, int col){
    BishopLegalMoves(row,col);
    RookLegalMoves(row,col);
}

// Fills the legal_moves array with the legal moves of a king on a given square
void KingLegalMoves(int row, int col){
    if(white_to_move){
        FindBlackProtectedSquares();
        if(row-1 >= 0){
            if(col-1 >= 0 && !IsWhitePiece(board[row-1][col-1]) && black_protected_squares[row-1][col-1] == 0){
                legal_moves[row-1][col-1] = 1;
            }
            if(!IsWhitePiece(board[row-1][col]) && black_protected_squares[row-1][col] == 0){
                legal_moves[row-1][col] = 1;
            }
            if(col+1 < NUM_COL && !IsWhitePiece(board[row-1][col+1]) && black_protected_squares[row-1][col+1] == 0){
                legal_moves[row-1][col+1] = 1;
            }
        }

        if(col-1 >= 0 && !IsWhitePiece(board[row][col-1]) && black_protected_squares[row][col-1] == 0){
            legal_moves[row][col-1] = 1;
        }
        if(col+1 < NUM_COL && !IsWhitePiece(board[row][col+1]) && black_protected_squares[row][col+1] == 0){
            legal_moves[row][col+1] = 1;
        }
        if(row+1 < NUM_ROW){
            if(col-1 >= 0 && !IsWhitePiece(board[row+1][col-1]) && black_protected_squares[row+1][col-1] == 0){
                legal_moves[row+1][col-1] = 1;
            }
            if(!IsWhitePiece(board[row+1][col]) && black_protected_squares[row+1][col] == 0){
                legal_moves[row+1][col] = 1;
            }
            if(col+1 < NUM_COL && !IsWhitePiece(board[row+1][col+1]) && black_protected_squares[row+1][col+1] == 0){
                legal_moves[row+1][col+1] = 1;
            }
        }
    }
    else{
        FindWhiteProtectedSquares();
        if(row-1 >= 0){
            if(col-1 >= 0 && board[row-1][col-1] == 0 && white_protected_squares[row-1][col-1] == 0){
                legal_moves[row-1][col-1] = 1;
            }
            if(board[row-1][col] == 0 && white_protected_squares[row-1][col] == 0){
                legal_moves[row-1][col] = 1;
            }
            if(col+1 < NUM_COL && board[row-1][col+1] == 0 && white_protected_squares[row-1][col+1] == 0){
                legal_moves[row-1][col+1] = 1;
            }
        }

        if(col-1 >= 0 && board[row][col-1] == 0 && white_protected_squares[row][col-1] == 0){
            legal_moves[row][col-1] = 1;
        }
        if(col+1 < NUM_COL && board[row][col+1] == 0 && white_protected_squares[row][col+1] == 0){
            legal_moves[row][col+1] = 1;
        }
        if(row+1 < NUM_ROW){
            if(col-1 >= 0 && board[row+1][col-1] == 0 && white_protected_squares[row+1][col-1] == 0){
                legal_moves[row+1][col-1] = 1;
            }
            if(board[row+1][col] == 0 && white_protected_squares[row+1][col] == 0){
                legal_moves[row+1][col] = 1;
            }
            if(col+1 < NUM_COL && board[row+1][col+1] == 0 && white_protected_squares[row+1][col+1] == 0){
                legal_moves[row+1][col+1] = 1;
            }
        }
    }
}

// Combines all of the PieceLegalMoves() functions 
void FindLegalMoves(int row, int col){
    for(int i = 0; i < NUM_ROW; i++){ // clear legal moves
        for(int j = 0; j < NUM_COL; j++){
            legal_moves[i][j] = 0;
        }
    }  
    int piece = board[row][col];
    if(piece == white_unicode[5] || piece == black_unicode[5])
        PawnLegalMoves(row, col);
    else if(piece == white_unicode[4] || piece == black_unicode[4])
        KnightLegalMoves(row, col);
    else if(piece == white_unicode[3] || piece == black_unicode[3])
        BishopLegalMoves(row, col);
    else if(piece == white_unicode[2] || piece == black_unicode[2])
        RookLegalMoves(row, col);
    else if(piece == white_unicode[1] || piece == black_unicode[1])
        QueenLegalMoves(row, col);
    else if(piece == white_unicode[0] || piece == black_unicode[0])
        KingLegalMoves(row, col);
    else return;
}

// Takes a starting square and an ending square and makes the moves
// (except in the case of promotions and castling),
// as well as updating castling rights and updating which pawns are en passantable
void MakeMove(int prev_row, int prev_col, int new_row, int new_col){
    short int capture_happened = 0;
    int piece = board[prev_row][prev_col]; // save the piece that is moving
    int target_square = board[new_row][new_col]; // save piece that was previously in the new position
    board[new_row][new_col] = piece; // place piece in new position
    board[prev_row][prev_col] = 0; // remove piece from the previous position

    if(target_square == 0 && (piece != white_unicode[5] && piece != black_unicode[5])){
        moves_since_pawn_move_or_capture++;
    }

    //determine if there was a capture (not including en passant)
    if(target_square != 0){
        capture_happened = 1;
        moves_since_pawn_move_or_capture = 0;
    }

    if(piece == white_unicode[5] || piece == black_unicode[5]){
        moves_since_pawn_move_or_capture = 0;
        // Delete the en passanted pawn if en passant happens
        if(new_col != prev_col && !capture_happened){
            board[prev_row][new_col] = 0;
        }

        //determine en passantable pawns
        if(piece == white_unicode[5] && new_row == 4 && prev_row == 6){
            white_pawns_en_passantable[new_col] = 1;
        }
        else if(piece == black_unicode[5] && new_row == 3 && prev_row == 1){
            black_pawns_en_passantable[new_col] = 1;
        }
    }

    // determine castling rights
    if(piece == white_unicode[0]){
        white_king_moved = 1;
    }
    if(piece == black_unicode[0]){
        black_king_moved = 1;
    }
    if(piece == white_unicode[2]){
        if(prev_col == 0){
            white_queenside_rook_moved = 1;
        }
        else if(prev_col == 7){
            white_kingside_rook_moved = 1;
        }
    }
    if(piece == black_unicode[2]){
        if(prev_col == 0){
            black_queenside_rook_moved = 1;
        }
        else if(prev_col == 7){
            black_kingside_rook_moved = 1;
        }
    }
}

// Returns true if the inputed string is a valid move, determines what the starting and ending squares are,
// and calls the MakeMove() function. Also carries out promotion and castling
short int FindMove(std::string input){
    if(input == "0-0" || input == "O-O"){ //kingside castle
        if(white_to_move && !white_king_moved && !white_kingside_rook_moved && board[7][5] == 0 && board[7][6] == 0
            && black_protected_squares[7][4] == 0 && black_protected_squares[7][5] == 0 && black_protected_squares[7][6] == 0){
            board[7][7] = 0; // remove rook from old position
            board[7][5] = white_unicode[2]; // move rook to new position
            board[7][4] = 0; // remove king from old position
            board[7][6] = white_unicode[0]; // move king to new position
        }
        else if(!white_to_move && !black_king_moved && !black_kingside_rook_moved && board[0][5] == 0 && board[0][6] == 0
            && white_protected_squares[0][4] == 0 && white_protected_squares[0][5] == 0 && white_protected_squares[0][6] == 0){
            board[0][7] = 0; // remove rook from old position
            board[0][5] = black_unicode[2]; // move rook to new position
            board[0][4] = 0; // remove king from old position
            board[0][6] = black_unicode[0]; // move king to new position
        }
        else{return 0;}
        return 1;
    }

    else if(input == "0-0-0" || input == "O-O-O"){//queenside castle  
        if(white_to_move && !white_king_moved && !white_queenside_rook_moved && board[7][1] == 0 && board[7][2] == 0 && board[7][3] == 0
            && black_protected_squares[7][1] == 0 && black_protected_squares[7][2] == 0 && black_protected_squares[7][3] == 0){
            board[7][0] = 0; // remove rook from old position
            board[7][3] = white_unicode[2]; // move rook to new position
            board[7][4] = 0; // remove king from old position
            board[7][2] = white_unicode[0]; // move king to new position
        }
        else if(!white_to_move && !black_king_moved && !black_queenside_rook_moved && board[0][1] == 0 && board[0][2] == 0 && board[0][3] == 0
            && white_protected_squares[0][1] == 0 && white_protected_squares[0][2] == 0 && white_protected_squares[0][3] == 0){
            board[0][0] = 0; // remove rook from old position
            board[0][3] = black_unicode[2]; // move rook to new position
            board[0][4] = 0; // remove king from old position
            board[0][2] = black_unicode[0]; // move king to new position
        }
        else{return 0;}
        return 1;
    }

    int length = input.length();
    // set previous row and column to invalid values so that if they arent changed the function will return false
    int prev_row = -1;
    int prev_col = -1;

    // get ascii char input for the row
    char row_char;
    if(input[length-2] == '='){row_char = input[length-3];}
    else{row_char = input[length-1];}
    int new_row = 8 - ((int)row_char - 48);
    // get ascii char input for the column
    char col_char;
    if(input[length-2] == '='){col_char = input[length-4];}
    else{col_char = input[length-2];}
    int new_col = (int)col_char - 97; 

    if(IsLowercase(input[0])){// pawn moves
        if(length == 2){// forward move
            prev_col = new_col;
            if(white_to_move){
                if(board[new_row+1][new_col] == white_unicode[5]){// single move
                    prev_row = new_row+1;
                }
                else if(board[new_row+2][new_col] == white_unicode[5]){// double move
                    prev_row = new_row+2;            
                }
                else{
                    return 0;
                }
            }
            else{
                if(board[new_row-1][new_col] == black_unicode[5]){// single move
                    prev_row = new_row-1;
                }
                else if(board[new_row-2][new_col] == black_unicode[5]){// double move
                    prev_row = new_row-2;            
                }
                else{
                    return 0;
                }
            }
        }
        else if(input[1] == 'x'){// pawn capture    
            if(white_to_move){
                prev_row = new_row+1;
            }
            else{
                prev_row = new_row-1;
            }
            if(((int)input[0]-97) > new_col){// converts the column letter to a number
                prev_col = new_col+1;
            }
            else{
                prev_col = new_col-1;
            }
        }
        if(input[length-2] == '='){// pawn promotion can happen with a push or a capture
            char piece_char = input[length-1];
            if(white_to_move && new_row == 0){
                if(piece_char == 'Q'){
                    board[new_row][new_col] = white_unicode[1];
                }
                else if(piece_char == 'N'){
                    board[new_row][new_col] = white_unicode[4];
                }
                else if(piece_char == 'R'){
                    board[new_row][new_col] = white_unicode[2];
                }
                else if(piece_char == 'B'){
                    board[new_row][new_col] = white_unicode[3];
                }
                else{
                    return 0;
                }
                board[prev_row][prev_col] = 0;
                return 1;
            }
            else if(!white_to_move && new_row == 7){
                if(piece_char == 'Q'){
                    board[new_row][new_col] = black_unicode[1];
                }
                else if(piece_char == 'N'){
                    board[new_row][new_col] = black_unicode[4];
                }
                else if(piece_char == 'R'){
                    board[new_row][new_col] = black_unicode[2];
                }
                else if(piece_char == 'B'){
                    board[new_row][new_col] = black_unicode[3];
                }
                else{return 0;}
                board[prev_row][prev_col] = 0;
                return 1;
            }
            else{return 0;}
        }
    }
    else if(IsUppercase(input[0])){// piece moves
        char piece_char = input[0];
        if(length == 3 || (length == 4 && input[1] == 'x')){// normal move or piece capture
            if(piece_char == 'N'){
                for(int i = 0; i < NUM_ROW; i++){
                    for(int j = 0; j < NUM_COL; j++){
                        if((white_to_move && board[i][j] == white_unicode[4]) || (!white_to_move && board[i][j] == black_unicode[4])){
                            FindLegalMoves(i,j);
                            if(legal_moves[new_row][new_col] == 1){
                                prev_row = i;
                                prev_col = j;
                            }
                        }
                    }
                }
            }
            else if(piece_char == 'B'){
                for(int i = 0; i < NUM_ROW; i++){
                    for(int j = 0; j < NUM_COL; j++){
                        if((white_to_move && board[i][j] == white_unicode[3]) || (!white_to_move && board[i][j] == black_unicode[3])){
                            FindLegalMoves(i,j);
                            if(legal_moves[new_row][new_col] == 1){
                                prev_row = i;
                                prev_col = j;
                            }
                        }
                    }
                }
            }
            else if(piece_char == 'R'){
                for(int i = 0; i < NUM_ROW; i++){
                    for(int j = 0; j < NUM_COL; j++){
                        if((white_to_move && board[i][j] == white_unicode[2]) || (!white_to_move && board[i][j] == black_unicode[2])){
                            FindLegalMoves(i,j);
                            if(legal_moves[new_row][new_col] == 1){
                                prev_row = i;
                                prev_col = j;
                            }
                        }
                    }
                }
            }
            else if(piece_char == 'Q'){
                for(int i = 0; i < NUM_ROW; i++){
                    for(int j = 0; j < NUM_COL; j++){
                        if((white_to_move && board[i][j] == white_unicode[1]) || (!white_to_move && board[i][j] == black_unicode[1])){
                            FindLegalMoves(i,j);
                            if(legal_moves[new_row][new_col] == 1){
                                prev_row = i;
                                prev_col = j;
                            }
                        }
                    }
                }
            }
            else if(piece_char == 'K'){
                for(int i = 0; i < NUM_ROW; i++){
                    for(int j = 0; j < NUM_COL; j++){
                        if((white_to_move && board[i][j] == white_unicode[0]) || (!white_to_move && board[i][j] == black_unicode[0])){
                            FindLegalMoves(i,j);
                            if(legal_moves[new_row][new_col] == 1){
                                prev_row = i;
                                prev_col = j;
                            }
                        }
                    }
                }
            }
            else{return 0;}
        }
        else if(((length == 4 && input[1] != 'x') || (length == 5 && input[2] == 'x')) && (IsLowercase(input[1]) || IsDigit(input[1]))){// singlely disambiguated
            char piece_char = input[0];
            if(IsDigit(input[1])){// row disambiguated
                prev_row = (8 - ((int)input[1] - 48));
            }
            else if(IsLowercase(input[1])){// column disambiguated
                prev_col = ((int)input[1] - 97);
            }
            if(piece_char == 'N'){
                for(int i = 0; i < NUM_ROW; i++){
                    for(int j = 0; j < NUM_COL; j++){
                        if((white_to_move && board[i][j] == white_unicode[4]) || (!white_to_move && board[i][j] == black_unicode[4])){
                            if(prev_row == i || prev_col == j){
                                FindLegalMoves(i,j);
                                if(legal_moves[new_row][new_col] == 1){
                                    if(prev_row < 0){prev_row = i;}
                                    if(prev_col < 0){prev_col = j;}
                                }
                            }
                        }
                    }
                }
            }
            else if(piece_char == 'B'){
                for(int i = 0; i < NUM_COL; i++){
                    for(int j = 0; j < NUM_COL; j++){
                        if((white_to_move && board[i][j] == white_unicode[3]) || (!white_to_move && board[i][j] == black_unicode[3])){
                            if(prev_row == i || prev_col == j){
                                FindLegalMoves(i,j);
                                if(legal_moves[new_row][new_col] == 1){
                                    if(prev_row < 0){prev_row = i;}
                                    if(prev_col < 0){prev_col = j;}
                                }
                            }
                        }
                    }
                }
            }
            else if(piece_char == 'R'){
                for(int i = 0; i < NUM_ROW; i++){
                    for(int j = 0; j < NUM_COL; j++){
                        if((white_to_move && board[i][j] == white_unicode[2]) || (!white_to_move && board[i][j] == black_unicode[2])){
                            if(prev_row == i || prev_col == j){
                                FindLegalMoves(i,j);
                                if(legal_moves[new_row][new_col] == 1){
                                    if(prev_row < 0){prev_row = i;}
                                    if(prev_col < 0){prev_col = j;}
                                }
                            }
                        }
                    }
                }
            }
            else if(piece_char == 'Q'){
                for(int i = 0; i < NUM_ROW; i++){
                    for(int j = 0; j < NUM_COL; j++){
                        if((white_to_move && board[i][j] == white_unicode[1]) || (!white_to_move && board[i][j] == black_unicode[1])){
                            if(prev_row == i || prev_col == j){
                                FindLegalMoves(i,j);
                                if(legal_moves[new_row][new_col] == 1){
                                    if(prev_row < 0){prev_row = i;}
                                    if(prev_col < 0){prev_col = j;}
                                }
                            }
                        }
                    }
                }
            }
            else{return 0;}
        }
        else if((length == 5 && input[2] != 'x') || (length == 6 && input[3] == 'x')){// doublely disambiguated
            prev_col = ((int)input[1]-97);
            prev_row = (8 - ((int)input[2]-48));
        }
        else{return 0;}
    }
    else{return 0;}

    // Don't make the move if the move was to castle or promote or if it wasn't a legal move
    FindLegalMoves(prev_row,prev_col);
    if((prev_row >= 0 && prev_col >= 0) && legal_moves[new_row][new_col] == 1){
        MakeMove(prev_row, prev_col, new_row, new_col);
        return 1;
    }
    else{return 0;}
}

// Returns true if the current player's king is under attack
short int IsInCheck(short int white_to_move){
    if(white_to_move){
        FindBlackProtectedSquares();
        for(int i = 0; i < NUM_ROW; i++){
            for(int j = 0; j < NUM_COL; j++){
                if((board[i][j] == white_unicode[0]) && (black_protected_squares[i][j] == 1)){
                    return 1;
                }
            }
        }
        return 0;
    }
    else{
        FindWhiteProtectedSquares();
        for(int i = 0; i < NUM_ROW; i++){
            for(int j = 0; j < NUM_COL; j++){
                if((board[i][j] == black_unicode[0]) && (white_protected_squares[i][j] == 1)){
                    return 1;
                }           
            }
        }
    }
    return 0;
}

// Returns true if the current player does not have a king on the board or
// is in check and does not have any legal moves
short int IsCheckmate(short int white_to_move){
    short int are_legal_moves = 0;
    short int king_on_board = 0;
    if(white_to_move){
        for(int i = 0; i < NUM_ROW; i++){
            for(int j = 0; j < NUM_COL; j++){
                if(!are_legal_moves && IsWhitePiece(board[i][j])){
                    FindLegalMoves(i,j);
                    for(int x = 0; x < NUM_ROW; x++){
                        for(int y = 0; y < NUM_COL; y++){
                            if(legal_moves[x][y] == 1){ // not stalemate
                                are_legal_moves = 1;
                            }
                        }
                    }
                }
                if(board[i][j] == white_unicode[0]){
                    king_on_board = 1;
                }
            }     
        }
    } 
    else{
        for(int i = 0; i < NUM_ROW; i++){
            for(int j = 0; j < NUM_COL; j++){
                if(!are_legal_moves && IsBlackPiece(board[i][j])){
                    FindLegalMoves(i,j);
                    for(int x = 0; x < NUM_ROW; x++){
                        for(int y = 0; y < NUM_COL; y++){
                            if(legal_moves[x][y] == 1){ // not stalemate
                                are_legal_moves = 1;
                            }
                        }
                    }
                }
                if(board[i][j] == black_unicode[0]){
                    king_on_board = 1;
                }
            }
        }
    }
    if(IsInCheck(white_to_move) && !are_legal_moves){
        int length = game_summary[move_num-1].length();
        game_summary[move_num] = "x";
        game_summary[move_num-1][length-1] = '#'; // replace the + character on the checkmating move with a #    
        return 1;
    }
    else if(!king_on_board){
        int length = game_summary[move_num-2].length();
        game_summary[move_num] = "x";
        game_summary[move_num-1] = "x";
        game_summary[move_num-2][length-1] = '#'; // replace the + character on the checkmating move with a #
        return 1;
    }
    else{
        return 0;
    }
}

// Returns true if the current players has no legal moves and is not in check
short int IsStalemate(){
    for(int i = 0; i < NUM_ROW; i++){
        for(int j = 0; j < NUM_COL; j++){
            if((IsWhitePiece(board[i][j]) && white_to_move) || (IsBlackPiece(board[i][j]) && !white_to_move)){
                FindLegalMoves(i,j);
                for(int x = 0; x < NUM_ROW; x++){
                    for(int y = 0; y < NUM_COL; y++){
                        if(legal_moves[x][y] == 1){ // There are legal moves
                            return 0;
                        }
                    }
                }
            }
        }
    }    
    if(!IsInCheck(white_to_move)){
        return 1;
    }
    else{
        return 0;
    }
    
}

// Adds the most recent move to the game_summary array so they can be printed later.
// Also erases the last two moves of the game when the king is taken so it matches how the game would actually end
void AddToGameSummary(std::string move){
    if(IsInCheck(!white_to_move)){ // checks if the other color is in check
        game_summary[move_num] = move;
        game_summary[move_num] += '+';
    }
    else{
        game_summary[move_num] = move;
    }
}

// Prints the game summary showing the formatted chess notation of the moves from each side
void PrintGameSummary(){
    std::cout << "\nGame Summary:\n" << std::endl;
    int i = 0;
    while(game_summary[i] != "x"){
        int length = game_summary[i].length();
        // if i is even, it was whites turn and if i is odd it was blacks
        if(i%2 == 0){
            // format the text so all the moves are lined up
            std:: cout << i/2 + 1 << ": " << game_summary[i];
            if((i/2+1) < 10){
                if(length < 5){std::cout << "\t\t";}
                else{std::cout << "\t";}
            }
            else{
                if(length == 4){std::cout << "\t";}
                else if(length < 4){std::cout << "\t\t";}
                else{std::cout << "\t";}
            }
        }
        else{
            std:: cout << game_summary[i] << std::endl;
        }
        i++;
    }
}

// Main setup and program loop
int main() {
    std::cout << 
    "Welcome to chess in C++!" << std::endl <<
    "Please enter all moves in standard chess notation." << std::endl <<
    "Don't include + or # to indicate check or checkmate." << std::endl <<
    "The game continues until one player's king is captured or stalemated" << std::endl <<
    "Enter 'q' to quit (claim a draw) at any time.\n" << std::endl;

    // At start of main():
    #ifdef _WIN32
    SetConsoleOutputCP(CP_UTF8);
    #endif

    //clear game summary array
    for(int i = 0; i < MAX_NUM_MOVES; i++){game_summary[i] = "x";}

    for(;;){
        PrintBoard();

        if(IsCheckmate(white_to_move)){
            if(white_to_move){std::cout << "\n\nThe white king has been checkmated! Black Wins!\n\n" << std::endl;}
            else{std::cout << "\n\nThe black king has been checkmated! Black Wins!\n\n" << std::endl;}
            break;
        }
        else if(IsStalemate()){
            if(white_to_move){std::cout << "\n\nWhite has no legal moves. The game ends in a draw by stalemate\n\n" << std::endl;}
            else{std::cout << "\n\nBlack has no legal moves. The game ends in a draw by stalemate\n\n" << std::endl;}
            break;
        }
        else if(moves_since_pawn_move_or_capture >= 100){
            std::cout << "\n\nThe game ends in a draw by the 50 move rule.\n\n" << std::endl;
            break;
        }

        short int found_move = 0;

        // reset en passant state
        if(white_to_move) {for(int i = 0; i < NUM_COL; i++) {white_pawns_en_passantable[i] = 0;}}
        else {for(int i = 0; i < NUM_COL; i++) {black_pawns_en_passantable[i] = 0;}}

        std::cout << (white_to_move ? "White's turn" : "Blacks's turn") << std::endl;

        do{
            std::cout << "Enter move: ";
            std::string input; 
            std::cin >> input; 
            if(input[0] == 'q'){ // quit
                std::cout << "\n\nThe game ends in a draw by agreement.\n\n";
                PrintGameSummary();
                return 0;
            } 
            found_move = FindMove(input);
            if(found_move) {
                AddToGameSummary(input);
                move_num++;
            } 
            else {
                std::cout << "Invalid Input" << std::endl;
            }
        }while(!found_move);      
        white_to_move = !white_to_move;
    }
    PrintGameSummary();
    return 0;
}