Introducción a C++

1

Todo lo que aprenderás sobre C++

2

¿Qué es programar y por qué aprender C++?

Conceptos Generales de C++

3

La Historia de C++ y sus diferencias con C

Preparando el entorno de trabajo

4

Instalando Codeblocks

5

Pasos para instalar en mac

6

Ejecutando nuestro primer programa

7

¿Qué son las librerías STD? - Portada del Proyecto

Manejo de memoria

8

¿Qué es la memoria y tipos de datos?

9

Alojando variables en memoria

10

¿Cómo usar operadores?

11

¿Qué son los apuntadores?

12

Reto: Escribir un programa que calcule áreas.

Entrada de datos y funciones

13

¿Cómo introducir datos a nuestro programa?

14

¿Cómo usar condicionales?

15

Usando condicionales

16

¿Cómo encapsular código en funciones ?

17

¿Qué son los parámetros y como usarlos?

18

Reto: Juego narrativo implementando condicionales y entrada de datos.

Loops y arreglos

19

¿Qué son los arreglos?

20

¿Qué son los Loops?

21

Programando Loops

22

Loops , arreglos y arreglos bidimensionales

23

Dibujando el mapa de nuestro juego con arreglos

24

Manipulando mi jugador con inputs en arreglos unidimensionales

25

Arreglos bidimensionales

26

Reto: Moviendo a mi personaje en mi arreglo bidimensional

Lectura de Archivos

27

Creando y leyendo un archivo externo

28

Leyendo archivos externos

29

Reto: En el mapa, crear punto de inicio y salida del jugador

Programación Orientada a Objetos

30

¿Qué es POO?

31

Definiendo una clase y creando sus instancias

32

Encapsulación

33

Abstracción

34

Herencia

35

Propiedades de clase en herencia

36

Polimorfismo

Finalizando nuestro proyecto

37

Creación de personaje y archivo de encabezado

38

Moviendo mi personaje con entrada de datos

39

Mapa

40

Interacción entre el personaje y el mapa

41

Paredes

42

Optimizando trazado de mapa

43

Colisiones

44

Creando nuestra portada de juego

45

Tesoro y victoria

46

Conclusiones

47

Proyecto final

Reto: En el mapa, crear punto de inicio y salida del jugador

29/47

Lectura

Nuestro siguiente reto es marcar en el mapa la posición del jugador, la manera de hacer esto es poniendo un número que represente donde va a aparecer al inicio, interpretarlo en la lectura del archivo y asignarlo a la posición del jugador para que funcione correctamente.
(Spoilers abajo)

Tips:

  1. Modificar el archivo del mapa asignando un símbolo único que represente donde va a aparecer el personaje (con un ‘3’ por ejemplo).
  2. Cargar las líneas del archivo usando fstream e iterar con un for carácter por carácter.
  3. Cuando se encuentra con el símbolo único ‘3’ guardar la posición de la fila y la columna ( la línea y el índice del for).
  4. Pasarle esos datos al jugador ya sea directamente con una referencia o leyendo los valores en variables de la clase.
  5. Dibujar el mapa.

Aportes 132

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Comparto mi código:

#include <iostream>
using namespace std;
#include <fstream>
#include <string>

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[][5])
{
    for(int i = 0; i < 5; i++)
    {
        for(int j = 0; j < 5; j++)
        {
            if(i == HeroPosX && j == HeroPosY)
            {
                cout << "H";
            }
            else
            {
                cout << GameMap[i][j];
            } 
        }
        cout << endl;
    }
}

void OpenFile(int *x, int *y, string *Name, char GameMap[][5])
{
    ifstream FileMap("Mapa.txt"); // abre el archivo
    string line;
    int renglon = 0;
    int row = 0;

    if(FileMap.is_open())
    {
        while(getline(FileMap, line))
        {
            if(renglon == 0)
                *Name = line; // Nombre de Jugador
            else
            {
                for(int i = 0; i < 5; i++)
                {
                    if(line[i] == 'H')
                    {
                        *x = row; // Guardar la posicion del jugador
                        *y = i;
                        GameMap[row][i] = '1';
                    }
                    else
                        GameMap[row][i] = line[i];
                }
                row++;
            }
            renglon++;
        }
        
        FileMap.close();
    }
    else
    {
        cout << "Error. No se pudo abrir el archivo." << endl;
    }
}

void SaveFile(int *x, int *y, string *Nombre, char GameMap[][5])
{
    ofstream FileMap("Mapa.txt"); // abre el archivo
    if(FileMap.is_open())
    {
        FileMap << *Nombre << endl;
        for(int i = 0; i < 5; i++)
        {
            for(int j = 0; j < 5; j++)
            {
                if(i == *x && j == *y)
                    FileMap << "H";
                else
                    FileMap << GameMap[i][j];
            
            }
            FileMap << endl;
        }
    }

    FileMap.close(); // cierra el archivo
}

int main()
{
    int HeroPosX;
    int HeroPosY;
    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5];
    string NamePlayer = "";

    OpenFile(&HeroPosX, &HeroPosY, &NamePlayer, GameMap);
    
    cout << "Bienvenido/a " << NamePlayer << endl;
    DrawMap(HeroPosX, HeroPosY, GameMap);

    cout << "Usa las teclas w (arriba), a (izquierda), d (derecha) y s (abajo)." << endl;
    cout << "Para salir, presiona p." << endl;
    while(isGameOver == false)
    {
        cin >> Input;
        
        switch (Input)
        {
            case 'd':
                if(HeroPosY < 4)
                    HeroPosY++;
                break;
            case 'a':
                if(HeroPosY > 0)
                    HeroPosY--;
                break;
            case 'w':
                if(HeroPosX > 0)
                    HeroPosX--;
                break;
            case 's':
                if(HeroPosX < 4)
                    HeroPosX++;
                break;
            case 'p':
                isGameOver = true;
                break;
            default:
                cout << "Opcion Invalida" << endl;
                break;
        }
        DrawMap(HeroPosX, HeroPosY, GameMap);
    }

    SaveFile(&HeroPosX, &HeroPosY, &NamePlayer, GameMap);

    return 0;
}

https://repl.it/@DaneliaSanchez/Mapa

Ay caray, caray, un reto difícil para su servidor, más que nada por la redacción del mismo aquí en esta sección. Sin embargo, después de leer aportaciones de los colegas e investigar, aquí está mi versión:

Bueno, no incluiré el código, mejor léanlo y véanlo funcionar aquí.

#include <iostream>
#include <fstream>

using namespace std;

void DrawMap(int PosicionHeroeX, int PosicionHeroeY,char mapaDraw[5][5])
{

ofstream gamemap("mapa.txt");

if(gamemap.is_open())
{
    for(int i=0; i<5; i++)
    {
        for(int j=0; j<5; j++){
            if(i!=PosicionHeroeY)
            {
                gamemap<<mapaDraw[j][i];
            }
            else
            {
                if(j!=PosicionHeroeX)
                {
                    gamemap<<mapaDraw[j][i];
                }
                else
                {
                    cout<<'H';
                }
            }
        }
        cout<<endl;
        gamemap<<endl;
    }
}
gamemap.close();

}

int main()
{

int PosicionHeroeX=0;
int PosicionHeroeY=0;

bool GameOver = false;

char Input = ' ';

char mapaDraw[5][5] =
{
    {'3',' ',' ',' ',' '},
    {' ',' ',' ',' ',' '},
    {' ',' ',' ',' ',' '},
    {' ',' ',' ',' ',' '},
    {' ',' ',' ',' ','3'}
};



DrawMap(PosicionHeroeX,PosicionHeroeY,mapaDraw);

ifstream gamemapRead("mapa.txt");
string line;

if(gamemapRead.is_open())
{   
    while(GameOver == false)
    {
        cin>>Input;
        if(Input == 'd')
        {
            PosicionHeroeX++;
        }
        else{
            if(Input == 'a')
            {
                PosicionHeroeX--;
            }
            else
            {
                if(Input=='w')
                {
                    PosicionHeroeY--;
                }
                else
                {
                    if(Input=='s')
                    {
                        PosicionHeroeY++;
                    }
                    else
                    {
                        if(Input=='p')
                        {
                            GameOver=true;
                        }
                    }

                }
            }
        }
        DrawMap(PosicionHeroeX,PosicionHeroeY,mapaDraw);
    }
}

return 0;

}

<code>
#include <iostream>
#include <fstream>

using namespace std;

//Contexto: Eres un pirata, cuyo viaje le lleva a explorar una gran isla, en busca de un tesoro legendario.

void DrawMap(int playerposX,int playerposY, char gameMap[6][6])
{
    for( int i = 0; i < 6; i++)
    {
        for(int f = 0; f < 6; f++)
        {
          if( f != playerposX)
          {
           cout << gameMap[f][i];
          }
          else
          {
           if(i != playerposY)
           {
               cout << gameMap[f][i];
           }
           else
           {
               cout <<"H";
           }
           }
         }
         cout << endl;
    }
}

int generateRandom(){
    return rand() % 3 + 3;}

int main()
{
    ofstream MyFile("GameData.txt");
    string playerName = "";
    int playerposX = 0;
    int playerposY = 0;
    bool isgameover = false;
    char mover = ' ';

    if(MyFile.is_open())
        {
        cout << "Introduce tu nombre: "<< endl;
        cin >> playerName;
        MyFile << "Ve por ese tesoro" << endl;
        MyFile << playerName;

        cout << "Hay que elegir un lugar para bajar el ancla, escoge uno de los 6 sectores (0-4)" << endl;
        cin >> playerposX;
        cout << "Bien, pero hara falta ser mas especifico, Apresurate (0-4)" << endl;
        cin >> playerposY;
        }

    MyFile.close();

    ifstream MyFileR("GameData.txt");
    string line;

    if(MyFileR.is_open())
    {
            while(getline(MyFileR, line))
            {
                cout << line << endl;
            }
    }
    else
    {
        cout << "Ha ocurrido un error al abrir el archivo, revisa tu antivirus";
    }
    char gameMap[6][6] =
    {
        {'.', '.', '~', '~', '-','-'},
        {'.', '.', '~', '~', '-','-'},
        {'.', '.', '~', '~', '-','-'},
        {'.', '.', '~', '~', '-','-'},
        {'.', '.', '~', '~', '-','-'},
        {'.', '.', '~', '~', '-','-'}

    };

    int treasureX = generateRandom();
    int treasureY = generateRandom();
    gameMap[treasureX][treasureY] = 'X';

    DrawMap(playerposX, playerposY, gameMap);


    while(isgameover == false)
{
    cout <<"\nEncuentra el tesoro, marcado con una X en el mapa " << endl;
    cin >> mover;
    switch (mover)
        {
        case'd':
            playerposX++;
            break;
        case'a':
            playerposX--;
            break;

        case'w':
            playerposY--;
            break;
        case's':
            playerposY++;
            break;

        case'p':
            isgameover = true;
            break;
        default:
            cout<<"No es momento de filosofar pirata"<<endl;
            break;
        }

    DrawMap(playerposX, playerposY, gameMap);


    if (playerposX < 0 || playerposX > 5 || playerposY < 0 || playerposY > 5)
        {
            cout<<"PERDISTE: Hemos perdido un gran camarada"<<endl;
            isgameover = true;
        }
    else if(playerposX == treasureX && playerposY == treasureY)
    {
            cout<<"GANASTE: Lo lograste, bajen las velas! "<<endl;
            isgameover = true;
    }
}

    return 0;
}

Pensé en crear una arreglo que guardara la coordenadas por cada iteración del ciclo while para evitar los condicionales que la función me regresara el arreglo. Sin embargo, C++ no regresa arreglos en las funciones a diferencia de otros lenguajes como Python.

Para poder llamar los valores de un arreglo desde otra función tenemos saber de los pointer y tener cuidado como hacemos llamadas indirectas a esos valores en memoria.

Aquí les dejo mi código:




Creo que lo hice de manera algo diferente a la sugerencia, pero igual salió UWU

#include <iostream>
#include <fstream>
#include <string.h>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5]){

    for(int j = 0; j < 5; j++){

        for(int i = 0; i < 5; i++){

            if(i != HeroPosX){

                cout << GameMap[j][i];

            }else{

                if(j != HeroPosY){

                   cout << GameMap[j][i];

                }else{

                    cout << 'H';

                }


            }


        }

        cout << endl;
    }

}

int main(){

    int HeroPosX = 1;
    int HeroPosY = 1;
    int renglon = 0;
    int lineI;
    string line;
    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5];
    ifstream FileRead("Game.txt");


    for(int i = 0; i < 5; i++){

        for(int j = 0; j < 5; j++){

            GameMap[i][j] = '1';

        }

    }

    if(FileRead.is_open()){

        while( getline(FileRead, line) ){

            lineI = stoi(line);

            switch(renglon){

                case 0:
                    HeroPosX = lineI;
                break;

                case 1:
                    HeroPosY = lineI;
                break;

                default:

                break;
            }

            renglon++;
        }

    }else;

    DrawMap(HeroPosX, HeroPosY, GameMap);
    ofstream FileWrite("Game.txt");

    while(isGameOver == false){

        cin >> Input;
        system("cls");

        switch(Input){

            case 'd':
                HeroPosX++;
            break;

            case 'a':
                HeroPosX--;
            break;

            case 'w':
                HeroPosY--;
            break;

            case 's':
                HeroPosY++;
            break;

            default:

                if(FileWrite.is_open()){

                    FileWrite << HeroPosX << endl;
                    FileWrite << HeroPosY << endl;
                    isGameOver = true;

                }else
                    cout << "Error, cierre la consola" << endl;

            break;

        }

        DrawMap(HeroPosX, HeroPosY, GameMap);

    }

    return 0;
}

Simple pero funciona!

#include <iostream>
#include <fstream>
#include <stdlib.h>


using namespace std;

void DrawMap(int HeroPosX,int HeroPosY, char Gamemap[5][5]){
    for (int i = 0; i < 5 ; i++)
    {
        for(int j = 0; j<5;j++)
        {
            if (j != HeroPosX)
            {
                cout << Gamemap[j][i];
            }
            else
            {
                if(i != HeroPosY)
                {
                    cout << Gamemap[j][i];
                }else
                {
                    cout  << 'H';
                }
            }
        }
        cout << endl;
    }

}

void save(int HeroPosX,int HeroPosY){
    ofstream saveGame("SaveMap.txt");
    if(saveGame.is_open())
    {
        saveGame << HeroPosX << endl;
        saveGame << HeroPosY << endl;
    }
    saveGame.close();
}

void open(int &saveX,int &saveY){
    ifstream loadGame("SaveMap.txt");
    string line;
    int cont = 0;
    if (loadGame.is_open()){
        while(getline(loadGame,line))
        {
            cont++;
            switch(cont){
            case 1:
                saveX = atoi(line.c_str());
                break;
            case 2:
                saveY= atoi(line.c_str());
                break;
            default:
                break;
            }
        }
    }
}


int main()
{

    int HeroPosX;
    int HeroPosY;
    int saveX;
    int saveY;
    int opcion;

    cout << "Eliga opcion: " << endl
         << "Cargar Juego=1" << endl
         << "Nuevo juego=2" << endl;

    cin >> opcion;

    if (opcion == 2)
    {
        HeroPosX = 0;
        HeroPosY = 0;
        ofstream saveGame("SaveMap.txt");

    }else if(opcion == 1)
    {
        open(saveX,saveY);
        HeroPosX=saveX;
        HeroPosY=saveY;
    }

    bool isGameOver = false;
    char Input = ' ';
    char Gamemap[5][5]=
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'}
    };

     DrawMap(HeroPosX,HeroPosY,Gamemap);

     while(isGameOver == false)
    {
        cin >> Input;

        if(Input == 'd'){
            HeroPosX +=1;
        }else if (Input == 'a'){
            HeroPosX -=1;
        }else if(Input == 'w')
        {
            HeroPosY -=1;
        }else if (Input == 's')
        {
            HeroPosY +=1;
        }else if(Input == 'g'){
            isGameOver = true;
            save(HeroPosX,HeroPosY);
        }
        DrawMap(HeroPosX,HeroPosY,Gamemap);
     }


    return 0;
}

Listo! Fue divertido este reto, empiezo a idearme ser desarrollador de videojuegos jajaj me gusto mucho 😄

#include <iostream>
#include <fstream>
#include <string>

using namespace std;
int main()
{
	char input = ' ';
	bool isGameOver = false;
	int heroPosX = 4;
	int heroPosY = 2;
	char gameMap[5][5] = 
	{ 
		{ '. ', '. ', '. ', '. ', '. ' },
		{ '. ', '. ', '. ', '. ', '. ' },
		{ '. ', '. ', '. ', '. ', '. ' },
		{ '. ', '. ', '. ', '. ', '. ' },
		{ '. ', '. ', '. ', '. ', '. ' }
	};

	cout << "Mueve al heroe sin salirte del mapa (SI SALES DEL MAPA PIERDES)" << endl;
	cout << ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::" << endl;
	cout << endl;

	do {
		ofstream mapFile("Mapa.txt");
		if (mapFile.is_open()) {
			for (int i = 0; i < 5; i++) {
				for (int j = 0; j < 5; j++) {
					if (j != heroPosX)
					{
						mapFile << gameMap[i][j] << ", ";
					}
					else {
						if (i != heroPosY) {
							mapFile << gameMap[i][j] << ", ";
						}
						else {
							mapFile << '3';
						}

					}
				}
				mapFile << endl;
			}
			mapFile << "Este es tu mapa, tu posicion actual es: " << endl;
			mapFile << "X = " << heroPosX << "  Y = " << heroPosY << endl;
		}
		mapFile.close();
		
		ifstream mapFileRead("Mapa.txt");
		string line = "";

		if (mapFileRead.is_open()) {
			while (getline(mapFileRead, line)) {
				int row = 0;
				for (int i = 0; i < 5; i++) {
					if (i == '3') {
						heroPosX = row;
						heroPosY = i;
					}
				}
				cout << line << endl;
				row++;
			}
		}

		cin >> input;

		if (input == 'd' || input == 'D') {
			heroPosX++;
		}
		else if (input == 'a' || input == 'A') {
			heroPosX--;
		}
		else if (input == 'w' || input == 'W') {
			heroPosY--;
		}
		else if (input == 's' || input == 'S') {
			heroPosY++;
		}

		if (heroPosX > 4 || heroPosX < 0) {
			cout << "GAME OVER";
			isGameOver = true;
		}
		if (heroPosY > 4 || heroPosY < 0) {
			cout << "GAME OVER";
			isGameOver = true;
		}
	} while (isGameOver == false); 

}

Reto

#include <iostream>
#include <fstream>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5])
{
    for(int c = 0; c < 5; c++)
    {
        for(int f = 0; f < 5; f++)
        {
            if(HeroPosX != f)
            {
                cout << GameMap[f][c];
            }
            else if(HeroPosY != c)
            {
                cout << GameMap[f][c];
            }
            else
            {
                cout << 'X';
            }
        }
        cout << endl;
    }
}

void SaveLastPlayerPos(int HeroPosX, int HeroPosY)
{
    ofstream UserFile("PlayerData.txt");
    if(UserFile.is_open())
    {
        UserFile << HeroPosX << endl;
        UserFile << HeroPosY << endl;
    }
    UserFile.close();
}

int main()
{
    int HeroPosX = 0;
    int HeroPosY = 0;
    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5] = {
        {'_','_','_','_','_'},
        {'_','_','_','_','_'},
        {'_','_','_','_','_'},
        {'_','_','_','_','_'},
        {'_','_','_','_','_'}
        };

    ifstream UserFileRead("PlayerData.txt");
    string line;
    int renglon = 0;

    if(UserFileRead.is_open())
    {
        while(getline(UserFileRead, line))
        {
            if(renglon == 0)
            {
                HeroPosX = stoi(line);
                renglon++;
            }
            else if(renglon == 1)
            {
                HeroPosY = stoi(line);
            }
        }
    }

    cout << ":::: Game Controls ::::" << endl;
    cout << "Up = 'w'" << endl;
    cout << "Down = 's'" << endl;
    cout << "Left = 'a'" << endl;
    cout << "Right = 'd'" << endl;
    cout << "Exit = 'p'\n" << endl;

    DrawMap(HeroPosX, HeroPosY, GameMap);

    while(isGameOver == false)
    {
        cin >> Input;

        if(Input == 'd')
        {
            HeroPosX++;
        }

        else if (Input == 'a')
        {
            HeroPosX--;
        }

        else if (Input == 'w')
        {
            HeroPosY--;
        }

        else if (Input == 's')
        {
            HeroPosY++;
        }

        else if(Input == 'p')
        {
            isGameOver = true;

        }

        DrawMap(HeroPosX, HeroPosY, GameMap);

        SaveLastPlayerPos(HeroPosX, HeroPosY);
    }

    return 0;
}

Esta es mi solución:
https://repl.it/@israelyance/Juego-C-Platzi

#include <iostream>
#include <fstream>

using namespace std;

void DrawMap(int PosX, int PosY, char Map[5][5]) {
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j <5; j++) {
            if (i != PosY) {
                cout << Map[j][i];
            } else if (j != PosX) {
                cout << Map[j][i];
            } else {
                cout << 'H';
            }
        }
        cout << endl;
    }
}

int main() {
    char GameMap[5][5] = {
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'}
    };
    ifstream MyReadFile("GameData.txt");
    string line1;
    string NameHero;
    int Renglon = 0;
    int HeroPosX = 0;
    int HeroPosY = 0;

    if (MyReadFile.is_open()) {
        while (getline(MyReadFile, line1)) {
            Renglon += 1;
            if (Renglon == 3) {
                NameHero = line1;
            }
            if (Renglon == 5) {
                HeroPosX = stoi(line1);
            }
            if (Renglon == 7) {
                HeroPosY = stoi(line1);
            }
        }
    }
    MyReadFile.close();

    if (Renglon < 3) {
        cout << "Introduce el nombre de tu héroe" << endl;
        cin >> NameHero;
    }

    cout << "Bienvenida a tu aventura: " << endl;
    cout << NameHero << endl;
    cout << "Tu posición actual es: " << endl;
    DrawMap(HeroPosX, HeroPosY, GameMap);

    bool isGameOver = false;
    char Input;

    cout << "Usa las teclas w (arriba), a (izquierda), d (derecha) y s (abajo)." << endl;
    cout << "Presiona cualquier otra tecla para salir" << endl;

    while (isGameOver == false) {
        cin >> Input;

        if (Input == 'd') {
            HeroPosX = HeroPosX + 1;
        } else if (Input == 'a') {
            HeroPosX = HeroPosX - 1;
        } else if (Input == 'w') {
            HeroPosY = HeroPosY - 1;
        } else if (Input == 's') {
            HeroPosY = HeroPosY + 1;
        } else {
            isGameOver = true;
        }

        DrawMap(HeroPosX, HeroPosY, GameMap);
    }

    ofstream MyFile("GameData.txt");

    if (MyFile.is_open()) {
        MyFile << "Hola Platzi" << endl;
        MyFile << "Mi nombre es:" << endl;
        MyFile << NameHero << endl;
        MyFile << "X" << endl;
        MyFile << HeroPosX << endl;
        MyFile << "Y" << endl;
        MyFile << HeroPosY << endl;
    } else {
        cout << "No logré abrir el archivo. Revisar el antivirus" << endl;
    }
    MyFile.close();

    cout << "Hasta Pronto" << endl;
    cout << "¡Te estaremos esperando!" << endl;

    return 0;
}

alguien por favor que me explique en si lo que hay que hacer ? no entiendo esa redacción casi , lo que he visto es que hay que hacer que cuando el jugador se salga del juego y vuelva entrar exista como una opcion de cargar la partida , es decir donde estaba el jugador antes de salirse del juego ?

versión 0.0 jajaja


#include <iostream>
#include <string>
#include <fstream>
#include <conio.h>

using namespace std;

//funcion para guardar los  datos
void GameGuard(int HeroPosX, int HeroPosY) {
	ofstream SaveGamex("GameWar.txt");
	if (SaveGamex.is_open())
	{
		SaveGamex << HeroPosX ;
		SaveGamex << HeroPosY;	}
	else {
		cout << "No se guardaron bien los datos" << endl;
	}

};

//funcion cargar mapa en pantalla
void GameScreen(char Mapa[5][5], int HeroPosX, int HeroPosY) {

	for (int Fila = 0; Fila < 5; Fila++)
	{
		cout << " " << endl;
		for (int Columna = 0; Columna < 5; Columna++)
		{
			if (Fila != HeroPosX) {
				cout << Mapa[Fila][Columna];

			}
			else
			{
				if (Columna != HeroPosY) {

					cout << Mapa[Fila][Columna];
				}
				else
				{
					cout << 'H';
				}

			}
		}
	}
	
};
//funcion para los controles de movimiento.
void Gamecontrols(char& HeroWalk, int& HeroPosX, int& HeroPosY, char Mapa[5][5]) {
	while (HeroWalk != 't')
	{
		cin >> HeroWalk;
		if (HeroWalk == 'a') {

			HeroPosY = HeroPosY - 1;
		}
		else if (HeroWalk == 'd')
		{
			HeroPosY = HeroPosY + 1;

		}
		else if (HeroWalk == 'w')
		{
			HeroPosX = HeroPosX - 1;
		}
		else if (HeroWalk == 's')
		{
			HeroPosX = HeroPosX + 1;
		}

		GameScreen(Mapa, HeroPosX, HeroPosY);
		GameGuard(HeroPosX, HeroPosY);

	}
	
	
};

//carga datos guardados de partidas
void LoadingGame(int& HeroPosX, int& HeroPosY) {
	
	string DatosGame;
	ifstream SaveGame("GameWar.txt");
	if (SaveGame.is_open())
	{
		getline(SaveGame, DatosGame);		
		HeroPosX = DatosGame[0] - '0';
		HeroPosY = DatosGame[1] - '0';
		cout << HeroPosX;
		cout << HeroPosY;		
	}
	else
	{
		cout << "Los datos guardados no se cargaron correctamente" << endl;

	}
	cout << " " << endl;

};




void Start()
{
	
	cout << " ######  ########    ###    ########  ########" << endl;
	cout << "##    ##    ##      ## ##   ##     ##    ##   " << endl;
	cout << "##          ##     ##   ##  ##     ##    ##   " << endl;
	cout << " ######     ##    ##     ## ########     ##   " << endl;
	cout << "      ##    ##    ######### ##   ##      ##   " << endl;
	cout << "##    ##    ##    ##     ## ##    ##     ##   " << endl;
	cout << " ######     ##    ##     ## ##     ##    ##   " << endl;


};

int main()
{
	cout << "   _////         _/       _//       _//_////////" << endl;
	cout << " _/    _//      _/ //     _/ _//   _///_//      " << endl;
	cout << "_//            _/  _//    _// _// _ _//_// " << endl;
	cout << "_//           _//   _//   _//  _//  _//_//////" << endl;
	cout << "_//   _////  _////// _//  _//   _/  _//_// " << endl;
	cout << " _//    _/  _//       _// _//       _//_// " << endl;
	cout << "  _/////   _//         _//_//       _//_////////" << endl;

	//variables
	char opcion = ' ';
	char HeroWalk= ' ';
	int HeroPosX = 0, HeroPosY = 0;
	char Mapa[5][5] = { //siempre sera nuestro mapa de inicio
		{'1','1','1','1','1'},
		{'1','1','1','1','1'},
		{'1','1','1','1','1'},
		{'1','1','1','1','1'},
		{'1','1','1','1','1'}


	};
	ifstream SaveGame("Game.txt");
	int FilaDatosGame = 0;
	string DatosGame = " ";
	

	//_______________________________
	cout << "(N)ueva Partida" << endl;
	cout << "(C)argar Ultima partida"<<endl;
	cout << "(S)alir" << endl;
	cin >> opcion;    
	switch (opcion)
	{
	case 'N':
	case 'n':
		
		Start();		
		cout << " " << endl;
		cout << "presione (a) para ir a la Izquierda" << endl;
		cout << "presione (d) para ir a la Derecha" << endl;
		cout << "presione (w) para ir a  Arriba" << endl;
		cout << "presione (s) para ir a Abajo" << endl;
		cout << "presione (t) para salir y guardar" << endl;
		GameScreen(Mapa, HeroPosX, HeroPosY);
		Gamecontrols (HeroWalk, HeroPosX, HeroPosY, Mapa);	
		
		break;
    
	case 'C':
	case 'c':

		
		LoadingGame(HeroPosX, HeroPosY);
	    HeroPosX = HeroPosX;
		HeroPosY = HeroPosY;
		Start();
		GameScreen(Mapa, HeroPosX, HeroPosY);
		Gamecontrols(HeroWalk, HeroPosX, HeroPosY, Mapa);
			
		break;

	case 'S':
	case 's':
		cout << "Gracias por jugar";
		break;

	default:
		cout << "Opcion no valida" << endl;
		break;
	}

	
	
	return 0;
}```
#include<iostream>
#include<fstream>
#include <string>

using namespace std;

// Declarando función de impreción de mapa
void GameMapOnli (int HeroPosX, int HeroPosY,char GameMap[5][7]);
void SaveHeroPos (int SaveHeroPosX, int SaveHeroPosY);

int main(){

int HeroPosX = 0;
int HeroPosY = 0;
bool GameOver = false;
char Move = ' ';
char ReturnLastPos = ' ';
char GameMap[5][7] = {
    {'1','1','1','1','1','1','1'},
    {'1','1','1','1','1','1','1'},
    {'1','1','1','1','1','1','1'},
    {'1','1','1','1','1','1','1'},
    {'1','1','1','1','1','1','1'},
    };



cout << "Derecha = c" << endl;
cout << "Izquierda = z" << endl;
cout << "arriba = d" << endl;
cout << "Abajo = x" << endl;
cout << "Guardar partida = s" << endl;
cout << "Game Over = q" << endl << endl;


cout << "¿Desea continuar con la ANTERIOR partida? : s / n " << endl ;
cin >> ReturnLastPos;


if (ReturnLastPos == 's'){

    ifstream ReadSaveHeroPos ("SaveHeroPos.txt");
    string Linea = "";
    int Renglon = 0;

    if (ReadSaveHeroPos.is_open()){

        while(getline(ReadSaveHeroPos, Linea )){

            if (Renglon == 0)
            {
            HeroPosX = stoi(Linea);
            Renglon = Renglon + 1;
                cout <<"Posicion guardada en X=  " << HeroPosX << endl;
            }
            else if (Renglon == 1)
            {
            HeroPosY = stoi(Linea);
            Renglon = Renglon + 1;
                cout <<"Posicion guardada en Y=  " << HeroPosY << endl;
            }
        }
    GameMapOnli (HeroPosX, HeroPosY,GameMap);
    }
}

else if (ReturnLastPos == 'n'){

    GameMapOnli (HeroPosX, HeroPosY,GameMap);

}

while (GameOver == false){
            cin >> Move;
            if (Move == 'c'){
            HeroPosX = HeroPosX + 1;
            }
            else if (Move == 'z'){
            HeroPosX = HeroPosX - 1;
            }
            else if (Move == 'x'){
            HeroPosY = HeroPosY + 1;
            }
            else if (Move == 'd'){
            HeroPosY = HeroPosY - 1;
            }
            else if (Move == 'q'){
                GameOver = true;
            }
            else if (Move == 's'){
                SaveHeroPos (HeroPosX, HeroPosY);
            }

GameMapOnli (HeroPosX, HeroPosY,GameMap);//Llamado de funcione para IMPRIMIR

}
    cout<<"Game Over";
    return 0;
}

void GameMapOnli (int HeroPosX, int HeroPosY,char GameMap[5][7]){

	for (int i = 0; i < 5; i++){

            for (int p = 0; p < 7; p++){

                if (i != HeroPosY){

                    cout<<GameMap[i][p];}

                else if(p != HeroPosX)
                    cout<<GameMap[i][p];

                else{cout<<'H';}
            }
            cout<<endl;
    }
}

void SaveHeroPos (int SaveHeroPosX, int SaveHeroPosY){


ofstream FirsHeroPos ("SaveHeroPos.txt");

if (FirsHeroPos.is_open()){

    FirsHeroPos << SaveHeroPosX << endl;
    FirsHeroPos << SaveHeroPosY;

}
else {

    cout << "Error. No se abrio el archivo" << endl;

}

FirsHeroPos.close();

}

por aqui les dejo mi pequeño aporte, le agregue un menu para acceder a una nueva partida, controles y cargar el juego

#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

//mapa, posicion del hero
    char input = ' ';
    char moveHero = ' ';
    bool isGameOver = false;
    int heroPosX = 9;
    int heroPosY = 9;
    char gameMap[10][20]
    {
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
        {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'}
    };

//dibujo del mapa
void drawingMap(int heroPosX, int heroPosY, char gameMap[5][20])
{
     for(int i = 0; i < 10; i++)
    {
        for(int x = 0; x < 20; x++)
        {

            if( i != heroPosY)
            {
                cout << gameMap[i][x];
            }
            else
            {
                if(x != heroPosX)
                {
                    cout << gameMap[i][x];
                }
                else
                {
                    cout << 'H';
                }
            }
        }
        cout << endl;
    }

};

// guardado del mapa
void saveGame(int heroPosX, int heroPosY)
{
    ofstream saveGameWrite("save.txt");
    int positionX = heroPosX;
    int positionY = heroPosY;

    if(saveGameWrite.is_open())
    {
        saveGameWrite << positionX << endl;
        saveGameWrite << positionY << endl;
    }
    else
    {
        cout << "no puede abrir el archivo" << endl;
    }

    saveGameWrite.close();
};

//movimiento del hero
void movimiento()
{
    char moveHero = ' ';
    while(isGameOver == false)
    {
        cin >> moveHero;
        switch(moveHero)
        {
            case 'w':
                heroPosY = heroPosY - 1;
                drawingMap(heroPosX, heroPosY, gameMap);
            break;

            case 's':
                heroPosY = heroPosY + 1;
                drawingMap(heroPosX, heroPosY, gameMap);
            break;

            case 'd':
                heroPosX = heroPosX + 1;
                drawingMap(heroPosX, heroPosY, gameMap);
            break;

            case 'a':
                heroPosX = heroPosX - 1;
                drawingMap(heroPosX, heroPosY, gameMap);
            break;

            default:
                saveGame(heroPosX, heroPosY);
                isGameOver = true;
            break;
        }

    }
};

void cargarGame(char z = ' ' )
{
    ifstream loadGame("save.txt");
    string line;
    int lineas = 0;
    bool dibujar = true;
         if(loadGame.is_open())
        {

            while(getline(loadGame, line))
            {

                lineas++;

                    if( lineas == 1)
                    {

                        stringstream geek(line);
                        geek >> heroPosX;

                    }

                    else
                    {
                        stringstream x(line);
                        x >> heroPosY;
                        dibujar = false;
                    }

                    if(dibujar == false)
                    {
                        drawingMap(heroPosX, heroPosY, gameMap);
                        movimiento();
                    }
                }

        }
};

//reglas del juego
void reglas(char x = ' ')
{

    if(x == 'q')
    {
        char empezar = 's';
        cout << "w para mover arriba" << endl;
        cout << "s para mover abajo" << endl;
        cout << "a para mover a la izquierda" << endl;
        cout << "d para mover a la derecha" << endl;
        cout << "estas listo para empezar (s/n)" << endl;
    }
};

// para iniciar el juego
void empezarGame(char go = ' ' )
{
     char gameMap[10][20]
    {
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'},
            {'|', '-', '-', '-', '-', '-', '-', '-', '-', '*','*', '-', '-', '-', '-', '-', '-', '-', '-', '|'}
    };

    if( go == 's')
    {
            cout << "que empieze el juego" << endl;
            drawingMap(heroPosX, heroPosY, gameMap);
    }

    else
    {
        cout << "fin de juego" << endl;

    }
}

//menu
void menu()
{
    cout << "bienvenido al game" << endl;
    cout << "empezar juego (s/n)" << endl;
    cout << "controles (q)" << endl;
    cout << "cargar partida guardad (y/t)" << endl;
}
int main()
{

    menu();
    //comandos del menu
    char menu = ' ';
    cin >> menu;
    switch (menu)
    {
        case 's':
            empezarGame('s');
            movimiento();
        break;

        case 'n':
            return 1;
        break;

        case 'q':
            reglas('q');
            cin >> input;
            empezarGame(input);
            movimiento();
        break;

        case 'y':
            cargarGame();
        break;
    }

    return 0;
}```

