El mapa no se debe compartir tal cual, solo consultar...
Un servicio o usuario específico hace las veces de la banca, juez...
Éste es quien debiera recibir las peticiones de los usuarios para decidir su movimiento/jugada, que traslada al mapa si es posible y devuelve true, o false si el movimiento o jugada es ilegal...
Igualmente, es este servidor quien reparte los turnos a los jugadores (si el juego funciona por turnos).
...y también quien verifica cuando termina la partida, y quien inicializa la partida, previa inscripción de los jugadores...

Supongo (o al menos eso espero), que esto te ofrece una perspectiva más clara de por dónde deben ir las cosas.

Sí. Si el juego tiene más de un jugador, es preciso tener una banca, río, juez, árbitro o jugador que hace las veces de banca...
La clase que realiza esa labor, bien puedes llamarla juego.
Nota que el tablero es una instancia y si ha de ser servida a cada jugador, cada jugador tendrá una imagen (solo lectura) del tablero, porque quien realmente maneja el tablero es la clase 'juego'...

Cada jugador cuando el 'juego' le otorgue el turno, hara su jugada indicándoselo al 'juego', el uego verifica si su jugada es legal, hace el movimiento y verifica lo que proceda (puede desencadenar ciertos acontenimientos, según el tipo de juego que sea), luego que actualice el tablero, comunica al resto de jugadores la jugada realizada por qué jugador (por ejmplo, una banda pone el nombre en ella del jugador que tiene el turno) y qué acontenicmientos ha desmbocado (por ejemplo si es un juego de cartas, que ha tirado x carta sobre la mesa, si es un juego de apuestas, el monto de su apuesta... etc...

Tampoco te complique en exceso creando objetos... es bastante común que cuando un programador nobel empieza a entender los objetos, crea objetos para cada cosa, y en vez de tener un jardin delante d ela casa, directamente al abrir la puerta tienes el Amazonas... y al final hay un objeto 'cálcular' que a su vez contiene objetos sumar, restar,... que a su vez contienen objetos número... No. No atomices todo, sólo hasta el punto lógico de entender el proceso con fluidez. Que todo quede bien ubicado entre los objetos que 'naturalmente' surjen...

Un pequeño diagrama representando cada clase, los métodos que contiene y flechas dirigiendo (clases) entre si el flujo, te permiten tener a la vista la lógica de la comunicación. Amplía en prosa (comentarios), la descripcón de cada clase, lo que hace, los miembros que tiene... es común que pasado el tiempo si no lo dominas bien o no recuerdas todos, tengas dudas que en su día ya resolviste, pero que has olvidado, un pequeño comentario te ayuda a recordar enseguida ese detalle que parece que era o es complicado.
Siempre podrás cambiarlo, pero si antes de nada partes de un esuquema, te será más fácil seguirlo y decidir si tal o cual función debe pertenecer a está o aquella clase... y entonces verás que muchas de las dudas se responden con claridad aplastante la mayoría de las veces.

Te respondo sobre lo de pasar datos como de sólo lectura, porque la forma en que funcionan las constantes en C++ es muy peculiar, y si encima lo combinas con punteros o referencias, las reglas son complejas y pueden ser confusas y muy específicas de este lenguaje.

En general, si quieres que una función no pueda modificar los parámetros que recibe, los declaras como const. Si se trata de datos "grandes" como estructuras u objetos, lo conveniente es que sean referencias o punteros const (aunque en general deberías preferir las referencias). Sin embargo, en C++ si quieres poder tener objetos constantes de alguna clase, entonces hay que declarar todas las funciones miembro de esa clase que no modifican sus variables miembro (por ejemplo, los getters) como const. Ejemplo:

class Mapa
{
...
public:
	int getX () const;
	int getY () const;
...
};
 
int Mapa::getX () const
{
	return x;
}
// etc.

Además, las variables miembro const y/o referencia (que no sean static), se deben inicializar en la lista de inicializadores del constructor:

class Persona
{
private:
	const Mapa& map;
	int x, y;
 
public:
	Persona (const Mapa &m) ;
};
 
// Nota como se inicializa map
Persona::Persona (const Mapa& m) : map{m}
{
	x = 9;
	y = 18;
}

También podrías hacer eso, pero que sea referencia const. En cualquier caso, no olvides declarar como const las funciones miembro de Mapa que no modifican sus datos.

Las referencias siempre deben referirse (valga la redundancia) a algo, desde el momento de su creación, y por lo tanto se deben inicializar en su definición. Esto no es válido:

int& ref;

porque ¿a qué hace referencia ref? A nada. Está básicamente en el limbo, y eso no correcto. Esto sí:

int x;
int& ref = x;

Y algo similar ocurre con las constantes. En el caso de los constructores, las variables miembro son creadas antes de que el constructor se ejecute. El constructor simplemente les asigna valores. Por eso esto no sería válido:

Persona::Persona (const Mapa& m)
{
	/* Error: antes de haber llegado aqui (al cuerpo del constructor), ya se deberia
	haber creado la variable mapa, pero obviamente no hay nada a lo cual haga referencia
	(seria como en el ejemplo incorrecto que te puse al inicio de este mensaje) */
 
	/* Esta linea no estaria inicializando map (como te dije, eso sucede antes de ejecutar
	el constructor) sino simplemente intentando cambiar su valor. */
	map = m;
}

Para eso se deben usar las listas de inicializadores de miembros en los constructores:

Clase::Clase() : variable_miembro{valor_de_inicializacion}

Esto hace que "variable_miembro" se cree e inicialice con el valor indicado. Eso se ejecuta antes de llamar al constructor.

Nota, también se pueden usar paréntesis en lugar de llaves:

Persona::Persona (const Mapa& m) : map(m)

Aunque hay diferencia entre estas dos formas (paréntesis y llaves), de momento lo mejor es no complicarte y usar la que te guste más. No sé si ya estés leyendo algún manual de C++, pero si no, deberías conseguirte uno para aprender estos temas, ya que hay otras circunstancias en las que es recomendable (y a veces necesario) inicializar las variables de esta manera.

Por cierto, en mi anterior respuesta me limité a decirte cómo podías hacer lo que preguntabas en tu último mensaje, pero no necesariamente pienso que alguna de las dos formas que mencionaste (tener una referencia como miembro o pasarla a las funciones que la necesiten) sea la más correcta. Por lo que veo, aún tienes un nivel básico, por lo que, si de verdad necesitas que los personajes accedan al mapa, probablemente sea mejor la segunda opción: simplemente pasar referencias const a las funciones. Tener como variable miembro una referencia viene con ciertas complicaciones que sería mejor evitar mientras no tengas más experiencia.