Made a Tic-Tac-Toe console application and I have multiple errors that I unable to resolve

Question

merry Christmas to all. I have made a little tic-tac-toe game to practice using OOP techniques and this is my second application in doing so. The project was working before I made some slight additions with a scoring system but I think I tinkered with a particular line and everything broke it seems.

The error messages I am getting are: 'Syntax error: identifier 'board'' 'Player::PlayerMove::' function does not take 3 arguments'

Here is all of my code. Sorry if it is too long to be posting here.

Thank you for your time.

Main

// TicTacToeOOPV2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "Board.h"
#include "Player.h"

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

int main()
{
    Board board;
    Player player;

    std::vector<char> playingBoard(board.GetNumbOfSquares(), board.GetEmpty()); //The playing board
    bool gameOver = false;
    int move = 0, //Position player to on board
        player1Score = 0,
        player2Score = 0;
    char player1 = player.PlayerGamePiece(board);
    char player2 = player.OpponentGamePiece(board, player1); //Player two gets their gamePiece 
    //Decide first turn
    char turn = board.GetGamePieceX(); //Player who is 'X' gets the first turn

    board.DisplayBoard(playingBoard); //Display the pplaying board

    //Game Logic
    while (!player.CheckGameOver(gameOver, player1Score, player2Score))
    {
        while (board.FindWinner(playingBoard) == board.GameOnGoing())
        {
            //If its player1's turn
            if (turn == player1)
            {
                move = player.PlayerMove(board, playingBoard, move); //Get players move position
                playingBoard[move] = player1; //Assign positon onto playingboard
                turn = player2; //Change turn 
            }

            //If its player 2's turn
            else
            {
                move = player.PlayerMove(board, playingBoard, move); //Get player2's move position
                playingBoard[move] = player2; //Assign move positionto playing board
                turn = player1; //Change to player 1's turn
            }

            board.DisplayBoard(playingBoard); //Display the playing board to players    
        }

        board.AnnounceRoundWinner(board.FindWinner(playingBoard), player1, player2, player1Score, player2Score);
        board.ClearPlayingBoard(playingBoard);
    }


    //Announce winner
    board.AnnounceWinner(player, player1Score, player2Score);


    //board.AnnounceWinner(board.FindWinner(playingBoard), player1, player2); //Announce the winner of the game

    //Keep window open
    std::string barn;
    std::cin >> barn;
    return 0;
}

Player.h

#pragma once
#include "Board.h"
#include "Player.h"
#include <vector>

class Player
{
private:
    const int winningScore = 3; //Score that player must reach to win game

public:
    int GetWinningScore();

    bool DecideFirstTurn(Board& board); //Decides who gets the first turn
    char PlayerGamePiece(Board& board); //Player gets their game piece
    char OpponentGamePiece(Board& board, char player1); //Opponent gets their gamne piece
    int PlayerMove(Board& board, const std::vector<char>& playingBoard, int move); //Gets the players movement on board
    int PositionOfMove(const std::vector<char>& playingBoard, int high, int low); //Asks player where they would like to move on board


    bool CheckGameOver(bool gameOver, int player1Score, int player2Score); //Check to see if scores have reached maximum amount
};

Player.cpp

#include "stdafx.h"
#include "Player.h"
#include "Board.h"

#include <iostream>

int Player::GetWinningScore()
{
    return winningScore;
}

//Decides what player gets the first turn
bool Player::DecideFirstTurn(Board& board)
{
    char responce;

    std::cout << "Do you wish to go first? 'y' - Yes. 'n' - No. ";
    std::cin >> responce;

    switch (responce)
    {
    case 'y':
        return true;
        break;

    case 'n':
        return false;
        break;

    default:
        std::cout << "Did not enter the right data.";
    }
}

//Returns apprioriate game piece to who gets the first turn
char Player::PlayerGamePiece(Board& board)
{

    bool firstTurn = DecideFirstTurn(board);
    if (firstTurn)
    {
        return board.GetGamePieceX();
    }

    else
    {
        return board.GetGamePieceO();
    }
}

//Opponent gets opposite game piece than player
char Player::OpponentGamePiece(Board& board, char player1)
{
    if (player1 == board.GetGamePieceX())
    {
        return board.GetGamePieceO();
    }

    else
    {
        return board.GetGamePieceX();
    }
}

int Player::PlayerMove(Board& board, const std::vector<char>& playingBoard, int move)
{
    bool moveAllowed = false;
    do
    {
        move = PositionOfMove(playingBoard, playingBoard.size() - 1, 0);
        if (board.MoveIsLegal(playingBoard, move))
        {
            moveAllowed = true;
        }

        else
        {
            std::cout << "\nMove not allowed." << "\n";
        }
    } while (!moveAllowed);

    return move;    
}

int Player::PositionOfMove(const std::vector<char>& playingBoard, int high, int low)
{
    int numb = 0;
    do
    {
        std::cout << "\n\nEnter a digit between " << low << " and " << high << "\n";
        std::cin >> numb;

    } while (numb > high || numb < low);

    return numb;
}

bool Player::CheckGameOver(bool gameOver, int player1Score, int player2Score)
{
    if (player1Score < winningScore || player2Score < winningScore)
        return false;


    return true;
}