Les dejo acá mi solución:

Le agregué un par de detalles: realiza un realiza una limpieza de pantalla para que no imprima a cada rato el mapa y se genere un efecto de movimiento más realista, además como control, indica las coordenadas actual del jugador.

solo un detalle si alguien me puede ayudar: Al limpiar la pantalla, imprime un “0” y no logro hacer que no lo muestre

aquí mi código:

#include <iostream>
#include <stdlib.h>
#include <fstream>


using namespace std;
void drawMap(int heroPosX, int heroPosY, char gameMap[5][5])
{
   cout << system("cls");
   for(int i = 0; i < 5; i++) //for columnas
    {

        for(int p = 0; p < 5; p++) //for filas
        {
                if(i != heroPosY)
                    {
                        cout << gameMap[p][i];

                    }else
                    {
                        if(p != heroPosX)
                        {

                            cout << gameMap[p][i];
                        } else
                        {
                            cout << 'H';
                        }

                    }
        }
        cout << endl;

    }
        cout << "La posicion actual es: ";
        cout << heroPosX;
        cout << " ";
        cout << heroPosY << endl;
        cout << "Pulse la tecla P para finalizar " << endl;
}

void saveGame(int heroPosX, int heroPosY, char gameMap[5][5])
{
    ofstream myFile("position.txt");
    if(myFile.is_open())
        {
            for(int i = 0; i<5; i++)
    {
        for(int j = 0; j<5; j++)
        {
           if(i != heroPosY)
           {
             myFile << gameMap[j][i];
           }
           else
           {
               if(j != heroPosX)
               {
                   myFile << gameMap[j][i];
               }
               else
               {
                   myFile << 'H';
               }
           }
        }
        myFile << endl;
    }
        }
    myFile.close();
}

int main()
{

    int heroPosX = 1;
    int heroPosY = 1;

    ifstream myFileRead("position.txt");
    string line = " ";
    int reglon = 0;
    bool isGameOver = false;
    char input = ' ';
        char gameMap[5][5] =
    {
        {'*', '*','*','*','*'},
        {'*', '*','*','*','*'},
        {'*', '*','*','*','*'},
        {'*', '*','*','*','*'},
        {'*', '*','*','*','*'}
    };


    if(myFileRead.is_open())
    {
        while(getline(myFileRead, line))
        {
            for(size_t i = 0; i<5; i++)
            {
                if(line[i] != '0')
                {
                   heroPosX = i;
                   heroPosY = reglon;
                }
            }
            reglon++;
         }
         drawMap(heroPosX, heroPosY, gameMap);
    }
    else
    {
        drawMap(heroPosX, heroPosY, gameMap);
    }

    while(isGameOver == false)
    {
            cin >> input;

            if(input == 'd')
                {
                heroPosX++;
                }else if(input == 'a')
                    {
                    heroPosX--;
                    } else if(input == 'w')
                        {
                        heroPosY--;
                        }else if(input == 's')
                            {
                            heroPosY++;
                            }
                            else if (input == 'p')
                                {
                                isGameOver = true;
                                }
            drawMap(heroPosX, heroPosY, gameMap);
    }
    saveGame(heroPosX, heroPosY, gameMap);

    return 0;
}```
#include <iostream>
#include <fstream>

using namespace std;

void draw_map(int HeroPos_x, int HeroPos_y, string maze[21]){
    for(int f=0; f<21; f++){
        for(int c=0; c<51; c++){
            if(c != HeroPos_x || f != HeroPos_y){
                cout << maze[f][c];
            }else{
                cout << 'X';
            }
        }
        cout << endl;
    }
}

int main()
{
    ifstream MyMap("maze.txt");
    string maze[21];

    if(MyMap.is_open()){
        for(int f=0; f<21; f++){
            getline(MyMap,maze[f]);
        }
    }else{
        cout << "Maze file could not be read" << endl;
    }

    MyMap.close();

    int HeroPos_x;
    int HeroPos_y;
    char input = ' ';

    for(int f=0; f<21; f++){
        for(int c=0; c<51; c++){
            if(maze[f][c] == 'O'){
                HeroPos_x = c;
                HeroPos_y = f;
            }
        }
    }

    while(input != 'x'){
        draw_map(HeroPos_x, HeroPos_y, maze);
        cin >> input;
        switch(input){
        case 'w':
            HeroPos_y--;
            break;
        case 'a':
            HeroPos_x--;
            break;
        case 's':
            HeroPos_y++;
            break;
        case 'd':
            HeroPos_x++;
        default:
            break;
        }
    }

    return 0;
}

Mi Mapa:

    |                                              
    V                                              
HHH O HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
HHH   HHH                  HHH                  HHH
HHH   HHH   HHHHHHHHHHHH   HHH   HHHHHHHHHHHH   HHH
HHH   HHH      HHH   HHH   HHH   HHH            HHH
HHH   HHHHHH   HHH   HHH   HHH   HHH   HHH   HHHHHH
HHH            HHH   HHH         HHH   HHH      HHH
HHH   HHHHHHHHHHHH   HHHHHHHHHHHHHHH   HHHHHH   HHH
HHH                     HHH               HHH   HHH
HHHHHHHHHHHHHHHHHHHHH   HHHHHHHHHHHHHHHHHHHHH   HHH
HHH               HHH   HHH                     HHH
HHH   HHHHHHHHH   HHHHHHHHH   HHHHHHHHHHHHHHHHHHHHH
HHH         HHH               HHH               HHH
HHHHHHHHH   HHHHHHHHHHHHHHHHHHHHH   HHHHHHHHH   HHH
HHH   HHH                     HHH   HHH         HHH
HHH   HHHHHHHHHHHHHHHHHHHHH   HHH   HHH   HHHHHHHHH
HHH                                 HHH         HHH
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH W HHH
                                              |    
                                              V    ```

Aunque me tomo varios dias, preferí no avanzar de clase hasta completar el reto, se siente muy bien cuando lo logras c:, mi única molestia es que sigo usando punteros sin entenderlos al 100%, es un mal que me persigue desde antaño…

#include <iostream>
#include <fstream>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5]){

    for(int i = 0; i < 5; i++){
        for(int p = 0; p < 5; p++){
            if (i == HeroPosY && p == HeroPosX){
               cout << 'H';
            }
            else{
                cout << GameMap[i][p];
            }
        }
        cout << endl;
    }
}

void posFinal(int HeroPosX, int HeroPosY, char GameMap[5][5]){
    ofstream pFinal ("Posicion.txt");

    if(pFinal.is_open()){
        for(int i = 0; i < 5; i++){
            for(int p = 0; p < 5; p++){
                if (i == HeroPosY && p == HeroPosX){
                    pFinal << 'H';
                }
                else{
                    pFinal << GameMap[i][p];
                }
            }
            pFinal << endl;
        }
    }
    else{
        cout << "\nNo se encontro el archivo..." << endl;
    }

    pFinal.close();
}

void PosInicial(int *pX, int *pY){
    ifstream checkPoint("Posicion.txt");

    string line;
    string str = "H"; // variable auxiliar para .find & .npos

    int renglon = 0;

    if(checkPoint.is_open()){
        while(getline(checkPoint, line) ){

            // .find devuelve un valor constante cuando no encuentra la cadena que es igual a .npos
            // entonces si estos son diferentes asigno el valor del renglon donde si se encontro la cadena
               if(line.find(str) != line.npos){
                   *pX = line.find(str); // .find devuelve la posicion del inicio de una cadena
                   *pY = renglon;
                }
               renglon++;
        }
    }
    else{
        cout << "\nEl archivo no puede ser leido..." << endl;
    }

    checkPoint.close();
}

int main(){

    bool isGameOver = false;
    char input = ' ';
    int HeroPosX = 1;
    int HeroPosY = 1;

    // punteros para poder cambiar la los valores de X y Y
    // en la funcion que lee la posicion inicial
    int *pX = &HeroPosX;
    int *pY = &HeroPosY;

    PosInicial(pX, pY);

    char GameMap[5][5] =
  {
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'}
  };

    while(isGameOver == false){

        DrawMap(HeroPosX, HeroPosY, GameMap);
        cin >> input;

        switch(input){
            case 'a':
                HeroPosX = HeroPosX - 1;
                //DrawMap(0, 1, GameMap);
                break;
            case 's':
                HeroPosY = HeroPosY + 1;
                break;
            case 'd':
                HeroPosX = HeroPosX + 1;
                break;
            case 'w':
                HeroPosY = HeroPosY - 1;
                break;
            case 'p':
                posFinal(HeroPosX, HeroPosY, GameMap);
                isGameOver = true;
                break;
        }
    }
}```

Lo logré

#include <iostream>
#include <array>
#include <fstream>
#include <sstream>
#define MAXSIZEMAP 5

using namespace std;

void drawMap(int heroPosX, int heroPosY, const array<array<char,MAXSIZEMAP>,MAXSIZEMAP>&gameMap);
void savePos(int heroPosX, int heroPosY);
void chargePos(int &heroPosX, int &heroPosY);
int extracNumber(string str);

int main (){
	array<array<char,MAXSIZEMAP>,MAXSIZEMAP> gameMap = 
	{{
	{'1', '1', '1', '1', '1'},
	{'1', '1', '1', '1', '1'},
	{'1', '1', '1', '1', '1'},
	{'1', '1', '1', '1', '1'},
	{'1', '1', '1', '1', '1'}
	}};

	char input = 0;
	bool isGameOver = false;
	int heroPosX = 0, heroPosY = 0;
	
	chargePos(heroPosX,heroPosY);

	do
	{
	drawMap(heroPosX,heroPosY,gameMap);

	cin >> input;

	switch (input)
	{
	case 'a':
		heroPosX--;
		break;
	case 'd':
		heroPosX++;
		break;
	case 'w':
		heroPosY--;
		break;
	case 's':
		heroPosY++;
		break;
	case 'p':
		isGameOver = true;
		break;
	
	default:
		cout << "Please type a right command" << endl;
		cout << "a-> move left, d-> move right, p-> exit" << endl;
		break;
	}

	} while (!isGameOver);

	savePos(heroPosX,heroPosY);

	return 0;

}

void drawMap(int heroPosX, int heroPosY, const array<array<char,MAXSIZEMAP>,MAXSIZEMAP>&gameMap){

		for(int y=0; y<gameMap.size();y++){
			for (int x = 0; x < gameMap[y].size(); x++)
			{
				if (heroPosX==x && heroPosY == y)
				{
					cout << "H";
				} else
				{
					cout<<gameMap[x][y];
				}
			}
			cout << endl;
	}
}

void savePos(int heroPosX, int heroPosY){
	ofstream writeFile("gamefile.txt");

	if (writeFile.is_open())
	{
		writeFile << "Hero Position in X: " << heroPosX << endl;
		writeFile << "Hero Position in Y: " << heroPosY << endl;
	} else
	{
		cout << "An error have ocurred!" << endl;
	}
	
	writeFile.close();
}

void chargePos(int &heroPosX, int &heroPosY){
	ifstream readfile("gamefile.txt");
	string buffer;

	if (readfile.is_open())
	{
		getline(readfile,buffer);
		heroPosX = extracNumber(buffer);
		getline(readfile,buffer);
		heroPosY = extracNumber(buffer);
	} else
	{
		cout << "An error have ocurred!" << endl;
		heroPosX = 0;
		heroPosY = 0;
	}
	
}

int extracNumber(string str){
	stringstream buffer;
	buffer << str;
	string temp;
	int found;

	while (!buffer.eof())
	{
		buffer >> temp;
		if (stringstream(temp)>>found)
		{
			cout << found << endl;
			break;
		}
	}
	return found;
}

CHALLENGE COMPLETED!

#include <iostream>
#include <fstream>


// global var
int hero_pos_x = 1;
int hero_pos_y = 1;
bool game_over = false;

void draw_map(int hero_pos_x, int hero_pos_y, char map_g[5][5])
{
    for (int i = 0; i < 5; ++i)
    {
        for (int l = 0; l < 5; ++l)
        {
            if (i != hero_pos_y | l != hero_pos_x)
            {
                std::cout << map_g[l][i];
            }
            else
            {
                std::cout << 'H';
            }
        }
        std::cout << std::endl;
    }
}


void read_inf(){
  std::ifstream read_file("data.txt"); 
  std::string line;
  if(read_file.is_open()){
    for(int i = 1; i < 2 ; ++i){
      if(i == 1){
        getline(read_file, line);
        hero_pos_x = std::stoi(line);
      }else if(i == 2){
        getline(read_file, line);
        hero_pos_y = std::stoi(line);
      }
    }
  }
}


void write_inf(std::string data){
  std::ofstream write_file("data.txt");
  if(write_file.is_open()){
    write_file << data << std::endl;
  }
}


void char_move()
{
    char input = ' ';
    std::cin >> input;
    switch (input)
    {
        case 's':
            if(hero_pos_y < 4){
                ++hero_pos_y;
            }
            break;
        case 'w':
            if(hero_pos_y > 1){
                --hero_pos_y;
            }
            break;
        case 'd':
            if(hero_pos_x < 4){
                ++hero_pos_x;
            }
            break;
        case 'a':
            if(hero_pos_x > 1){
                --hero_pos_x;
            }
            break;
        case 'q':
            // Guardando en la primera liena la posision x
            write_inf(std::to_string(hero_pos_x));
            write_inf(std::to_string(hero_pos_y));
            game_over = true;
            break;
    };
}

int main()
{
    char map_g[5][5] = {{'.', '.', '.', '.', '.'},
                        {'.', ' ', ' ', ' ', '.'},
                        {'.', ' ', ' ', ' ', '.'},
                        {'.', ' ', ' ', ' ', '.'},
                        {'.', '.', '.', '.', '.'}};


    read_inf();
    while (!game_over)
    {
        draw_map(hero_pos_x, hero_pos_y, map_g);
        char_move();
    }

    return 0;
}

Si en dado caso quieren transformar la línea que obtenemos con getline la cual es un string, a un entero(int) y colocarlo en otra variable, primero extraigan las librerías <sstream> y <string> y guiense con el ejemplo. Esta es una forma de hacerlo.

#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main()
{
    string line = "12";
    int HeroLocationX = 0;
    
    istringstream(locationX) >> HeroLocationX;
}

Les comparto mi código compañeros, espero todo su feedback, gracias de antemano.

#include <iostream>
#include <fstream>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5])
{
    ofstream PositionPlayerFile ("GamePosition.txt");
    if(PositionPlayerFile.is_open())
    {
         for(int i = 0; i < 5; i++)
        {
            for(int j = 0; j < 5; j++)
            {
                if (i != HeroPosY)
                {
                    PositionPlayerFile << GameMap[j][i];
                }
                else
                {
                    if (j != HeroPosX)
                    {
                        PositionPlayerFile << GameMap[j][i];
                    }
                    else
                    {
                        PositionPlayerFile << '3';
                    }
                }
            }

    // Necesitamos un salto de línea para diferenciar
    // las filas de las columnas:
    PositionPlayerFile << endl;
        }

        PositionPlayerFile << "Este es tu mapa, tu posición actual es: " << endl;
        PositionPlayerFile << "x = " << HeroPosX << "y = " << HeroPosY << endl;
    }

    PositionPlayerFile.close();

    ifstream PositionPlayerFileRead ("GamePosition.txt");
    string line = "";


    if (PositionPlayerFileRead.is_open())
    {
        while(getline(PositionPlayerFileRead, line))
        {
            int row = 0;
            for(int i = 0; i < 5; i++)
            {
                if (i == '3')
                {
                    HeroPosX = row;
                    HeroPosY = i;
                }
            }

            cout << line << endl;
            row ++;
        }
    }
    else
    {
        cout << "No consigo abrir el archivo, revisa el antivirus" << endl;
    }


}

int main()
{
  // ...

  int HeroPosX = 1;
  int HeroPosY = 1;
  char GameMap[5][5] =
  {
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
  };


    char input = ' ';
    bool isGameOver = false;

    DrawMap(HeroPosX, HeroPosY, GameMap);

    while (isGameOver != true)
    {
        cin >> input;
        switch(input)
        {
            case 'd':
                if (HeroPosX < 4 && HeroPosX >= 1)
                {
                    HeroPosX++;
                }else{
                    cout << "Game over"  << endl;
                    isGameOver = true;
                }
            break;

            case 'a':
                if (HeroPosX < 4 && HeroPosX >= 1)
                {
                    HeroPosX--;
                }else{
                    cout << "Game over"  << endl;
                    isGameOver = true;
                }
            break;

            case 'w':
                if (HeroPosY < 4 && HeroPosY >= 1)
                {
                    HeroPosY--;
                }else{
                    cout << "Game over"  << endl;
                    isGameOver = true;
                }

            break;

            case 's':
                if(HeroPosY < 4 && HeroPosY >= 1)
                {
                    HeroPosY++;
                }else{
                    cout << "Game over"  << endl;
                    isGameOver = true;
                }
            break;
            case 'p':
                {
                    isGameOver = true;
                }
            break;
            default:
                cout << "W -> arriba S -> abajo D -> derecha A-> izquierda" << endl;
            break;
        }

        DrawMap(HeroPosX, HeroPosY, GameMap);
    }



    return 0;
  // ...
}

😎

Mi código

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

//: posicion predeterminada 
int heroPosX = 0;
int heroPosY = 0;

void saveGameWrite(int heroPosX, int heroPosY) {
    ofstream saveGame("saveGame.txt");

    if (saveGame.is_open()) {
        cout << "leyendo archivo ..." << endl;

        //? construccion de saveGame
        saveGame << "Player: Initial Position XY" << endl;
        saveGame << heroPosX << endl;
        saveGame << heroPosY << endl;
        cout << "archivo leido y actualizado correctamente." << endl;
    };

    saveGame.close();
};

void saveGameLoad() {
    ifstream saveGameRead("saveGame.txt");
    string line;
    char posValue[1];
    int textLine = 0;

    if (saveGameRead.is_open()) {
        cout << "Recuperando Coordenadas Guardadas..." << endl << endl;
        while (getline(saveGameRead, line)) {
            if (textLine == 1) {
                posValue[0] = line[0];
                heroPosX = atoi(posValue);
                cout << "Coordenada X: " << heroPosX + 1 << endl;
            };
            if (textLine == 2) {
                posValue[0] = line[0];
                heroPosY = atoi(posValue);
                cout << "Coordenada Y: " << heroPosY + 1 << endl;
            };

            textLine++;
        };
    }
    else {
        cout << "Notice: No se ha encontrado ninguna partida guardada..." << endl;
        cout << "Iniciando nueva partida" << endl;
    };

    cout << endl;

    saveGameRead.close();
};

void drawMap(int heroPosX, int heroPosY, char gameMap[10][10]) {
    //? f: filas - c: columnas
    for (int f = 0; f < 10; f++) {
        for (int c = 0; c < 10; c++) {
            if (f != heroPosY) {
                cout << gameMap[f][c];
            }
            else {
                if (c != heroPosX) {
                    cout << gameMap[f][c];
                }
                else {
                    cout << 'H';
                };
            };
        };

        cout << endl;

    };
    
    //cout << endl;
};

int main()
{
    cout << "MAPA - JUEGO!\n";

    saveGameLoad();

    bool isGameOver = false;
    char input = ' ';
    char gameMap[10][10] = {
        { '1','1','1','1','1','1','1','1','1','1' },
        { '1','1','1','1','1','1','1','1','1','1' },
        { '1','1','1','1','1','1','1','1','1','1' },
        { '1','1','1','1','1','1','1','1','1','1' },
        { '1','1','1','1','1','1','1','1','1','1' },
        { '1','1','1','1','1','1','1','1','1','1' },
        { '1','1','1','1','1','1','1','1','1','1' },
        { '1','1','1','1','1','1','1','1','1','1' },
        { '1','1','1','1','1','1','1','1','1','1' },
        { '1','1','1','1','1','1','1','1','1','1' }
    };

    drawMap( heroPosX, heroPosY, gameMap );

    while (!isGameOver) {

        cin >> input;

        if (input == 'd' && heroPosX < 9) {
            heroPosX += 1;
        }
        else if (input == 'a' && heroPosX > 0) {
            heroPosX -= 1;
        }
        else if (input == 'w' && heroPosY > 0) {
            heroPosY -= 1;
        }
        else if (input == 's' && heroPosY < 9) {
            heroPosY += 1;
        }
        else if (input == 'x') {
            cout << "Coordenadas Actuales: " << endl;
            cout << "X: " << heroPosX + 1 << endl;
            cout << "Y: " << heroPosY + 1 << endl;
            saveGameWrite(heroPosX, heroPosY);
            cout << "Tus coordenadas han sido guardadas" << endl << endl;
            isGameOver = true;
        };

        drawMap( heroPosX, heroPosY, gameMap );
    };

    cout << endl; // rotura de linea

    system("pause");
    return 0;
}

Quizás les pueda servir:

#include <iostream>
#include <fstream>

using namespace std;

void WARGameMap(char Gamemap[5][5],int X_HeroPos,int Y_HeroPos, string File){
    // Escritura en el documento cada vez que se ejecuta, se actualiza el mapa y no guarda movimientos
    ofstream MyFile(File);

    if(MyFile.is_open()){
        for(int i = 0; i < 5; i++){
            for(int j = 0; j < 5; j++){
                if(j != X_HeroPos){
                    MyFile << Gamemap[i][j];
                }
                else{
                    if(i != Y_HeroPos){
                        MyFile << Gamemap[i][j];
                    }
                    else{
                        MyFile << '3';
                    }
                }
            }
            MyFile << endl;
        }
    }
    MyFile.close();

    // Lectura del documento
    ifstream MyReadFile(File);
    string line;
    int f = 0;
    if(MyReadFile.is_open()){
        while(getline(MyReadFile,line)){

            for(int c = 0; c<5; c++){
                if(line[c]=='3'){
                    cout << endl;
                    cout << "Tu Heroe se encuentra en la posicion:" << endl;
                    cout << "Columna = ";
                    cout << c << endl;
                    cout << "Fila = ";
                    cout << f << endl;
                }

            }
            f++;
        }
    }

}

void DrawMap(int HeroPos_X, int HeroPos_Y, char GameMap[5][5]){

    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++){
            if(j != HeroPos_X){
                cout << GameMap[i][j];
            }
            else{
                if(i != HeroPos_Y){
                    cout << GameMap[i][j];
                }
                else{
                    cout << 'H';
                }
            }
        }
        cout << endl;
    }

}

void WriteFile(string Mess, string File){
    ofstream MyFile(File,ios::app);

    if(MyFile.is_open()){
        MyFile << Mess << endl;
    }
    MyFile.close();
}

void SaveCoord(string File, int HeroPosX, int HeroPosY, int Movimiento){
    ofstream MyFile(File,ios::app);

    if(MyFile.is_open()){
        MyFile << "Coordenadas en Movimiento ";
        MyFile << Movimiento;
        MyFile << ":" << endl;
        MyFile << "X = ";
        MyFile << HeroPosX << endl;
        MyFile << "Y = ";
        MyFile << HeroPosY << endl;
    }
    MyFile.close();
}



int main(){

    char Input = ' ';
    bool isGameOver = false;
    int HeroPos_X = 0;
    int HeroPos_Y = 0;
    int mov = 1;
    string NamePlayer = " ";

    cout << "Ingresa el nombre de tu HEROE" << endl;
    cin >> NamePlayer;
    cout << "Ingresa la coordenada inicial en X" << endl;
    cin >> HeroPos_X;
    cout << "Ingresa la coordenada incial en Y" << endl;
    cin >> HeroPos_Y;

    char GameMap[5][5] = {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
    };

    WriteFile("Nombre del Heroe: ","CoordHero.txt");
    WriteFile(NamePlayer,"CoordHero.txt");
    SaveCoord("CoordHero.txt",HeroPos_X,HeroPos_Y,mov);
    DrawMap(HeroPos_X,HeroPos_Y,GameMap);
    WARGameMap(GameMap,HeroPos_X,HeroPos_Y,"GameMap.txt");


    while(isGameOver == false){
        cin >> Input;

        if(Input == 'd'){
            HeroPos_X = HeroPos_X + 1;
        }
        else if(Input == 'a'){
            HeroPos_X = HeroPos_X - 1;
        }
        else if(Input == 'w'){
            HeroPos_Y = HeroPos_Y - 1;
        }
        else if(Input == 's'){
            HeroPos_Y = HeroPos_Y + 1;
        }
        else if(Input == 'p'){
            isGameOver = true;
        }

        if(HeroPos_X == 5){
            HeroPos_X = 0;
        }
        else if(HeroPos_X == -1){
            HeroPos_X = 4;
        }

        if(HeroPos_Y == -1){
            HeroPos_Y = 4;
        }
        else if(HeroPos_Y == 5){
            HeroPos_Y = 0;
        }
        mov++;
        SaveCoord("CoordHero.txt",HeroPos_X,HeroPos_Y,mov);
        DrawMap(HeroPos_X,HeroPos_Y,GameMap);
        WARGameMap(GameMap,HeroPos_X,HeroPos_Y,"GameMap.txt");
    }
    return 0;
}
#include <iostream>
#include <fstream>
#include <stdlib.h>

using namespace std;

// data
int playerx;
int playery;
int savex;
int savey;
int option;
bool game = false;
char input = ' ';
char gmap[5][5] =
{
    {'+', '+', '+', '+', '+'},
    {'+', '+', '+', '+', '+'},
    {'+', '+', '+', '+', '+'},
    {'+', '+', '+', '+', '+'},
    {'+', '+', '+', '+', '+'}
};

// draw map
void dmap(int playerx, int playery, char gmap[5][5])
{
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (j != playerx)
            {
                cout << gmap[j][i];
            }
            else
            {
                if (i != playery)
                {
                    cout << gmap[j][i];
                }
                else
                {
                    cout << 'X';
                }
            }
        }
        cout << endl;
    }
}

// save data
void save(int playerx, int playery)
{
    ofstream saveGame("SaveMap.txt");
    if (saveGame.is_open())
    {
        saveGame << playerx << endl;
        saveGame << playery << endl;
    }
    saveGame.close();
}

void open(int &savex, int &savey)
{
    ifstream loadGame("SaveMap.txt");
    string line;
    int cont = 0;
    if (loadGame.is_open())
    {
        while (getline(loadGame, line))
        {
            cont++;
            switch (cont)
            {
            case 1:
                savex = atoi(line.c_str());
                break;
            case 2:
                savey = atoi(line.c_str());
                break;
            default:
                break;
            }
        }
    }
}

// maun function
int main()
{

    // main menu
    cout << "Welcome! keys: AWSD to move, P to save and exit. \n(1) Load saved game \n(2) New game" << endl;

    cin >> option;
    cout << endl;

    if (option == 2)
    {
        playerx = 0;
        playery = 0;
        ofstream saveGame("SaveMap.txt");
    }
    else if (option == 1)
    {
        open(savex, savey);
        playerx = savex;
        playery = savey;
    }

    // prints the map based on the saved data
    dmap(playerx, playery, gmap);

    while (game == false)
    {
        cin >> input;

        // movement keys
        if (input == 'd')
        {
            playerx += 1;
        }
        else if (input == 'a')
        {
            playerx -= 1;
        }
        else if (input == 'w')
        {
            playery -= 1;
        }
        else if (input == 's')
        {
            playery += 1;
        }
        else if (input == 'p')
        {
            cout << "Saving and leaving" << endl;
            // saving the game
            save(playerx, playery);
            // leaveing the game
            game = true;
        }
        else
        {
            cout << "Invalid key, closing the program..." << endl;
            save(playerx, playery);
            exit(0);
        }

        // fix position
        if (playerx >= 5 || playerx <= -1)
        {
            playerx = 0;
            playery = 0;
        }
        else if (playery >= 5 || playery <= -1)
        {
            playerx = 0;
            playery = 0;
        }

        // update map
        cout << endl;
        dmap(playerx, playery, gmap);
        cout << endl;
    }

    return 0;
}
#include <iostream>
#include <fstream>
#include <string>

using namespace std;
	int posx = 0;
	int posy = 0;
void establecerProgreso() {
	ifstream readFile("posicion del jugador.txt");

	if (readFile.is_open()) {
		readFile >> posx;
		readFile >> posy;
		
	}
	else {
		cout << "fail";
	}
}
void guardarProgreso(int x, int y) {
	ofstream file("posicion del jugador.txt");
	if (file.is_open()) {
		file << x << endl;
		file << y << endl;
		cout << "se guardo";
	}
	else {
		cout << "fail";
	} file.close();
}
int clamp(int value, int min, int max) {
	if (value <= min)
	{
		return min;
	}
	else if (value >= max)
	{
		return max;
	}
	else 
	{
		return value;
	}
}
void DrawMap(int posx,int posy) {
    char map[5][5];

	for (size_t y = 0; y < 5; y++)
	{
		for (size_t x = 0; x < 5 ;x ++)
		{
			if ((posx != x) || (posy != y))
			{
				cout << "1";
			}
			else {
				cout << "H";
			}
		}
		cout << endl;
	}
}


int main()
{
	
	establecerProgreso();

	bool isGameOver = false;
	char Jugada = ' ';

	//agregar el progreso

    ifstream myFileRead("posicion del jugador.txt");
	int renglon = 0;
	string line = " ";
	

	DrawMap(posx,posy);
	
	//controlles 
	while (!isGameOver)
	{
				cin >> Jugada;
		switch (Jugada)
	{
	case'a':
		posx--;
		break;
	case'd':
		posx++;
		break;
	case'w':
		posy--;
		break;
	case's':
		posy++;
		break;
	case'p':
		isGameOver = true;
		break;
	}
		posx = clamp(posx,0, 4);
		posy = clamp(posy, 0, 4);
		DrawMap(posx, posy);
		}
		//guarda los datos
	guardarProgreso(posx,posy);

	

}


Mi solución al reto, con sus respectivas entradas y salidas en el mapa, asi como el guardado de las coordenadas en un archivo.txt

#include <iostream>
#include <cstdlib>
#include <fstream>

using namespace std;

void DrawMap(int HeroIntX, int HeroIntY, char GameMap[5][5])
{
    system("cls");
    for (int i = 0; i < 5; i++)
    {
        for (int p = 0; p < 5; p++)
        {
            if (i != HeroIntY)
            {
                cout << GameMap[i][p];
            }
            else
            {
                if (p != HeroIntX)
                {
                    cout << GameMap[i][p];
                }
                else
                {
                    cout << 'H';
                }
            }
        }
        cout << endl;
    }
}

void SaveCoor(char GameMap[5][5])
{
    ofstream Coor("coordinates.txt");
    if (Coor.is_open())
    {
        for (int i = 0; i < 5; i++)
        {
            for (int p = 0; p < 5; p++)
            {
                if (GameMap[i][p] == 'I')
                {
                    Coor << "INPUT" << endl;
                    Coor << i << endl;
                    Coor << p << endl;
                }
                if (GameMap[i][p] == 'O')
                {
                    Coor << "OUTPUT" << endl;
                    Coor << i << endl;
                    Coor << p << endl;
                }
            }
        }
    }
    Coor.close();
}

void ReturnCoor(int &HeroIntX, int &HeroIntY, int &HeroOutX, int &HeroOutY)
{
    ifstream Coor("coordinates.txt");
    string line;
    int Rinput = 0;
    int Routput = 0;

    if (Coor.is_open())
    {
        while (getline(Coor, line))
        {
            if (line == "INPUT")
            {
                Rinput++;
                continue;
            }
            if (line == "OUTPUT")
            {
                Routput++;
                continue;
            }

            if (Rinput == 2)
            {
                HeroIntX = stoi(line);
                Rinput = 0;
            }
            else if (Rinput == 1)
            {
                HeroIntY = stoi(line);
                Rinput++;
            }

            if (Routput == 2)
            {
                HeroOutX = stoi(line);
                Routput = 0;
            }
            else if (Routput == 1)
            {
                HeroOutY = stoi(line);
                Routput++;
            }
        }
    }
    Coor.close();
}

void ControlHero(char Input, bool &isNoGameOver, int &HeroIntX, int &HeroIntY, int &HeroOutX, int &HeroOutY)
{
    if (Input == 'p')
    {
        isNoGameOver = false;
    }
    else if (Input == 'd')
    {
        HeroIntX++;
    }
    else if (Input == 'a')
    {
        HeroIntX--;
    }
    else if (Input == 'w')
    {
        HeroIntY--;
    }
    else if (Input == 's')
    {
        HeroIntY++;
    }

    if (HeroIntX > 4)
    {
        HeroIntX = 0;
    }
    else if (HeroIntX < 0)
    {
        HeroIntX = 4;
    }

    if (HeroIntY > 4)
    {
        HeroIntY = 0;
    }
    else if (HeroIntY < 0)
    {
        HeroIntY = 4;
    }

    if ((HeroOutX == HeroIntX) && (HeroOutY == HeroIntY))
    {
        isNoGameOver = false;
    }
}
int main()
{
    char Input = ' ';
    int HeroIntX;
    int HeroIntY;
    int HeroOutX;
    int HeroOutY;
    bool isNoGameOver = true;
    char GameMap[5][5] =
        {
            {'1', 'I', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', 'O'},
            {'1', '1', '1', '1', '1'}};

    SaveCoor(GameMap);
    ReturnCoor(HeroIntX, HeroIntY, HeroOutX, HeroOutY);
    system("cls");
    DrawMap(HeroIntX, HeroIntY, GameMap);

    while (isNoGameOver)
    {
        cin >> Input;
        ControlHero(Input, isNoGameOver, HeroIntX, HeroIntY, HeroOutX, HeroOutY);
        if (isNoGameOver)
        {
            DrawMap(HeroIntX, HeroIntY, GameMap);
        }
    }

    system("cls");
    if ((HeroOutX == HeroIntX) && (HeroOutY == HeroIntY))
    {
        cout << "Felicidades encontraste la salida, GAME OVER" << endl;
    }
    else
    {
        cout << "Saliste del juego" << endl;
    }
    

    return 0;
}

INPUT
0
1
OUTPUT
3
4

1I111
11111
111H1
1111O
11111

Así me quedó:
agregué una función location para guardar las coordenadas mediante los caracteres “r” (filas) y “c”(columnas) un caracter por linea. Esto para que al leerlo se contaran las rs y las cs.

También agregue el caso r para regresar a la posición inicial

espero les sirva para encontrar una mejor solución.

Animo!! 😄

#include <iostream>
#include <fstream>

using namespace std;


void SaveLocation(int HeroPosX, int HeroPosY)
{
    ofstream MyFile("GameData.txt");
    string location = "";
    if (MyFile.is_open())
    {
        MyFile << "Ubicacion actual: " << endl;
        for (int i = HeroPosX; i > 0; i--)
        {
            MyFile << "r" << endl;
        }
        for (int i = HeroPosY; i > 0; i--)
        {
            MyFile << "c" << endl;
        }
    }
    MyFile.close();
}

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5])
{
    for (int i = 0; i < 5; i++)
    {
        for (int p = 0; p < 5; p++)
        {
            if (i == HeroPosX & p == HeroPosY)
            {
                cout << 'H';
            }
            else
                cout << GameMap[i][p];
        }
        cout << endl;
        SaveLocation(HeroPosX, HeroPosY);
    }   
}

int main()
{
    int HeroPosX = 0;
    int HeroPosY = 0;
    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5] = 
    {
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'}
    };    

    ifstream MyFileRead("GameData.txt");
    string line;
    string NombreDelHeroe = "";
    int renglon = 0;

    if (MyFileRead.is_open())
    {
        while (getline(MyFileRead, line))
        {
            renglon = renglon + 1;
            if (renglon > 1)
            {
                if (line == "r")
                    HeroPosX = HeroPosX + 1;
                if (line == "c")
                    HeroPosY = HeroPosY + 1;
            }
        }    
    }
    else
    {
        cout << "No logre abrir mi archivo, checar el antivirus!!" << endl;
    }

    DrawMap(HeroPosX, HeroPosY, GameMap);

    while (isGameOver == false)
    {
        cin >> Input;

        switch (Input)
        {
        case 'd':
            if (HeroPosY < 4)
                HeroPosY = HeroPosY +1;   
            break;
        case 'a':
            if (HeroPosY > 0)
                HeroPosY = HeroPosY -1;
            break;
        case 'w':
            if (HeroPosX > 0)
                HeroPosX = HeroPosX -1;
            break;
        case 's':
            if (HeroPosX < 4)
                HeroPosX = HeroPosX +1;
            break;
        default:
            if (Input == 'r')
            {
                HeroPosX = 0;
                HeroPosY = 0;
            }
            else
                isGameOver = true;
            break;
        }
        DrawMap(HeroPosX, HeroPosY, GameMap);
        cout << endl;
    }
}
 
#include <iostream>
#include <fstream>
using namespace std;

void drawMap(char map[5][5], short posX, short posY)
{
    for (int i=0; i<5; i++)
    {
        for (int p=0; p<5; p++)
        {   
            if (p==posX && i==posY)
                cout << 'H';
            else
                cout << map[i][p];
        }
        cout << endl;
    }
    cout << endl;
    
}

int main()
{
    short posX = 0;
    short posY = 0;
    char input = ' ';

    char game_map[5][5] = {
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'}
    };
    
    ifstream myFileRead("gameData.txt");

    string line;
    short column = 0;

    if (myFileRead.is_open())
    {
        while (getline(myFileRead, line))//Permite leer caracteres hasta un salto de linea
        {   
            for (short i=0; i<line.length(); i++)
            {
                if (line[i]=='3')
                {
                    posX = i;
                    cout << "fila: " << posX << endl; 
                    
                    posY = column;
                    cout << "columna: " << posY << endl; 
                }
            }
            column++;
        }

    }
    
    
    while (input != 'p')
    {   
        drawMap(game_map, posX, posY);
        cin >> input;

        switch (input){
            case 'd':
                posX++;
                break;
            case 'a':
                posX--;
                break;
            case 'w':
                posY--;
                break;
            case 's':
                posY++;
                break;
            case 'p':
                cout << "Fin del juego" << endl;
                break;
            default:
                cout << "Entrada no valida, intentalo de nuevo" << endl;
                break;
        }
    }
    return 0;

}

Dejo aca mi aporte, espero que les sirva.

<
#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

void drawMap(int heroPosX, int heroPosY, char gameMap[5][5]){

    for( int i = 0; i < 5; i++) {
        for( int p = 0; p < 5; p++){
            if(i != heroPosY){
                cout << gameMap[p][i];
            } else if (p != heroPosX){
                cout << gameMap[p][i];
            } else {
                cout << 'H';
            }
        } cout << endl;
    }
}

void createFile (){
    ofstream myFile ("GameData.txt");
    string playerName;
    int x;
    int y;


    if (myFile.is_open()){
        cout << "Ingrese el nombre de tu personaje" << endl;
        cin >> playerName;
        myFile << playerName << endl;
        cout << "Ingrese su punto de partida X (0-4)" << endl;
        cin  >> x;
        myFile << x << endl;
        cout << "Ingrese su punto de partida Y (0-4)" <<endl;
        cin >> y;
        myFile << y << endl;
    }
    myFile.close();
}

void openFile(int *x, int *y, string *name){
    ifstream myFileRead("GameData.txt");
    string line;
    int renglon = 0;
    string nombreHeroe;

    if (myFileRead.is_open()){
        while (getline(myFileRead, line)){
            if(renglon == 0){
                nombreHeroe = line;
                *name = line;
            } else if (renglon == 1){
                stringstream sx;
                sx << line;
                sx >> *x;
            } else if (renglon == 2){
                stringstream sy;
                sy << line;
                sy >> *y;
            } renglon ++;
        }
        cout << "Bienvenido a tu aventura:" << endl;
        cout << nombreHeroe << endl;
    }
}

void saveFile(int heroPosX,int heroPosY, string nombreHeroe){
    ofstream myFile("GameData.txt");
    if(myFile.is_open()){
        myFile << nombreHeroe << endl;
        myFile << heroPosX << endl;
        myFile << heroPosY << endl;
    } else {
        cout << "Error al guardar el archivo." << endl;
    }
}

int main()
{
    char partida = ' ';
    int heroPosX, heroPosY;
    string heroName;
    bool isGameOver = false;
    char input = ' ';
    char gameMap[5][5] ={
     {'1', '1', '1', '1', '1'},
     {'1', '1', '1', '1', '1'},
     {'1', '1', '1', '1', '1'},
     {'1', '1', '1', '1', '1'},
     {'1', '1', '1', '1', '1'},
    };

    cout << "Ingrese N para crear nueva partida, y C para cargar partida existente" << endl;
    while (partida != 'N' && partida != 'C'){
        cin >> partida;
        if(partida == 'N'){
            createFile();
            openFile(&heroPosX, &heroPosY, &heroName);
        } else if (partida == 'C') {
            openFile(&heroPosX, &heroPosY, &heroName);
        } else {
            cout << "Por favor ingrese una opcion correcta" << endl;
        }
    }

    drawMap(heroPosX, heroPosY, gameMap);

    cout << "Puede mover su personaje libremente por el mapa con los comandos W , A, S, D" << endl;
    cout << "Evite salirse del mapa, esto podria causar la perdida de su personaje" << endl;
    cout << "Para guardar su progrso oprima 'g', para terminar la partida oprima 'p'" << endl;


    while (isGameOver == false){
        cin >> input;
        if(input == 'd'){
            heroPosX++;
        } else if(input == 'a'){
            heroPosX--;
        }else if(input == 'w'){
            heroPosY--;
        }else if(input == 's') {
            heroPosY++;
        } else if (input == 'p'){
            isGameOver = true;
        } else if (input == 'g') {
            saveFile(heroPosX, heroPosY, heroName);
        }
        drawMap(heroPosX, heroPosY, gameMap);
    }

    cout << "El juego ha terminado, muchas gracias por jugar." << endl;

    return 0;
}
> 

Yo lo hice de esta manera usando tres bibliotecas y cuatro funciones para poder notar que es lo que debemos guardar.

#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;

void drawmap (int heroposx, int heroposy, char gamemap[5][5] );
void savepost(int heroposx, int heroposy);
int posinx();
int posiny();


int main()
{
    int heroposx = posinx();
    int heroposy = posiny();
    bool isgameover = false;
    char input = ' ';
    char gamemap[5][5]= 
    {
        {'1' , '1' , '1', '1' ,'1'},
        {'1' , '1' , '1', '1' ,'1'},
        {'1' , '1' , '1', '1' ,'1'},
        {'1' , '1' , '1', '1' ,'1'},
        {'1' , '1' , '1', '1' ,'1'}
    };

    drawmap(heroposx, heroposy, gamemap);
    
    cout << "Bienvenido a CARRITO DE CHIMICHANGAS, para mover a tu carrito presiona: arriba (w) abajo(s) izquierda(a) derecha(d) salir(e). Diviertete uwu "<<endl;
    
    while ( isgameover == false)
    {

        cin>> input;

        if (input == 'd')
        {
            heroposx = heroposx + 1;
        }
        else if(input == 'a')
        {
            heroposx = heroposx - 1;
        }
        else if (input == 's')
        {
            heroposy = heroposy + 1;
		}
		else if (input == 'w')
		{
			heroposy = heroposy - 1;
		}

        drawmap(heroposx, heroposy, gamemap);

        if(input == 'e')
        {
            cout << "La posicion actual del jugador es..." <<endl;
            savepost(heroposx, heroposy);
            cout << "Gracias por haber venido! Presiona cualquier tecla para salir";
            cin >> input;
            isgameover = true;
        }

    }
    
    return 0;
}

//FUNCION QUE DIBUJA EL MAPA
void drawmap (int heroposx, int heroposy, char gamemap[5][5] )
{
    for (int i = 0; i < 5; i++ )
    {
        for(int j = 0; j < 5; j++)
        {
            if (i != heroposy)
            {
                cout << gamemap[i][j];
            }
            else
            {
                if (j != heroposx)
                {
                    cout << gamemap[j][i];
                }
                else
                {
                    cout << 'C';  //dibuja la posicion del jugador  en el arreglo 
                }   
            }
        }        
        cout <<endl; // saltos de linea 
    }
}

//FUNCION QUE GUARDA LA POSICION GENERAL
void savepost(int heroposx, int heroposy)
{
    ofstream MyFile("SaveAdvance.txt");
    if (MyFile.is_open())
    {
        MyFile << "Posicion en X"<<endl;
        MyFile << heroposx <<endl;
        MyFile << "Posicion en Y"<<endl;
        MyFile << heroposy <<endl;
    }
    MyFile.close();
}

//FUNCION CON LA POSICION X
int posinx()
{
    ifstream Myreadx("SaveAdvance.txt");
    string line;
    int fila = 0;
    int posx = 0;
    if (Myreadx.is_open())
    {
        while(getline(Myreadx, line)) //obtiene la primera linea del texto
        {
            fila = fila + 1;
            if (fila == 2)
            {
                stringstream X(line); //se crea un obtejo temporal para almacenar el string

                X >> posx; //se convierte de string a int 

                cout << "En X estabas en:  "<< posx <<endl;

            }
        }
    } return posx;

}

//FUNCION CON LA POSICION Y
int posiny()
{
    ifstream Myready("SaveAdvance.txt");
    string line;
    int fila = 0;
    int posy = 0;
    if (Myready.is_open())
    {
        while(getline(Myready, line)) //obtiene la primera linea del texto
        {
            fila = fila + 1;
            if (fila == 4)
            {
                stringstream Y(line); //se crea un obtejo temporal para almacenar el string

                Y >> posy; //se convierte de string a int 

                cout << "Y en Y estabas en: "<< posy<<endl;

            }
        }
    }return posy;
}

Yo pensé en usar lo aprendido para aplicarlo al juego, eso seria salvar y recuperar la partida, me funciono, me encanto el ejercicio y es muy emocionante decir que hice mi primer juego, jeje

#include<iostream>
#include<fstream>
#include<sstream> // libreria para usar char to int
// https://www.geeksforgeeks.org/converting-strings-numbers-cc/
using namespace std;

int ROWS = 4;
int COLUMNS = 4;

void drawMap(int, int, char[4][4]);
void saving(int, int);
	
int main()
{	
	int playerPosX = 0;
	int playerPosY = 0;
	char continueGame = ' ';
	char input = ' ';
	bool gameOver = false;
	char gameMap[4][4];
	
	cout << "[email protected] al juego\nPulsa una tecla o la tecla 'e' si quieres continuar el juego anterior ";
	cin >> continueGame;
	
	for(int i = 0; i < ROWS; i++)
	{
		for(int j = 0; j < COLUMNS; j++)
		{
			gameMap[i][j] = '.';
		}
	}
	
	if(continueGame == 'e')
	{
		ifstream restoredGame("SavedGame.txt");
		string line;
		int positionInt = 0;
		
		if(restoredGame.is_open())
		{
			while(getline(restoredGame, line))
			{
				stringstream positionStr(line);
				if(positionInt == 0)
				{
					positionStr >> playerPosX;
					positionInt += 1;
				} else {
					positionStr >> playerPosY;
				}
			}
			cout << "Posicion anterior: " << playerPosX << ", " << playerPosY << endl;
			cout << endl;
		} else {
			cout << "File could not be open";
			playerPosX = 0;
			playerPosY = 0;
		}
	}
	
	cout << "Recuerda que puedes pulsar la tecla 'c' para guardar y salir o 'x' para solo salir" << endl;

	while(!gameOver)
	{
		cout << "Usa las teclas para moverte: izquierda(a) abajo(s) arriba(w) derecha(d): ";
		cin >> input;
	
		switch(input)
		{
			case 'a':
				playerPosX -= 1;
				break;
			case 's':
				playerPosY += 1;
				break;
			case 'w':
				playerPosY -= 1;
				break;
			case 'd':
				playerPosX += 1;
				break;
			case 'x':
				gameOver = true;
				break;
			case 'c':
				saving(playerPosX, playerPosY);
				gameOver = true;
				break;
			default:
				cout << "La tecla seleccionada no es valida";
				break;
		}

		drawMap(playerPosX, playerPosY, gameMap);
		cout << endl;
	}
}

void drawMap(int posX, int posY, char gameMap[4][4])
{
	for(int i = 0; i < ROWS; i++)
	{
		for(int j = 0; j < COLUMNS; j++)
		{
			if(i != posY || j != posX)
			{
				cout << gameMap[i][j];
			} else {
				cout << '*';
			}
		}
		cout << endl;
	}
}

void saving(int currentX, int currentY)
{
	ofstream savedGame("SavedGame.txt");
	
	if (savedGame.is_open())
	{
		savedGame << currentX << endl;
		savedGame << currentY << endl;
		cout << "Juego guardado, posicion " << currentX << ", " << currentY << endl;
	} else {
		cout << "Problemas guardando la partida";
	}
	savedGame.close();
}

No entendí el reto al principio. Pero dividí el proyecto en varios archivos


GameMap.h

#ifndef GAMEMAP_H_INCLUDED
#define GAMEMAP_H_INCLUDED
#include <iostream>
#include <stdlib.h>
#include <fstream>

using namespace std;

class GameMap
{
private:

    bool IsFirstTime = true;
    int MaxRows = 5;
    int MaxColumns = 5;
    string MapLine = "";
    int Counter = 0;
    char GameMapMatrix [5][5];


    int HeroPosX = 0;
    int HeroPosY = 0;
    char HeroChar = 'H';

public:

    GameMap();

    //Funcion que obtiene el mapa de un archivo de texto llamado GameMap.txt
    void GetGameMap();

    //Funcion que dibuja el mapa dependiendo la posicion del heroe y el arreglo del mapa
    void DrawMap();

    int GetHeroPosX(){return HeroPosX;}
    int GetHeroPosY(){return HeroPosY;}

    void SetHeroPosX(int NewPos);
    void SetHeroPosY(int NewPos);
};


#endif // GAMEMAP_H_INCLUDED```

