Arreglos bidimensionales

Curso Práctico de C++

Introducción a C++

Todo lo que aprenderás sobre C++

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

Conceptos Generales de C++

La Historia de C++ y sus diferencias con C

Preparando el entorno de trabajo

Instalando Codeblocks

Pasos para instalar en mac

Ejecutando nuestro primer programa

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

Manejo de memoria

¿Qué es la memoria y tipos de datos?

Alojando variables en memoria

¿Cómo usar operadores?

¿Qué son los apuntadores?

Reto: Escribir un programa que calcule áreas.

Entrada de datos y funciones

¿Cómo introducir datos a nuestro programa?

¿Cómo usar condicionales?

Usando condicionales

¿Cómo encapsular código en funciones ?

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

Reto: Juego narrativo implementando condicionales y entrada de datos.

Loops y arreglos

¿Qué son los arreglos?

¿Qué son los Loops?

Programando Loops

Loops , arreglos y arreglos bidimensionales

Dibujando el mapa de nuestro juego con arreglos

Manipulando mi jugador con inputs en arreglos unidimensionales

Arreglos bidimensionales

Reto: Moviendo a mi personaje en mi arreglo bidimensional

Lectura de Archivos

Creando y leyendo un archivo externo

Leyendo archivos externos

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

Programación Orientada a Objetos

¿Qué es POO?

Definiendo una clase y creando sus instancias

Encapsulación

Abstracción

Herencia

Propiedades de clase en herencia

Polimorfismo

Finalizando nuestro proyecto

Creación de personaje y archivo de encabezado

Moviendo mi personaje con entrada de datos

Mapa

Interacción entre el personaje y el mapa

Paredes

Optimizando trazado de mapa

Colisiones

Creando nuestra portada de juego

Tesoro y victoria

Conclusiones

Proyecto final

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

En esta clase debemos crear un mapa (un arreglo bidimensional) con todas las posibles posiciones de nuestro héroe. Esto significa que, además de nuestro ciclo for para imprimir cada posición de nuestra columnas, debemos crear otro ciclo para imprimir las columnas (o al revés).

Además, debemos verificar la posición de nuestro héroe en ambas partes, filas y columnas. La forma más rápida de hacerlo es creando dos nuevas variables, heroPosX y heroPosY, para validar sus posiciones en sus respectivos ciclos.

En reto de esta clase es programar la funcionalidad de que nuestro jugador pueda moverse por todo el mapa, incluyendo hacia arriba y abajo, no solo a la izquierda y a la derecha.

Puntos extra si puedes evitar que el jugador salga del mapa, es decir, que la posición de nuestro héroe no pueda ser menor ni mayor que las posiciones de nuestro arreglo bidimensional.

Código de la clase:

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 (i != HeroPosY)
        {
          cout << GameMap[p][i];
        }
        else
        {
          cout << 'H';
        }
      }
    }

    // Necesitamos un salto de línea para diferenciar
    // las filas de las columnas:
    cout << 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'},
  }

  // ...
}

Aportes 76

Preguntas 5

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

LuisLazcano

hace 5 años

Me gusta más como se ve con Switch Case 😃

#include <iostream>
using namespace std;


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



int main(){

  int posX=0;
  int posY=0;
  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'}};
  char teclado;
  bool gameOver= false;

  drawMap(posX,posY,map);
  while(!gameOver){
  cin>>teclado;
  switch (teclado)
  {
  case 'a':
       posX-=1;
       break;
  case 'd':
	 posX+=1;
       break;
  case 'w':
         posY-=1;
       break;
  case 's':
         posY+=1;
       break;
  case 'p':
	 gameOver=true;
  default:
      break;
  }
  drawMap(posX,posY,map);
  }
 
 return 0;
}

Enrique Alberto Ciganda Chá

hace 5 años

Agregué la librería stdlib para usar la función de sistema "cls"y mantener el mapa en el mismo lugar

<
#include <iostream>
#include <stdlib.h> // Libreria para funcion de sistema cls
using namespace std;

void DrawMap(int HeroPosX,int HeroPosY,char GameMap[5][5]) {
     system("cls"); //llamada a funcion de sistema
    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()
{
    int HeroPosX =1;
    int HeroPosY =1;
    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')
        {
          HeroPosY++;
        }
         else if(Input == 'a')
         {
             HeroPosY--;
         }
         if(Input == 'w')
        {
          HeroPosX++;
        }
         else if(Input == 's')
         {
             HeroPosX--;
         }
         else if(Input == 'p')
         {
             isGameOver = true;
         }
        DrawMap(HeroPosX,HeroPosY,GameMap);
        }

 return 0;
}
>

