Posicionamiento del Jugador en el Mapa de Juego

Clase 29 de 47 • Curso Práctico de C++

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:

Modificar el archivo del mapa asignando un símbolo único que represente donde va a aparecer el personaje (con un ‘3’ por ejemplo).
Cargar las líneas del archivo usando fstream e iterar con un for carácter por carácter.
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).
Pasarle esos datos al jugador ya sea directamente con una referencia o leyendo los valores en variables de la clase.
Dibujar el mapa.

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

void drawMaps(char Input, int HeroPositionX, int HeroPositionY, char map[5][5]) {
    ifstream GameMapRead("Garden.txt");
    string line;
    int row = 0;
    int column = 1;
    int count = 1;
    bool foundPlayer = false;
    if(GameMapRead.is_open()){
        while (getline(GameMapRead, line)){
            for (int i = 0; i < 5; i++){
                cout << line[i];
                if(line[i] == 'H'){
                    row = i + 1;
                    column = count;
                    foundPlayer = true;
                }
            }
            cout << endl;
            count = count + 1;
        }
        if (foundPlayer) {
            cout << "Player in row: " << row << " column: " << column;
        }
    } else {
        cout << "An error ocurred while opening the file" << endl;
    }
    cout << endl;
}

int main() {
    int HeroPositionX = 0;
    int HeroPositionY = 0;
    char map[5][5] = {
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
        {'1','1','H','1','1'},
        {'1','1','1','1','1'},
        {'1','1','1','1','1'},
    };
    ofstream GameMap("Garden.txt");
    if(GameMap.is_open()){
        for(int row = 0; row < 5; row++) {
            for(int column = 0; column < 5; column++){
                GameMap << map[row][column];
            }
            GameMap << endl;
        }
    }
    GameMap.close();

    char Input = ' ';
    bool isGameOver = false;

    drawMaps(Input ,HeroPositionX, HeroPositionY, map);

    while(isGameOver == false){
        cin >> Input;
        drawMaps(Input, HeroPositionX, HeroPositionY, map);
    }
    return 0;
}

#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;
}

#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 drawMap(int heroPosX, int heroPosY, char gameMap[10][10])
{
  ofstream myFile("textMap.txt");

  if(myFile.is_open())
  {
    for(int i = 0; i < 10; i++)
    {
      for(int p = 0; p < 10; p++)
      {
        if(i != heroPosY){
          cout << gameMap[p][i];
          myFile << gameMap[p][i];
        }else{
          if(p != heroPosX){
            cout << gameMap[p][i];
            myFile << gameMap[p][i];
          }else{
            cout << '8';
            myFile << '8';
          }
        }
      }
      cout << endl;
      myFile << endl;
    }
  }
  myFile.close();
}

/*void textMap()
{
  ofstream myFile("textMap.txt");

  if(myFile.is_open())
  {
    myFile << "Hola Mundo!" << endl;
  }

  myFile.close();
}*/