----------------------------------------------------

GameMap.cpp




#include <iostream>
#include <stdlib.h>
#include <fstream>
#include “GameMap.h”

using namespace std;

GameMap::GameMap()
{
GetGameMap();
}

//Funcion que obtiene el mapa de un archivo de texto llamado GameMap.txt
void GameMap::GetGameMap()
{
std::ifstream InGameMap (“GameMap.txt”);
if(InGameMap.is_open())
{

    while(getline(InGameMap, MapLine))
    {
        //counter fila -- i columna;
        for(int i = 0; i < MaxColumns ; i++)
        {

            if(MapLine[i] == 'x')
            {
                HeroPosX = i;
                HeroPosY = Counter;


            }

            GameMapMatrix[Counter][i] = MapLine[i];



        }
        Counter++;

    }

}
else
{
    cout << "It's not possible open the file, check your antivirus or if the file exists." << endl;
}

InGameMap.close();

}

//Funcion que dibuja el mapa dependiendo la posicion del heroe y el arreglo del mapa
void GameMap::DrawMap()
{
//system (“CLS”);
// i fila, j columna
for (int i = 0; i < MaxRows; i++)
{
for (int j = 0; j < MaxColumns; j++)
{

        if(IsFirstTime)
        {
            if(GameMapMatrix[i][j] == 'x')
            {
                cout << HeroChar;
                IsFirstTime = false;
            }
            else
            {
                cout << GameMapMatrix[i][j];
            }

        }
        else
        {
            if(HeroPosY != i)
            {
                cout << GameMapMatrix[i][j];
            }
            else
            {
                if(HeroPosX != j)
                {
                    cout << GameMapMatrix[i][j];
                }
                else
                {
                    cout << HeroChar;
                }
            }

        }
    }

    cout << endl;
}

}

void GameMap::SetHeroPosX(int NewPos)
{
HeroPosX = NewPos;
}
void GameMap::SetHeroPosY(int NewPos)
{
HeroPosY = NewPos;
}```


main.cpp

#include <iostream>
#include <stdlib.h>
#include <fstream>
#include "GameMap.h"

using namespace std;

GameMap::GameMap()
{
    GetGameMap();
}

//Funcion que obtiene el mapa de un archivo de texto llamado GameMap.txt
void GameMap::GetGameMap()
{
    std::ifstream InGameMap ("GameMap.txt");
    if(InGameMap.is_open())
    {

        while(getline(InGameMap, MapLine))
        {
            //counter fila -- i columna;
            for(int i = 0; i < MaxColumns ; i++)
            {

                if(MapLine[i] == 'x')
                {
                    HeroPosX = i;
                    HeroPosY = Counter;


                }

                GameMapMatrix[Counter][i] = MapLine[i];



            }
            Counter++;

        }

    }
    else
    {
        cout << "It's not possible open the file, check your antivirus or if the file exists." << endl;
    }

    InGameMap.close();
}

//Funcion que dibuja el mapa dependiendo la posicion del heroe y el arreglo del mapa
void GameMap::DrawMap()
{
    //system ("CLS");
    // i fila, j columna
    for (int i = 0; i < MaxRows; i++)
    {
        for (int j = 0; j < MaxColumns; j++)
        {

            if(IsFirstTime)
            {
                if(GameMapMatrix[i][j] == 'x')
                {
                    cout << HeroChar;
                    IsFirstTime = false;
                }
                else
                {
                    cout << GameMapMatrix[i][j];
                }

            }
            else
            {
                if(HeroPosY != i)
                {
                    cout << GameMapMatrix[i][j];
                }
                else
                {
                    if(HeroPosX != j)
                    {
                        cout << GameMapMatrix[i][j];
                    }
                    else
                    {
                        cout << HeroChar;
                    }
                }

            }
        }

        cout << endl;
    }
}

void GameMap::SetHeroPosX(int NewPos)
{
    HeroPosX = NewPos;
}
void GameMap::SetHeroPosY(int NewPos)
{
    HeroPosY = NewPos;
}```



Yo utilice tres funciones, una para guardar la posicion X y Y, otra para leer la posicion X, y otra para leer posicion Y. Use la libreria sstream para poder convertir strings a int.

#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

void DrawMap(int PlayerPosX, int PlayerPosY, char GameMap[5][5])
{
    for(int Fila = 0; Fila < 5; Fila++)  //el ciclo for verifica donde esta posicionado el jugador
    {
        for(int Colum = 0; Colum < 5; Colum++)
        {
            if(Fila != PlayerPosY)      //si en esa coordenada i, no esta el jugador, entonces dibuja el mapa
            {
                cout << GameMap[Fila][Colum];
            } else if(Colum != PlayerPosX)
            {
                cout << GameMap[Fila][Colum];
            } else
            {
                cout << 'P';        //posiciona al jugador en el mapa
            }
        }
        cout << endl;
    }
}

void SavePos(int PlayerPosX, int PlayerPosY)
{
    ofstream MyFile("SavedData.txt");
    if(MyFile.is_open())
    {
        MyFile << "Posicion X = " << endl;
        MyFile << PlayerPosX << endl;
        MyFile << "Posicion Y = " << endl;
        MyFile << PlayerPosY << endl;
    }

    MyFile.close();
}

int ReadPosX()
{
    ifstream MyFileRead("SavedData.txt");
    string line;
    int Fila = 0; 
    int PosX = 0;
    if(MyFileRead.is_open())
    {
        while(getline(MyFileRead, line))        //Obtiene la primera linea del texto
        {
            Fila++;
            if(Fila == 2)
            {
                stringstream X(line);               //Se crea un objeto temporal para almacenar el string
                X >> PosX;                          //Se convierte de string a int
                cout << "Value of X = " << PosX;
            }
            
        }      
        
    }
    return PosX;
}

int ReadPosY()
{
    ifstream MyFileRead("SavedData.txt");
    string line;
    int Fila = 0;
    int PosY = 0;
    if(MyFileRead.is_open())
    {
        while(getline(MyFileRead, line))
        {
            Fila++;
            if(Fila == 4)
            {
                stringstream Y(line);
                Y >> PosY;
                cout << " Value of Y = " << PosY << endl;
            }

        }
    }
    return PosY;
}    

int main()
{
    int PlayerPosX = ReadPosX();
    int PlayerPosY = ReadPosY();
    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5] = 
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'}
    };

    DrawMap(PlayerPosX, PlayerPosY, GameMap);         //Dibuja el mapa al inicio

    while(isGameOver == false)
    {
        cin >> Input;
        if(Input == 'd')                //Si input es d, se mueve a la derecha, si es a, se movera a la izq.
        {
            PlayerPosX++;
        } else if(Input == 'a')
        {
            PlayerPosX--; 
        } else if(Input == 'w')
        {
            PlayerPosY--;
        } else if(Input == 's')
        {
            PlayerPosY++;
        } 
        
        DrawMap(PlayerPosX, PlayerPosY, GameMap);    //Dibuja el mapa con la PlayerPos actualizada

        if(Input == 'p')
        {
            cout << "Saving Player Position..." << endl;
            SavePos(PlayerPosX, PlayerPosY);
            cout << "Thanks for playing! Press any key to exit.";
            cin >> Input;
            isGameOver = true;
        }
        
    }

    return 0;
}
void DrawMap(int HeroPos[2], char GameMap[5][5])
{
    // pinto columnas
    for (int x = 0; x < 5; x++)
    {

        // pinto filas
        for (int y = 0; y < 5; y++)
        {
            if (HeroPos[0] == x && HeroPos[1] == y)
            {
                cout << 'H';
            }
            else
            {
                cout << GameMap[y][x];
            }
        }
        cout << endl;
    }
}

bool validateMaxPosition(int MaxPos, int Pos)
{
    return MaxPos == Pos;
}

bool validateMinPosition(int MinPos, int Pos)
{
    return MinPos == Pos;
}

void createMap()
{
    ofstream MyFile("GameData.txt");
    if (MyFile.is_open())
    {
        MyFile << "--------------" << endl;
        MyFile << "LVL: 1" << endl;
        MyFile << "MAPA" << endl;
        MyFile << "ooooo" << endl;
        MyFile << "ooooo" << endl;
        MyFile << "ooooo" << endl;
        MyFile << "ooooo" << endl;
        MyFile << "ooooo" << endl;
        MyFile << "PJ Position" << endl;
        MyFile << "1,1" << endl;
        MyFile << "--------------" << endl;
    }
    MyFile.close();
}

vector<string> split(string s, string delimiter)
{
    size_t pos_start = 0, pos_end, delim_len = delimiter.length();
    string token;
    vector<string> res;

    while ((pos_end = s.find(delimiter, pos_start)) != string::npos)
    {
        token = s.substr(pos_start, pos_end - pos_start);
        pos_start = pos_end + delim_len;
        res.push_back(token);
    }

    res.push_back(s.substr(pos_start));
    return res;
}

int main()
{
    char GameMap[5][5] = {
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'}};

    int HeroPos[2] = {0, 0};
    ifstream MyFileRead("GameData.txt");
    string line;
    if (MyFileRead.is_open())
    {
        bool flagPosPj = false;
        bool flagMap = false;
        int positionMapY=0;
        while (getline(MyFileRead, line))
        {
            if (flagPosPj)
            {
                vector<string> p = split(line, ",");
                HeroPos[0] = stoi(p[0]);
                HeroPos[1] = stoi(p[1]);
                flagPosPj = false;
            }
            
            if (line == "PJ Position")
            {
                flagMap = false;
                flagPosPj = true;
            }
            
            if (flagMap)
            {
                for(int i=0;i<line.length();i++){
                    GameMap[positionMapY][i]=line[i];
                }
                positionMapY++;
            }

            if (line == "MAPA")
            {
                flagMap = true;
                positionMapY=0;
            }
        }
    }
    else
    {
        cout << "error al cargar el archivo" << endl;
    }

    int MaxPosX = sizeof(GameMap[0]) - 1;
    int MaxPosY = sizeof(GameMap) / sizeof(GameMap[0]) - 1;

    char input = ' ';

    do
    {
        DrawMap(HeroPos, GameMap);
        cin >> input;
        switch (input)
        {
        case 'd':
            if (!validateMaxPosition(MaxPosX, HeroPos[1]))
            {
                HeroPos[1]++;
            }
            break;
        case 'a':
            if (!validateMinPosition(0, HeroPos[1]))
            {
                HeroPos[1]--;
            }
            break;
        case 'w':
            if (!validateMinPosition(0, HeroPos[0]))
            {
                HeroPos[0]--;
            }
            break;
        case 's':
            if (!validateMaxPosition(MaxPosY, HeroPos[0]))
            {
                HeroPos[0]++;
            }
            break;
        default:
            break;
        }

    } while (input != 'p');

    return 0;
}

En mi caso use la stoi para pasar de los datos leidos a un valor entero.
En mi logica tome la posicion x e y del heroe y las guarde en disco. Luego las leí (con un bucle for y getline) reemplazando el valor de las posiciones en el mapa.
Además cabe recalcar que use 3 variables globales. HeroPosX, HeroPosY y file_name.

#include <iostream>
#include <fstream>
using namespace std;

string file_name = "HeroData.txt";

int HeroPosX;
int HeroPosY;


void LoadData(){
    ifstream Data(file_name);
    
    //string line;
    int i=0;


    if(Data.is_open())
    {
        //while(getline(Data, line))
        for(string line; getline(Data, line); i++)
        {
            if(i==0)
            {
                HeroPosX = stoi(line);
            }
            else if(i==1)
            {
                HeroPosY = stoi(line);
            }
            
            
        }    
    }   
    

}

void SaveData(){

    ofstream Data(file_name);
    if(Data.is_open())
    {
        Data << HeroPosX << endl;
        Data << HeroPosY << endl;
    }
    
}

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5])
{
    for(int i = 0; i<5; i=i+1)
    {
        for(int p = 0; p<5; p++)
        {
            if(i != HeroPosY)
            {
                cout << GameMap[i][p];
            }
            else
            {
                if(p != HeroPosX)
                {
                    cout << GameMap[i][p];
                }
                else
                {
                    cout << "H";
                }

            }
        }
        cout << endl;


    }
}

int main()
{
    LoadData();
    
    bool isGameOver = false;
    char Input = ' ';

    char GameMap[5][5] =
    {
        {'#', '#', '#', '#', '#'},
        {'#', '#', '#', '#', '#'},
        {'#', '#', '#', '#', '#'},
        {'#', '#', '#', '#', '#'},
        {'#', '#', '#', '#', '#'}
    };


    DrawMap(HeroPosX, HeroPosY, GameMap);

    while(isGameOver == false)
    {
        cin >> Input;

        if(Input == 'd')
        {
            HeroPosX = HeroPosX + 1;
        }
        else if(Input == 'a')
        {
            HeroPosX = HeroPosX - 1;
        }
        else if(Input == 'p')
        {
            isGameOver = true;
        }
        else if(Input == 'w')
        {
            HeroPosY = HeroPosY - 1;
        }
        else if(Input == 's')
        {
            HeroPosY = HeroPosY + 1;
        }

        DrawMap(HeroPosX, HeroPosY, GameMap);

    }

    SaveData();

    return 0;
}


void save(int heroPosX, int heroPosY, char gameMap[5][5], string name){
  ofstream savegame("SaveMap.txt");
  if(savegame.is_open()){
    for( int i=0; i < 5; i++ ){
      for( int j=0; j < 5; j++){
        if(gameMap[j][i] == '3'){
          savegame << name << endl;
          savegame << heroPosX << endl;
          savegame << heroPosY << endl;
        }
      }
    }
  }
  savegame.close();
}

