#include <iostream>
#include<string>
#include <vector>

using namespace std;

// Define the chess board
char board[8][8] = {
    {'R', 'N', 'B', 'Q', 'K', 'B', 'N', 'R'},
    {'P', 'P', 'P', 'P', 'P', 'P', 'P', 'P'},
    {' ', '.', ' ', '.', ' ', '.', ' ', '.'},
    {'.', ' ', '.', ' ', '.', ' ', '.', ' '},
    {' ', '.', ' ', '.', ' ', '.', ' ', '.'},
    {'.', ' ', '.', ' ', '.', ' ', '.', ' '},
    {'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p'},
    {'r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'}
};

bool is_check(char board[8][8], bool white_to_move);
bool is_checkmate(char board[8][8], bool white_to_move);
bool is_check(char board[8][8], bool white_to_move);
// Function to display the chess board
void print_board() {
    cout << endl << "   a  b  c  d  e  f  g  h" << endl;
    for (int i = 0; i < 8; i++) {
        cout << i + 1 << "  ";
        for (int j = 0; j < 8; j++) {
            cout << board[i][j] << "  ";
        }
        cout << i + 1 << endl;
    }
    cout << "   a  b  c  d  e  f  g  h" << endl << endl;
}

// Function to check if a move is valid
bool is_valid_move(int from_x, int from_y, int to_x, int to_y) {
    // Check if the move is within the board limits
    if (from_x < 0 || from_x > 7 || from_y < 0 || from_y > 7 || to_x < 0 || to_x > 7 || to_y < 0 || to_y > 7) {
        return false;
    }
    // Check if the piece at the starting position is the player's own piece
    if (board[from_x][from_y] >= 'A' && board[from_x][from_y] <= 'Z') {
        return false;
    }
    // Check if the piece at the starting position is not an empty space
    if (board[from_x][from_y] == ' ' || board[from_x][from_y] == '.') {
        return false;
    }
    // Check if the piece at the destination position is the player's own piece
    if (board[to_x][to_y] >= 'a' && board[to_x][to_y] <= 'z') {
        return false;
    }
    // Check if the move is legal for the piece
    char piece = board[from_x][from_y];
    if (piece == 'P') {
        if (to_x != from_x - 1) {
            return false;
        }
        if (to_y != from_y) {
            if (to_y != from_y - 1 && to_y != from_y + 1) {
                return false;
            }
            if (board[to_x][to_y] == ' ') {
                return false;
            }
        }
        else {
            if (to_x == 0) {
                // Promotion to Queen
                board[to_x][to_y] = 'Q';
            }
        }
    }
    else if (piece == 'p') {
        if (to_x != from_x + 1) {
            return false;
        }
        if (to_y != from_y) {
            if (to_y != from_y - 1 && to_y != from_y + 1) {
                return false;
            }
            if (board[to_x][to_y] == ' ') {
                return false;
            }
        }
        else {
            if (to_x == 7) {
                // Promotion to Queen
                board[to_x][to_y] = 'q';
            }
        }
    }
    else if (piece == 'R' || piece == 'r') {
        if (from_x != to_x && from_y != to_y) {
            return false;
        }
        if (from_x == to_x) {
            int start = min(from_y, to_y);
            int end = max(from_y, to_y);
            for (int i = start + 1; i < end; i++) {
                if (board[from_x][i] != ' ' && board[from_x][i] != '.') {
                    return false;
                }
            }
        }
        else {
            int start = min(from_x, to_x);
            int end = max(from_x, to_x);
            for (int i = start + 1; i < end; i++) {
                if (board[i][from_y] != ' ' && board[i][from_y] != '.') {
                    return false;
                }
            }
        }
    }
    else if (piece == 'N' || piece == 'n') {
        if ((to_x == from_x - 1 && to_y == from_y - 2) || (to_x == from_x - 2 && to_y == from_y - 1) ||
            (to_x == from_x - 2 && to_y == from_y + 1) || (to_x == from_x - 1 && to_y == from_y + 2) ||
            (to_x == from_x + 1 && to_y == from_y + 2) || (to_x == from_x + 2 && to_y == from_y + 1) ||
            (to_x == from_x + 2 && to_y == from_y - 1) || (to_x == from_x + 1 && to_y == from_y - 2)) {
            // Valid move
        }
        else {
            return false;
        }
    }
    else if (piece == 'B' || piece == 'b') {
        if (abs(to_x - from_x) != abs(to_y - from_y)) {
            return false;
        }
        int x_dir = (to_x > from_x) ? 1 : -1;
        int y_dir = (to_y > from_y) ? 1 : -1;
        for (int i = from_x + x_dir, j = from_y + y_dir; i != to_x; i += x_dir, j += y_dir) {
            if (board[i][j] != ' ' && board[i][j] != '.') {
                return false;
            }
        }
    }
    else if (piece == 'Q' || piece == 'q') {
        if (from_x == to_x || from_y == to_y) {
            int start = min(from_y, to_y);
            int end = max(from_y, to_y);
            if (from_x == to_x) {
                for (int i = start + 1; i < end; i++) {
                    if (board[from_x][i] != ' ' && board[from_x][i] != '.') {
                        return false;
                    }
                }
            }
            else {
                for (int i = start + 1; i < end; i++) {
                    if (board[i][from_y] != ' ' && board[i][from_y] != '.') {
                        return false;
                    }
                }
            }
        }
        else if (abs(to_x - from_x) == abs(to_y - from_y)) {
            int x_dir = (to_x > from_x) ? 1 : -1;
            int y_dir = (to_y > from_y) ? 1 : -1;
            for (int i = from_x + x_dir, j = from_y + y_dir; i != to_x; i += x_dir, j += y_dir) {
                if (board[i][j] != ' ' && board[i][j] != '.') {
                    return false;
                }
            }
        }
        else {
            return false;
        }
    }
    else if (piece == 'K' || piece == 'k') {
        if (abs(to_x - from_x) <= 1 && abs(to_y - from_y) <= 1) {
            // valid move for king
        }
        else {
            return false;
        }
    }
    else {
        return false;
    }

    return true;
}
vector<string> getPossibleMoves(char board[][8], bool white_to_move) {
    vector<string> moves;
    char piece;
    string move;

    // Iterate through each square on the board
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            // Check if the piece on this square belongs to the current player
            piece = board[i][j];
            if ((white_to_move && isupper(piece)) || (!white_to_move && islower(piece))) {
                // Check all possible moves for this piece and add them to the vector
                for (int x = 0; x < 8; x++) {
                    for (int y = 0; y < 8; y++) {
                        move = "";
                        if (is_valid_move(i, j, x, y)) {
                            move += 'a' + j;
                            move += '8' - i;
                            move += 'a' + y;
                            move += '8' - x;
                            moves.push_back(move);
                        }
                    }
                }
            }
        }
    }

    return moves;
}
bool is_checkmate(char board[8][8], bool white_to_move) {
    vector<pair<int, int>> moves = getPossibleMoves(board, white_to_move);
    for (auto move : moves) {
        char copy[8][8];
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                copy[i][j] = board[i][j];
            }
        }
        make_move(copy, move.first / 10, move.first % 10, move.second / 10, move.second % 10);
        if (!is_check(copy, white_to_move)) {
            return false;
        }
    }
    return true;
}