int main()
{

  int heroPosX = 0;
  int heroPosY = 0;
  bool isGameOver = false;
  bool exit = false;
  char input = ' ';

  char gameMap[10][10] =
  {
    {'3', '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', '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', 'E'}
  };

  drawMap(heroPosX, heroPosY, gameMap);

  while(isGameOver == false && exit == 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;
    }

    if(heroPosX == 9 && heroPosY == 9){
      exit = true;
    }

    drawMap(heroPosX, heroPosY, gameMap);
    cout << "posición en x: " << heroPosX << endl;
    cout << "posición en y: " << heroPosY << endl;
    cout << "Exit: " << exit << endl;
    cout << "Pausa: " << isGameOver << endl;

  }

  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;
}

    |                                              
    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    ```

#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;
}

#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); 

}

ofstream gamemap(&quot;mapa.txt&quot;);

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

int PosicionHeroeX=0;
int PosicionHeroeY=0;

bool GameOver = false;

char Input = ' ';

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



DrawMap(PosicionHeroeX,PosicionHeroeY,mapaDraw);

ifstream gamemapRead(&quot;mapa.txt&quot;);
string line;

if(gamemapRead.is_open())
{   
    while(GameOver == false)
    {
        cin&gt;&gt;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;

#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;fstream&gt;
#include &lt;conio.h&gt;

using namespace std;

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

};

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

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

			}
			else
			{
				if (Columna != HeroPosY) {

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

			}
		}
	}
	
};
//funcion para los controles de movimiento.
void Gamecontrols(char&amp; HeroWalk, int&amp; HeroPosX, int&amp; HeroPosY, char Mapa[5][5]) {
	while (HeroWalk != 't')
	{
		cin &gt;&gt; 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&amp; HeroPosX, int&amp; HeroPosY) {
	
	string DatosGame;
	ifstream SaveGame(&quot;GameWar.txt&quot;);
	if (SaveGame.is_open())
	{
		getline(SaveGame, DatosGame);		
		HeroPosX = DatosGame[0] - '0';
		HeroPosY = DatosGame[1] - '0';
		cout &lt;&lt; HeroPosX;
		cout &lt;&lt; HeroPosY;		
	}
	else
	{
		cout &lt;&lt; &quot;Los datos guardados no se cargaron correctamente&quot; &lt;&lt; endl;

	}
	cout &lt;&lt; &quot; &quot; &lt;&lt; endl;

};




void Start()
{
	
	cout &lt;&lt; &quot; ######  ########    ###    ########  ########&quot; &lt;&lt; endl;
	cout &lt;&lt; &quot;##    ##    ##      ## ##   ##     ##    ##   &quot; &lt;&lt; endl;
	cout &lt;&lt; &quot;##          ##     ##   ##  ##     ##    ##   &quot; &lt;&lt; endl;
	cout &lt;&lt; &quot; ######     ##    ##     ## ########     ##   &quot; &lt;&lt; endl;
	cout &lt;&lt; &quot;      ##    ##    ######### ##   ##      ##   &quot; &lt;&lt; endl;
	cout &lt;&lt; &quot;##    ##    ##    ##     ## ##    ##     ##   &quot; &lt;&lt; endl;
	cout &lt;&lt; &quot; ######     ##    ##     ## ##     ##    ##   &quot; &lt;&lt; endl;


};

int main()
{
	cout &lt;&lt; &quot;   _////         _/       _//       _//_////////&quot; &lt;&lt; endl;
	cout &lt;&lt; &quot; _/    _//      _/ //     _/ _//   _///_//      &quot; &lt;&lt; endl;
	cout &lt;&lt; &quot;_//            _/  _//    _// _// _ _//_// &quot; &lt;&lt; endl;
	cout &lt;&lt; &quot;_//           _//   _//   _//  _//  _//_//////&quot; &lt;&lt; endl;
	cout &lt;&lt; &quot;_//   _////  _////// _//  _//   _/  _//_// &quot; &lt;&lt; endl;
	cout &lt;&lt; &quot; _//    _/  _//       _// _//       _//_// &quot; &lt;&lt; endl;
	cout &lt;&lt; &quot;  _/////   _//         _//_//       _//_////////&quot; &lt;&lt; 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(&quot;Game.txt&quot;);
	int FilaDatosGame = 0;
	string DatosGame = &quot; &quot;;
	

	//_______________________________
	cout &lt;&lt; &quot;(N)ueva Partida&quot; &lt;&lt; endl;
	cout &lt;&lt; &quot;(C)argar Ultima partida&quot;&lt;&lt;endl;
	cout &lt;&lt; &quot;(S)alir&quot; &lt;&lt; endl;
	cin &gt;&gt; opcion;    
	switch (opcion)
	{
	case 'N':
	case 'n':
		
		Start();		
		cout &lt;&lt; &quot; &quot; &lt;&lt; endl;
		cout &lt;&lt; &quot;presione (a) para ir a la Izquierda&quot; &lt;&lt; endl;
		cout &lt;&lt; &quot;presione (d) para ir a la Derecha&quot; &lt;&lt; endl;
		cout &lt;&lt; &quot;presione (w) para ir a  Arriba&quot; &lt;&lt; endl;
		cout &lt;&lt; &quot;presione (s) para ir a Abajo&quot; &lt;&lt; endl;
		cout &lt;&lt; &quot;presione (t) para salir y guardar&quot; &lt;&lt; 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 &lt;&lt; &quot;Gracias por jugar&quot;;
		break;

	default:
		cout &lt;&lt; &quot;Opcion no valida&quot; &lt;&lt; endl;
		break;
	}

	
	
	return 0;
}```

#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;
}```

#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();

}

#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;
        }
    }
}```

#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;
}

#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;
  // ...
}

#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;
}

<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;
}

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

using namespace std;