void load(int &heroPosX, int &heroPosY, string &name, bool verif){
  ifstream loadgame("SaveMap.txt");
  string line;
  int cont = 0;
  if(loadgame.is_open()){
    while(getline(loadgame, line)){
      cont++;
      switch(cont){
        case 1:{
          name = line;
          break;
        }
        case 2: {
          heroPosX = atoi(line.c_str());
          break;
        }
        case 3: {
          heroPosY = atoi(line.c_str());
          break;
        }
      }
    }
    verif = true;
  }else{
    verif = false;
    cout << "Verifique que el archivo exista" << endl;
  }

les dejo mi reto resuelto, espero que les sirva y acepto feedback:D

#include <iostream>
#include <stdlib.h>
#include <fstream>

using namespace std;
// obtiene los datos que se hayan guardado
void obtenerDatos(int &PostX, int &PostY)
{
    ifstream fileread("Laberinto.txt");
    int PosicionX;
    int PosicionY;
    string line;
    int i = 0;
    if (fileread.is_open())
    {
        while (getline(fileread, line))
        {
            i++;
            switch (i)
            {
            case 1:
                PostX = atoi(line.c_str());
                break;

            case 2:
                PostY = atoi(line.c_str());
                break;

            default:
                break;
            }
        }
    }
}
// crea el archivo
void crearArchivo()
{
    ofstream myfile("Laberinto.txt");
    if (myfile.is_open())
    {
        myfile << "0" << endl;
        myfile << "0" << endl;
    }
    myfile.close();
}
// se guarda la partida que esta en curso
void guardar(int PostX, int PostY)
{
    ofstream guardarDatos("Laberinto.txt");
    if (guardarDatos.is_open())
    {
        guardarDatos << PostX << endl;
        guardarDatos << PostY << endl;
    }
    guardarDatos.close();
}
// Se dibuja el mapa y el personaje
void drawMap(int heroPostX, int heroPostY, char GameMap[5][5])
{
    for (int i = 0; i < 5; i++)
    {
        cout << endl;

        for (int j = 0; j < 5; j++)
        {

            if (i != heroPostY)
            {
                cout << GameMap[j][i];
            }
            else
            {

                if (j != heroPostX)
                {
                    cout << GameMap[j][i];
                }
                else
                {
                    cout << 'h';
                }
            }
        }
    }
}

int main()
{
    int heroPostX;
    int heroPostY;
    int PostX;
    int PostY;
    int eleccion = 0;
    cout << "Eliga opcion: " << endl
         << "Cargar Juego=1" << endl
         << "Nuevo juego=2" << endl;
    cin >> eleccion;
    if (eleccion == 2)
    {
        heroPostX = 0;
        heroPostY = 0;
        crearArchivo();
    }
    else if (eleccion == 1)
    {
        obtenerDatos(PostX, PostY);
        heroPostX = PostX;
        heroPostY = PostY;
    }

    char moveLateral = ' ';
    bool gameOver = false;
    char GameMap[5][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'}};

    drawMap(heroPostX, heroPostY, GameMap);
    while (gameOver == false)
    {

        cout << endl
             << "dime donde ir: derecha(d), izquierda(a), arriba(w), abajo(s), Terminar(P)" << endl;
        cin >> moveLateral;
        switch (moveLateral)
        {
        case 'd':
            heroPostX++;
            break;
        case 'p':
            gameOver = true;
            break;
        case 'a':
            heroPostX--;
            break;
        case 's':
            heroPostY++;
            break;
        case 'w':
            heroPostY--;
            break;

        default:
            break;
        }
        guardar(heroPostX, heroPostY);
        drawMap(heroPostX, heroPostY, GameMap);
    }
}```

![](

#include <iostream>
#include <fstream>

using namespace std;

void llena(char mapa[5][5]){
    for (int i=0;i<5;i++){
        for (int j=0;j<5;j++){
            mapa[i][j] = '0';
        }
    }
}

void muestra(char mapa[5][5], int posx, int posy){
    for (int i=0;i<5;i++){
        for (int j=0;j<5;j++){
            if (i == posx && j == posy){
                cout << " " << 'H';
            }
            else{
                cout << " " << mapa[i][j];
            }
        }
        cout << endl;
    }
}


int main(int argc, const char * argv[]) {
    // insert code here...
    int posx = 0;
    int posy = 0;
    char mapa [5][5];
    char mov;
    bool salir = false;
    int opc;
    string linea;
    
    
    llena(mapa);
    
    cout << "1.-Cargar partida" << endl;
    cout << "2.-Nuevo juego" << endl;
    cin >> opc;
    
    switch (opc){
        case 1: {
            ifstream partida ("Partida1.txt");
            if (partida.is_open()){
                getline(partida,linea);
                posx = stoi(linea);
                cout << posx << endl;
                getline(partida,linea);
                posy = stoi(linea);
                cout << posy << endl;
                cout << "Cargado con exito!" << endl;
            }
            partida.close();
            break;
            
        }
        case 2: {
            cout << "ingresa posicion en x: " << endl ;
            cin >> posx;
            cout << "ingresa posicion en y: " << endl ;
            cin >> posy;
            break;
        }
            
    }
    
    
    while (!salir){
        muestra(mapa,posx,posy);
        cout << "Mover:" << endl;
        cout << "    U    " << endl;
        cout << "         " << endl;
        cout << "R       L" << endl;
        cout << "         " << endl;
        cout << "    D    " << endl;
        cout << "S -> Guardar estado" << endl;
        cout << "X -> Salir" << endl;
        cin >> mov;
        switch (toupper(mov)) {
            case 'U':
                if(posx - 1 < 0){
                    cout << "movimiento no posible";
                }else{
                    posx --;
                }
                break;
            case 'D':
                if(posx + 1 >= 5){
                    cout << "movimiento no posible";
                }else{
                    posx ++;
                }
                break;
            case 'R':
                if(posy + 1 >= 5){
                    cout << "movimiento no posible";
                }else{
                    posy ++;
                }
                break;
            case 'L':
                if(posy - 1 < 0){
                    cout << "movimiento no posible";
                }else{
                    posy --;
                }
                break;
            case 'S':{
                ofstream partida("Partida1.txt");
                if (partida.is_open()){
                    partida << posx << endl;
                    partida << posy << endl;
                    cout << "Guardado con exito!" << endl;
                }
                partida.close();
                break;
            }
            case 'X':
                salir = true;
                break;
            default:
                cout << "movimiento no posible";
                break;
        }
        cout << endl;
    }

    return 0;
}

¿Por qué el compilador no me esta compilando ni ejecutando el programa actual? Le doy build and run y ejecuta un programa de la clase pasada. Y no me arroja los errores del programa actual. Gracias de antemano por su ayuda.

![](

qui el enlace por si lo quieren ver correr
https://repl.it/repls/BestMysteriousBackups
tube algunos incobenientes ya que mi idea para este reto era el de hacer un mapa vairable con multiples partidas aguardadas en un archivo donde se guardara laposicion en cordenadas del heroe y la dimencion del mapa incluso cree varias funciones como un contador de lineas y caracteres, un convertidor de caracteres a enteros, un identificador de cadenas de texto y enteros que habia probado con exito pero al intentar dar forma a mi idea rompi muchas veces el codigo y desespere asi que opte por el camino facil y segui las reglas de este reto aqui les dejo el codigo final de este reto funciona muy bien.
Por si les interesan las funciones de las que les hable las dejo asta el final por si quieren darles algun uso

#include <iostream>
#include <fstream>

using namespace std;

void CrearMapa (int X,int Y,int Dimencion){
    for (int i = 0;i<Dimencion; i++)    {
        for (int j = 0; j<Dimencion;j++)   {
            if (j == X && i == Y)     {
                cout <<'O';           }
            else{cout <<'*';}         }
        cout << endl;                 }}

void GuardarPartida (int X,int Y, int Dimencion){
    ofstream NuevaPartida ("data.txt");
    for (int i = 0;i<Dimencion; i++)    {
        for (int j = 0; j<Dimencion;j++)   {
            if (j == X && i == Y)     {
                NuevaPartida <<'O';   }
            else{NuevaPartida <<'*';} }
        NuevaPartida << endl;         }
    NuevaPartida.close();                }

int main()
{
   ifstream UltimaPartida ("data.txt");

   int TamDelMapa = 0,
       heroCorX = 0,
       heroCorY = 0;
   char input;
   bool GameOver = false;
   string linea;

   cout << "quieres empesar una nueva partida" << endl
        << "o continuar con la ultima partida guardada"<< endl
        << "N (Nueva) / C (Continuar)" << endl;
   cin >> input;
   cout << endl;
   if(input == 'n' || input == 'N'){
        cout << "de que tamaño quieres tu mapa" << endl;
        cin >> TamDelMapa;}

   else if (UltimaPartida.is_open()&&input == 'c' || input == 'C' ){
        while(getline(UltimaPartida,linea))     {
            for (int j = 0;linea[j] != NULL;j++){
                    if (linea [j] == 'O')       {
                     heroCorX = j;
                     heroCorY = TamDelMapa;     }}
            TamDelMapa++;                       }}
   else if (!UltimaPartida.is_open() &&input == 'c' || input == 'C'){
       cout <<"No existe una partida guardada crea una"<< endl
            << "de que tamaño quieres tu mapa" << endl;
       cin >> TamDelMapa;}

   else {GameOver = true;}

    if (!GameOver) {
        cout << "\nLa partida a comenzado"<< endl
             << "es momento de jugar" << endl
             << "usa a (izquierda)" << endl
             << "usa d (deracha)" << endl
             << "usa w (arriba)" << endl
             << "usa s (abajo)" << endl
             << "usa E (salir del juego)" << endl;}
    while (!GameOver)                  {
        cin >> input;
        switch (input)        {
            case 'd': heroCorX++; break;
            case 'a': heroCorX--; break;
            case 's': heroCorY++; break;
            case 'w': heroCorY--; break;
            case 'e': case 'E':
                cout <<"deseas guardar tu partida" <<endl
                    << "S (SI) cualquier tecla (NO)" << endl;
                cin >> input;
                if (input == 's')         {
                    UltimaPartida.close();
                    GuardarPartida(heroCorX,heroCorY,TamDelMapa);
                    GameOver = true;}
                else {GameOver = true;}
                break;
            default: GameOver = true;
                break;        }

        if (heroCorX < 0 || heroCorX > TamDelMapa -1 ||
            heroCorY < 0 || heroCorY > TamDelMapa -1) {
                GameOver = true;    }
        if (!GameOver)                          {
            CrearMapa(heroCorX,heroCorY,TamDelMapa);}
        else {cout << "Game Over";}}

    return 0;
}


/*aqui dejo las funciones de las que les hablel una mide la longitud de una linea de texto, otra es capas de convertir un texto a un entero y por ultimo una tiene la capasidad de saber si lo que esta leyendo es un caracter o un entero*/

int Nx10n (int Numero ,int potencia) {
    int resultado,
        decena = 1;
    if (potencia < 0)                {
        decena = 0;
        cout << "_ERROR_";           }
    else if (potencia > 0)                 {
        for (int i = 1;i <= potencia; i++) {
            decena = decena * 10;          }}
    resultado = Numero * decena;
    return resultado;                }

int letrasXlinea (string palabra) {
    int Caracters = 0;
    for (int i = 0; palabra[i] != NULL; i++){
        Caracters = i+1;                    }
    return Caracters;             }

bool Enumerador (char NumTxt,int *numero){
    bool HayUnNumero = true;
    switch (NumTxt)                {
       case '0': *numero = 0; break;
       case '1': *numero = 1; break;
       case '2': *numero = 2; break;
       case '3': *numero = 3; break;
       case '4': *numero = 4; break;
       case '5': *numero = 5; break;
       case '6': *numero = 6; break;
       case '7': *numero = 7; break;
       case '8': *numero = 8; break;
       case '9': *numero = 9; break;
       default: HayUnNumero = false;
                 *numero = 0; break;}
    return HayUnNumero;                 }

bool EsNumero (char Caracter) {
   bool Es = true;
   switch (Caracter)      {
      case '1': case '4': case '7':
      case '2': case '5': case '8':
      case '3': case '6': case '9':
      case '0': break;
      default: Es = false;}
   return Es;                 }

int Char_a_Int (char *texto)    {
    int total = 0,
        indice,
        *Numeros;
    if (*texto != NULL)                    {
        indice = letrasXlinea(texto);
        for (int i = indice - 1, j = 0; i >= 0;i--,j++) {
            Enumerador(texto[i],&Numeros[j]);
            Numeros [j] = Nx10n(Numeros[j],j);          }
        for (int k = 0; k < indice; k++)                {
            total = total + Numeros[k];                 }}
    else {total = 0;}
    return total;                   }

void String_a_Char (string palabra,char *Char) {
   for (int j = 0; palabra[j]!= NULL; j++){
        Char[j]=palabra[j];               }}```

Mi intención fue controlar el juego desde crear un nuevo ingreso de datos hasta aperturar un juego guardado… ingresando todos los datos. Para completar el detalle de conversión de String a Int para la lectura de posiciones y los limites use la libreria de CSTDLIB <-- No tuve otra opcion.

#include <iostream>
#include <fstream>
#include <cstdlib>

using namespace std;

void DrawGame(int X, int Y, int PosHeroX, int PosHeroY)
{
    for(int i=0; i<Y; i++)
    {
        for(int j=0; j<X; j++)
        {
            if(i != PosHeroY)
            {
                cout << "-";
            }
            else
            {
                if(j != PosHeroX)
                {
                    cout << "-";
                }
                else
                {
                    cout << 'H';
                }
            }
        }
        cout << endl;
    }
}

void SaveGame(int HeroGLimitX, int HeroGLimitY, int HeroGPosX, int HeroGPosY, string HeroGName)
{
    ofstream MyFile("GameData.txt");
    if(MyFile.is_open())
    {
        MyFile << "Hola!" << endl;
        MyFile << "Bienvenido al Juego mas divertido..." << endl;

        MyFile << HeroGName << endl;
        MyFile << HeroGLimitX << endl;
        MyFile << HeroGLimitY << endl;
        MyFile << HeroGPosX << endl;
        MyFile << HeroGPosY << endl;
    }
    MyFile.close();
}

void Game(int limitX, int limitY, int HeroPosX, int HeroPosY, string NamePlayer)
{
    DrawGame(limitX, limitY, HeroPosX, HeroPosY);
    int limitC = 0;
    bool IsGameOver = false;
    char Input = ' ';
    while(IsGameOver == false)
    {
        cin >> Input;
        switch(Input)
        {
            case 'd':
                if(HeroPosX != limitX-1)
                {
                    HeroPosX++;
                }
                break;
            case 'a':
                if(HeroPosX != limitC)
                {
                    HeroPosX--;
                }
                break;
            case 's':
                if(HeroPosY != limitY-1)
                {
                    HeroPosY++;
                }
                break;
            case 'w':
                if(HeroPosY != limitC)
                {
                    HeroPosY--;
                }
                break;
            default:
                IsGameOver = true;
                break;
        }
        DrawGame(limitX, limitY, HeroPosX, HeroPosY);
    }
    cout << "posicion eje x..." << HeroPosX+1 << endl;
    cout << "posicion eje y..." << HeroPosY+1 << endl;
    SaveGame(limitX, limitY, HeroPosX, HeroPosY, NamePlayer);
}

void NewGame()
{
    int HeroPosX = 1;
    int HeroPosY = 1;
    string NamePlayer;
    int limitX;
    int limitY;
    cout << "Introduce el nombre de tu Heroe...";
    cin >> NamePlayer;
    cout << "Dibuja un mapa ingresando sus limites:" << endl;
    cout << "limite eje x...";
    cin >> limitX;
    cout << "limite eje y...";
    cin >> limitY;
    Game(limitX, limitY, HeroPosX, HeroPosY, NamePlayer);
}

void LoadGame(int HeroGLimitX, int HeroGLimitY, int HeroGPosX, int HeroGPosY, string HeroGName)
{
    ifstream MyFileRead("GameData.txt");
    string line;
    int UbiName = 0; //Ubicacion de Nombre posicion 2
    int UbiLimitX = 0; //Ubicacion de limite eje X 3
    int UbiLimitY = 0; //Ubicacion de limite eje Y 4
    int UbiPosX = 0; //Ubicacion de posicion eje X 5
    int UbiPosY = 0; //Ubicacion de posicion eje Y 6
    if(MyFileRead.is_open())
    {
        while(getline(MyFileRead, line))
        {
            if(UbiName == 2)
            {
                HeroGName = line;
            }
            if(UbiLimitX == 3)
            {
                HeroGLimitX = std::atoi(line.c_str());
            }
            if(UbiLimitY == 4)
            {
                HeroGLimitY = std::atoi(line.c_str());
            }
            if(UbiPosX == 5)
            {
                HeroGPosX = std::atoi(line.c_str());
            }
            if(UbiPosY == 6)
            {
                HeroGPosY = std::atoi(line.c_str());
            }
            UbiName = UbiName + 1;
            UbiLimitX = UbiLimitX + 1;
            UbiLimitY = UbiLimitY + 1;
            UbiPosX = UbiPosX + 1;
            UbiPosY = UbiPosY + 1;
        }
    }
    Game(HeroGLimitX, HeroGLimitY, HeroGPosX, HeroGPosY, HeroGName);
}

int main(int HeroGLimitX, int HeroGLimitY, int HeroGPosX, int HeroGPosY, string HeroGName)
{
    cout << "BIENVENIDO AL HEROGAME" << endl;
    cout << "======================" << endl;
    cout << endl;
    cout << "1.- Juego Nuevo" << endl;
    cout << "2.- Juego Guardado" << endl;
    cout << endl;
    cout << "Escoge una opcion...";
    char op = ' ';
    cin >> op;
    cout << endl;
    switch(op)
    {
        case '1':
            cout << "Bienvenido, empecemos el juego!" << endl;
            NewGame();
            break;
        case '2':
            cout << "Bienvenido, aqui esta tu grabacion!" << endl;
            LoadGame(HeroGLimitX, HeroGLimitY, HeroGPosX, HeroGPosY, HeroGName);
            break;
        default:
            cout << "Error!... Opcion invalida." << endl;
            break;
    }
    return 0;
}

reto cumplido 😃
nota: la funcion stoi no lo compila el compilador de code::blocks
lo compìle en visual studio code

#include <iostream>
#include <fstream>
#include <string.h>
#include <stdlib.h>

using namespace std;

void DrawMap(int PlayerPosX, int PlayerPosY, char GameMap[5][5])
{
    for (int i = 0; i < 5; i++)
    {
        for(int p = 0; p < 5; p++)
        {
            if(i == PlayerPosX && p == PlayerPosY )
            {

                cout << 'H';
            }
            else
            {

                cout << GameMap[i][p];

            }


        }

        cout << endl;
    }

}

int main()
{
    int PlayerPosX = 0;
    int PlayerPosY = 0;
    string line;
    int Renglon = 0;
    char input;
    bool IsPlayerDead = false;
    char GameMap[5][5] =
    {
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'}
    };
    ifstream MyPos("PlayerPos.txt");
    while(getline(MyPos, line))
    {
        if (Renglon == 0)
        {
            PlayerPosX = stoi(line);
        }
        else if (Renglon == 1)
        {
            PlayerPosY = stoi(line);
        }
        Renglon++;
    }


    while(!IsPlayerDead)
    {
        DrawMap(PlayerPosY, PlayerPosX, GameMap);
        cin >> input;
        if (PlayerPosX == 5)
        {
            PlayerPosX--;
        }
        else if(PlayerPosX == -1)
        {
            PlayerPosX++;
        }
        else if(PlayerPosY == 5)
        {
            PlayerPosY--;
        }
        else if(PlayerPosY == -1)
        {
            PlayerPosY++;
        }


        else if ( ( (PlayerPosX + 1) * (PlayerPosY + 1)) == 25 )
        {
            cout << "felicidades as completado el juego\n" << endl;
            IsPlayerDead = true;

        }
        else if (input == 'd')
        {
            PlayerPosX++;
        }
        else if (input == 'a')
        {
            PlayerPosX--;
        }
        else if(input == 's')
        {
            PlayerPosY++;
        }
        else if(input == 'w')
        {
            PlayerPosY--;
        }
        else if (input == 'p')
        {
            IsPlayerDead = true;
        }
        else if(PlayerPosX == 5)
        {
            PlayerPosX = PlayerPosX - 2;

        }
        else if(input == 'g')
        {
            ofstream MyFile("PlayerPos.txt");
            MyFile << PlayerPosX << endl;
            MyFile << PlayerPosY << endl;
            MyFile.close();
            IsPlayerDead = true;
        }
        else
        {
            cout << "error. mueve al heroe con las teclas a/d/w/s" << endl;
        }



    }




    return 0;
}```

Asi fue como yo lo hice

#include <iostream>
#include <fstream>

using namespace std;

void DrawMap (int HeroPosX, int HeroPosY, char GameMap[5][5])
{
for (int i = 0; i < 5; i++)
{
for (int p = 0; p < 5; p++)
{
if (i != HeroPosY)
{
cout << GameMap [p][i];
}
else {
if (p != HeroPosX)
{
cout << GameMap [p][i];
} else
{
cout << ‘3’;
}
}
} cout << endl;
}
}
int main() {

ofstream MyFile(“GameData.txt”);

int HeroPosX = 0;
int HeroPosY = 0;
bool IsGameOver = false;
char Input;
char GameMap [5][5] =
{
{‘1’,‘1’,‘1’,‘1’,‘1’},
{‘1’,‘1’,‘1’,‘1’,‘1’},
{‘1’,‘1’,‘1’,‘1’,‘1’},
{‘1’,‘1’,‘1’,‘1’,‘1’},
{‘1’,‘1’,‘1’,‘1’,‘1’}
};

DrawMap (HeroPosX, HeroPosY, GameMap);

while(IsGameOver == false)
{
cout << HeroPosX;
cout << “,”;
cout << HeroPosY;
cin >> Input;

if (MyFile.is_open())
{
MyFile <<"Tu posicion es: ";
MyFile << HeroPosX;
MyFile << “,”;
MyFile << HeroPosY << endl;
}

if (Input == ‘d’)
{
HeroPosX = HeroPosX + 1;
}else if (Input == ‘a’)
{
HeroPosX = HeroPosX - 1;
} else if (Input == ‘w’)
{
HeroPosY = HeroPosY - 1;
} else if (Input == ‘z’)
{
HeroPosY = HeroPosY + 1;
} else if (Input == ‘p’)
{
IsGameOver = true;
cout << “GameOver”<< endl;
MyFile.close();
}
DrawMap (HeroPosX, HeroPosY, GameMap);
}
return 0;
}

`<code>

RETO CUMPLIDO! 😂

#include <iostream>
#include <stdlib.h>
#include <fstream>

using namespace std;

//DIBUJAR MAPA
void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5]){
    system("cls");
    for (int i = 0; i < 5; i++){
        for (int p = 0; p < 5; p++){
            if (i != HeroPosY){
                cout << GameMap[i][p];
                cout << ' ';
            } else {
                if (p != HeroPosX){
                    cout << GameMap[i][p];
                    cout << ' ';
                } else {
                    cout << 'H';
                    cout << ' ';
                }
            }
        }
        cout << endl;
    }
}

void DrawMenu(){
    system("cls");
    cout << "*****************************" << endl;
    cout << "*-----------RED LINE--------*" << endl;
    cout << "* 1 - Nuevo Juego           *" << endl;
    cout << "* 2 - Cargar Ultima Partida *" << endl;
    cout << "* 3 - Salir                 *" << endl;
    cout << "*****************************" << endl;
}

int main()
{

    //POSICIONES DEL HEROE
    int HeroPosX;
    int HeroPosY;

    char Input;
    bool isGameOver = false;

    int Opcion;

    char GameMap[5][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'}
    };

    DrawMenu();
    cin >> Opcion;

    if (Opcion == 2){
        ifstream MyFileRead("GameData.txt");

        string Line;
        string PosY;
        string PosX;

        int Renglon = 0;



        while (getline(MyFileRead, Line)){

            Renglon++;
            if (Renglon == 1){
                HeroPosX =  atoi(Line.c_str());;
            }
            if (Renglon == 2){
                HeroPosY =  atoi(Line.c_str());;
            }
        }
    } else {
        HeroPosX = 0;
        HeroPosY = 0;
    }

    DrawMap(HeroPosX, HeroPosY, GameMap);

    while (isGameOver == false){
        cin >> Input;

        if (Input == 'd'){
            HeroPosX++;
        } else if (Input == 'a'){
            HeroPosX--;
        } else if (Input == 'w'){
            HeroPosY--;
        } else if (Input == 's'){
            HeroPosY++;
        } else if (Input == 'p'){
            ofstream MyFile("GameData.txt");
            MyFile << HeroPosX << endl;
            MyFile << HeroPosY << endl;

            isGameOver = true;
            MyFile.close();

        }

        DrawMap(HeroPosX, HeroPosY, GameMap);
    }

}

Reto aquí, saludos!

void DramMap(int posX, int posY, char map[5][5]){

     for(int i=0; i<5; i++){

       for(int j=0; j<5; j++){
            if(posX == j && posY == i){
                cout << 'X';
            }else{
                cout << map[i][j];
            }
       }
       cout << '\n';
   }

}

int main()
{

    int posX = 1;
    int posY = 1;
    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5] =
    {
        {
            'M','M','M','M','M'
        },
        {
            'M','M','M','M','M'
        },
        {
            'M','M','3','M','M'
        },
        {
            'M','M','M','M','M'
        },
        {
            'M','M','M','M','M'
        }
    };

    ofstream GameMapFile("GameMapFile.txt");
    if(GameMapFile.is_open()){
        for(int i = 0; i < 5; i++){
            for(int j = 0; j < 5; j++){
                GameMapFile << GameMap[i][j];
            }
            GameMapFile << endl;
        }
    }else{
        cout << "No se pudo abrir el archivo";
    }

    GameMapFile.close();

    string line;
    int renglon = 0;

    ifstream ReadGameMap("GameMapFile.txt");
    if(ReadGameMap.is_open()){
        while(getline(ReadGameMap, line)){
            for(int l = 0; l < 5; l++){
                if(line[l] == '3'){
                    posX = l;
                    posY = renglon;
                }
            }
            renglon++;
        }
    }else{
        cout << "No se pudo abrir el archivo";
    }

    DramMap(posX, posY, GameMap);

    cout << '\n';

    while(isGameOver == false){
        cin >> Input;

        switch(Input){

            case 'd': {
                posX += 1;
                break;
            }
            case 'a': {
                posX -= 1;
                break;
            }
            case 'w': {
                posY -=1;
                break;
            }
            case 's': {
                posY += 1;
                break;
            }
            default: {
                isGameOver = true;
            }

        }

        DramMap(posX, posY, GameMap);
    }```

alguno que me pueda ayudar es que no me lo guarda en el archivo de texto

#include <iostream>
#include <fstream>

using namespace std;

void dibujodemapa(int posicionheroex,int posicionheroey, char map[5][5] )
{
    for(int i = 0; i<5; i++)
    {
        for(int f = 0; f<5; f++)
        {
            if(i != posicionheroey)
            {
                cout<<map[f][i];
            }
            else
            {
                if(f != posicionheroex)
                {
                    cout<<map[f][i];
                }
                else
                {
                    if ((f == 4)&&(i ==  4))
                    {
                        cout<<'X';
                    }
                    else
                    {
                    cout<<'H';
                    }
                }
                
            }
        }
        cout<<endl;
    }
}
int main()
{
    ofstream miarchivo("datosjuego.txt"); // archivo de texto
    int elnumero;
    int savex;
    int savey;
    bool gameover = false;
    char input = ' ';
    
    char map[5][5]=
    {
        {'-','|','|','|','-'},
        {'-',' ',' ',' ','-'},
        {'-',' ',' ',' ','-'},
        {'-',' ',' ',' ','-'},
        {'-','|','|','|','O'}
    };
    
    cout<<"introduce las cordenadas de inicio:"<<endl;
    cout<<"recurda que es en un mapa 5X5 y seleccionas con f"<<endl;
    cout<<"en X:"<<endl;
    cin>>savex;
    cout<<"en Y"<<endl;
    cin>>savey;
    
    int posicionheroex = savex;
    int posicionheroey = savey;
    
    dibujodemapa(posicionheroex,posicionheroey,map);
    
    while(gameover == false)
    {
        cin>>input;
        
        if(input == 'd')
        {
            posicionheroex = posicionheroex + 1;
        }
        else if(input == 'a')
        {
            posicionheroex = posicionheroex -1;
          
        }
        else if(input == 'w')
        {
            posicionheroey = posicionheroey -1;
        
        }
        else if(input == 's')
        {
            posicionheroey = posicionheroey +1;
    
        }
        else if(input == 'f')
        {
            posicionheroey = posicionheroey;
            posicionheroex = posicionheroex;
            if ((posicionheroex == 4)&&(posicionheroey ==  4))
            {
                gameover = true;
                cout<<"explotaste :v"<<endl;
                cout<<"fin del juego"<<endl;
            }
        }
        else if(input == 'p')
        {
            cout<<"******* menu *********"<<endl;
            cout<<"1 - salvar partida"<<endl;
            cout<<"2 - regresar al juego"<<endl;
            cout<<"3 - controles"<<endl;
            cout<<"4 - salir del juego"<<endl;
            cout<<"**********************"<<endl;
            cin>>elnumero;
            
            if(elnumero == 4)
            {
                gameover = true;
            }
            else if(elnumero == 1)
            {
                if(miarchivo.is_open())
                {
                miarchivo<<posicionheroex;
                miarchivo<<posicionheroey;
                }
                else
                {
                    cout<<"tu chingadera no jala >:u"<<endl;
                }
            }
            else if(elnumero == 2)
            {
                gameover = false;
            }
            else if(elnumero == 3)
            {
                cout<<"***************************"<<endl;
                cout<<"      arriba - w "<<endl;
                cout<<"       abajo - s"<<endl;
                cout<<"     derecha - d"<<endl;
                cout<<"   izquierda - a"<<endl;
                cout<<" seleccionar - f"<<endl;
                cout<<"        pusa - p"<<endl;
                cout<<"***************************"<<endl;
            }
        }
        dibujodemapa(posicionheroex,posicionheroey,map);
    }
    miarchivo.close();
   
    return 0;
}

Hola buenas tardes, aquí adjunto mi respuesta al reto

#include <iostream>
#include <fstream>
#include <stdlib.h>

using namespace std;

void DrawMap (int HeroPosX, int HeroPosY, char GameMap [5][5]){
    for (int i = 0; i < 5; i++){
            for (int p = 0; p < 5; p++){
                if (i != HeroPosX){
                    cout << GameMap[p][i];
                }
                else {
                    if (p != HeroPosY)
                    {
                        cout << GameMap[p][i];

                    }else
                    {
                        cout << 'H';
                    }
                }

            }
            cout << endl;
    }
}


int main()
{
    ofstream MyFile("GameData.txt");
    string PlayerName = "";
    char GameMap [5][5]=
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
    };

    if (MyFile.is_open())
    {
        MyFile << 3 << endl;
        MyFile << 4 << endl;
        //MyFile << "Zelda" << endl;

    }

    MyFile.close();

    ifstream MyFileRead ("GameData.txt");
    string line;
    string NombreDelHeroe = " ";
    int Renglon = 0;
    int xPos = 0;
    int yPos = 0;

    if (MyFileRead.is_open())
    {
        while (getline (MyFileRead, line)){

            if (Renglon == 0){
                xPos = atoi(line.c_str());
            }
            if (Renglon == 1){
                yPos = atoi(line.c_str());
            }

            Renglon = Renglon + 1;
        }
        DrawMap(xPos, yPos, GameMap);

    }else
    {
        cout << "No logre abrir mi archivo, checar el antivirus!!" << endl;
    }

    return 0;
}

Buenas,
Adjunto el código con el que resolvi este reto.
Mi forma de solucionarlo es que el usuario debe indicar en el bloc de notas en la primera línea el valor en x y en la segunda linea el valor en y

#include <iostream>
#include <fstream>
#include <stdlib.h>

using namespace std;

void DrawMap (int HeroPosX, int HeroPosY, char GameMap [5][5]){
    for (int i=0; i< 5; i++){
            for (int j = 0; j<5; j++){
                if (i !=HeroPosY)
                {
                    cout << GameMap[i][j];
                }else
                {
                    if (j !=HeroPosX)
                    {
                        cout << GameMap[i][j];
                    }
                    else
                    {
                        cout << 'H';
                    }
                }
            }
            cout << endl;
    }
}

int main()
{
    int HeroPosX= 1;
    int HeroPosY=1;
    char Input = ' ';
    bool isGameOver = false;
    char GameMap [5][5] =
    {
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'}

    };
        ifstream MyFileRead ("GameData.txt");
        string line;
        int cont = 0;

        if (MyFileRead.is_open())
        {
            while (getline (MyFileRead, line) &&(cont <2))
            {
                if (cont == 0){
                    HeroPosX = atoi(line.c_str());
                }
                else
                {
                    HeroPosY = atoi(line.c_str());
                }
                cont++;
            }

        }
        else
        {
           cout << "No se pudo leer el archivo" << endl;
        }
        DrawMap(HeroPosX,HeroPosY, GameMap);
        while (!isGameOver)
        {
            cin >> Input;

            if (Input == 'd')
            {
                HeroPosX = HeroPosX + 1;
            }
            else if (Input == 'a')
            {
                HeroPosX = HeroPosX - 1;
            }
            else if (Input == 'w')
            {
                HeroPosY = HeroPosY - 1;
            }
            else if (Input == 's')
            {
                HeroPosY = HeroPosY + 1;
            }
            else if (Input == 'p')
            {
                isGameOver = true;
            }
            DrawMap(HeroPosX, HeroPosY, GameMap);
        }
    return 0;
}```

#include <iostream>
#include <fstream>

using namespace std;

void Draw(int HeroeX, int HeroeY, char maps [10][10]){
for(int x=0;x < 10; x++)
{ for(int y=0;y < 10; y++)
{ if(x!=HeroeX)
{
cout<< maps[x][y];
}else {
if(y!=HeroeY)
{
cout<< maps[x][y];
}
else
cout<< ‘H’;
}

}cout<< endl;}}