Isaac Miranda Madrigal

hace 5 años

Cuando dijo lo del reto ya lo había hecho jaja. Espero que le sirva a alguien.

#include <iostream>
#include <conio.h>
using namespace std;
typedef unsigned int uint;

void drawMap(const int * pheroPosX, const int * pheroPosY, char pmap[5][5]);

bool mover(char pinput, int &pheroPosX, int &pheroPosY);

int main()
{
    bool isGamerOver = false;
    int* heroPosX = new int;
    *heroPosX = 1;
    int* heroPosY = new int;
    *heroPosY = 1;
    char input = ' ';
    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'}
    };

    drawMap(heroPosX, heroPosY, mapa);

    while (!isGamerOver){
        cout << endl;
        cin >> input;
        isGamerOver = mover(input, *heroPosX, *heroPosY);
        drawMap(heroPosX, heroPosY, mapa);
    }



    delete heroPosX;

//    cout << endl << "\nPresione enter para terminar" << endl;
//    getch();
    return 0;
}

void drawMap(const int * pheroPosX, const int * pheroPosY, char pmap[5][5]){
    for(uint col = 0; col < 5; col++){
        for(uint row = 0; row < 5; row++){
            if(col != *pheroPosY){
                cout << pmap[row][col];
            }
            else {
                if(row != *pheroPosX){
                    cout << pmap[row][col];
                } else{
                    cout << 'H';
                }
            }
        }
        cout << endl;
    }
}

bool mover(char pinput, int &pheroPosX, int &pheroPosY){
    bool terminar = false;
    switch(pinput){
        case 'd':
            pheroPosX++;
            break;
        case 'a':
            pheroPosX--;
            break;
        case 'w':
            pheroPosY--;
            break;
        case 's':
            pheroPosY++;
            break;
        case 'p':
            terminar = true;
            break;
        default:
            terminar = true;
            break;
    }
    return terminar;
}

Juan

Profe Platzi

hace 6 años

Mi solución del reto incluyendo las funcionalidades de moverse hacia arriba y abajo y no poder salirse del mapa: https://repl.it/repls/TrimIndelibleParticle

Código:

#include <iostream>

char ask_move() {
  char lastMove;
  
  std::cout << "Up/Down/Left/Right (u/d/l/r): ";
  std::cin >> lastMove;

  return lastMove;
}

void draw_world(
  int lives, char map[3][3],
  int heroPosRow, int heroPosCol
) {
  std::cout << "\n";

  std::cout << "Vidas: " << lives << "\n";

  // MAPA BIDIMENSIONAL
  for (int row = 0; row < 3; row++) {
    // Salto de linea por cada row
    std::cout << "\n";

    for (int col = 0; col < 3; col++) {
      char rowColPos = map[row][col];

      if (heroPosRow == row && heroPosCol == col) {
        std::cout << "X";
      } else {
        std::cout << rowColPos;
      }
    }
  }

  std::cout << "\n\n";
}

int main() {
  std::cout << "Hello World!\n";

  char map[3][3] = {
    {'-', '-', '-'},
    {'o', '-', '-'},
    {'-', '-', 'o'},
  };
  int heroPosRow = 0;
  int heroPosCol = 0;
  char lastMove = ' ';
  int lives = 5;

  do {
    draw_world(
      lives, map,
      heroPosRow, heroPosCol
    );

    char move = ask_move();

    switch (move) {
      case 'u':
        if ((heroPosRow - 1) < 0) {
          std::cout << "\nNO TE PUEDES SALIR DEL MAPA\n";
          lives--;
        } else {
          heroPosRow--;
        }
      break;

      case 'd':
        if ((heroPosRow + 1) > 2) {
          std::cout << "\nNO TE PUEDES SALIR DEL MAPA\n";
          lives--;
        } else {
          heroPosRow++;
        }
      break;

      case 'l':
        if ((heroPosCol - 1) < 0) {
          std::cout << "\nNO TE PUEDES SALIR DEL MAPA\n";
          lives--;
        } else {
          heroPosCol--;
        }
      break;

      case 'r':
        if ((heroPosCol + 1) > 2) {
          std::cout << "\nNO TE PUEDES SALIR DEL MAPA\n";
          lives--;
        } else {
          heroPosCol++;
        }
      break;

      default: std::cout << "Vuelve a intentarlo.";
      break;
    }
  } while (lives > 0);

  std::cout << "\nGAME OVER!\n";
}