Board.h

    #pragma once
    #include "Board.h"
    #include "Player.h"

    #include <vector>

    class Board
    {
    private:
        const char X = 'X';
        const char O = 'O';
        const char TIE = 'T';
        const char NOONE = 'N';
        const char EMPTY = ' ';
        const int numbOfSquares = 9; //Number of squares on playingBoard

    public:
        char GetGamePieceX(); 
        char GetGamePieceO();
        int GetNumbOfSquares(); //Gets number of squares on playing board
        char GetEmpty();
        char GameOnGoing(); 

        void DisplayBoard(const std::vector<char>& playingBoard); //Display the board
        char FindWinner(const std::vector<char>& playingBoard); //Find winning combinations, resulting in winer of game
        char IsGameTie(const std::vector<char>& playingBoard); //Is the game a tie?
        bool MoveIsLegal(const std::vector<char>& playingBoard, int move); //Determine whether the requested move is legal

        void AnnounceWinner(Player& player, int player1Score, int player2Score); //Announce the winner of the game
        void AnnounceRoundWinner(char winner, char player1, char player2, int& player1Score, int& player2Score); //Announces the winner of the round
        void ClearPlayingBoard(std::vector<char>& playingBoard); //Clear the playing board
    };

**Board.cpp**
#include "stdafx.h"
#include "Board.h"
#include "Player.h"

#include <iostream>

//Get game piece 'X'
char Board::GetGamePieceX()
{
    return X;
}

//Get game piece X
char Board::GetGamePieceO()
{
    return O;
}

//Get number of squares that are on the board
int Board::GetNumbOfSquares()
{
    return numbOfSquares;
}

//Get the empty square on the playing board
char Board::GetEmpty()
{
    return EMPTY;
}

//Nobody has won, game still on-going
char Board::GameOnGoing()
{
    return NOONE;
}

//Display the board to players
void Board::DisplayBoard(const std::vector<char>& playingBoard)
{
    std::cout << "\n\t" << playingBoard[0] << " | " << playingBoard[1] << " | " << playingBoard[2];
    std::cout << "\n\t" << "---------";
    std::cout << "\n\t" << playingBoard[3] << " | " << playingBoard[4] << " | " << playingBoard[5];
    std::cout << "\n\t" << "---------";
    std::cout << "\n\t" << playingBoard[6] << " | " << playingBoard[7] << " | " << playingBoard[8];
}

char Board::FindWinner(const std::vector<char>& playingBoard)
{
    /*
    The playing board
    0, 1, 2
    3, 4, 5
    6, 7, 8
    */
    //All possible winning combinations 
    const int winningRows[8][3] =
    {
        //Horizontal combinations
        { 0, 1, 2 },
        { 3, 4, 5 },
        { 6, 7, 8 },
        //Vertical combinations
        { 0, 3, 6 },
        { 1, 4, 7 },
        { 2, 5, 8 },
        //Diagonal combinations
        { 0, 4, 8 },
        { 2, 4, 6 }
    };
    const int maxRows = 8; //Maximum amount of rows to search through to find a winning combination
    //const int winningRows = WinningRows();
    //Search for winning combination
    for (int row = 0; row < maxRows; row++)
    {
        if ((playingBoard[winningRows[row][0]] != EMPTY) &&
            (playingBoard[winningRows[row][0]] == playingBoard[winningRows[row][1]]) &&
            (playingBoard[winningRows[row][1]] == playingBoard[winningRows[row][2]]))
        {
            //Return fisrt character of winning combination for winner
            return playingBoard[winningRows[row][0]];
        }
    }
    //If a winning combination wasn't found,
    //Declare if game is TIE or game is still on-going
    return IsGameTie(playingBoard);
}

char Board::IsGameTie(const std::vector<char>& playingBoard)
{
    //If there are no more empty squares on game board, game is tie
    if (count(playingBoard.begin(), playingBoard.end(), EMPTY) == 0)
    {
        return TIE;
    }

    //If there are still empty squares, game is still on-going
    else
    {
        return NOONE;
    }
}

//Is square where player wants to move empty
bool Board::MoveIsLegal(const std::vector<char>& playingBoard, int move)
{
    return (playingBoard[move] == EMPTY);
}

void Board::AnnounceWinner(Player& player, int player1Score, int player2Score)
{
    if (player1Score >= player.GetWinningScore())
        std::cout << "\n\nPlayer 1 has won the game!" << "\n";

    if (player2Score >= player.GetWinningScore())
        std::cout << "\n\nPlayer 2 has won." << "\n";
}

void Board::AnnounceRoundWinner(char winner, char player1, char player2, int& player1Score, int& player2Score)
{
    //If player1 has won the round.
    if (winner == player1)
    {
        std::cout << "Player 1 has won the round." << "\n";
        player1Score++;
    }

    //If player 2 has won the round
    else if (winner == player2)
    {
        std::cout << "Player 2 has won the round." << "\n";
        player2Score++;
    }

    else
    {
        std::cout << "Game is tie." << "\n";
    }
}

void Board::ClearPlayingBoard(std::vector<char>& playingBoard)
{
    std::cout << "\n\n\n";
    std::vector<char> board(numbOfSquares, EMPTY);
    playingBoard.swap(board);

}

Answer 1

You are including Board.h in Player.h and Player.h in Bord.h. Circular including is not possible. Further there it makes no sens to include a header file itsef like Player.h in Player.h.To dissolve circular includes use forward declarations.

Board.h:

#pragma once
// #include <Payer.h>   <- remove this
// #include <Boarder.h> <- remove this
#include <vector>

class Player; // forward declaration of class Player (you can use Player* and Player& in header file)

Player.h:

#pragma once
// #include <Payer.h>   <- remove this
// #include <Boarder.h> <- remove this
#include <vector>

class Boarder; // forward declaration of class Boarder(you can use Boarder* and Boarder& in header file)