int main()
{ofstream InfoPersonaje(“personaje.txt”);
string Name=" ";

int HeroeY=0;
int HeroeX=0;
char input=’ ';
bool GameOver=false;
char maps [10][10]={
{‘0’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’},
{‘0’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’},
{‘0’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’},
{‘0’,‘0’,‘0’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’},
{‘1’,‘1’,‘0’,‘0’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’},
{‘1’,‘1’,‘1’,‘0’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’},
{‘1’,‘1’,‘1’,‘0’,‘0’,‘0’,‘0’,‘0’,‘H’,‘1’},
{‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’},
{‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘0’},
{‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘1’,‘0’}
};

if (InfoPersonaje.is_open()){
cout<< “Cual es el nombre del jugador?”<<endl;
cin>>Name;
cout<< "El nombre del jugador es "<< Name<<endl;
InfoPersonaje<<Name;
cout<<“Para moverte usa ‘w’,‘s’,‘a’ y ‘d’”<<endl;
cout<<“Sigue el camino de los ‘0’”<<endl;

 Draw(HeroeX,HeroeY,maps);
    while(GameOver==false){
    cin >> input;

    if (input=='d')
    {
        HeroeY= HeroeY+1;
    }
    else if ( input=='a')
    {
        HeroeY=HeroeY-1;
    }
    else if ( input=='s')
    {
        HeroeX=HeroeX+1;
    }
    else if ( input=='w')
    {
        HeroeX=HeroeX-1;
    }
    else if ( input=='p')
    {
        GameOver= true;
    }

    Draw(HeroeX,HeroeY,maps);
}

}
InfoPersonaje.close();

ifstream PersRead(“personaje.txt”);
string line;
string Nombre=" ";

return 0;

}

No he podido 😦 hay algun recurso adicional donde pueda yo guiarme para poder lograr este reto?

Estuvo divertido este reto a la forma en que lo entendí cree estas opciones

  1. Iniciar el juego en 0 y permitirle guardar en un archivo
  2. Leer los datos ya guardados por el jugador y continuar con el juego y permitir guardar el avance
  3. Instrucciones del juego
    Adjunto código
#include <iostream>
#include<fstream>
#include<string>
#include<stdlib.h>
using namespace std;
void menu();
void drawmap(int heroposX,int heroposY, char gamemap[5][5] );
void SaveTest(int heroposX,int heroposY,char gamemap[5][5]);
void move_player(int heroposX,int heroposY,char gamemap[5][5]);
void Game_Rules();
void start();
void load();
bool isgameover =false;

char input=' ';
int main()
{
    menu();

    return 0;
}
void drawmap(int heroposX,int heroposY, char gamemap[5][5] )
{
for (int i =0; i<5; i++)
    {
        for(int p=0; p<5; p++)
        {
            if(i !=heroposY)
        {
            cout<<gamemap[p][i];
        }else
        {
            if(p != heroposX)
            {
                cout<<gamemap[p][i];
            }else
            {
                cout<<'H';
            }
        }
        }
        cout<<endl;
    }

}

void start()
{
    int heroposX = 0;
    int heroposY = 0;
    string line;
    char gamemap[5][5]=
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
    };
    drawmap(heroposX,heroposY,gamemap);
    move_player(heroposX,heroposY,gamemap);

}
void move_player(int heroposX,int heroposY,char gamemap[5][5])
{
    while(isgameover == false)
    {
    cin>>input;
    if(input=='d')
    {
        heroposX=heroposX + 1;
    }else if(input=='a')
    {
        heroposX=heroposX - 1;
    }
    else if(input == 's')
    {
        heroposY=heroposY + 1;
    }
    else if(input == 'w')
    {
        heroposY=heroposY - 1;
    }
    else if(input =='g')
    {
        SaveTest(heroposX,heroposY,gamemap);
    }
    else if(input == 'p')
    {
        isgameover = true;
    }
    drawmap(heroposX,heroposY,gamemap);
    }
}
void SaveTest(int heroposX,int heroposY,char gamemap[5][5])
{
    ofstream Myfile("Gamedata.txt");
    if(Myfile.is_open())
    {
    for (int i =0; i<5; i++)
    {
        for(int p=0; p<5; p++)
        {
            if(i !=heroposY)
        {
            Myfile<<gamemap[p][i];
        }else
        {
            if(p != heroposX)
            {
                Myfile<<gamemap[p][i];
            }else
            {
                Myfile<<'H';
            }
        }
        }
        Myfile<<endl;
    }Myfile.close();
    }
    isgameover = true;
}
void load()
{

    char line;
    char mapg[5][5];
    int X =0;
    int Y =0;
    ifstream Myfileread("Gamedata.txt");
    fflush(stdin);
    if(Myfileread.is_open())
    {
        for (int i=0; i<5; i++)
        {
            for(int j=0;j<5; j++)
            {
                fflush(stdin);
                Myfileread>>line;
                mapg[i][j]='1';
                if(line =='H')
                {
                    Y=i;
                    X=j;
                }
            }
            }
        }
    Myfileread.close();
    drawmap(X,Y,mapg);
    move_player(X,Y,mapg);
}
void Game_Rules()
{
    char regreso;
    cout<<"La tecla s para bajar"<<endl;
    cout<<"La tecla w para subir"<<endl;
    cout<<"La tecla a para mover hacia la Izquierda"<<endl;
    cout<<"La tecla d para mover hacia la derecha"<<endl;
    cout<<"La tecla p para Salir sin guardar"<<endl;
    cout<<"La tecla s para Guardar el juego"<<endl;
    cout<<"Ingrese la tecla r para regresar al menu"<<endl;
    cin>>regreso;
    if(regreso=='r' or regreso =='R' )
    {
        system("cls");
        menu();
    }else
    {
        cout<<"Opcion no valida"<<endl;
    }
}
void menu()
{
    string name;
    int option;
    cout<<"    Bienvenido al Juego"<<endl;
    cout<<"Ingresa Tu nombre de jugador"<<endl;
    getline(cin,name);
    cout<<"Ingresa la opcion a realizar "<<name<<endl;
    cout<<"1....Iniciar juego desde cero"<<endl;
    cout<<"2....Cargar partida anterior"<<endl;
    cout<<"3....Reglas del Juego"<<endl;
    cin>>option;
    switch(option)
    {
    case 1:
            start();
        break;
    case 2:
            load();
        break;
    case 3:
            Game_Rules();
        break;
    default:

        break;
    }

}

Ahí va mi resultado:

#include <iostream>
#include <fstream>

using namespace std;

void drawMap( int heroPosX, int heroPosY, char gameMap[5][10]){
    for(int i=0; i<5; i++){
        for(int j=0; j<10; j++){
           if(j == heroPosX && i==heroPosY){
              cout<<'H';
        } else{
            cout<< gameMap[i][j];
        }
        }
        cout<<' '<<endl;
    }
}

int main()
{

    ifstream myFileRead("heroPosition.txt");
    string line;

    int heroPosX;
    int heroPosY;
    int row = 0;

    if(myFileRead.is_open()){
        while(getline(myFileRead, line)){
            if(row==0){
                heroPosX = stoi(line);
                //cout<<"line x"<<line<<endl;
            }
            if(row==1){
                heroPosY = stoi(line);
                //cout<<"line y" <<line<<endl;
            }
            row++;
        }
    }
    else{
        cout<< "Can't open the file, the hero will start at the beginning" <<endl;
        heroPosX = 0;
        heroPosY = 0;
    }

    //cout<<"x="<<heroPosX<<endl;
    //cout<<"y="<<heroPosY<<endl;

    bool isGameOver = false;

    char input =' ';
    char gameMap[5][10] = {
        {'1', '1','1','1','1','1','1','1','1','1'},
        {'1', '1','1','1','1','1','1','1','1','1'},
        {'1', '1','1','1','1','1','1','1','1','1'},
        {'1', '1','1','1','1','1','1','1','1','1'},
        {'1', '1','1','1','1','1','1','1','1','1'}
    };
    drawMap(heroPosX, heroPosY, gameMap);

    while(!isGameOver){

        cin >> input;

            if(input == 'd'){
                if(heroPosX < 9){
                    heroPosX++;
                }
            } else if(input == 'a'){
                if(heroPosX>0){
                heroPosX--;
                }
            }else if(input == 'w'){
                if(heroPosY>0){
                heroPosY--;
                }
            } else if(input == 's'){
                if(heroPosY<4){
                heroPosY++;
                }
            }else if(input == 'p'){
                isGameOver = true;
            }

        drawMap(heroPosX, heroPosY, gameMap);
    }

    ofstream myFile("heroPosition.txt");

    if(myFile.is_open()){
        myFile << heroPosX<<endl;
        myFile << heroPosY<<endl;
    }

    myFile.close();

    return 0;
}

Estuvo un poco complejo el reto pero eso hace que se aprenda más!!💪
Creo que la redacción no es clara…pero viendo los ejemplos de los compañeros, entendí que la idea era básicamente poder guardar y cargar el progreso del juego desde un archivo de texto y así poder guardar la posición del juego anterior.
 
Dejo por acá mi código (espero que le ayude para guiarse a algunos)

#include <iostream>
#include <unistd.h>
#include <fstream>

using namespace std;

void saveProgress(string name, int heroPosX, int heroPosY) {
  ofstream data("gameData.txt");
  if (data.is_open())
  {
    data << name << endl;
    data << heroPosX << endl;
    data << heroPosY << endl;
    cout << "Type your hero name: " << endl;

    cout << "Saving you session..." << endl;
    sleep(1);
    cout << "Saved! See you soon.";
  }
  data.close();
};

void drawMap(int heroPosX, int heroPosY, char gameMap[5][5] ) {
  cout << endl << "   Map" << endl;
  for (int i = 0; i < 5; i++)
  {
    for(int j=0; j < 5; j++){
      if (i == heroPosY && j == heroPosX)
      {
        cout << 'H' << " ";
      }
      else
      {
        cout << gameMap[i][j] << " ";
      }
    }
    cout << endl;
  }
}

void playGame(bool gameOver, int heroPosX, int heroPosY, char gameMap[5][5], string name) {
  drawMap(heroPosX, heroPosY, gameMap);
  char Inpt = ' ';
  while (gameOver == false) {
    cout << endl;
    cin >> Inpt;

    switch (Inpt)
    {
    case 'd':
      heroPosX++;
      drawMap(heroPosX, heroPosY, gameMap);
      break;
    case 'a':
      heroPosX--;
      drawMap(heroPosX, heroPosY, gameMap);
      break;
    case 'w':
      heroPosY--;
      drawMap(heroPosX, heroPosY, gameMap);
      break;
    case 's':
      heroPosY++;
      drawMap(heroPosX, heroPosY, gameMap);
      break;
    case 'p':
      gameOver = true;
      break;
    default:
      gameOver = true;
      break;
    }    
  }
  cout << endl << "Would you like to save this session?" << endl;
  cout << "(Y) Yes" << endl;
  cout << "(N) No" << endl;
  char save = ' ';
  cin >> save;
  if (save == 'Y')
  {
    saveProgress(name, heroPosX, heroPosY);
  }
}

void loadProgress(bool gameOver, char gameMap[5][5]) {
  ifstream dataRead("gameData.txt");

  int heroPosX = 0, heroPosY = 0;
  int lineNumber = 0;
  string line = "", name = "";

  if (dataRead.is_open())
  {
    while (getline(dataRead, line))
    {
      lineNumber++;
      switch (lineNumber)
      {
      case 1:
        name = line;
        cout << endl
             << "Welcome back to you previous game " << name << endl;
        cout << "You know the rules, so, let's play" << endl;
        break;
      case 2:
        heroPosX = stoi(line);
        break;
      case 3:
        heroPosY = stoi(line);
        break;
      }
    }
  }
  dataRead.close();

  cout << endl
       << "Your last position was:" << endl;
  cout << "X: " << heroPosX << endl;
  cout << "Y: " << heroPosY << endl;

  playGame(gameOver, heroPosX, heroPosY, gameMap, name);
};

void printRules(string name){
  cout << endl << "Hello " << name << " welcome to this top game" << endl;
  cout << "Here the rules:" << endl;
  cout << "- Type s to move down" << endl;
  cout << "- Type w to move up" << endl;
  cout << "- Type d to move right" << endl;
  cout << "- Type a to move left" << endl;
  cout << "- Type p to exit game (and save)" << endl;
  cout << endl << "Please, the bounds of map are 5x5. Don't move out" << endl;
}

int main() {

  // Basic config
  bool gameOver = false;
  int heroPosX = 0;
  int heroPosY = 0;

  char gameMap[5][5] = {
      {'1', '1', '1', '1', '1'},
      {'1', '1', '1', '1', '1'},
      {'1', '1', '1', '1', '1'},
      {'1', '1', '1', '1', '1'},
      {'1', '1', '1', '1', '1'},
  };

  cout << "Welcome to your favorite game!" << endl;
  cout << endl << "Options:" << endl;
  cout << "1 -> Start a new game" << endl;
  cout << "2 -> Load previous game" << endl;
  cout << endl << "Type your options ";

  int initMode = 0;
  string name = "";
  cin >> initMode;

  if (initMode == 1) {    
    cout << "First, please type you nickname: "; cin >> name;
    printRules(name);

    playGame(gameOver, heroPosX, heroPosY, gameMap, name);
  } else if(initMode == 2) {
    loadProgress(gameOver, gameMap);
  }

  return  0;
}

Este es el mío: https://github.com/jcalvarezj/practice/blob/master/C%2B%2B/juego2D.cpp

Por si alguien se pierde un poco leyendo mi código, aquí unas explicaciones…

  • No quise usar namespace std y usé los elementos con std:: , solo como por seguir la buena práctica

  • In enligsh, porque hay que darle al inglés, y quedó documentadito

  • Definí constantes para manejar valores que se mantienen igual en todo el programa con

    #define NOMBRE_CONSTANTE valor

  • En lugar de números quise usar otros caracteres… por ejemplo espacio vacío (_), personaje (I), guardado del personaje (*)

  • Le di al mapa otras dimensiones (manejadas por constantes), y en los parámetros es opcional poner el tamaño de la primera dimensión de arrays

  • Usé punteros (o apuntadores) para modificar por referencia las variables pasadas como argumentos de métodos (con la forma clásica de C… porque acabo de descubrir que en C++ existen los parámetros por referencia que no necesitan punteros… pero ya que, son equivalentes… xD).

  • (Sobre lo anterior, por ejemplo, modificaA y modificaB cumplen el mismo fin:)

    #include <iostream>

    using namespace std;

    void modificaA(int * a) { // Forma clásica de C
    * a = 888;
    }

    void modificaB(int & b) { // Nueva forma de C++ , no es necesario dereferenciar b
    b = 111;
    }

    int main(int argc, char ** args) {
    int a = 1, b = 2;

      modificaA(&a);
      modificaB(b);
    
      cout << "a: " << a << " b: " << b << endl;
    
      return 0;
    

    }

  • Usé prototipos de funciones. Esto es, definir las firmas de las funciones antes del ‘main’ para poder definirlas después de éste (y para tener tanto orden en el código, como que no haya problemas con funciones que llaman a otras y no las encuentren anteriormente definidas)

  • Y quise como cuadrarlo en la regla de 80 caracteres máximo por línea, solo como para seguir estilos

Comparto mi solución

#include <iostream>
#include <fstream>
#include <cstdlib>

using namespace std;

void SaveGame(int PosX, int PosY)
{
    ofstream MyFile("SaveGame.txt");

    if(MyFile.is_open())
    {
        MyFile << PosX << endl;
        MyFile << PosY << endl;
    }

    MyFile.close();
}

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5])
{
    for(int i = 0; i < 5; i++)
    {
        for(int j = 0; j < 5; j++)
        {
            if(i != HeroPosY)
            {
                cout << GameMap[i][j];
            }
            else if (j != HeroPosX)
            {
                cout << GameMap[i][j];
            }
            else
            {
                cout << 'H';
            }
        }
        cout << endl;
    }
}

int main()
{
    ifstream MyFile("SaveGame.txt");
    string Line;
    int CountLine = 0;
    int SavePosX = 0;
    int SavePosY = 0;

    if(MyFile.is_open())
    {
        while(getline(MyFile, Line))
        {
            if(CountLine == 0)
            {
                SavePosX = atoi(Line.c_str());
            }
            if(CountLine == 1)
            {
                SavePosY = atoi(Line.c_str());
            }
            CountLine++;
        }
    }

    MyFile.close();

    int HeroPosX = SavePosX;
    int HeroPosY = SavePosY;
    bool GameOver = false;
    char Input = ' ';
    char GameMap[5][5] =
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'}
    };

    DrawMap(HeroPosX, HeroPosY, GameMap);

    while(GameOver == false)
    {
        cin >> Input;

        if(Input == 'd')
        {
            HeroPosX = HeroPosX + 1;
        }else if(Input == 'a')
        {
            HeroPosX = HeroPosX - 1;
        }else if(Input == 'w')
        {
            HeroPosY = HeroPosY - 1;
        }else if(Input == 's')
        {
            HeroPosY = HeroPosY + 1;
        }else if(Input == 'q')
        {
            SaveGame(HeroPosX, HeroPosY);
        }
        else if(Input == 'p')
        {
            GameOver = true;
        }
        DrawMap(HeroPosX, HeroPosY, GameMap);
    }

    return 0;
}


Ha costado un poco, pero lo he conseguido.

#include <iostream>
#include <fstream>
#include <string>
#include <stdlib.h>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5]) {
    ofstream Archivo ("SavedGame.txt");

    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            if (i != HeroPosY) {
                cout << GameMap[j][i];
            } else {
                if (j != HeroPosX) {
                    cout << GameMap[j][i];
                } else {
                    cout << 'H';
                    if (Archivo.is_open()) {
                        Archivo << j << endl;
                        Archivo << i << endl;
                    }
                }
            }
        }

        cout << endl;

    }
    cout << "Enter p to quit" << endl;
}

int main()
{

    int HeroPosX;
    int HeroPosY;
    string line;
    int count = 0;

    // Abrimos el archivo para poder guardar las posiciones
    ifstream Archivo ("SavedGame.txt");

    if (Archivo.is_open()) {
        while (getline(Archivo, line)) {
            if (count == 0) {
                HeroPosX = atoi(line.c_str());
            } else if (count == 1) {
                HeroPosY = atoi(line.c_str());
            }

            count++;
        }
    }


    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5] = {
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
    };



    DrawMap(HeroPosX, HeroPosY, GameMap);



    while (!isGameOver) {
cout << "w -> arriba" << endl;
        cout << "c -> abajo" << endl;
        cout << "a -> izquierda" << endl;
        cout << "d -> derecha" << endl;
        cin >> Input;
        if (Input == 'd') {
        HeroPosX = HeroPosX + 1;
        } else if (Input == 'a') {
            HeroPosX = HeroPosX - 1;
        } else if (Input == 'p') {
            isGameOver = true;
        } else if (Input == 'w') {
            HeroPosY -= 1;
        } else if (Input == 'c') {
            HeroPosY += 1;
        }

        DrawMap(HeroPosX, HeroPosY, GameMap);

    }

    return 0;
}

Tuve que buscar los errores que retornaba mi código debido a que no hemos visto los temas, pero aquí tengo mi reto concluido:

#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5])
{
    for(int i = 0; i < 5; i++)
    {
        for(int p = 0; p < 5; p++)
        {
            if(i != HeroPosY)
            {
                cout << GameMap[p][i];
            }
            else
            {
                if(p != HeroPosX)
                {
                    cout << GameMap[p][i];
                }else
                {
                    cout << 'H';
                }
            }
        }
        cout << endl;
    }
}

void savePosition(int HeroPosX, int HeroPosY)
{
    ofstream svPositionFile("savedPosition.txt");
    if(svPositionFile.is_open())
    {
        svPositionFile << HeroPosX << endl;
        svPositionFile << HeroPosY << endl;
    }
    svPositionFile.close();
}

int* getSavedPosition()
{
    ifstream getPositionFile("savedPosition.txt");
    string line;
    int* output = new int[2];
    int curLine = 0;

    if(getPositionFile.is_open())
    {
        while(getline(getPositionFile, line))
        {
            stringstream conv(line);
            conv >> output[curLine];
            curLine = curLine + 1;
        }
    }
    return output;
}

int main()
{
    int HeroPosX = 0;
    int HeroPosY = 0;
    char Input = ' ';
    bool isGameOver = false;
    int* lastPosition;
    char GameMap[5][5] = {
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'}
    };

    DrawMap(HeroPosX, HeroPosY, GameMap);

    while(isGameOver == false)
    {
        cin >> Input;

        if(Input == 'd')
        {
            HeroPosX = HeroPosX + 1;
        }else if(Input == 'a')
        {
            HeroPosX = HeroPosX - 1;
        }else if(Input == 's')
        {
            HeroPosY = HeroPosY + 1;
        }else if(Input == 'w')
        {
            HeroPosY = HeroPosY - 1;
        }else if(Input == '3')
        {
            savePosition(HeroPosX, HeroPosY);
        }else if(Input == '4')
        {
            lastPosition = getSavedPosition();
            HeroPosX = lastPosition[0];
            HeroPosY = lastPosition[1];
        }else if(Input == 'p')
        {
            isGameOver = true;
        }

        DrawMap(HeroPosX, HeroPosY, GameMap);
    }

    return 0;
}

No entendí del todo la instrucción, así que lo que hice fue que si el archivo no existía lo crea y si existe lo lee y asigna las coordenadas en el juego

#include <iostream>
#include <stdlib.h>// usar función system("cls||clear");
#include <conio.h> //usar función getch();
#include <ctype.h> //convertir a minúsculas
#include<fstream>
using namespace std;
char character = 'x';
int positionX = 0;
int positionY = 0;
char move;//guarda el comando para moverse
char map[5][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'},
};

void draw(char move) {
  move = tolower(move); //convierte a minúsculas
  switch (move) {
    case 'a':
      positionX--;
      break;
    case 'd':
      positionX++;
      break;
    case 'w':
      positionY--;
      break;
    case 's':
      positionY++;
      break;
    default:
      break;
  }
  if (positionX > 4) { //if's para establecer los límites
    positionX = 4;
  } else if (positionX < 0) {
    positionX = 0;
  }
  if (positionY > 4) {
    positionY = 4;
  } else if (positionY < 0) {
    positionY = 0;
  }
  system("cls||clear"); //borra lo que hay en la pantalla
  for (int i = 0; i <= 4; i++) {
    for (int j = 0; j <= 4; j++) {
      if (positionX == j && positionY == i) {
        cout << character;
      }
      else {
        cout << map[i][j];
      }
    }
    cout << endl;
  }
  cout << "\n\n\npress x to end";
}

int main() {
  string line;
  int renglon = 0;
  ifstream myFileRead("gameData.txt");
  if (myFileRead.is_open()) { //si el archivo ya existe
    while (getline(myFileRead, line)) {
      if (renglon == 0) {
        positionX = atoi(line.c_str()); //asigna coordenada X y atoi convierte a entero
      }
      if (renglon == 1) {
        positionY = atoi(line.c_str()); //asigna coordenada Y
      }
      renglon++;
    }
  } else {
    ofstream savePosition("gameData.txt"); //si no exite el archivo, lo crea
    if (savePosition.is_open()) {
      savePosition << positionX << endl; // y asina los valores de X y Y por defecto osea '0'
      savePosition << positionY << endl;
    }
  }
  cout << "press C to start";
  while (move != 'c') { //el juego inicia hasta pulsar la letra c
    move = _getch();
    move = tolower(move);
  }
  draw(move);
  while (move != 'x') {
    move = _getch(); //getch() nos evita presionar enter
    draw(move);
    ofstream savePosition("gameData.txt");
    if (savePosition.is_open()) {
      savePosition << positionX << endl; // asinación de las coordenadas guardadas en el archivo
      savePosition << positionY << endl;
    }
  }
  return 0;
}

El programa va a buscar el archivo con el mapa.
La primera linea representa el numero de files, despues se representa el mapa con las posiciones del heroe (H) y la salido (*).
IMPORTANTE: las filas deben tener los mismos caracteres

Ejemplo del contenido del archivo:
5
0H00000000
0000000000
0000000000
0000000000
0000000*00

Codigo:

#include <iostream>
#include <fstream>
#include <string>
#include <stdlib.h>

using namespace std;

int MAP_X_SIZE = 5;
int MAX_X = 4;
int MIN_X = 0;

int MAX_Y = 4;
int MIN_Y = 0;
int MAP_Y_SIZE = 5;

typedef struct point {
    int x;
    int y;
} Point;

typedef struct element {
    char name;
    Point position;
} Element;

Element hero;
Element finish;
char** map;

const char EMPTY_POINT = '0';
const char EXIT_POINT = '*';
const char HERO_POINT = 'H';

Point createPoint(int x, int y) {
    Point position;
    position.x = x;
    position.y = y;
    return position;
}

Point randomPoint() {
    return createPoint(rand() % MAP_X_SIZE, rand() % MAP_Y_SIZE);
}

Point initialPoint() {
    return createPoint(0, 0);
}

bool pointsAreEquals(Point p1, Point p2) {
    return p1.x == p2.x && p1.y == p2.y;
}

bool isValidYPosition(int y) {
    if (y < MIN_Y || y > MAX_Y) {
        cout << "Error: Position Y out of map" << endl;
        return false;
    }
    return true;
}

bool isValidXPosition(int x) {
    if (x < MIN_X || x > MAX_X) {
        cout << "Error: Position X out of map" << endl;
        return false;
    }
    return true;
}

bool isValidPosition(Point position) {
    return isValidXPosition(position.x) && isValidYPosition(position.y);
}

void setElementToMap(Element element) {
    if (isValidPosition(element.position)) {
        map[element.position.y][element.position.x] = element.name;
    }
}

int convertCharToMove(char move) {
    switch (move) {
        case 'd':
        case 'r':
            return 1;
        case 'u':
        case 'l':
            return -1;
        default:
            return 0;
    }
}

Point pointMovement(Point origin, char up_down, char left_right) {
    int y_move = convertCharToMove(up_down);
    int x_move = convertCharToMove(left_right);
    Point new_position = createPoint(origin.x + x_move, origin.y + y_move);
    if (!isValidPosition(new_position)) {
        return origin;
    }    
    return new_position;
}

Element createElement(char name, Point point) {
    Element element;
    element.name = name;
    element.position = point;
    return element;
}

void generateMovement(Element * element, char y_move, char x_move) {
    Point new_point = pointMovement((*element).position, y_move, x_move);
    setElementToMap(createElement(EMPTY_POINT, (*element).position));
    (*element).position = new_point;
    setElementToMap((*element));
}

void showMap() {
    cout << "Map:" << endl;
    for (int i = 0; i < MAP_Y_SIZE; i++) {
        for (int j = 0; j < MAP_X_SIZE; j++) {
            cout << map[i][j] << " ";
        }
        cout << endl;
    }
}

void init() {
    hero = createElement('H', initialPoint());
    finish = createElement('*', randomPoint());

    ifstream file_map("map.txt");
    if (file_map.is_open()) {
        string line;
        int line_length;
        int row = 0;
        bool first_row_read = true;
        while (getline(file_map, line)) {
            if (first_row_read) {
                first_row_read = false;
                MAP_Y_SIZE = atoi(line.c_str());
                MAX_Y = MAP_Y_SIZE - 1;
                map = new char*[MAP_Y_SIZE];
            } else {
                if (row == 0) {
                    MAP_X_SIZE = (int) line.length();
                    MAX_X = MAP_X_SIZE - 1;
                }
                map[row] = new char[MAP_X_SIZE];
                for (int column = 0; column < MAP_X_SIZE; column++) {
                    if (line[column] == HERO_POINT) {
                        hero.position = createPoint(column, row);
                    } else if (line[column] == EXIT_POINT) {
                        finish.position = createPoint(column, row);
                    }
                    map[row][column] = line[column];
                }
                row++;
            }
        }
    } else {
        map = new char*[MAP_Y_SIZE];
        for(int i = 0; i < MAP_X_SIZE; ++i) {
            map[i] = new char[MAP_X_SIZE];
        }
    }
    setElementToMap(finish);
    setElementToMap(hero);
}