jose luis gonzalez aguilera

hace 5 años

listo, limitado para que el heroe no salga del mapa y con funcion de finalizado:

#include <iostream>

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

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

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

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

        }


    }




    return 0;
}```

Juan Sebastian Garavito Ballesteros

hace un año

Agregué el comando “cls” para refrescar la terminal cada vez que se dibuja el mapa.
Además, agregue la librería <conio.h> para utilizar la función getch() la cual recibe el input del teclado sin tener que dar enter, esto hace más dinámico el movimiento.

// ------------------------Controles del juego------------------------
// Izquierda → "a" Derecha → "d" Arriba → "w" Abajo → "s" Salir → "x"

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

using namespace std;

struct player_pos{
        int x = 0;
        int y = 0;
    };

// Altura y largo del mapa
const int length = 6, height = 3;

void dibujar_mapa(player_pos new_player_pos, player_pos last_player_pos, char map[height][length], int map_length, int map_height){ // Genera el mapa
    
    // Coloca al jugador en el mapa
    map[last_player_pos.y][last_player_pos.x] = '_';
    map[new_player_pos.y][new_player_pos.x] = '*';
    
    // Dibuja el mapa
    system("cls");
    //cout << "X: " << new_player_pos.x << " Y: " << new_player_pos.y <<endl;
    for (int c = 0; c <  map_height; c++){
        for(int i = 0; i < map_length; i++){
            cout << map[c][i];
        }
        cout << endl;
    }
    cout << endl << endl;
}

player_pos movimiento(player_pos last_player_pos, int map_length, int map_height){ // Movimiento del jugador
    char instruccion;
    player_pos new_player_pos;
    new_player_pos.x = last_player_pos.x;
    new_player_pos.y = last_player_pos.y;

    // Recibe la instrucción del teclado
    instruccion = getch();
    
    // Verifica la instrucción de entrada para moverse 
    // Izquierda → "a" Derecha → "d" Arriba → "w" Abajo → "s" Salir → "x"
    switch (instruccion)
    {
    case 'a': // Mover izquierda
        if (last_player_pos.x <= 0){
            // Condición por si desborda por la izquierda
            new_player_pos.x = map_length - 1;
            return new_player_pos;
        }
        new_player_pos.x = last_player_pos.x - 1;
        return new_player_pos;
        break;

    case 'd': // Mover derecha
        if (last_player_pos.x >= map_length - 1){
            // Condición por si desborda por la derecha
            new_player_pos.x = 0;
            return new_player_pos;
        }
        new_player_pos.x = last_player_pos.x + 1;
        return new_player_pos;
        break;

    case 'w': // Mover arriba
        if (last_player_pos.y <= 0){
            // Condición por si desborda por arriba
            new_player_pos.y = map_height - 1;
            return new_player_pos;
        }
        new_player_pos.y = last_player_pos.y - 1;
        return new_player_pos;
        break;
    
    case 's': // Mover abajo
        if (last_player_pos.y >= map_height - 1){
            // Condición por si desborda por abajo
            new_player_pos.y = 0;
            return new_player_pos;
        }
        new_player_pos.y = last_player_pos.y + 1;
        return new_player_pos;
        break;
    
    case 'x': // Salir
        new_player_pos.x = map_length + 1;
        return new_player_pos;

    default:
        // Condición si presiona cualquier otra tecla
        return new_player_pos;
        break;
    }
}

int main(){
    
    // Se genera el mapa
    char map[height][length];
    for (int c = 0; c <  height; c++){
        for(int i = 0; i < length; i++){
            map[c][i] = '_';
        }
    }

    player_pos player_pos, last_player_pos;
    last_player_pos.x = 1;
    last_player_pos.y = 1;

    cout << "X: " << player_pos.x << " Y: " << player_pos.y <<endl;

    while(player_pos.x <= length){
        dibujar_mapa(player_pos, last_player_pos, map, length, height);
        last_player_pos = player_pos;
        player_pos = movimiento(player_pos, length, height);
    }
}

Jose Antonio Rojas Ollarves