bool is_stalemate(char board[8][8], bool white_to_move) {
    vector<pair<int, int>> moves = get_possible_moves(board, white_to_move);
    for (auto move : moves) {
        char copy[8][8];
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                copy[i][j] = board[i][j];
            }
        }
        make_move(copy, move.first / 10, move.first % 10, move.second / 10, move.second % 10);
        if (!is_check(copy, white_to_move)) {
            return false;
        }
    }
    return true;
}

bool is_check(char board[8][8], bool white_to_move) {
    int king_x, king_y;
    char king = (white_to_move) ? 'K' : 'k';
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            if (board[i][j] == king) {
                king_x = i;
                king_y = j;
                break;
            }
        }
    }
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            if ((isupper(board[i][j]) == white_to_move)) {
                if (is_valid_move(i, j, i, j)) {
                    return true;
                }
            }
        }
    }
    return false;
}

bool is_gameover(char board[8][8], bool white_to_move) {
    if (is_checkmate(board, white_to_move) || is_stalemate(board, white_to_move)) {
        return true;
    }
    return false;
}


int main() {
    char board[8][8] = {
    {'r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'},
    {'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p'},
    {' ', '.', ' ', '.', ' ', '.', 'p', ' '},
{' ', '.', ' ', '.', ' ', '.', ' ', ' '},
{' ', '.', ' ', '.', ' ', '.', ' ', ' '},
{' ', '.', ' ', '.', ' ', '.', ' ', ' '},
{'P', 'P', 'P', 'P', 'P', 'P', 'P', 'P'},
{'R', 'N', 'B', 'Q', 'K', 'B', 'N', 'R'}
    };
    bool white_to_move = true;
    while (!is_gameover(board, white_to_move)) {
        print_board();
        cout << "It is " << ((white_to_move) ? "white" : "black") << "'s turn" << endl;
        bool valid_move = false;
        while (!valid_move) {
            string move;
            cout << "Enter your move: ";
            getline(cin, move);
            if (move.size() == 4) {
                int from_x = move[0] - 'a', from_y = move[1] - '1', to_x = move[2] - 'a', to_y = move[3] - '1';
                if (is_valid_move(from_x, from_y, to_x, to_y) && ((isupper(board[from_x][from_y]) == white_to_move))) {
                    make_move(board, from_x, from_y, to_x, to_y);
                    valid_move = true;
                }
            }
            if (!valid_move) {
                cout << "Invalid move. Try again." << endl;
            }
        }
        white_to_move = !white_to_move;
    }
    print_board();
    if (is_checkmate(board, white_to_move)) {
        cout << ((white_to_move) ? "Black" : "White") << " wins by checkmate!" << endl;
    }
    else if (is_stalemate(board, white_to_move)) {
        cout << "The game is a draw by stalemate." << endl;
    }
    return 0;
}

This is a code for a chess game , it has some unknown error, can you correct it and give me the corrected code.