int main(int argc, char const *argv[]) {
    init();
    char y_move;
    char x_move;
    cout << "Try to arrive to exit (*)" << endl;
    while (!pointsAreEquals(hero.position, finish.position)) {
        showMap();
        cout << "Specify movement:" << endl;
        cout << "[up: 'u', down: 'd', none: 'n']" << endl;
        cin >> y_move;
        cout << "[left: 'l', right: 'r', none: 'n']" << endl;
        cin >> x_move;
        generateMovement(&hero, y_move, x_move);
    }

    cout << "GAME FINISHED!!" << endl;
    showMap();
    for(int i = 0; i < MAP_Y_SIZE; ++i) {
        delete [] map[i];
    }
    delete [] map;
    return 0;
}```
#include <iostream>
#include <fstream>
#include <stdlib.h>

using namespace std;

int heroPos[2]= {0,0};

void drawMap(int heroPos[2], char gameMap[5][5])
{
    for(int i = 0; i < 5 ; i++)
    {
        for(int j = 0; j < 5; j++)
        {
            if((i != heroPos[0])||(j != heroPos[1]))
            {
                cout << gameMap[i][j];
            }else
            {
                cout << 'H';
            }
        }
        cout << endl;
    }
}

void savePos(int heroPos[2])
{
    ofstream FilePosSave("PlayerPosData.txt");
    string line;
    if(FilePosSave.is_open())
    {
        FilePosSave << heroPos[0] << endl;
        FilePosSave << heroPos[1] << endl;
    }
}

void getPos()
{
    ifstream FilePosRead("PlayerPosData.txt");
    string line;
    int renglon = 0;
    if(FilePosRead.is_open())
    {
        while(getline(FilePosRead, line))
        {
            heroPos[renglon] = atoi(line.c_str());
            renglon++;
        }
    }else
    {
        savePos(heroPos);
    }
    FilePosRead.close();

}

int main()
{
    getPos();
    bool isGameOver = false;
    char input = ' ';
    char gameMap[5][5] =
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'}
    };

    drawMap(heroPos,gameMap);
    while(isGameOver==false)
    {
        cin >> input;

        if (input == 'd')//derecha
        {
            heroPos[1]++;
            savePos(heroPos);
        }else if(input == 'a')//izquierda
        {
            heroPos[1]--;
            savePos(heroPos);
        }else if(input == 'f')//salir
        {
            savePos(heroPos);
            isGameOver=true;
        }else if(input == 'w')//arriba
        {
            heroPos[0]--;
            savePos(heroPos);
        }else if(input == 's')//abajo
        {
            heroPos[0]++;
            savePos(heroPos);
        }
        drawMap(heroPos,gameMap);
    }

    return 0;
}

aqui esta mi reto 3:

#include <iostream>
#include <fstream>
bool stop = true;
using namespace std;
char input;
int heroPosY=0;
int heroPosX=0;
//array y for
char gameMap[40][40]={{'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
                      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'},
                      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}};

void drawMap(int dmPosX,int dmPosY,char gameMap[40][40]){
for (int y=0;y<20;y++){

        for (int x=0;x<40;x++)
        {
                 if (y != dmPosY){
                 cout<<gameMap[x][y];
                 }

                 else
                 {
                         if (x != dmPosX){
                         cout<<gameMap[x][y];
                         }
                         else{
                         cout<<'3';

                         }
                 }
        }
cout<<endl;
}
}
void loadGame(){
char resp;
int renglon =0;
cout<<endl;
cout<<"Do you wanna load your last saved game?? (y/n) "<<endl;
cin>>resp;
if (resp == 'y'){
        string line;
        string nameRecovered;
        int renglon = 1;

     ifstream myFileRead("gameData.txt");
     if (myFileRead.is_open()){

        while(getline(myFileRead,line)){

                if (renglon == 1){
                nameRecovered = line;
                heroPosY = stoi(nameRecovered);
                }
                else if(renglon == 2) {
                nameRecovered = line;
                heroPosX = stoi(nameRecovered);
                }
                renglon = renglon + 1;
             }
         cout<<"heroPosY: "<<heroPosY<<endl;
         cout<<"heroPosX: "<<heroPosX<<endl;
        }
     else{
          cout<<"File could NOT be open..."<<endl;
        }
     }else
        {
          cout<<"Loading new Game :)"<<endl;
        }
drawMap(heroPosX,heroPosY,gameMap);
}

void saveGame(){


                ofstream myGameFile("gameData.txt");
                if (myGameFile.is_open()){
                myGameFile << heroPosY <<endl;
                myGameFile << heroPosX <<endl;

                /*for (int i=0;i<10;i++){
                myGameFile << i<<endl;
                }
                myGameFile << "Otra cosa...";*/
                 }
        myGameFile.close();
}
//FUNCION PARA DIBUJAR EL MAPA DEL JUEGO.
bool movePositionHero(char mpInput){
char resp;
//cout<<"bandera de mpStop: "<<mpStop<<endl;
//do{
switch(mpInput){


        case 'd':
                  heroPosY = heroPosY + 0;
                  heroPosX = heroPosX + 2;
                  cout <<heroPosY<<endl;
                  cout <<heroPosX<<endl;
                  break;

        case 'a':
                  heroPosY = heroPosY + 0;
                  heroPosX = heroPosX - 2;
                  cout <<heroPosY<<endl;
                  cout <<heroPosX<<endl;
                  break;

        case 'x':
                  heroPosY = heroPosY + 1;
                  heroPosX = heroPosX + 0;
                  cout <<heroPosY<<endl;
                  cout <<heroPosX<<endl;
                  break;

        case 'w':
                  heroPosY = heroPosY - 1;
                  heroPosX = heroPosX - 0;
                  cout <<heroPosY<<endl;
                  cout <<heroPosX<<endl;
                  break;
        case 'p': cout<<endl;
                  cout<<"Do you want to save your game (y/n)"<<endl;
cin>>resp;
                  if (resp == 'y'){
                  saveGame();
                  }
                  else{
                  cout<<"Game stopped (NOT saved)..."<<endl;
                  }
                  stop = false;
                  //return stop2;
                  break;
}

}
void Play(){


                while (stop){
                cout<<endl;
                cout<<"(D)Right,(A)Left,(W)Up,(X)Down,(P)ause"<<endl;
                cin>>input;
                movePositionHero(input);
                cout<<"Dimension 1: "<<heroPosY<<" (Columnas) "<<endl;
                cout<<"Dimension 2: "<<heroPosX<<" (Filas) "<<endl;
                drawMap(heroPosX,heroPosY,gameMap);
                }

}

void initialPosition(){
char input;
drawMap(heroPosX,heroPosY,gameMap);
while (stop){
        cout<<endl;
        cout<<"Move your Hero to the Position you want..."<<endl;
        cout<<"(D)Right,(A)Left,(W)Up,(X)Down -- press (S) to set"<<endl;
        cin>>input;
        if (input == 's'){
        cout<<"Your position is already set."<<endl;
        cout<<"Enjoy your Game :)"<<endl;
        Play();
        }
        movePositionHero(input);
        cout<<"Dimension 1: "<<heroPosY<<" (Columnas) "<<endl;
        cout<<"Dimension 2: "<<heroPosX<<" (Filas) "<<endl;
        drawMap(heroPosX,heroPosY,gameMap);
        }
}
int main()
{
char option;
char resp;
system("clear");
cout<<"          Main Menu        "<<endl;
cout<<"---------------------------"<<endl;
cout<<"        1.New Game         "<<endl;
cout<<"        2.Load Game        "<<endl;
cout<<"        3.Quit             "<<endl;
cout<<"-------------------------- "<<endl;
cout<<"************************** "<<endl;
cout<<"-------------------------- "<<endl;
cin>>option;

switch (option){

        case '1':
                cout<<endl;
                cout<<"Do you wanna set Your Initial Position?? (y/n)"<<endl;
                cin>>resp;
                        if ( resp == 'y' ){
                                initialPosition();
                        }else{
                drawMap(heroPosX,heroPosY,gameMap);
                Play();
                        }
                break;
        case '2':
                loadGame();
                Play();
                break;

        case '3':
                cout<<"Quiting the game"<<endl;
                break;
}
return 0;
}

#include <iostream>
#include <fstream>

using namespace std;

void GameMenu() {
cout << “Juego de Laberinto!!!” << endl;
cout << “Mueve tu personaje en diferentes posiciones dentro del mapa\n”;
cout << “Usa las teclas de direccion para moverte por el mapa.\n”;
cout << “Arriba: w | Abajo: s | Izquierda: a | Derecha: d\n”;
cout << “Usa la tecla x para salir del juego.\n”;
cout << “No te preocupes por la posicion de tu personaje, el juego guarda\n”;
cout << “tus datos al salir y continua donde te quedaste.” << endl;
}

void DrawMap(int heroPosX, int heroPosY, char map[5][5]) {
system(“clear”);
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (i != heroPosY) {
cout << map[i][j];
}
else if (j != heroPosX) {
cout << map[i][j];
} else {
cout << ‘#’;
}
}
cout << endl;
}
}

void SaveHeroPos (int heroPosX, int heroPosY) {
ofstream file(“GameConf.txt”);
if (file.is_open()) {
file << “Hero Position Coordinates” << endl;
file << heroPosX << endl;
file << heroPosY << endl;
}
file.close();
}

int main() {

// ---------------------------------------
//      $ Game Settings
// ---------------------------------------
int HeroPosX = 0;
int HeroPosY = 0;
bool IsGameOver = false;
char Input = '\0';

char GameMap[5][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'}
};



// ---------------------------------------
//      $ Acceso a ficheros
// ---------------------------------------
ifstream file("GameConf.txt");

if (file.is_open()) {

    string line = "";
    int columna = 0;

    while (getline(file, line)) {
        if (columna == 1) {
            HeroPosX = atoi(line.c_str());
        }
        if (columna == 2) {
            HeroPosY = atoi(line.c_str());
        }
        columna++;
    }
}
else {
    SaveHeroPos(HeroPosX, HeroPosY);
}
file.close();


// ---------------------------------------
//      $ Game Loop
// ---------------------------------------
while (!IsGameOver) {
    GameMenu();
    DrawMap(HeroPosX, HeroPosY, GameMap);
    /*----- Entrada de coordenadas -----*/
    cout << "> ";
    cin >> Input;

    switch (Input) {
        case 'w':
            HeroPosY--;
            break;
        case 's':
            HeroPosY++;
            break;
        case 'd':
            HeroPosX++;
            break;
        case 'a':
            HeroPosX--;
            break;
        case 'x':
            IsGameOver = true;
            break;
    }

    /*----- Fixin Parameters -----*/
    if (HeroPosX > 4) {
        HeroPosX = 4;
    }
    else if (HeroPosX < 0) {
        HeroPosX = 0;
    }
    if (HeroPosY > 4) {
        HeroPosY = 4;
    }
    else if (HeroPosY < 0) {
        HeroPosY = 0;
    }

    SaveHeroPos(HeroPosX, HeroPosY);
}
cout << "Gracias por jugar este juego. Adios!" << endl;

return 0;

}

RETO LOGRADO!!!
Tuve que crear el Mapa en archivo de texto primero , pero el codigo funciona perfectamente 😃

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

void DrawMap(int HeroPosx, int HeroPosy, char GameMap[5][5])
{
    for(int i = 0; i<5; i++ )
    {
        for (int p = 0 ; p< 5; p++ )
        {
            if ( i != HeroPosy)
            {
                cout << GameMap[p][i];
            }
            else
            {
                if ( p != HeroPosx)
                {
                    cout << GameMap[p][i];
                }
                else
                {
                    cout << 'H';

                }
            }
        }
        cout << endl;

    }
}

int main()
{
    int HeroPosx;
    int HeroPosy;
    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5] =
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'}
    } ;

    ifstream ReadMap("FileMap.txt");
    string line;
    int row = 0;
    if(ReadMap.is_open())
    {
        while(getline(ReadMap, line))
        {
            for(int i = 0; i < line.size(); i++)
            {
                if (line[i] == '3')
                {
                    HeroPosx = i;
                    HeroPosy = row;
                }
            }
            row++;
        }
    }

    DrawMap(HeroPosx, HeroPosy,GameMap);

    while( isGameOver == false)
    {

        cin >> Input;
        switch(Input)
        {
        case 'd':
            HeroPosx++;
            break;
        case 'a':
            HeroPosx--;
            break;
        case 's':
            HeroPosy++;
            break;
        case 'w':
            HeroPosy--;
            break;
        case 'p':
            isGameOver = true;
            break;
        default:
            cout << "Input invalido"<<endl;
            break;
        }

        DrawMap(HeroPosx, HeroPosy,GameMap);

    }

    return 0;
}
#include <iostream>
#include <string>
#include <fstream>

using namespace std;

const char HERO = '$';

char mapGame[5][10] =
{
    {'o','o','o','o','o','o','o','o','o','o'},
    {'o','o','o','o','o','o','o','o','o','o'},
    {'o','o','o','o','o','o','o','o','o','o'},
    {'o','o','o','o','o','o','o','o','o','o'},
    {'o','o','o','o','o','o','o','o','o','o'}
};

//fun dibujar mapa
void drawMap(int posX, int posY, char mapGame[5][10])
{
    for(int i=0;i<5;i++)
    {
        for(int j=0;j<10;j++)
        {
            if((posX==j) && (posY==i)){
                cout << HERO;
            }
            else
            {
                cout << mapGame[i][j];
            }
        }
        cout << endl;
    }
}

int main()
{
    bool isGameOver = false;
    int posX = 0;
    int posY = 0;
    char movimiento = 0;
    string line;

    cout << "Bienvendio al juego" << endl<< endl;

    /*
    cout << "Donde quieres iniciar a tu héroe (valores entre 1 y 10)" << endl;
    do
    {
        cout << "Posicion X: ";
        cin >> posX;
    }while( posX > 10 || posX < 1 );
    do
    {
        cout << "Posicion Y: ";
        cin >> posY;
    }while( posY > 5 || posY < 1 );
    */

    //------------------------------
    //Abriri archivo: para obtener las posiciones X y Y del heroe
    //------------------------------
    ifstream MyFile("game.txt");
    if(MyFile.is_open())
    {
        while(getline(MyFile, line))
        {
            for(int i=0; i < line.size(); i++)
            {
                if(i==0)
                {
                    posX=(int)line[i]-48;
                }
                else if(i==1)
                {
                    posY=(int)line[i]-48;
                }
            }
        }
    }
    //cierra archivo
    MyFile.close();

    cout << posX+1 << endl;
    cout << posY+1 << endl;

    drawMap(posX,posY,mapGame);
    cout << "Para desplazarte a la izq:a, der:d, arri:w, abaj:s" << endl;
    //movimiento
    do
    {
        cin >> movimiento;
        switch(movimiento)
        {
        case 'a'://izquierda
            if(posX > 0)
            {
                posX--;
            }
            break;
        case 'd'://derecha
            if(posX < 9)
            {
                posX++;
            }
            break;
        case 's'://abajo
            if(posY < 4)
            {
                posY++;
            }
            break;
        case 'w'://arriba
            if(posY > 0)
            {
                posY--;
            }
            break;
        case 'p'://pausa
            isGameOver=true;
        }
        drawMap(posX,posY,mapGame);
    }while(isGameOver==false);

    ofstream Myfile("game.txt");
    Myfile << posX << posY;

    return 0;
}```
#include <iostream>
#include <fstream>

using namespace std;

void DrawMap(int player_posX,int player_posY, char game_Map[5][5])
{
    ofstream mapa("map.txt");




    for(int i=0; i<5; i++)
    {
        for(int j=0; j<5; j++)
        {

            if(mapa.is_open())
            {
                mapa<<game_Map[j][i];
            }

            if(i != player_posY)
            {
                cout<<game_Map[j][i];

            }
            else
            {
                if(j !=player_posX)
                {
                    cout<<game_Map[j][i];
                }
                else
                {
                    cout<<'P';
                }

            }
        }
        cout<<endl;
        mapa<<endl;

    }
}

int main()
{


    bool isGameOver= false;
    char input=' ';
    char game_Map [5][5] =
    {
        {'0','_','_','_','_'},
        {'_','_','_','_','_'},
        {'_','_','_','_','_'},
        {'_','_','_','_','_'},
        {'_','_','_','_','_'}

    };
    int player_posX = 0;
    int player_posY = 0;

    for(int i=0;i<5;i++)
    {
        for(int j=0; j<5; j++)
        {
            if(game_Map[j][i]=='0')
            {
                player_posX = i;
                player_posY = j;
            }

        }
    }







    DrawMap(player_posX, player_posY, game_Map);



    while(isGameOver==false)
    {
        cin>>input;

        if (input == 'd')
        {
            player_posX++;
        }

        else if(input == 'a')
        {
            player_posX--;
        }
        else if (input == 's')
        {
            player_posY++;
        }

        else if(input == 'w')
        {
            player_posY--;
        }
        else if(input=='p')
        {
            isGameOver=true;

        }

        DrawMap(player_posX, player_posY, game_Map);
    }





   return 0;
}

Reto cumplido✌🏼

<#include <iostream>
#include <fstream>

using namespace std;

void DrawMap(int heroPosX, int heroPosY, char gameMap[5][5]){
    for(int x = 0; x < 5; x++){
        for(int y = 0; y < 5; y++){
            if(heroPosX == x && heroPosY == y){
                cout<<"H";
            }else{
                cout<<gameMap[x][y];
            }            
        }
        cout<<endl;
    }
}

int main()
{
    int heroPosX = 0, heroPosY = 0, tam = 5;
    bool gameOver = false;
    char input;
    char gameMap[5][5] =
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'3','1','1','1','1'},
        {'1','1','1','1','1'},
    };

    //Escribo un archivo con el mapa del juego
    ofstream write("GameMap.txt");

    if(write.is_open()){
        for(int x = 0; x < 5; x++){
            for(int y = 0; y < 5; y++){
                write<<gameMap[x][y];
            }
            write<<endl;
        }
    }else{
        cout<<"No se pudo abrir el archivo"<<endl;
    }
    //Leo el archivo para luego encontrar el punto de partida del jugador
    //nro 3
    ifstream read("GameMap.txt");
    string line;
    int cont = 0;

    if(read.is_open()){
        while(getline(read, line)){
            heroPosY = line.find_first_of("3");
            if(heroPosY != -1){
                heroPosX = cont;
                break;
            }
        cont++;
        }
    }else{
        cout<<"No se pudo abrir el archivo"<<endl;
    }

    DrawMap(heroPosX, heroPosY, gameMap);
    while(!gameOver){

        cin>>input;
        if(input == 'w'){
            heroPosX--;
        }else if(input == 's'){
                heroPosX++;
        }else if(input == 'a'){
            heroPosY--;
        }else if(input == 'd'){
            heroPosY++;
        }else if(input == 'p'){
            gameOver = true;
        }

        DrawMap(heroPosX, heroPosY, gameMap);

    }

    return 0;
}>

espero a verlo hecho bien

#include <iostream>
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


using namespace std;
//funcion para dubujar mapa
void DrawMap(int HeroPosX, int HeroPosY , char GameMap[5][5])
{
     for (int i = 0; i < 5; i = i + 1){
            for (int j = 0; j < 5; j = j + 1){
                if(i != HeroPosY){
                    cout << GameMap[j][i];
                }
                else{
                    if(j != HeroPosX){
                        cout << GameMap[j][i];
                    }else{
                        cout << '3';
                    }
                }

            }
            cout << endl;
        }

}
void WriteFlie(int HeroPosX, int HeroPosY , char GameMap[5][5]){
    ofstream MyFile("GameData.txt");

    if(MyFile.is_open()){
         for(int i = 0; i < 5; i+=1){
            for(int j = 0; j < 5; j+=1){
                if(i != HeroPosY){
                    MyFile << GameMap[j][i];
                }
                else{
                    if(j != HeroPosX){
                        MyFile << GameMap[j][i];
                    }else{
                        MyFile << '3';
                    }
                }
            }
            MyFile << endl;
         }
    }else{
        cout << "No logre abrir el archivo" << endl;
    }

    MyFile.close();
}

void ReadFile(){

    ifstream MyFileRead("GameData.txt");
    string line;
    char * cadenaDinamica = NULL;
    int lenghtArray = 0;
    int counter = 0;

    if(MyFileRead.is_open()){
        while(getline(MyFileRead, line)){
            //cout << line << endl;
            lenghtArray = line.length();

            cadenaDinamica = new char[lenghtArray];
            strcpy(cadenaDinamica,line.c_str());
            for(int i = 0; i < lenghtArray; i+=1){
                //cadenaDinamica[i] = line;

                //cout << counter;
                if(cadenaDinamica[i] == '3'){
                    cout << "Renglon: " << counter << endl;
                }
            }
            counter += 1;
        }
        //limpiar arreglo
        delete[] cadenaDinamica;
        cadenaDinamica = NULL;
        MyFileRead.close();
        counter = 0;

    }else{
        cout << "I can't find the file" << endl;
    }
}
int main()
{
    //Mapa videojuego
    int HeroPosX = 1;//Jugador
    int HeroPosY = 1;
    char Input = ' ';
    bool IsGameOver = false;
    char GameMap[5][5] =
    {
            {'1','1','1','1','1'},
            {'1','1','1','1','1'},
            {'1','1','1','1','1'},
            {'1','1','1','1','1'},
            {'1','1','1','1','1'}
    };
    //Guardar informacion en txt



    DrawMap(HeroPosX,HeroPosY,GameMap);
    WriteFlie(HeroPosX,HeroPosY,GameMap);

    while(IsGameOver == false)
    {
        cin >> Input;

        if(Input == 'r'){
            HeroPosX += 1; //right
        }else if(Input == 'l'){
            HeroPosX -= 1; //left
        }else if (Input == 'u'){
            HeroPosY -=1; //up
        }else if (Input == 'd'){
            HeroPosY +=1;//down
        }else if(Input == 'p'){
            IsGameOver = true;//pause Game
        }
        WriteFlie(HeroPosX,HeroPosY,GameMap);
        ReadFile();

        DrawMap(HeroPosX,HeroPosY,GameMap);

    }


}

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5]) {

    for (int c = 0; c < 5; c++)
    {
        for (int f = 0; f< 5; f++) 
        {
            if (c != HeroPosY) 
            {
                cout << GameMap[f][c];
            }
            else 
            {
                if (f != HeroPosX)
                {
                    cout << GameMap[f][c];
                }
                else {
                    cout << "H";
                }
                
            }
        }
        cout << endl;
        
    }
}

void saveGame(int HeroPosX, int HeroPosY)
{
    // Escribir archivos
    ofstream MyFile("GameData.txt");

    if (MyFile.is_open())
    {
        MyFile << "###################" << endl;
        MyFile << "Coordenadas de ubicacion" << endl;
        MyFile << HeroPosX << endl; // posicion de X : 2
        MyFile << HeroPosY << endl; // posicion de y : 3
        MyFile << "###################" << endl;

    }

    MyFile.close();


}

string openGame(int posicion)
{
    // Leer archivos
    ifstream MyFileRead("GameData.txt");
    string ubicacion;
    string line;

    int renglon = 0;

    try
    {
        if (MyFileRead.is_open())
        {
            while (getline(MyFileRead, line))
            {
                if (renglon == posicion)
                {
                    ubicacion = line;
                }
                renglon++;
            }
        }
        // Sino nueva partida 
    }
    catch (const std::exception&)
    {
        cout << "No logro abrir el archivo, chekear el antivirus" << endl;
    }
    
    return ubicacion;
}

int main()
{
    string lineX, lineY;
    int HeroPosX = 0;
    int HeroPosY = 0;

    cout << "Bienvenido a tu aventura" << endl;

    lineX = openGame(2);    
    lineY = openGame(3);
    

    if (lineX != "" && lineY != "")
    {
        HeroPosX = stoi(lineX);
        HeroPosY = stoi(lineY);
    }
    
    bool isGameOver = false;
    char input = ' ';
    char GameMap[5][5] = {
        { '1', '1', '1', '1', '1' },
        { '1', '1', '1', '1', '1' },
        { '1', '1', '1', '1', '1' },
        { '1', '1', '1', '1', '1' },
        { '1', '1', '1', '1', '1' }
    };

    DrawMap(HeroPosX, HeroPosY, GameMap);

    while (isGameOver == false) 
    {
        cin >> input;

        switch (input)
        {
            case 'a':   HeroPosX--;
                        break;
            case 'd':   HeroPosX++;
                        break;
            case 'w':   HeroPosY--;
                        break;
            case 's':   HeroPosY++;
                        break;
            case 'p':   isGameOver = true;
                        saveGame(HeroPosX, HeroPosY);
                        break;
            default:
                        break;
        }

        DrawMap(HeroPosX, HeroPosY, GameMap);
    }


    return 0;
}

#include <iostream>
#include <fstream>>

using namespace std;


void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5]) {
  for(int i = 0; i < 5; i++) {
     for(int p = 0; p < 5; p++) {
      if (i != HeroPosY)
      {
        cout << GameMap[p][i];
      }
      else
      {
        if (p != HeroPosX)
        {
          cout << GameMap[p][i];
        }
        else
        {
          cout << 'H';
        }
      }
    }

    // Necesitamos un salto de línea para diferenciar
    // las filas de las columnas:
    cout << endl;
  }
}

int main()
{
  // ...

  char decision;
  int HeroPosX = 1;
  int HeroPosY = 1;
  char MoveHero;
  char SaveGame;
  bool GameOver = false;
  char GameMap[5][5] =
  {
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
    {'1','1','1','1','1'},
  };


    cout<<"Desea contnuar la partida anterior? s/n"<<endl;
    cin>>decision;

    if(decision =='s'){

        ifstream ArchivoGameRead("ArchivoGame.txt");
        string  line;
        int renglon=0;

        if(ArchivoGameRead.is_open()){


        while(getline(ArchivoGameRead, line) && renglon <2){

                if (renglon == 0){

                    HeroPosX=atoi(line.c_str());
                }else if(renglon==1){
                    HeroPosY=atoi(line.c_str());
                    renglon++;
                }

        }
    }else
        cout<<"No logre abrir el archivo, problemascon el antivirus" <<endl;





    }else if(decision=='n'){
        cout<<"Empieza el juego"<<endl;
    }
   while(GameOver == false){



    DrawMap(HeroPosX,HeroPosY,GameMap);
    cout<<"["<<HeroPosX<<"] "<<"["<<HeroPosY<<"]"<<endl;
    cin>>MoveHero;
    system("cls");

    switch(MoveHero){

        case 'd':
            if(HeroPosX<4){
                HeroPosX++;
            }else DrawMap(HeroPosX,HeroPosY,GameMap);
        break;

        case 'a':
            if(HeroPosX>0){
                HeroPosX--;
            }else DrawMap(HeroPosX,HeroPosY,GameMap);
        break;

        case 'w':
            if (HeroPosY>0){
            HeroPosY=HeroPosY-1;
            }else DrawMap(HeroPosX,HeroPosY,GameMap);
        break;

        case 's':
        if (HeroPosY<4){
            HeroPosY= HeroPosY+1;
        }else DrawMap(HeroPosX,HeroPosY,GameMap);

        break;

        case 'l':

             ofstream ArchivoGame("ArchivoGame.txt");

            cout<<"Se a guardado la partida"<<endl;

        system("pause");

            if(ArchivoGame.is_open()){


                    ArchivoGame<<HeroPosX<<endl;
                    ArchivoGame<<HeroPosY<<endl;

            }else
                cout<<"problemas al guardar la partida"<<endl;


            ArchivoGame.close();

         break;

    }





        DrawMap(HeroPosX,HeroPosY,GameMap);

    system("CLS");

   }


  // ...
return 0;
}

Reto superado!!!

#include <iostream>
#include <fstream>

using namespace std;

void drawmap(int hposx, int hposy, char gmap [10][10], char ghor[10], char gver[10])
{
    cout << "  ";
    for(int j = 0; j < 10; j++)
    {
        cout << gver[j]<< " ";
    }
    cout << endl;
    //system(cls); junto a libreria stdlib
    for(int i = 0; i < 10; i++)
    {
        cout << ghor[i] << " ";
        for(int j = 0; j < 10; j++)
        {
            if (i != hposy)
            {
                    cout << gmap[i][j]<<" ";
            }
            else
            {
                if (j!= hposx)
                {
                    cout << gmap[i][j]<<" ";
                }
                else
                {
                    cout << 'H' << " ";
                }
            }
        }
        cout<<endl;
    }
}
int main()
{
    ofstream arch1("save.txt");
    ifstream arch2("save.txt");
    string recorre = "", result = "";
    int hposx = 0, hposy = 0, fil = 0, col = 0, lr = 0;
    char input = ' ';
    bool gameover = false, goal = false;
    char ghor[10] = {'0','1','2','3','4','5','6','7','8','9'}, gver[10] = {'0','1','2','3','4','5','6','7','8','9'};
    char gmap[10][10] =
    {
        {'_','_','_','_','_','_','_','_','_','_'},
        {'_','_','_','_','_','_','_','_','_','_'},
        {'_','_','_','_','_','_','_','_','_','_'},
        {'_','_','_','_','_','_','_','_','_','_'},
        {'_','_','_','_','_','_','_','_','_','_'},
        {'_','_','_','_','_','_','_','_','_','_'},
        {'_','_','_','_','_','_','_','_','_','_'},
        {'_','_','_','_','_','_','_','_','_','_'},
        {'_','_','_','_','_','_','_','_','_','_'},
        {'_','_','_','_','_','_','_','_','_','_'},
    };

    drawmap(hposx, hposy, gmap, ghor, gver);

    cout <<"En que pocision desea ubicar la salida "<< endl;
    cout <<"Fila: ";
    cin >> fil;
    cout <<"Columna: ";
    cin >> col;
    gmap[fil][col] = 'E';

    while(gameover == false)
    {
        cout << "Adonde va el heroe: ";
        cin >> input;

        if ((input == 'a') || (input == 'd') || (input == 'w') || (input == 's') || (input == 'p'))
        {
            if(input == 'd')
            {
                hposx ++;
            }
            else if(input == 'a')
            {
                hposx --;
            }
            else if(input == 'w')
            {
                hposy --;
            }
            else if(input == 's')
            {
                hposy ++;
            }
            else if (input == 'p')
            {
                gameover = true;
            }
        }
        else
        {
           cout << "Direccion incorrecta" << endl;
        }

        if(hposx < 0 || hposx > 9 || hposy < 0 || hposy > 9)
        {
            if(hposx < 0)
            {
                hposx = 0;
            }
            else if(hposx > 9)
            {
                hposx = 9;
            }
            else if(hposy < 0)
            {
                hposy = 0;
            }
            else if(hposy > 9)
            {
                hposy = 9;
            }
        }
        if ((hposx == col) && (hposy == fil))
        {
            cout << "Llego a la META!!!!" << endl;
            if (arch1.is_open())
            {
                arch1 << "Guardado" << endl;
                arch1 << "La meta estaba en la fila: " << fil << endl;
                arch1 << "La meta estaba en la columna: " << col << endl;
            }
            arch1.close();
            gameover = true;
        }
        drawmap(hposx, hposy, gmap, ghor, gver);
    }

    cout << "Juego terminado" << endl;
    cout << "Resultado" << endl;

    if(arch2.is_open())
    {
        while(getline(arch2, result))
        {
            if (lr >= 1)
            {
                cout << result << endl;
            }
            lr++;
        }
    }
    else
    {
        cout << "No logre abrir el archivo" << endl;
    }
    arch2.close();
    return 0;
}
#include <iostream>
#include <fstream>
using namespace std;

//FUNCION PARA DIBUJAR EL MAPA
void dibujarMapa(int posicionHeroe[2], char mapa[5][5]){
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (posicionHeroe[0] == i && posicionHeroe[1] == j)
            {
                cout << 'H';
            }
            else
            {
                cout << mapa[i][j];
            }
        }
        cout << endl;
    }
}

//FUNCION PARA ASIGNAR UNA NUEVA POSICIÓN AL HÉROE
bool asignarNuevaPosicion(char movimiento, int posicionHeroe[2]){
    switch (movimiento)
    {
        case 'a':
            posicionHeroe[1]--;
        break;
        case 'd':
            posicionHeroe[1]++;
        break;
        case 's':
            posicionHeroe[0]++;
        break;
        case 'w':
            posicionHeroe[0]--;
        break;
        case 'p':
            return true;
        break;
        default:
            break;
    }
    return false;
}

//FUNCIÓN PARA BUSCAR Y LEER UN ARCHIVO GUARDADO CON ANTERIORIDAD Y CARGAR LOS DATOS QUE CONTENGA
void leerArchivo(int posicionHeroe[2]){
    ifstream Archivo_Lectura("Datos.txt");
    string linea;
    char leer = ' ';
    if (Archivo_Lectura.is_open())
    {   
        cout << "Hemos encontrado un archivo de guardado. Deseas leerlo?" << endl <<
        "(y) Si" << endl <<
        "(cualquier tecla) No" << endl;
        cin >> leer;
        if (leer == 'y')
        {
            cout << "Leyendo tu archivo de guardado..." << endl;
            int i = 0;
            while(getline(Archivo_Lectura, linea)){
                posicionHeroe[i] = stoi(linea);
                i++;
            }
        }
    }
    else
    {
        cout << "No fue posible abrir el archivo" << endl;
    }
}

//FUNCIÓN PARA GUARDAR EL ARCHIVO UNA VEZ QUE LOS DATOS SON CONFIRMADOS.
void guardarArchivo(int posicionHeroe[2]){
    cout << "Guardando archivo..." << endl;
    ofstream Archivo("Datos.txt");
    if (Archivo.is_open())
    {
        Archivo << posicionHeroe[0] << endl;
        Archivo << posicionHeroe[1] << endl;
    }
    Archivo.close();
    cout << "Archivo guardado..." << endl;
}

//FUNCIÓN PARA CONFIGURAR LA POSICIÓN DEL HÉROE ANTES DE GUARDARLA
void configurarPosicionHeroe(int posicionHeroe[2], char mapa[5][5]){
    char movimiento = ' ';
    cout << "Selecciona la posicion de tu heroe:" << endl <<
    "(a) Izquierda" << endl << 
    "(b) Derecha" << endl <<
    "(w) Arriba" << endl <<
    "(s) Abajo" << endl << 
    "(y) para confirmar" << endl << endl;
    bool confirmarPosicion = false;
    do
    {
        dibujarMapa(posicionHeroe, mapa);
        cin >> movimiento;
        if (movimiento == 'y')
        {
            cout << "Esta seguro que desea configurar esta posicion de inicio?" << endl <<
            "(y) Si" << endl <<
            "(cualquier tecla) No" << endl;
            char confirmacion = ' ';
            cin >> confirmacion;
            if (confirmacion == 'y')
            {
                confirmarPosicion = true;
            }
        }
        else
        {
            asignarNuevaPosicion(movimiento, posicionHeroe);
        }
    } while (confirmarPosicion == false);
    guardarArchivo(posicionHeroe);
}

int main(){
    int posicionHeroe[2] = {0, 0};
    char movimiento = ' ';
    bool fin = false;
    char mapa[5][5] = {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'}
    };

    leerArchivo(posicionHeroe);
    configurarPosicionHeroe(posicionHeroe, mapa);    
    cout << "Guardando tus preferencias..." << endl;

    cout << endl << "Iniciando tu partida..." << endl;
    dibujarMapa(posicionHeroe, mapa);
    while(fin == false){
        cin >> movimiento;
        if (movimiento == 'p')
        {
            fin = true;
            char guardar = ' ';
            cout << "Deseas guardar tu partida?" << endl <<
            "(y) Si" << endl <<
            "(cualquier tecla) No" << endl;
            cin >> guardar;
            if (guardar == 'y')
            {
                guardarArchivo(posicionHeroe);
            }
        }
        else
        {
            asignarNuevaPosicion(movimiento, posicionHeroe);
            dibujarMapa(posicionHeroe, mapa);
        }
    }
    return 0;
}```

Working

#include <iostream>
#include <fstream>

using namespace std;

void dibujarMapa (int posX, int posY, char mapa[5][5])
{
    for (int i = 0; i < 5; i++)
    {
        for (int p = 0; p < 5; p++)
        {
            if (posY != i)
            {
                cout << mapa[i][p];
            }
            else if (posX != p)
            {
                cout << mapa[i][p];
            }
            else
            {
                cout << 'H';
            }
        }
            cout << endl;
    }
}


void moverJugador()
{
    char mapa[5][5] =
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},

    };

int posX = 0;
int posY = 0;
char mov = ' ';

cin >> mov;

do
{
    switch(mov)
    {
    case 's':
        {
            if (posY == 4) //la coordenada Y crece hacia abajo
            {
                dibujarMapa(posX, posY, mapa);
                cin >> mov;
            }
            else
            {
                posY++;
                dibujarMapa(posX, posY, mapa);
                cin >> mov;
            }
            break;
        }

    case 'w':
        {
            if (posY == 0)
            {
                dibujarMapa(posX, posY, mapa);
                cin >> mov;
            }
            else
            {
                posY--;
                dibujarMapa(posX, posY, mapa);
                cin >> mov;
            }
            break;
        }

    case 'd':
        {
            if (posX == 4)
            {
                dibujarMapa(posX, posY, mapa);
                cin >> mov;
            }
            else
            {
               posX++;
               dibujarMapa(posX, posY, mapa);
               cin >> mov;
            }
            break;
        }
    case 'a':
        {
            if (posX == 0)
            {
                dibujarMapa(posX, posY, mapa);
                cin >> mov;
            }
            else
            {
                posX--;
                dibujarMapa(posX, posY, mapa);
                cin >> mov;
            }
            break;
        }

    case 'g':
        {
            if (mov == 'g')
            {
                ofstream archivoGuardar("GameData.txt");
                if (archivoGuardar.is_open())
                {
                    archivoGuardar << posX << endl;
                    archivoGuardar << posY << endl;
                    archivoGuardar.close();
                }
                else
                {
                    cout << "No se puede abrir el archivo!" << endl;
                }
                cout << endl <<"++ La posicion ha sido correctamente guardada. ++" << endl;
                mov = 'e';
                break;

            }
        }

    default:
        {
            break;
        }
    }
}while (mov != 'e');
}


int main()
{

    char mapa[5][5] =
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},

    };

int posX, posY = 0;
char confirmar = ' ';
string linea = "";
cout << "Bienvenido jugador!" << endl;
cout << "Utiliza (wasd) para mover al heroe por el mapa, (g) para guardar su posicion: " << endl << endl;
dibujarMapa(0, 0, mapa);
moverJugador();

cout << "Quieres volver a la posicion guardada? (y) para confirmar. " << endl;
cin >> confirmar;

if (confirmar == 'y')
{
    ifstream archivoLeer("GameData.txt");
    if (archivoLeer.is_open())
    {
        getline(archivoLeer, linea);
        posX = stoi(linea);
        getline(archivoLeer, linea);
        posY = stoi(linea);

    }
    else
        {
            cout << "No se puede abrir el archivo!" << endl;;
        }

    cout << endl << "Esta es la ultima partida guardada. ¡Diviertete!" << endl;
    dibujarMapa(posX, posY, mapa);
    moverJugador();
}

return 0;
}```

Hecho!

#define _GLIBCXX_USE_C99 1

#include <iostream>
#include <fstream>
#include <string>


using namespace std;

void DrawMap(int, int, char map[5][5]);