void DrawMap (int heroPosX, int heroPosY, int gatoY, int gatoX, char gameMap[7][7], char hero, char cat) {

    ofstream MyFile ("Juego.txt");
    if (MyFile.is_open()) {
        for (int i = 0; i < 7; i++) {
            for (int k = 0; k < 7; k++) {
                if (i == heroPosY && k == heroPosX) { 
                    MyFile << hero;
                } else if (i == gatoY && k == gatoX) {
                    MyFile << '1';
                } else {
                    MyFile << gameMap[i][k];
                }
            }
            MyFile << endl;
        }   
    }
    
    ifstream MyFileRead("Juego.txt");
    string line;
    int renglon = 0;
    int posicionX;
    int posicionY;

    if (MyFileRead.is_open()) {
        while (getline(MyFileRead, line)) {
            
            for (int i = 0 ; i < 7 ; i = i+1) {
                if (line[i] == 'H') {
                    posicionY = renglon ;
                    posicionX = i;
                }
            }
            cout << line << endl;
            renglon = renglon +1;
        }
        cout << "La posicion del heroe es: " << posicionX << posicionY << endl;
        cout << "La posicion del gato es: " << gatoX << gatoY << endl;

    } else {
        cout << "Error al leer el archivo" << endl;
    }
}

int main () {
    char hero = 'H';
    int heroPosX = 3;
    int heroPosY = 3;
    char cat = 'G';
    int gatoX = rand()%5+1;
    int gatoY = rand()%5+1;
    int vidas = 3;
    bool isGameOver = false;
    char input = ' ';
    char gameMap[7][7] = {
        {'0','0','0','0','0','0','0'},
        {'0','1','1','1','1','1','0'},
        {'0','1','1','1','1','1','0'},
        {'0','1','1','1','1','1','0'},
        {'0','1','1','1','1','1','0'}, 
        {'0','1','1','1','1','1','0'},
        {'0','0','0','0','0','0','0'},
    };

    cout << "Atrapa al gato escondido!" << endl;


    while (isGameOver == false) {
        DrawMap (heroPosX,heroPosY, gatoY, gatoX, gameMap, hero, cat);
        cout << endl;
        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;
        } 
        if (heroPosX == 0 || heroPosX == 6 || heroPosY == 0 || heroPosY == 6) {
            vidas = vidas -1;
            heroPosX = 3;
            heroPosY = 3;
            cout << "Perdiste una vida." << endl;
            cout << "Vidas: " << vidas << endl;
        } 
        if (vidas == 0) {
            cout << "Game Over" << endl;
            isGameOver = true;
        }
        if (heroPosX == gatoX && heroPosY == gatoY) {
            vidas = vidas + 1;
            heroPosX = 3;
            heroPosY = 3;
            gatoX = rand()%5+1;
            gatoY = rand()%5+1;
            cout << "Ganaste una vida." << endl;
            cout << "Vidas: " << vidas << endl;
        }
    }
} 

Christian Alexis Serrato Guerrero

student•

Desconozco si era la idea pero al menos ya sabe donde ubicarse: (me fallo el moverlo izquierda o derecha)

Ernán Alexander Velásquez Ramírez

Lo logré

David Lara

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:

Camilo Arias Céspedes

En la primera linea de código cambie de esto.

cout << system("cls");

a esto

system("cls");

Eso le soluciona el cero de más que le aparece.

Bueno realmente es en la primera línea de la función DrawMap

Miguel Angel Ramirez Echeverry

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 ?

Francisco Angel Núñez Luna

Buenas Miguel, tampoco estoy muy seguro de lo que pide el reto, pero como yo lo interprete es que pudiéramos hacer lo mismo que sucede en el reto anterior, pero incorporando lo que se vio en esta lección. Yo hice que, al igual que en el reto pasado, con las teclas se moviera un personaje por un mapa, pero a la vez estos movimientos fueran registrados en un archivo de texto, como si cada paso en cualquier dirección reescribiera el mapa que aparecería en el archivo de texto, por ejemplo; cuando tecleo “P” el programa acaba y guardaba información en el archivo de texto, mostrando lo mismo que se vería en la consola, solo que ya guardado en un archivo de texto en el disco duro, como si no perdiera el progreso por así decirlo, ya que este se encontraría en el .txt. Te dejo mi código por si quieres ver como funciona al final.

![](

Fernando Reséndiz Bautista

Mi Mapa:

Giovanni Chavarro

Reto

Obed Paz

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

Piero Acevedo

#include <iostream> #include <fstream>

using namespace std;

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

}

int main() {

Cesar Augusto Alarcon Garcia

versión 0.0 jajaja

jhossue Daniel Sanchez Prato

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

Luis Felipe Correa Vera

Javier Gamez

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...

Rodolfo Vargas

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;
}

Alejandro Andrade Soriano

CHALLENGE COMPLETED!

Santiago Gómez

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

Gary César Aldair Jiménez Gregorio

Simple pero funciona!

José Martínez Santana

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:

Juan Henao

GABRIELA ZAMBRANO

El juego :)