int main()
{
    ofstream Myfile("GameData.txt");
    string playerName;
    int puntos  = 100;
    int heroPosX = 0;
    int heroPosY = 0;

    cout << "Introduce el nombre de tu heroe" << endl;
    if(Myfile.is_open())
    {
        cin >> playerName;
        Myfile << "Player Name:" << endl;
        Myfile << playerName << endl;
        Myfile << "Score:" << endl;
        Myfile << puntos << endl;
        Myfile << "Xpos:" << endl;
        Myfile << 2 << endl;
        Myfile << "Ypos:" << endl;
        Myfile << 2 << endl;
    }
    Myfile.close();

    ifstream myFileRead("GameData.txt");
    string line;
    int valueCopy = 0;

    if (myFileRead.is_open())
    {
        while(getline(myFileRead, line))
        {
            if(valueCopy == 1)
            {
                heroPosX = stoi(line);
            }else if(valueCopy == 2)
            {
                heroPosY = stoi(line);
            }

            if(line == "Xpos:")
            {
                valueCopy = 1;
            }else if(line == "Ypos:")
            {
                valueCopy = 2;
            }else{
                valueCopy = 0;
            }

        }
    }else{
        cout << "Imposible abrir archivo. Permiso denegado" << endl;
    }

    char Input;
    bool isGameOver = false;
    char map[5][5] =
    {
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'}
    };

    cout << endl << "Mueve el jugador a la derecha (d), izquierda (a), arriba (w) y abajo (s)" << endl;

    DrawMap(heroPosX, heroPosY, map);

    do
    {
        cin >> Input;
        if(Input == 'd')
        {
            heroPosX++;
        }else if(Input == 'a')
        {
            heroPosX--;
        }else if(Input == 'w')
        {
            heroPosY--;
        }else if(Input == 's')
        {
            heroPosY++;
        }
        else if(Input == 'e')
        {
            isGameOver = true;
        }

        DrawMap(heroPosX,  heroPosY, map);
    }while(isGameOver == false);


    return 0;
}

void DrawMap(int heroPosX, int heroPosY, char map[5][5])
{
    for(int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if(j == heroPosX && i == heroPosY)
            {
                cout << 'H';
            }else
            {
                cout << map[j][i];
            }
        }
        cout << endl;
    }
    cout << endl;
}
#include <iostream>
#include <fstream>
#include <sstream>

using namespace std; //Esto evita tener que usar std::cout

void mapDraw(int heroPosX, int heroPosY, char map[5][5])
{
    for(int i = 0; i < 5; i++)
    {
        for(int p = 0; p < 5; p++)
        {
            if(i == heroPosY && p == heroPosX)
            {
                cout << 'H';
                
            }else
            {
                cout << map[p][i];
            } 
        }
        cout << "" << endl;
    }
}

int main()
{
    int heroPosX = 0;
    int heroPosY = 0;
    string sPosX = "";
    string sPosY = "";
    char input = ' ';
    char gameMap[5][5] = 
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'}
    };

    //Informacion Archivo
    ifstream archivoRead("gamedata.txt");
    if(archivoRead.is_open())
    {
        getline(archivoRead, sPosX) ;
        getline(archivoRead, sPosY);
        archivoRead.close();

        stringstream x(sPosX);
        stringstream y(sPosY);

        x >> heroPosX;
        y >> heroPosY;
        
    }
    


    mapDraw(heroPosX, heroPosY, gameMap);

    bool isGameOver = false;
    
   while(isGameOver == false)
   {

        cin >> input;
        switch(input)
        {
            case 'd':
                heroPosX++;
                break;
            case 'a':
                heroPosX--;
                break;
            case 'w':
                heroPosY--;
                break;
            case 's':
                heroPosY++;
                break;
            case 'p':
                isGameOver = true;
                break;
        }
        mapDraw(heroPosX, heroPosY, gameMap);
   }
    ofstream archivo("gamedata.txt");
    if(archivo.is_open())
    {
        archivo << heroPosX << endl;
        archivo << heroPosY << endl;
        archivo.close();
    }
    return 0;
}```

Aqui mi Aporte resolviendo el Reto

#include <iostream> //libreria para entrada y salida de datos input output
#include <fstream>//libreria mara manejo|escritura|lectura de archivos externos
				//ofstream -> tipo dato, crea flujos de datos escritura
				//open/close -> abrir y cerrar archivos
#include <string>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5])//Clase Creacion de Mapa & Track Hero Position
{
	ofstream posSave("HeroPosData.txt");
	if(posSave.is_open())
	{
		for(int colum=0; colum<5; colum++)
		{
			for(int fila=0; fila<5; fila++)
			{
				if(colum != HeroPosY || fila != HeroPosX )
				{
				cout<<GameMap[fila][colum];	
				}else{
				cout<<'H';
				posSave<<HeroPosX<<endl;
				posSave<<HeroPosY;
				}	
			}
		cout<<endl;
		}		
	}
	posSave.close();	
}

int main()
{	
	string frame;
	int framecont = 0;
	int HeroPosX = 0; int HeroPosY = 0; 
	char Input = ' '; char resp = ' ';
	bool isGameOver = false;
	char GameMap[5][5] = 
	{
		{'*','-','-','-','*'},
		{'|','1','1','1','|'},
		{'|','1','1','1','|'},
		{'|','1','1','1','|'},
		{'*','-','-','-','*'}
	};
	cout<<"Cargar Ultimo CheckPoint? Y/N"<<endl;
	cin>>resp;
	if(toupper(resp) == 'Y')
	{
		ifstream checkPos("HeroPosData.txt");
		if(checkPos.is_open())
		{
			while(getline(checkPos,frame))
			{
				if(framecont == 0)
				{
					HeroPosX = stoi(frame);
				}else if(framecont == 1){
					HeroPosY = stoi(frame);
				}
				framecont++;
			}
		}
		checkPos.close();	
	}else if(toupper(resp) != 'N')
			{
				cout<<"Tas mal!"<<endl;
			}else
			{
				HeroPosX = 0; 
				HeroPosY = 0;
			}		
	DrawMap(HeroPosX,HeroPosY,GameMap);
	while(isGameOver == false)
	{
	cin>>Input;
	//Controles de Movimiento
		switch(toupper(Input))
		{
			case 'W':	HeroPosY--;
				break;
			case 'S':	HeroPosY++;
				break;
			case 'A':	HeroPosX--;
				break;
			case 'D':	HeroPosX++;
				break;
			case 'P':	isGameOver = true;
				break;
		}
		DrawMap(HeroPosX,HeroPosY,GameMap); 
	}
		return 0;	
}```
#include <iostream>
#include <fstream>

using namespace std;

void drawMap(int posX, int posY, char gameMap[6][5]){
    for(int i = 0; i < 6; i++){
        for(int j = 0; j < 5; j++){
            if(posX == j && posY == i){
                cout << 'H';
            } else {
                cout << gameMap[j][i];
            }
        }
        cout << endl;
    }
}

int main()
{
    int posX = 0;
    int posY = 0;
    int goOn = 0;
    char choice = ' ';
    cout << "New Game (N)" << endl;
    cout << "Load Game (L)" << endl;
    cin >> choice;

    char gameMap[6][5] = {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
    };

    if (choice == 'L' || choice == 'l'){
        ifstream savedGameRead("savedGame.txt");
        string line;
        int index = 0;
        if(savedGameRead.is_open()){
            while(getline(savedGameRead, line)){
                if (index == 0) {
                    posX = stoi(line);
                } else {
                    posY = stoi(line);
                }
                index++;
            }
        }
        goOn = 1;
    }

    if (choice == 'N' || choice == 'n') goOn = 1;

    if(goOn) {
        char nextMove = ' ';
        do {
            drawMap(posX, posY, gameMap);
            cin >> nextMove;
            switch(nextMove){
                case 'a':
                    posX--;
                    break;
                case 'd':
                    posX++;
                    break;
                case 'w':
                    posY--;
                    break;
                case 's':
                    posY++;
                    break;
                default:
                    cout << "Valor incorrecto" << endl;
                    cout << "Quiere seguir jugando? (Y/N)" << endl;
                    cin >> choice;

                    while (choice != 'Y' && choice != 'N' && choice != 'y' && choice != 'n'){
                        cout << "Quiere seguir jugando? (Y/N)" << endl;
                        cin >> choice;
                    }

                    if (choice == 'N' || choice == 'n'){
                        goOn = 0;
                        cout << "¿Desea guardar? (Y/N)" << endl;
                        cin >> choice;
                        if (choice == 'Y' || choice == 'y'){
                            ofstream savedGame ("savedGame.txt");
                            if(savedGame.is_open()){
                                savedGame << posX << endl;
                                savedGame << posY << endl;
                            } else {
                                cout << "Error guardando" << endl;
                            }
                            savedGame.close();
                        }
                    }
                    break;
            }
        } while (goOn);
    }
    return 0;
}```
#include <iostream>
#include <fstream>
#include <sstream>

using namespace std; //Esto evita tener que usar std::cout

void mapDraw(int heroPosX, int heroPosY, char map[5][5])
{
    for(int i = 0; i < 5; i++)
    {
        for(int p = 0; p < 5; p++)
        {
            if(i == heroPosY && p == heroPosX)
            {
                cout << 'H';
                
            }else
            {
                cout << map[p][i];
            } 
        }
        cout << "" << endl;
    }
}

int main()
{
    int heroPosX = 0;
    int heroPosY = 0;
    string sPosX = "";
    string sPosY = "";
    char input = ' ';
    char gameMap[5][5] = 
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'}
    };

    //Informacion Archivo
    ifstream archivoRead("gamedata.txt");
    if(archivoRead.is_open())
    {
        getline(archivoRead, sPosX) ;
        getline(archivoRead, sPosY);
        archivoRead.close();

        stringstream x(sPosX);
        stringstream y(sPosY);

        x >> heroPosX;
        y >> heroPosY;
        
    }
    


    mapDraw(heroPosX, heroPosY, gameMap);

    bool isGameOver = false;
    
   while(isGameOver == false)
   {

        cin >> input;
        switch(input)
        {
            case'd':
                heroPosX++;
                break;
            case'a':
                heroPosX--;
                break;
            case'w':
                heroPosY--;
                break;
            case's':
                heroPosY++;
                break;
            case'p':
                isGameOver = true;
                break;
        }
        mapDraw(heroPosX, heroPosY, gameMap);
   }
    ofstream archivo("gamedata.txt");
    if(archivo.is_open())
    {
        archivo << heroPosX << endl;
        archivo << heroPosY << endl;
        archivo.close();
    }
    return0;
}```
#include <iostream>
#include <array>
#include <fstream>

using namespace std;

// Recorriendo un arreglo y dibujandolo
void drawMap(char gameMap[][5], int mapSize, int x, int y) {

    for ( int i = 0; i < mapSize; i++ ) {

        cout << endl;
        for ( int j = 0; j < mapSize; j++ ) {

            // Dibujar mapa o jugador
            if ( ( i == y ) && ( x == j ) ){
                cout << 'H';
            }
            else {
                cout << gameMap[i][j];
            }

        }
    }
}


// Rellenando un arreglo
void fillMap( char gameMap[][5], int mapSize ) {
    const char EMPTY = '1'; // constante de lugar vacio

    // Recorriendo el arreglo y rellenando
    for ( int i = 0; i < mapSize; i++ ) {
        for ( int j = 0; j < mapSize; j++ ) {
            gameMap[i][j] = EMPTY;
        }
    }
}


// Carga la posicion del jugador desde
// un archivo hacia un arreglo
void getState( int estado[2] ) {
    ifstream myFile("mapita.txt");
    string x;
    string y;

    if ( myFile.is_open() ) {
        getline( myFile, x );
        getline( myFile, y );

        estado[0] = stoi(x);
        estado[1] = stoi(y);
        cout << "Conitnue...";
    }
    else {
        cout << "Nuevo juego.." << endl;
        estado[0] = 0;
        estado[1] = 0;
    }

    myFile.close();
    return;
}


// Guarda el estado del jugador en un archivo
void setState( int x, int y ) {
    ofstream myFile("mapita.txt");

    if ( myFile.is_open() ) {
        myFile << x << endl;
        myFile << y << endl;
    }
    else {
        cout << "Error, no se pudo guardar los datos";
    }

    myFile.close();
}

int main() {
    // Constant
    const int mapSize = 5;

    // Mapa y coordenadas de jugador
    char gameMap[mapSize][mapSize];

    int estadoInicial[2];
    getState( estadoInicial );

    int heroPosX = estadoInicial[0];
    int heroPosY = estadoInicial[1];

    // track de seguir jugando
    bool keepPlaying = true;

    // Entrada de jugador y rellenando mapa
    char input = ' ';
    fillMap( gameMap, mapSize );

    // TMover al jugador por el mapa acorde a la entrada del usuario
    while ( keepPlaying ) {
        // Dibujando mapa
        drawMap( gameMap, mapSize, heroPosX, heroPosY );

        // Tomando input del usuario
        cin >> input;

        // Cambiando la posicion del jugador dependiendo del input

        // Posicion en X
        if ( input == 'd' ) {
            heroPosX++;
        }
        else if ( input == 'a' ) {
            heroPosX--;
        }

        // Posicion en Y
        else if ( input == 'w' ) {
            heroPosY--;
        }
        else if ( input == 's' ) {
            heroPosY++;
        }

        // GameOver
        else if ( input == 'p' ) {
            setState( heroPosX, heroPosY );
            keepPlaying = false;
        }

    }

    return 0;
}

/*
    Compilar así: clang++ -std=c++11 source.cpp -o source.out     
*/

#include <iostream>
#include <fstream>

using namespace std;

const int MAP_ARRAY_LEN_X = 5;
const int MAP_ARRAY_LEN_Y = 5;

void SaveMap(const char GameMap[MAP_ARRAY_LEN_X][MAP_ARRAY_LEN_Y])
{
    ofstream MyFile("GameMap.txt");
    for (int i = 0; i < MAP_ARRAY_LEN_X; i++)
    {
        for (int j = 0; j < MAP_ARRAY_LEN_Y; j++)
        {
            MyFile  << GameMap[i][j];
        }
        MyFile << endl;
    }
    MyFile.close();
}

void ReadMap( int& heroPosX, int& heroPosY )
{
    ifstream MyFileRead("GameMap.txt");
    string line;
    int fila = 0, columna = 0;

    if (MyFileRead.is_open())
        while (getline(MyFileRead, line)) {
            for (char mapValue : line) {
                if (mapValue == '3') {
                    heroPosX = fila;
                    heroPosY = columna;
                }
                columna++;
            }
            columna = 0;
            fila++;
        }
    else
        cout << "Error opening file" << endl;

    cout << "Initial heroPosX: " << heroPosX << endl;
    cout << "Initial heroPosY: " << heroPosY << endl;
}

void DrawMap(const int &heroPosX, const int &heroPosY, char GameMap[MAP_ARRAY_LEN_X][MAP_ARRAY_LEN_Y])
{
    ofstream MyFile("GameMap.txt");
    for (int i = 0; i < MAP_ARRAY_LEN_X; i++)
    {
        for (int j = 0; j < MAP_ARRAY_LEN_Y; j++)
        {
            if (i != heroPosX || j != heroPosY) {
                GameMap[i][j] = '1';
                cout << GameMap[i][j];
            }
            else {
                GameMap[i][j] = 'H';
                cout << 'H';
            }
            MyFile << GameMap[i][j];
        }
        MyFile << endl;
        cout << endl;
    }
    MyFile.close();
}

int main ()
{
    int heroPosX = 1, heroPosY = 1;
    char GameMap[MAP_ARRAY_LEN_X][MAP_ARRAY_LEN_Y] =
        {
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '3', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'}
        };
    SaveMap( GameMap );
    ReadMap(heroPosX, heroPosY);
    DrawMap(heroPosX, heroPosY, GameMap);

    bool isGameOver = false;
    char input = ' ';
    while (isGameOver == false)
    {
        cin >> input;
        switch (input)
        {
        case 'd':
            heroPosY++;
            break;
        case 'a':
            heroPosY--;
            break;
        case 'w':
            heroPosX--;
            break;
        case 's':
            heroPosX++;
            break;
        case 'p':
            isGameOver = true;
            break;
        default:
            break;
        }

        if (heroPosY < 0)
            heroPosY = 0;
        else if (heroPosY == MAP_ARRAY_LEN_Y)
            heroPosY = MAP_ARRAY_LEN_Y - 1;
        if (heroPosX < 0)
            heroPosX = 0;
        else if (heroPosX == MAP_ARRAY_LEN_X)
            heroPosX = MAP_ARRAY_LEN_X - 1;

        DrawMap(heroPosX, heroPosY, GameMap);
        SaveMap( GameMap);
    } 

    return 0;
}
#include <iostream>
#include <fstream>

using namespace std;

const int MAP_ARRAY_LEN_X = 5;
const int MAP_ARRAY_LEN_Y = 5;

void SaveMap(const char GameMap[MAP_ARRAY_LEN_X][MAP_ARRAY_LEN_Y])
{
    ofstream MyFile("GameMap.txt");
    for (int i = 0; i < MAP_ARRAY_LEN_X; i++)
    {
        for (int j = 0; j < MAP_ARRAY_LEN_Y; j++)
        {
            MyFile  << GameMap[i][j];
        }
        MyFile << endl;
    }
    MyFile.close();
}

void ReadMap( int& heroPosX, int& heroPosY )
{
    ifstream MyFileRead("GameMap.txt");
    string line;
    int fila = 0, columna = 0;

    if (MyFileRead.is_open())
        while (getline(MyFileRead, line)) {
            for (char mapValue : line) {
                if (mapValue == '3') {
                    heroPosX = fila;
                    heroPosY = columna;
                }
                columna++;
            }
            columna = 0;
            fila++;
        }
    else
        cout << "Error opening file" << endl;

    cout << "Initial heroPosX: " << heroPosX << endl;
    cout << "Initial heroPosY: " << heroPosY << endl;
}

void DrawMap(const int &heroPosX, const int &heroPosY, char GameMap[MAP_ARRAY_LEN_X][MAP_ARRAY_LEN_Y])
{
    ofstream MyFile("GameMap.txt");
    for (int i = 0; i < MAP_ARRAY_LEN_X; i++)
    {
        for (int j = 0; j < MAP_ARRAY_LEN_Y; j++)
        {
            if (i != heroPosX || j != heroPosY) {
                GameMap[i][j] = '1';
                cout << GameMap[i][j];
            }
            else {
                GameMap[i][j] = 'H';
                cout << 'H';
            }
            MyFile << GameMap[i][j];
        }
        MyFile << endl;
        cout << endl;
    }
    MyFile.close();
}

int main ()
{
    int heroPosX = 1, heroPosY = 1;
    char GameMap[MAP_ARRAY_LEN_X][MAP_ARRAY_LEN_Y] =
        {
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '3', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'}
        };
    SaveMap( GameMap );
    ReadMap(heroPosX, heroPosY);
    DrawMap(heroPosX, heroPosY, GameMap);

    bool isGameOver = false;
    char input = ' ';
    while (isGameOver == false)
    {
        cin >> input;
        switch (input)
        {
        case'd':
            heroPosY++;
            break;
        case'a':
            heroPosY--;
            break;
        case'w':
            heroPosX--;
            break;
        case's':
            heroPosX++;
            break;
        case'p':
            isGameOver = true;
            break;
        default:
            break;
        }

        if (heroPosY < 0)
            heroPosY = 0;
        elseif (heroPosY == MAP_ARRAY_LEN_Y)
            heroPosY = MAP_ARRAY_LEN_Y - 1;
        if (heroPosX < 0)
            heroPosX = 0;
        elseif (heroPosX == MAP_ARRAY_LEN_X)
            heroPosX = MAP_ARRAY_LEN_X - 1;

        DrawMap(heroPosX, heroPosY, GameMap);
        SaveMap( GameMap);
    } 

    return0;
}```
#include <iostream>
#include <fstream>

using namespace std;

void DrawMap(string nom, int Px, int Py, char Mapita[5][5]){
    cout << "\nHola " << nom << " esta es tu ubicacion: \n" << endl;
    for(int i=0;i<5;i++){
        for(int j=0;j<5;j++){
            if(Py != i || Px != j){
                cout << Mapita[i][j];
            }else{
                cout << 'H';
            }
        }
        cout<<endl;
    }

}

int main()
{
    // Variables
    string PlayerName = "";
    string PosX = "";
    string PosY = "";
    string name = "";
    string line;
    bool IsGameOver = false;
    int PosicionX = 0;
    int PosicionY = 0;
    int Renglon = 0;
    char Map[5][5]={
      {'1','1','1','1','1'},
      {'1','1','1','1','1'},
      {'1','1','1','1','1'},
      {'1','1','1','1','1'},
      {'1','1','1','1','1'},
    };


    //Crear y agregar datos al archivo
    ofstream MyMap("Posiciones.txt");
    if(MyMap.is_open()){
        cout << "Ingresa tu nombre: ";
        cin >> PlayerName;
        cout << "\nIngresa tu posicion en x: ";
        cin >> PosX;
        cout << "\nIngresa tu posicion en y: ";
        cin >> PosY;
        MyMap << PlayerName << endl;
        MyMap << PosX << endl;
        MyMap << PosY << endl;
    }
    MyMap.close();

    ifstream MyMapRead("Posiciones.txt");
    if(MyMapRead.is_open()){
        while(getline(MyMapRead, line)){
            if(Renglon==0){
                name = line;
            }else if(Renglon==1){
                PosicionX = atoi(line.c_str())-1;
            }else if(Renglon==2){
                PosicionY = atoi(line.c_str())-1;
            }
            Renglon++;
        }
        DrawMap(name, PosicionX, PosicionY, Map);
    }
    MyMapRead.close();

    return 0;
}```
#include <iostream> //libreria de entrada y salida
#include <fstream>  //libreria mara manejo|escritura|lectura de archivos externos
#include <sstream>
using namespace std; // permite usar con facilidad cout cin
// Recorriendo un arreglo y dibujandolo
void DrawMap(int HeroPos, int HeroPosJ ,char Gamemap[5][5]) //creamos la funcion dibujar mapa donde LLAMAMOS a los PARAMETROS que estan en la funcion principal
{
     for (int i = 0 ; i<5; i ++ )
     {
         for (int j = 0 ; j<5; j ++ )
         {
         if(i!= HeroPosJ)
         {
           cout<<Gamemap[j][i];
         }
         else
         {
             if(j!= HeroPos)
             {
              cout<<Gamemap[j][i];
             }
             else
             {
                cout<< 'H';
             }

         }
         }
        cout << endl;
     }
}
int main()//funcion principal donde nuestro programa empieza a correr
{
    int HeroPos=1;//posicion actual de mi personaje
    int HeroPosJ=1;
    bool isGameOver = false;
    string sPosX = "";
    string sPosY = "";
    char Input = ' '; // creo una variable char
    char Gamemap [5] [5] =
    {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'}

    }; // en que poscion del mapa estara el jugador
    //Informacion Archivo
    ifstream archivoRead("gamedata.txt");
    if(archivoRead.is_open())
    {
        getline(archivoRead, sPosX) ;
        getline(archivoRead, sPosY);
        archivoRead.close();

        stringstream i(sPosX);
        stringstream j(sPosY);

        i >> HeroPos;
        j >> HeroPosJ;

    }
    DrawMap(HeroPos,HeroPosJ,Gamemap); // llamamos a los parametros para leerlos
    while (isGameOver== false)
    {
       cin>> Input; // pedimos a la consola que meta entrada y almacena en input
    if (Input=='d')//si se cumple la condicional input nuestro jugador se mueve a la DERECHA
    {
        HeroPos= HeroPos+1;
    }
    else if (Input=='a')
    {
       HeroPos = HeroPos-1;
    }
    else if (Input=='w')
    {
       HeroPosJ = HeroPosJ-1;
    }
    else if (Input=='s')
    {
       HeroPosJ = HeroPosJ+1;
    }
    else if (Input=='p')
    {
        isGameOver= true;
    }
    DrawMap(HeroPos,HeroPosJ,Gamemap); // llamamos a los parametros para leerlos

    }
    ofstream archivo("gamedata.txt");
    if(archivo.is_open())
    {
        archivo << HeroPos << endl;
        archivo << HeroPosJ << endl;
        archivo.close();
    }

    return 0;
}

Creo que solo había que guardar los datos de la posición en el archivo de texto y esos datos los pase de manera directa al jugador

#include <iostream>
#include <fstream>
using namespace std;
void DibujarMapa(int PosX,int PosY,char Mapa[10][10]){
    for(int y=0;y<10;y++){
        for(int x=0;x<10;x++){
            if(y!=PosY || x!=PosX){
                cout<<Mapa[y][x];
             }else{
                cout<<'*';
             }
        }
        cout<<endl;
    }
}
int main(){
    ofstream Archivo("GameData.txt");
    bool IsGameOver=false;
    int X=0;
    int Y=0;
    string Nombre="";                             //Y:
    char Input=' ';//--------------------------------
    char map[10][10]={                            //
   /*|*/{'o','o','H','o','o','o','o','o','o','o'},//0
   /*|*/{'o','.','.','.','.','.','.','.','.','H'},//1
   /*|*/{'o','.','.','.','o','o','o','o','o','o'},//2
   /*|*/{'o','.','o','.','.','.','.','o','.','o'},//3
   /*|*/{'[','.','.','.','o','o','.','o','.','='},//4
   /*|*/{'o','.','o','o','o','o','.','.','.','o'},//5
   /*|*/{'o','.','.','.','.','o','.','o','o','o'},//6
   /*|*/{'o','.','o','o','.','.','.','o','o','o'},//7
   /*|*/{'o','.','o','o','o','o','.','o','o','o'},//8
   /*|*/{'o','H','o','o','o','o','H','o','o','o'} //9
//X:      0   1   2   3   4   5   6   7   8   9
    };
    cout<<"Bienvenido al laberinto"<<endl;
    cout<<"Ingresa un nombre para tu jugador"<<endl;
    cin>>Nombre;
    for(int y=0;y<10;y++){
        for(int x=0;x<10;x++){
            if(map[y][x]=='['){
                X=x;
                Y=y;
                y=10;
                x=10;
                if(Archivo.is_open()){
                    Archivo<<"Posicion Inicial"<<endl;
                    Archivo<<"X: "<<X<<endl;
                    Archivo<<"Y: "<<Y<<endl;
                }else{
                    cout<<"el archivo no esta abierto"<<endl;
                }
             }
        }
    }
    cout<<Nombre<<" para poder ganar tienes que seguir los puntos '.' y llegar hasta la marca '='(tu eres '*')"<<endl;
    cout<<"!Pero evita llegar a la letra 'H' o te saldras del mapa!"<<endl;
    while(IsGameOver==false){
        DibujarMapa(X,Y,map);
        cout<<"X:"<<X<<", Y:"<<Y<<endl;
        cout<<"n para salir"<<endl;
        cin>>Input;
        switch (Input){
            case 'd':
                if(map[Y][X+1]=='o'||X==9){
                    cout<<"no se puede ir mas hacia la derecha"<<endl;
                }else{
                    X=X+1;
                 }
            break;
            case 'a':
                if(map[Y][X-1]=='o'|| X==0){
                    cout<<"no se puede ir mas hacia la izquierda"<<endl;
                }else{
                    X=X-1;
                }
            break;
            case 'w':
                if(map[Y-1][X]=='o'||Y==0){
                    cout<<"no se puede avanzar mas"<<endl;
                }else{
                    Y=Y-1;
                }
            break;
            case 's':
                if(map[Y+1][X]=='o'||Y==9){
                    cout<<"no se puede retroceder mas"<<endl;
                }else{
                    Y=Y+1;
                }
            break;
            case 'n':
                IsGameOver=true;
                cout<<"Juego terminado"<<endl;
            break;
        }
        if(map[Y][X]=='H'){
            DibujarMapa(X,Y,map);
            cout<<"Te has salido del mapa"<<endl;
            cout<<"Juego terminado"<<endl;
            IsGameOver=true;
        }
        if(map[Y][X]=='='){
            DibujarMapa(X,Y,map);
            cout<<"Has llegado hasta el final ¡Felicidades!"<<endl;
            IsGameOver=true;
        }
    }
    Archivo.close();//siempre cerrar el archivo abierto
    return 0;
}


Hice lo mejor que pude

#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <conio.h>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5])
{
    system("cls");
    cout << endl;
    for(int i = 0; i < 5; i++)
    {
        for(int j = 0; j < 5; j++)
        {
            if(i != HeroPosY)
            {
                cout << GameMap[i][j];
            }else
            {
                if(j != HeroPosX)
                {
                    cout << GameMap[i][j];
                }else
                {
                    cout << 'H' ;
                }
            }
        }
        cout << endl;
    }
}

void loadGame (string *name, int *posX, int *posY)
{
    ifstream MyFileRead("GameData.txt");
    string line;
    int conta = 0;

    if(MyFileRead.is_open())
    {
        while(getline(MyFileRead, line))
        {
            switch(conta)
            {
            case 0:
                *name = line;
                break;
            case 1:
                *posX = atoi(line.c_str());
                break;
            case 2:
                *posY = atoi(line.c_str());
                break;
            }
            conta++;
        }
        MyFileRead.close();
        cout << endl << "Hola! " << *name;
        getch();
    }else{
        cout << endl << "NO SE ENCUENTRARON DATOS, ENTER PARA CONTINUAR";
        getch();
    }

}

void saveGame (string *name, int posX, int posY)
{
    ofstream MyFile("GameData.txt");
    if(MyFile.is_open())
    {
        if(*name == "")
        {
            cout << "Introduzca un nombre: " << endl;
            cin >> *name;
            MyFile << *name << endl;
        }else{
            MyFile << *name << endl;
        }

        MyFile << posX << endl;
        MyFile << posY << endl;
    }
    MyFile.close();
}
int main()
{
    string name = "";
    int HeroPosX = 0;
    int HeroPosY = 0;
    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5] =
    {
        {'~','~','~','~','~'},
        {'~','~','~','~','~'},
        {'~','~','~','~','~'},
        {'~','~','~','~','~'},
        {'~','~','~','~','~'}
    };

    loadGame (&name, &HeroPosX, &HeroPosY);
    DrawMap(HeroPosX, HeroPosY, GameMap);

    while(!isGameOver)
    {
        cin >> Input;
        Input = tolower(Input); //Transforma la entrada a minusculas

        if(Input == 'd')
        {
            HeroPosX=(HeroPosX+1)%5;
        }
        else if(Input == 'a')
        {
            HeroPosX=((HeroPosX-1)%5+5)%5;
        }
        else if(Input == 's')
        {
            HeroPosY=(HeroPosY+1)%5;
        }
        else if(Input == 'w')
        {
            HeroPosY=((HeroPosY-1)%5+5)%5;
        }
        else if(Input == 'p')
        {
            cout << "Desea guardar cambios? (s/n)" << endl;
            cin >> Input;
            Input = tolower(Input);
            if (Input == 's')
            {
                saveGame (&name, HeroPosX, HeroPosY);
                isGameOver= true;
                cout << endl << "Adios: " << name;
                getch();
            }
            else
            {
                isGameOver= true;

            }
        }

        DrawMap(HeroPosX, HeroPosY, GameMap);
    }

    return 0;
}
#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

void DrawMap (int HeroPosX, int HeroPosY, char GameMap[5][5])
{
    for (int i = 0; i < 5;i = i + 1)
    {
       for(int p = 0; p < 5; p = p + 1)
       {
           if(i != HeroPosY)
       {
           cout << GameMap[p][i];
       } else {
           if(p != HeroPosX)
           {
               cout << GameMap[p][i];
           } else {
               cout << '0';
           }
         }

       }
      cout << endl;
    }
}
int main()
{
    int HeroPosX = 1;
    int HeroPosY = 1;
    bool isGameOver = false;
    char Input = ' ';
    string PositionX = "";
    string PositionY = "";
    char GameMap[5][5] =
    {
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
        {'.','.','.','.','.'}
    };
    ifstream archivoRead("GameDataReto4");
    if(archivoRead.is_open()){
        getline(archivoRead, PositionX);
        getline(archivoRead, PositionY);
        archivoRead.close();

        stringstream i(PositionX);
        stringstream p(PositionY);

        i >> HeroPosX;
        p >> HeroPosY;
    }

    DrawMap(HeroPosX, HeroPosY, GameMap);

    while (isGameOver == false)
    {
        cin >> Input;
        if(Input == 'd')
    {
        HeroPosX = HeroPosX + 1;
    } else if (Input == 'w')
    {
        HeroPosY = HeroPosY - 1;
    }
     else if (Input == 'a')
    {
        HeroPosX = HeroPosX - 1;
    } else if (Input == 'x')
    {
        HeroPosY = HeroPosY + 1;
    }
     else if(Input == 'p')
    {
       isGameOver = true;
    }

    DrawMap(HeroPosX, HeroPosY, GameMap);
    }

     ofstream Myarchivo("GameDataReto4.txt");
     if(Myarchivo.is_open()){
        Myarchivo << HeroPosX << endl;
        Myarchivo << HeroPosY << endl;
        Myarchivo.close();
     }

    return 0;
}```
#include <iostream>
#include <fstream>

using namespace std;

int PjPosx, pjposy,x=8,y=8,DMov;
char input;
string PlayerName="";


void drawMap(int PjPosx,int pjposy, int x=0, int y=0){
    char GameMap[x][y];

        for (int i = 0; i < x; i++)
        {
            for (int j = 0; j <y ; j++)
            {   
                if (i==PjPosx && j==pjposy)
                {
                    GameMap[i][j]='P';
                    
                }else
                {
                GameMap[i][j]='*';  
                }
            }
        }
  

    for (int i = 0; i < x; i++)
    {
        for (int j = 0; j <y ; j++)
        {   
            if (j==y-1)
            {
                cout<<GameMap[i][j]<<endl;
            }else
            {
                cout<<GameMap[i][j];
            } 
        }
    }
}


void movePj(int DMov){
    if (pjposy!=0 && DMov==2)//Left
    {
         pjposy-=1;
    }else if (pjposy<y-1 && DMov==1)//right
    {
       pjposy+=1; 
    }else if(PjPosx >0 && DMov==3){//up
        PjPosx-=1;
    }else if (PjPosx <x-1 && DMov==4)//down
    {
        PjPosx+=1;
    }
    
}


void Load(){
    ifstream DataR("Data.txt");
    if (DataR.is_open())
    {
        
        string pjposxS=to_string(PjPosx);
        string pjposyS=to_string(pjposy);
        getline(DataR,PlayerName);
        if(PlayerName==""){
            cout<<"Bienvenido ¿Cual es tu nombre? ";
            cin>>PlayerName;           
            pjposy=0;
            PjPosx=0;
        }else
        {    
            getline(DataR,pjposxS);
            getline(DataR,pjposyS);
            pjposy=stoi(pjposyS);
            PjPosx=stoi(pjposxS);
            DataR.close();
        }
    }
    
    
}


void save(){
    ofstream DataR("Data.txt");
    if(DataR.is_open()){
        DataR<<PlayerName<<endl;
        DataR<<PjPosx<<endl;
        DataR<<pjposy<<endl;
        cout<<"Adios "<< PlayerName<<endl;
        cout<< "Pos X: "<< PjPosx<<endl;
        cout<< "Pos Y: "<<pjposy<<endl;
        DataR.close();
    }
}


bool first( ){


}

int main(int argc, char const *argv[])
{
    Load();
    bool playing=true;
    drawMap(PjPosx,pjposy,x,y);
    while (playing==true)
    {
        cin>>input;  
        switch (input)
        {
        case 'a':
            movePj(2);
            drawMap(PjPosx,pjposy,x,y);
            break;
        case 'd':
            movePj(1);
            drawMap(PjPosx,pjposy,x,y);
            break;
        case 's':
            movePj(4);
            drawMap(PjPosx,pjposy,x,y);
             cout<<pjposy;
            break;
        case 'w':
            movePj(3);
            drawMap(PjPosx,pjposy,x,y);
           
            break;
        case 'e':
            save();
            playing=false;
            break;
        default:
            break;
        }      
    }
    
    
    return 0;
}
#include <iostream>
#include <fstream>
#include <cstdlib>

using namespace std;

void DrawMap (int HeroPosX, int HeroPosY, char GameMap[5][5])
{
	system("cls");
	cout << "Press 'p' for out\n" << endl;
	
    for (int i = 0; i < 5;i++)
    {
       	for(int j = 0; j < 5; j++)
       	{
           	if(i != HeroPosY)
       		{
           		cout << GameMap[j][i];
       		} else {
           		if(j != HeroPosX)
           		{
               		cout << GameMap[j][i];
           		} else {
               		cout << 'O';
           		}
         	}
       	}
      	cout << endl;
    }
}

int main()
{
    int HeroPosX = 0, HeroPosY = 0;
    bool isGameOver = false;
    char Input = ' ';
    char GameMap[5][5] =
    {
        {'_','_','_','_','_'},
        {'_','_','_','_','_'},
        {'_','_','_','_','_'},
        {'_','_','_','_','_'},
        {'_','_','_','_','_'}
    };
    string posicion;

    while (isGameOver == false)
    {
    	DrawMap(HeroPosX, HeroPosY, GameMap);
    	ofstream filePosition("position");
	    if ( filePosition.is_open() )
	    {
	    	filePosition << "Posicion: [" << HeroPosX << "][" << HeroPosY << "]" << endl;
		}
		ifstream filePositionRead("position");
		if ( filePositionRead.is_open() )
		{
			while (getline(filePositionRead, posicion))
			{
				cout << posicion << endl;
			}
		}
		filePosition.close();
		filePositionRead.close();
    	cin >> Input;
        if(Input == 'd')
	    {
	        HeroPosX = HeroPosX + 1;
	    } else if (Input == 'w')
	    {
	        HeroPosY = HeroPosY - 1;
	    }
	     else if (Input == 'a')
	    {
	        HeroPosX = HeroPosX - 1;
	    } else if (Input == 's')
	    {
	        HeroPosY = HeroPosY + 1;
	    }
	     else if(Input == 'p')
	    {
	       isGameOver = true;
	    }
    }
    return 0;
}
#include <iostream>
#include <fstream>

using namespace std;

void DrawMap(int HeroPosX, int HeroPosY, char GameMap[5][5])
{
    for(int i = 0; i < 5; i++)
    {
        for(int p = 0; p < 5; p++)
        {
            if(i != HeroPosY)
            {
                cout << GameMap[p][i];
            }
            else
            {
                if(p != HeroPosX)
                {
                    cout << GameMap[p][i];
                }
                else
                {
                    cout << 'H';
                }
            }
        }
        cout << endl;
    }
}

void Save(int HeroPosX, int HeroPosY)			//funcion que crea el punto de guardado
{
    ofstream SaveFile("Save.txt");
    if( SaveFile.is_open() )
    {
        SaveFile << HeroPosX << endl;
        SaveFile << HeroPosY << endl;
    }
    SaveFile.close();
}

void Read(int* HeroPosX, int* HeroPosY)			//funcion que lee el archivo de guardado mediante punteros
{
	int Renglon;
        string line;
        ifstream SaveFileRead("Save.txt");
        if( SaveFileRead.is_open() )
        {
            while( getline(SaveFileRead, line) )
            {
                if(Renglon == 0)
                {
                    *HeroPosX = stoi(line);
                }
                else if(Renglon == 1)
                {
                    *HeroPosY = stoi(line);
                }
		Renglon++;
            }
        }
        SaveFileRead.close();
}

int main()
{
    int HeroPosX = 1;
    int HeroPosY = 1;
    bool isGameOver = false;
    int isSaving;
    char Input = ' ';
    char GameMap[5][5] =
    {
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'},
        {'1', '1', '1', '1', '1'}
    };

    cout << "Bienvenido a la experiencia del Platzi Juego, elige una de la opciones siguientes:" << endl;
    cout << "1: Comenzar Nueva Partida\n2: Continuar punto de guardado\n3: Salir\n";
    cin >> isSaving;
    switch(isSaving)					//condicional para elegir una de las opciones del menú de inicio
    {
        case 1:
            DrawMap(HeroPosX, HeroPosY, GameMap);
            break;
        case 2:
            Read(&HeroPosX, &HeroPosY);
            DrawMap(HeroPosX, HeroPosY, GameMap);
            break;
        case 3:
            isGameOver = true;
            break;
    }

    while(isGameOver == false)
    {
        cin >> Input;

        if(Input == 'd')
        {
            HeroPosX = HeroPosX + 1;
        }
        else if(Input == 'a')
        {
            HeroPosX = HeroPosX - 1;
        }
        else if(Input == 'w')
        {
            HeroPosY = HeroPosY - 1;
        }
        else if(Input == 's')
        {
            HeroPosY = HeroPosY + 1;
        }
        else if(Input == 'p')
        {
            cout << "Quieres guardar antes de salir? (1 si, 0 no)" << endl;
            cin >> isSaving;
            if(isSaving == 1)
            {
                Save(HeroPosX,HeroPosY);
            }
            isGameOver = true;
        }

        DrawMap(HeroPosX, HeroPosY, GameMap);
    }

    return 0;
}

Buenos tengo rato leyendo la descripción de lo que dice aquí que se debe hacer y veo lo que cada quien interpreta y eso confunde un poco, por que no cuadran todas las interpretaciones y ademas cada quien aumenta el grado de complejidad:

  • Primero dice que se marque la posición del jugador en el mapa, entonces ¿hay que tener designado esto previamente en el mapa?, por que en la parte de tips se menciona que se modifique el archivo del mapa asignando un símbolo único donde aparecerá el personaje, entonces esto indica que se debe tener un archivo y el punto inicial ya asignado.
  • En el párrafo superior se menciona que se interpreta la lectura del archivo, entonces quiere decir que se debe mandar abrir un archivo donde este guardado el mapa, de hecho en el punto dos se menciona como usando el fstream se lee el archivo y mediante for se lee caracter por caracter, osea cada posición.
    -En el punto 3 se menciona que al encontrar el símbolo de inicio en el ejemplo el ‘3’, se debe guardar la posicion, osea que si pusimos en un archivo con el símbolo de inicio ‘3’ en la posición 3,5, pues esa posición se deber guardar, como punto de inicio.
  • En el punto 4 dice que se le pasara esa información al jugador mediante una referencia, esta parte es la que mas me confunde, por que por lo que se entiende sería indicarle que el punto inicial seria el que se tienen indicado en el mapa, entonces te mostraré dónde está ese número ‘3’, que tu no “sabes”, por que ya estaba en el mapa no lo asigna en el juego.
  • En el punto 5 solo se entiende que te mostrará el mapa, con todos los valores, entonces veríamos la matriz y el punto inicial que nos indico.

Me gustaria que alguien me diera su opinión si es asi como lo entienden por que leo muchos codigos, algunos se parecen pero no van con lo que dice la indicación, aquí más que mover la posición es más una lectura de la matriz con un punto inicial y el retorno indicando dicho punto donde esta, y desplegando el mapa.

Si tienen alguna sugerencia para que mi código sea más limpio, les agradecería que me lo dijeran ^^

#include <fstream>
#include <sstream>

using namespace std;

void imprimir(int posX, int posY, char gameMap [10] [10]){

    //Imprime el mapa, incluyendo al heroe

    for(int i=0; i<10; i++){

        for(int j=0; j<10; j++){

            if((j==posX)&&(i==posY)){

                cout << "0 ";

            }else{

                cout << gameMap[i][j] << " ";

            }
        }
        cout <<endl;
    }

}

void loadGame(int *posX, int *posY){

    ifstream readingFile("positionData.txt");
    //Creación del ifstream para la obtención de datos
    int renglon = 0;
    string line;

    if(readingFile.is_open()){

        while(getline(readingFile, line)){

            if(renglon == 0){
                //En el renglon 0 se guarda la posición X
                stringstream convert(line);
                //Se convierte de string a int
                convert >> *posX;
                //Se almacena en el puntero

            }else if(renglon == 1){
                //En el renglon 0 se guarda la posición Y
                stringstream convert(line);
                //Se convierte de string a int
                convert >> *posY;
                //Se almacena en el puntero

            }

            renglon++;
        }

    }else{

        cout<<"Error, no logré abrir el archivo D:"<<endl;

    }
}

void saveGame(int *posX, int *posY){

    ofstream writingFile("positionData.txt");
    //Creación del ifstream para la escritura de datos

    if(writingFile.is_open()){

        writingFile << *posX << endl;
        //Se guarda la posición en X mediante el puntero
        writingFile << *posY << endl;
        //Se guarda la posición en Y mediante el puntero

    }else{
        cout<<"Error, no logré abrir el archivo D:"<<endl;
    }

}

int main()
{

    cout<<"-------------------------" <<endl;
    cout<<"--------WELCOME :D-------" <<endl;
    cout<<"-------------------------" <<endl;
    cout<<"----Choose an option-----" <<endl;
    cout<<"-------------------------" <<endl;
    cout<<"-------(1) New game------" <<endl;
    cout<<"-------(2) Load game-----" <<endl;
    cout<<"-------------------------" <<endl;

    int opc;

    cin>> opc;

    int posX = 0, posY = 0;

    int* addressX = &posX;

    int* addressY = &posY;
    //Creación del puntero
    if(opc == 2){

        loadGame(addressX, addressY);

    }
    //Opción única para cargar las coordenadas del fichero

    char movement = ' ';

    char gameMap [10] [10] =
    {
        {'#','#','#','#','#','#','#','#','#','#'},
        {'#','#','#','#','#','#','#','#','#','#'},
        {'#','#','#','#','#','#','#','#','#','#'},
        {'#','#','#','#','#','#','#','#','#','#'},
        {'#','#','#','#','#','#','#','#','#','#'},
        {'#','#','#','#','#','#','#','#','#','#'},
        {'#','#','#','#','#','#','#','#','#','#'},
        {'#','#','#','#','#','#','#','#','#','#'},
        {'#','#','#','#','#','#','#','#','#','#'},
        {'#','#','#','#','#','#','#','#','#','#'}
    };

    cout<<"------------------------------------" <<endl;
    cout<<"Para moverse utilice 'w' 'a' 's' 'd'" <<endl;
    cout<<"Para salir y guardar, utilice 'f'" <<endl;
    cout<<"------------------------------------" <<endl;
    cout <<endl;
    cout <<endl;
    cout <<endl;

    imprimir(posX, posY, gameMap);



    while(movement!= 'f'){

        cin >> movement;

        if(movement == 'w'){
            *addressY = *addressY-1;
        }else if (movement == 'a'){
            *addressX = *addressX-1;
        }else if(movement == 's'){
            *addressY = *addressY+1;;
        }else if(movement == 'd'){
            *addressX = *addressX+1;
        }

        imprimir(posX,posY,gameMap);
    }
    //Pantalla de juego

    saveGame(addressX, addressY);
    //Se guardan los datos finales

    return 0;
}

Me costó mucho entender cómo hacerlo. Para convertir los strings line a integer tuve que usar la biblioteca <sstream>
Adjunto recurso: https://www.geeksforgeeks.org/converting-strings-numbers-cc/

#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

void drawMap (int positionX, int positionY, char gameMap[5][5])
{
    for (int i = 0; i < 5; i++) /*Rows = constant*/
    {
        for (int j = 0; j < 5; j++) /*Columns = constant. First prints a full row*/
        {
            if (positionY != i || positionX != j)
            {
                cout << gameMap[i][j];
            }
            else
            {
                cout << 'H';
            }
        }
        cout << endl;
    }
}

int main()
{
    //Strings used for allocate temporarily the value written
    string auxX;
    string auxY;

    //Actual position
    int positionX = 0;
    int positionY = 0;

    ifstream playerInfoR ("playerinfo.txt");

    bool playing = true;
    char input = ' ';
    char gameMap[5][5] =
    {
        {'*','*','*','*','*'},
        {'*','*','*','*','*'},
        {'*','*','*','*','*'},
        {'*','*','*','*','*'},
        {'*','*','*','*','*'}
    };

    cout << "Welcome. Use AWSD for navigation and Q for quit" << endl;

    string line;
    int renglon = 0;

    while(getline(playerInfoR, line))
    {
        if (renglon == 1)
        {
            auxX = line;
        }
        if (renglon == 2)
        {
            auxY = line;
        }
        renglon++;
    }

    stringstream posX (auxX);
    stringstream posY (auxY);

    posX >> positionX;
    posY >> positionY;

    // This drawMap is used to initialize the map with the former position
    drawMap (positionX, positionY, gameMap);

    // Moving character in the map
    while (playing)
    {
        cin >> input;

        switch (input)
        {
            case 'd':
                if (positionX < 4)
                {
                    positionX++;
                }
            break;
            case 'a':
                if (positionX > 0)
                {
                    positionX--;
                }
            break;
            case 's':
                if (positionY < 4)
                {
                    positionY++;
                }
            break;
            case 'w':
                if (positionY > 0)
                {
                    positionY--;
                }
            break;
        }

        drawMap(positionX, positionY, gameMap);

        if (input == 'q')
        {
            playing = false;
            cout << "Game over" << endl;
        }
    }

    ofstream playerInfoW ("playerinfo.txt");

    // Writing in file the position after finishing the game
    if (playerInfoW.is_open())
    {
        for (int i = 0; i < 5; i++) /*Rows = constant*/
        {
            for (int j = 0; j < 5; j++) /*Columns = constant. First prints a full row*/
            {
                if (positionY == i && positionX == j)
                {
                    playerInfoW << "Successfully loaded" << endl;
                    playerInfoW << positionX << endl;
                    playerInfoW << positionY << endl;
                }
        }
    }

    playerInfoW.close();

    return 0;
    }
}
#include <iostream>
#include <fstream>
#include <stdlib.h>

using namespace std;

void DrawMap(int heroPosX, int heroPosY, char gameMap[5][5])
{
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {

            if (i != heroPosX)
            {
                cout << gameMap[j][i];
            }
            else
            {
                if (j != heroPosY)
                {
                    cout << gameMap[j][i];
                }
                else
                {
                    cout << 'H';
                }
            }
        }
        cout << endl;
    }

}

int main()
{
    int heroPosX = 1;
    int heroPosY = 1;
    bool isGameOver = false;
    char imput = ' ';
    string line = "";
    string posx ="";
    string posy ="";
    int renglon = 0;

    
    

    ifstream ArchivoRead("DatosJuegos.txt");
    
    if(ArchivoRead.is_open())
    {
        while(getline(ArchivoRead, line))
        {
            if(renglon == 0)
            {
                posx = line;
                renglon ++;   
            }
            if(renglon == 1)
            {
                posy = line;
            }
        }
        heroPosX = stoi(posx);
        heroPosY = stoi(posy);
    }
    

    char gameMap[5][5] =
        {
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '1', '1', '1', '1'}
        };

        
    
    DrawMap(heroPosX, heroPosY, gameMap);

    while (isGameOver == false)
    {
        cin >> imput;

        switch (imput)
        {
        case 'd':
            heroPosY += 1;
            break;

        case 'a':
            heroPosY -= 1;
            break;

        case 'w':
            heroPosX -= 1;
            break;

        case 'x':
            heroPosX += 1;
            break;

        default:
            cout << "Perdiste palomo" << endl;
            isGameOver = true;
            break;
        }

        DrawMap(heroPosX, heroPosY, gameMap);
        
        

    for(int i = 0; i<5; i++)
    {
        for(int j = 0; j<5; j++)
        {
            if(i != heroPosX)
            {
                gameMap[j][i];
            }
            else
            {
                if(j != heroPosY)
                {
                    gameMap[j][i];
                }
                else
                {
                    ofstream Archivo("DatosJuegos.txt");
                    if(Archivo.is_open())
                    {
                        Archivo<< j << endl;
                        Archivo<< i << endl;
                    }
                    Archivo.close();
                }
                
            }
            
        }
    }
    }

    return 0;
}```
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdlib.h>

using namespace std;

void dibujarMapa(int mapa[10][10],int heroX, int heroY){
  for(int i=0;i<10;i++){
    for(int p=0;p<10;p++){
      if((i!=heroY) && (p!=heroX)){
        cout<<mapa[i][p];
      }
      else if((i==heroY) && (p==heroX)){
        cout<<'H';
      }
      else{
        cout<<mapa[i][p];
      }
    }
    cout<<endl;
  }

}

int main(){
  ifstream posicionesUsables("GameData.txt");
  char goOn;
  int heroPosY=4;
  int heroPosX=4;
  char movement;

  int gameMap[10][10]{
    {1,1,1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1,1,1}
  };

  cout<<"Hola!! para empezar a jugar Presiona 'Y': ";
  cin>>goOn;

  string temporal;
  int lineas=0;
  
  while (getline(posicionesUsables,temporal)) {

    if (lineas==1) {
      stringstream posUserX(temporal);
      posUserX>>heroPosX;

    }
    else if(lineas==2){
      stringstream posUserY(temporal);
      posUserY>>heroPosY;
    }
    lineas++;
  }


  while(goOn=='y'){
    dibujarMapa(gameMap,heroPosX,heroPosY);
    cout<<"para dejar de jugar presiona N"<<endl;
    cout<<"proximo movimiento ";
    cin>> movement;
    switch (movement) {
      case 'w':
        heroPosY-=1;
        break;
      case 's':
        heroPosY+=1;
        break;
      case 'a':
        heroPosX-=1;
        break;
      case 'd':
        heroPosX+=1;
        break;
        case 'n':
          goOn='n';
          break;
      default:
      cout<<"movimiento invalido, solo se aceptan las teclas W,A,S,D."<<endl;
    }
    system("cls");
  }
  ofstream posiciones("GameData.txt");
  if(posiciones.is_open()){
    posiciones<<"primera linea posicones X, segunda linea posicion Y"<<endl;
    posiciones<<heroPosX<<endl;
    posiciones<<heroPosY<<endl;
  }


  return 0;
}

Les paso mi código, fue un gran reto y aclare mas dudas que tenía.

#include <iostream>
#include <fstream>
#include <cstdlib>

using namespace std;

void DrawMap (int PlayerPosX, int PlayerPosY, char GameMap[5][5])
{

    for (int i =0 ; i < 5; i ++)
    {
        for (int j = 0; j<5; j ++)
        {
            if (i != PlayerPosY)
            {
                cout << GameMap [j][i];
            }
            else
            {
                if (j != PlayerPosX)
                {
                    cout << GameMap [j][i];
                }else{
                    cout << 'H';
                }

            }
        }
        cout << endl;
    }
}

int LocMap (int &PlayerX, int &PlayerY)
{
    int x,y;
    bool GameOver = false;
    char Input = ' ';
    char GameMap [5][5] =
    {
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
    };

    while (GameOver == false)
    {
        DrawMap(PlayerX,PlayerY, GameMap);
        cin >> Input;

        if (Input == 'd')
        {
            PlayerX ++;
            if (PlayerX > 4)
            {
                GameOver= true;
                cout << "Fin del juego" << endl;
            }

        }
        else if(Input == 'a')
        {
            PlayerX -- ;
            if (PlayerX <0 )
            {
                GameOver= true;
                cout << "Fin del juego" << endl;
            }

        }
        else if(Input == 'w')
        {
            PlayerY --;
            if (PlayerY <0 )
            {
                GameOver= true;
                cout << "Fin del juego" << endl;
            }

        }
         else if(Input == 's')
        {
            PlayerY ++;
            if (PlayerY > 4 )
            {
                GameOver= true;
                cout << "Fin del juego" << endl;
            }

        }
        else if (Input == 'g'){
            GameOver= true;
            x = PlayerX;
            y = PlayerY;
            return x;
            return y;
        }
    }
}

int CreateFile (int &x,int &y)
{
    ofstream MyFile("Gamedatamap.txt");

    if (MyFile.is_open())
    {
        MyFile << "Coordenadas"<<endl;
        MyFile << x << endl;
        MyFile << y << endl;
    }

    MyFile.close();
}
int OpenFile (int &x , int &y)
{
    cout << "Cargando partida..." << endl;

    ifstream MyFileRead ("Gamedatamap.txt");
    string line;

    int renglon = 1;

    cout << "Hola Viajero!"<<endl;
    cout<<endl;

    if (MyFileRead.is_open())
    {
        while (getline(MyFileRead, line))
        {

            if (renglon == 2)
            {
                x = atoi(line.c_str());

            }
            else if (renglon == 3)
            {
                y = atoi(line.c_str());

            }
            renglon ++;
        }
    }else
    {
    cout << "Error" << endl;
    }
}

int main()
{
    int locx=0, locy=0;
    int menu;
    char save = ' ';

    cout << "--MAIN MENU--" << endl;
    cout << "1.Crear nueva partida"<< endl;
    cout << "2.Cargar partida "<< endl;
    cout << "-------------"<< endl;
    cin >> menu;


    switch (menu)
    {
        case 1:
            CreateFile(locx,locy);
            break;

        case 2:
            OpenFile(locx,locy);
            break;

        default:
            cout<< "aplicacion cerrada" << endl;
            break;
    }

    if (locx > 4)
    {
        locx --;
    }
    else if (locx < 0)
    {
        locx ++;
    }
    else if (locy > 4)
    {
        locy --;
    }
    else if (locy < 0)
    {
        locy ++;
    }
    cout<<"Inicio posicion x "<<locx<<endl;
    cout<<"Inicio posicion y "<<locy<<endl;
    do {
        LocMap(locx,locy);
        cout << "Para guardar y salir oprima s" << endl;
        cin >> save;
    }while(save != 's');

    CreateFile(locx,locy);

    return 0;
}

Esta es mi solución si tienen alguna duda con confianza me pueden preguntar y yo les explico igual y aprendo algo nuevo

#include <iostream>
#include <fstream>


using namespace std;



void CreateMap( char gameMap[5][5], int *ptrHeroPosY, int *ptrHeroPosX);
void DrawMap( int heroPosX, int heroposY, char gameMap[5][5]);
void DrawMapTxt( char gameMap[5][5], int *ptrHeroPosY, int *ptrHeroPosX);
int LoadMap( char gameMap[5][5], int *ptrHeroPosY, int *ptrHeroPosX);



int main()
{
    int heroPosY = 0;
    int heroPosX = 0;   
    char gameMap[5][5];
    bool isGameOver = false;
    
    
    char input = ' ';

    LoadMap( gameMap, &heroPosY, &heroPosX);


    while(!(isGameOver)){

        cin >> input;


        if( input == 'd' ) {
            heroPosX++;
            if(5 <= heroPosX){
                cout << "\n\tGame Over\n\n" << endl;
                break;
            }
        } else if( input == 'a' ) {
            heroPosX--;
            if(heroPosX < 0){
                cout << "\n\tGame Over\n\n" << endl;
                break;
            }
        } else if( input == 'w' ) {
            heroPosY--;
            if( heroPosY < 0 ){
                cout << "\n\tGame Over\n\n" << endl;
                break;
            }
        } else if( input =='s' ) {
            heroPosY++;
            if( 5 <= heroPosY){
                cout << "\n\tGame Over\n\n" << endl;
                break;
            }
        }
        else if( input == 'p' ){
            isGameOver = true;
        }


        DrawMap(heroPosX, heroPosY, gameMap);

    }
 

    return 0;
}


int LoadMap(  char gameMap[5][5], int *ptrHeroPosY, int *prtHeroPosX ){
    
    ifstream Map("GameMap.txt");

    if(Map.is_open()){
        Map.close();
        DrawMapTxt( gameMap, ptrHeroPosY, prtHeroPosX );
        return 0;
    } else{
        Map.close();
        CreateMap( gameMap, ptrHeroPosY, prtHeroPosX);
        return 0;
    }

}

void CreateMap(  char gameMap[5][5], int *ptrHeroPosY, int *ptrHeroPosX){
    
    ofstream Map("GameMap.txt");
    if( Map.is_open()){

        for (int y = 0; y < 5; y++){
            for (int x = 0; x < 5; x++ ){
    
                if( x != *ptrHeroPosX || y != *ptrHeroPosY){
                    Map << "0";
                    gameMap[y][x] = '0';
                } else {
                    Map <<"3";
                    gameMap[y][x] = '3';
                    *ptrHeroPosX = x;
                    *ptrHeroPosY = y;
                }
    
            }

            Map << endl;

        }

    } else
        cout << "I can't create the map"; 

}

void DrawMapTxt(  char gameMap[5][5], int *ptrHeroPosY, int *ptrHeroPosX){
    ifstream Map("GameMap.txt");
    
    if(Map.is_open()){
        string line = "";
        int y = 0;
        while( getline(Map, line) ){
            for(int x = 0; x < 5; x++){
                if(line[x] != '3'){
                    gameMap[y][x] = line[x];
                } else{
                    *ptrHeroPosX = x;
                    *ptrHeroPosY = y;
                }


            }
            y++;
        }
        
        DrawMap( *ptrHeroPosX, *ptrHeroPosY, gameMap );
        
    }
    
    Map.close();

}


void DrawMap(int heroPosX, int heroPosY, char gameMap[5][5]){


    for(int y = 0; y < 5; y++){
        for(int x = 0; x < 5; x++){

            if(x != heroPosX || y != heroPosY )
                cout << gameMap[y][x];
            else
                cout << "3";

        }

        cout << endl;
    }


    cout << endl;
}
#include <iostream>
#include <fstream>
#include <sstream>
//-----------------------------------
using namespace std;
//-------FUNCIONES------------------
void DrawMap(int JugadorMovX,int JugadorMovY,char Mapa[4][4])
{
     for(int g = 0; g < 4; g = g + 1)
    {
        for(int a = 0; a < 4 ; a = a +1 )
        {
           if(g != JugadorMovY)
            {

                cout << Mapa [a][g] ;


            }else
            {
                if(a != JugadorMovX)
                {
                    cout << Mapa [a][g] ;
                }
                else
                {
                    cout <<'*';
                }

            }
        }
        cout << endl;
    }

}

//----MENSAJES--------------------------------
void MensajeB()
{
cout << "Hola jugador, usa los siguientes comandos" << endl;
cout << "para moverte en el laberinto o realizar otra accion."<< endl;
cout << "" << endl;
cout << "(a)Izquierda  (d)Derecha (w)Arriba (s) Abajo" << endl;
cout << "(p)Salir" << endl;
cout << "" << endl;
}

//------FIN FUNCIONES-------------------------

int main()
{


 //-----VARIABLES
    int JugadorMovX  = 0;
    int JugadorMovY  = 0;
    char Opcion = ' ';
    bool FinDelJuego = false;
    string PosHeroX = "";
    string PosHeroY = "";

 //-------MAPA DEL JUEGO -------------------
    char Mapa[4][4] =
    {
       {'<','<','<','<'},
       {'>','>','>','>'},
       {'<','<','<','<'},
       {'>','>','>','>'}
    };

//---------FIN MAPA--------------------------------+
//------------------------------------------------
    ifstream MyFileRead("GameData.txt");

     if(MyFileRead.is_open())
    {
         getline(MyFileRead, PosHeroX );
         getline(MyFileRead, PosHeroY );
         MyFileRead.close();

         stringstream p (PosHeroX);
         stringstream b (PosHeroY);

         p >> JugadorMovX;
         b >> JugadorMovY;
    }

//------------------------------------------------
      MensajeB();
      DrawMap(JugadorMovX,JugadorMovY,Mapa);

//---------- BUCLE PARA MOVERSE-------------------

    while(FinDelJuego == false)
    {
        cin >> Opcion;

        if(Opcion == 'd')
        {
            JugadorMovX = JugadorMovX +1 ;

        }else if(Opcion == 'a')
        {
            JugadorMovX = JugadorMovX -1 ;
        }
        else if(Opcion == 's')
        {
            JugadorMovY = JugadorMovY +1;
        }else if(Opcion == 'w')
        {
            JugadorMovY = JugadorMovY -1;
        }
        else if(Opcion == 'p')
        {
            cout <<endl;
            cout << "FIN DEL JUEGO"<< endl;
            cout <<endl;

            FinDelJuego = true;
        }


        DrawMap(JugadorMovX,JugadorMovY,Mapa);
    }

        ofstream MyFile("GameData.txt");

            if(MyFile.is_open())
            {
                  MyFile << JugadorMovX << endl;
                  MyFile << JugadorMovY << endl;
                  MyFile.close();
            }


//-------FIN DEL BUCLE-------------------------


    return 0;
}

<#include <iostream>
#include <fstream>
using namespace std;
void DrawMap (int PlayerPosX, int PlayerPosY, char GameMap[5][5])
{

    for (int i =0; i < 5; i ++)
    {
        for (int j = 0; j<5; j ++)
        {
            if (i != PlayerPosY)
            {
                cout << GameMap [j][i];
            }
            else
            {
                if (j != PlayerPosX)
                {
                    cout << GameMap [j][i];
                }else{
                    cout << 'H';
                }
            }
        }
        cout << endl;
    }
}
int LocMap (int &PlayerX, int &PlayerY)
{
    int x,y;
    bool GameOver = false;
    char Input = ' ';
    char GameMap [5][5] =
    {
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
        {'.','.','.','.','.'},
    };
    while (GameOver == false)
    {
        DrawMap(PlayerX,PlayerY, GameMap);
        cin >> Input;
        if (Input == 'd')
        {
            PlayerX ++;
            if (PlayerX > 4)
            {
                GameOver= true;
                cout << "Fin del juego" << endl;
            }
        }
        else if(Input == 'a')
        {
            PlayerX -- ;
            if (PlayerX <0 )
            {
                GameOver= true;
                cout << "Fin del juego" << endl;
            }
        }
        else if(Input == 'w')
        {
            PlayerY --;
            if (PlayerY <0 )
            {
                GameOver= true;
                cout << "Fin del juego" << endl;
            }
        }
         else if(Input == 's')
        {
            PlayerY ++;
            if (PlayerY > 4 )
            {
                GameOver= true;
                cout << "Fin del juego" << endl;
            }
        }
        else if (Input == 'g'){
            GameOver= true;
            x = PlayerX;
            y = PlayerY;
            return x;
            return y;
        }
    }
}
int CreateFile (int &x,int &y)
{
    ofstream MyFile("Gamedatamap.txt");

    if (MyFile.is_open())
    {
        MyFile << "Coordenadas"<<endl;
        MyFile << x << endl;
        MyFile << y << endl;
    }
    MyFile.close();
}
int OpenFile (int &x , int &y)
{
    cout << "Cargando partida..." << endl;

    ifstream MyFileRead ("Gamedatamap.txt");
    string line = "";
    int renglon = 1;
    cout << "Hola Aventurero!!!"<<endl;
    cout<<endl;
    if (MyFileRead.is_open())
    {
        while (getline(MyFileRead, line))
        {
            if (renglon == 2)
            {
                x = atoi(line.c_str());

            }
            else if (renglon == 3)
            {
                y = atoi(line.c_str());

            }
            renglon ++;
        }
    }else
    {
    cout << "Error" << endl;
    }
}
int main()
{
    int locx=0, locy=0;
    int opciones;
    char save = ' ';

    cout << "--------OPCIONES--------" << endl;
    cout << "*. Crear nueva partida"<< endl;
    cout << "*. Cargar partida "<< endl;
    cout << "------------------------"<< endl;
    cin >> opciones;
    switch (opciones)
    {
        case 1:
            CreateFile(locx,locy);
            break;
        case 2:
            OpenFile(locx,locy);
            break;
        default:
            cout<< "aplicacion cerrada" << endl;
            break;
    }
    if (locx > 4)
    {
        locx --;
    }
    else if (locx < 0)
    {
        locx ++;
    }
    else if (locy > 4)
    {
        locy --;
    }
    else if (locy < 0)
    {
        locy ++;
    }
    cout<<"Inicio posicion x "<<locx<<endl;
    cout<<"Inicio posicion y "<<locy<<endl;
    do
    {
        LocMap(locx,locy);
        cout << "Para guardar y salir oprima s" << endl;
        cin >> save;
    }
    while(save != 's');
    CreateFile(locx,locy);
    return 0;
}>