Atrapa al gato escondido!

0000000

0111110

011H110

La posicion del heroe es: 33

La posicion del gato es: 35

La posicion del heroe es: 34

Ganaste una vida.

Vidas: 4

La posicion del gato es: 44

La posicion del heroe es: 32

01H1110

La posicion del heroe es: 22

0H11110

La posicion del heroe es: 12

Perdiste una vida.

Vidas: 3

La posicion del heroe es: 35

Vidas: 2

La posicion del heroe es: 25

Vidas: 1

La posicion del heroe es: 23

La posicion del heroe es: 13

Vidas: 0

Game Over

Gibrán Pelayo Miranda

Ya leí todos los mensajes de mis compañeros, y no logro entender el reto... ¿Alguien que pueda explicar??? Gracias de antemano.

Juan Castro

teacher•

¡Hola! Te explico.

Debes programar el código necesario para que el jugador pueda ver su posición en el mapa. Mejor aún si puedes dejarle un mensajito o algo así para ser más claros.

Por ejemplo:

¡Hola, Jugador!

X = tu posición en el mapa.
0 = lugares a donde puedes moverte.

000
0X0
000

Presiona alguna tecla para moverte (w\a\d\s):

Y suponiendo que el jugador presiona W (para moverse hacia arriba):

Presionaste W. ¡Te mueves hacia arriba!

0X0
000
000

Presiona alguna tecla para moverte (w\a\d\s):

David Santiago González Ramos

@juandc Entonces entendí otra cosa 😂 y por ende programe otra cosa jajajaja. Gracias por aclarar lo que eventualmente no era una duda😅

Posicionamiento del Jugador en el Mapa de Juego

Introducción a C++

Programación de Videojuegos con C++ desde Cero

Programación en C++: Fundamentos y Aplicaciones Prácticas

Conceptos Generales de C++

Historia y uso del compilador GCC en programación

Preparando el entorno de trabajo

Instalación de Code::Blocks en Windows paso a paso

Instalación de CodeBlocks en Mac paso a paso

Creación de un Proyecto de Consola en C++ Paso a Paso

Uso de Librerías y Entrada/Salida en C++

Manejo de memoria

Memoria y Tipos de Datos en Computadoras y Programación

Variables y tipos de datos en programación básica

Operadores Aritméticos y Lógicos en Programación

Uso de Apuntadores para Manipulación de Memoria en Programación

Cálculo del Área de Círculo y Esfera con Variables

Entrada de datos y funciones

Entrada y manejo de datos en programas C++

Operadores Relacionales y Condicionales en Programación

Condicionales y estructuras de control en programación

Funciones y Encapsulamiento en Programación

Funciones en Programación: Creación y Uso Eficiente

Creación de aventuras interactivas con C++ y decisiones de usuario

Loops y arreglos

Arreglos: Conceptos Básicos y Manipulación en Programación

Estructuras de Control: Bucles en Programación

Contadores y Bucles en Programación: While, Do-While y For

Arreglos Unidimensionales y Bidimensionales en Programación

Dibujar Mapas y Personajes en Juegos con Arreglos en C++

Movimiento de Personajes en Juegos con Python

Programación de Mapas Bidimensionales en Videojuegos

Movimiento de Personajes en Cuatro Direcciones con CIN

Lectura de Archivos

Lectura y escritura de archivos en C++ con fstream

Lectura y Escritura de Archivos en Programación

Posicionamiento del Jugador en el Mapa de Juego

Programación Orientada a Objetos

Programación Orientada a Objetos: Conceptos y Beneficios

Programación Orientada a Objetos: Clases e Instancias en Java

Encapsulación de Datos en Programación Orientada a Objetos

Abstracción en Programación Orientada a Objetos

Herencia en Programación Orientada a Objetos: Clases y Constructores

Tipos de acceso en la herencia de clases en programación

Polimorfismo en C++: Teoría y Práctica

Finalizando nuestro proyecto

Programación de un Juego de Laberinto en C++

Controles básicos de movimiento en videojuegos con programación en C++

Creación de Clases para Mapas en Juegos de Programación

Conexión de Jugador y Coordenadas en Mapas de Videojuegos

Carga y Lectura de Archivos para Mapas en Juegos

Colisiones y Movimiento en Juegos 2D con C++

Colisiones y restricciones de movimiento en mapas de juegos

Colisiones y Portadas en Videojuegos: Implementación en C++

Creación de Juegos de Aventuras en C++: Laberintos y Cofres del Tesoro

Programación Orientada a Objetos en Videojuegos Básicos

Creación de Enemigos y Laberintos en C++ Avanzado