Colisiones y restricciones de movimiento en mapas de juegos

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

Contenido del curso

Introducción a C++

Conceptos Generales de C++

3
Historia y uso del compilador GCC en programación
01:43 min

Preparando el entorno de trabajo

Manejo de memoria

Entrada de datos y funciones

Loops y arreglos

Lectura de Archivos

Programación Orientada a Objetos

Finalizando nuestro proyecto

Tomar examen

Resumen

Las colisiones en los videojuegos NO existen, solo son una abstracción de las colisiones para simular su comportamiento. En vez de programar el choque de nuestros elementos, vamos a crear algunas variables (lastMoveX y lastMoveY) para guardar los movimientos de nuestros jugadores y regresarlos al movimiento anterior en caso de que su último movimiento los haga "chocar" contra una pared.

Comentarios

Youssef Abarca

student•

Si quieren obtener el efecto pacman (Entrar por un lado y salir por el otro), puede usar el operador módulo para calcular la posición en x, y.

void Player::CallInput()
{
    char UserInput = ' ';
    cin >> UserInput;

    lastY=y;
    lastX=x;

    UserInput = tolower(UserInput);
    switch(UserInput)
    {
    case 'w':
        y = ((y - 1)%15+15)%15;
	//Deberia solo ser: (y-1)%15. Pero al momento de ser negativo el operador módulo deja de funcionar en mi c++
        break;
    case 's':
        y = (y + 1)%15;
        break;
    case 'd':
        x = (x + 1)%10;
        break;
    case 'a':
        x = ((x - 1)%10+10)%10;
        break;
    }
}

GERARDO EMMANUEL ALONSO CELIS

student•

Excelente!!

Francisco González Ortiz

student•

En el codigo del video hay un error al momento de guardar las coordenadas anteriores que tuvo el jugador, el profesor guarda estas coordenadas dentro del case, y es un error porque si te mueves primero con 's' la coordenada incrementara, bien si el siguiente movimiento es con 'd' solo actualizará la coordenada x de ese 'd' mas no actualizará el incremento de 's' anteriormente. La solución rapida que encontre fue actualizar las dos coordenadas afuera del case.

Adan Natanael Segura Galicia

student•

Supongo que te refieres a hacer esto:

void Player::callInput()
{
    char userInput = ' ';
    cin &gt;&gt; userInput;

    lastX = x;
    lastY = y;
    switch(userInput)
    {
        case 'w':
            x--;
            break;
        case 'a':
            y--;
            break;
        case 's':
            x++;
            break;
        case 'd':
            y++;
            break;
        default:
            break;
    }
}

Luis Javier Jaramillo García

student•

También funciona si guardas ambos en el case

switch(entradaUsuario){
    case 'w':
      ultimaX = x;
      ultimaY = y;
      y = y - 1;

Danelia Sanchez Sanchez

student•

Pienso que sería mejor evaluar primero antes de cambiar una coordenada, yo lo implementaría así.

Juan Castro

teacher•

Hmmm... A mi me gusta la opción de simular el movimiento del jugador y evaluar si el movimiento es válido antes de moverlo realmente. En la práctica es casi igual, debemos crear una variable de nextMove y en caso de que todo salga mal pos no mover nada pero si el movimiento es válido ahí si moverlo...

Sergio Brandon De Lucio Chavero

student•

Tengo un problema con las colisiones, me detecta paredes donde lo hay nada, y las paredes no las asigna tan bien.

main.cpp

#include <iostream>
#include "Player.h"
#include "MapCell.h"
#include "GameMap.h"

using namespace std;

int main()
{
    bool isGameOver = false;
    GameMap Map;
    Player Hero;

    while(isGameOver == false)
    {
        //Aqui es el loop de nuestro juego
        Hero.CallInput();
        //Actualizado de información
        if(Map.SetPlayerCell(Hero.x,Hero.y))
        {
            //Aqui dibujamos el mapa
            Map.Draw();
        }else{
            Hero.ResetToSafePosition();
            cout<<"Reseteado"<<endl;
            Map.Draw();
        }
    }
    return 0;
}

Player.cpp

#include "Player.h"
#include <iostream>

using namespace std;

Player::Player()
{
    //ctor
}
void Player::CallInput()
{
    char UserInput = ' ';
    cin>>UserInput;
    lastY = y;
    lastX =x;
    switch(UserInput)
    {
    case 'a':
        y--;
        break;
    case 's':
        x++;
        break;
    case 'w':
        x--;
        break;
    case 'd':
        y++;
        break;
    }
}

void Player::ResetToSafePosition()
{
    x = lastX;
    y = lastY;
}

Player.h

#ifndef PLAYER_H
#define PLAYER_H


class Player
{
    public:
        Player();

        void CallInput();
        void ResetToSafePosition();

        int x = 1,y = 1;

        int lastX, lastY;

    protected:

    private:
};

#endif // PLAYER_H

GameMap.cpp

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

using namespace std;

GameMap::GameMap()
{
    //ctor
    PlayerCell = NULL;
    LoadMapFromFile();
}
void GameMap::Draw()
{
    for(int i = 0; i < 15 ; i++)
    {
        for(int p = 0;p < 10; p++)
        {
            cout<<cells[i][p].id;
        }
        cout<<endl;
    }
}

bool GameMap::SetPlayerCell(int PlayerX, int PlayerY)
{
    if(cells[PlayerY][PlayerX].IsBlocked() == false)
    {
        if(PlayerCell != NULL)
        {
            PlayerCell->id = ' ';
        }
        PlayerCell = &cells[PlayerX][PlayerY];
        PlayerCell->id = 'S';
        return true;
    }else{
        return false;
    }

    //cout<<"Las coordenadas del jugador son: "<<PlayerX<<","<<PlayerY<<endl;
}

void GameMap::LoadMapFromFile()
{
    /*ofstream FileCreated("Map.txt");

    if(FileCreated.is_open()){

    }else{
    cout<<"ERROR : MAP FILE COULD NOT BE CREATED"<<endl;
    }
    */
    string line;
    int row = 0;
    ifstream MyFile("Map.txt");

    if(MyFile.is_open())
    {
        while(getline(MyFile,line))
        {
            for(int p = 0;p<line.length();p++)
            {
                if(line[p] == '0')
                {
                    cells[row][p].id =' ';
                }else
                {
                    cells[row][p].id = line[p];
                }
            }

            row++;
        }
    }else{
        cout<<"ERROR : MAP FILE COULD NOT BE LOADED"<<endl;
    }
}

GameMap.h

#ifndef GAMEMAP_H
#define GAMEMAP_H
#include "MapCell.h"

class GameMap
{
    public:
        GameMap();

        MapCell* PlayerCell;
        MapCell cells[15][10];
        //Draw the map
        void Draw();
        //coordenadas del jugador y actualiza el mapa
        bool SetPlayerCell( int PlayerX, int PlayerY);

    protected:

        void LoadMapFromFile();

    private:
};

#endif // GAMEMAP_H

MapCell.cpp

#include "MapCell.h"
#include <iostream>

using namespace std;

MapCell::MapCell()
{
    id = 0;
}
bool MapCell::IsBlocked()
{

    if(id == '1')
    {
        cout<<"blocked"<<endl;
        return true;

    }
    else{

        return false;
    }
}

MapCell.h

#include "MapCell.h"
#include <iostream>

using namespace std;

MapCell::MapCell()
{
    id = 0;
}
bool MapCell::IsBlocked()
{

    if(id == '1')
    {
        cout<<"blocked"<<endl;
        return true;

    }
    else{

        return false;
    }
}

Jose Eduardo Miranda Valderrama

student•

Tengo el mismo problema, ¿Pudiste solucionarlo?

Jose Eduardo Miranda Valderrama

student•

Acabo de solucionarlo para mi caso y fue que en el if cambié de orden a los índices, la forma correcta era

if(!cells[PlayerY][PlayerX].IsBlocked())

Pero veo que en tu caso eso esta bien, así que probablemente tenga que ver con los índices en alguna otra parte

Jose Antonio Rojas Ollarves

student•

La opcion mas optima es:

1.- Guardar la coordenada anterior antes del movimiento para en caso de no ser valido volver al anterior

--> Por que, por que los procesos son mas simples de identificar, en caso de que no pueda hacerlo, simplemente se de vuelva a la ultima, seria como un sensor de movimiento al momento de chocar retrocede y intenta por otro eje o otro angulo.

Alirio Alejandro Angel Arenas

student•

El unico error en el codigo del video es que iniciando el juego como el jugador no esta dibujado no lo dibuja hasta que pongas un movimiento valido!, lo solucione de la siguiente manera

bool GameMap::SetPlayerAxis(int *axis){

    if(cells[axis[1]][axis[0]].IsBlocked() == false){
        if(PlayerCell != NULL){
            PlayerCell->id = ' ';
        };
        PlayerCell = &cells[axis[1]][axis[0]];
        PlayerCell->id = '3';
        return true;
    }else{
        if(PlayerCell == NULL){
            PlayerCell = &cells[1][1];
            PlayerCell->id = '3';
        };
        std::cout << "WHOOPS!, te diste de frente contra una pared" <<std::endl;
        return false;
    }
    
};

Cabe acotar que he notado un movimiento extraño cuando colisionas con una pared existe la posiblidad de o que regrese x o y mal o que no se mueva en el siguiente movimiento por alguna razon que desconozco quizas es por mi funcion para tomar x y y.

int * Player::GetAxis(){
    static int axis[2];
    
    axis[0] = x;
    axis[1] = y;
    
    return axis;
};```

Alirio Alejandro Angel Arenas

student•

Esta fue la solucion que consegui!.

        axis = Hero.GetAxis();
        if(Map.SetPlayerAxis(axis)){
            //Dibuja el mapa con el movimiento correcto
            Hero.SetLastX(axis[0]);
            Hero.SetLastY(axis[1]);
            Map.Draw();
        }else{
            //Dibuja el mapa pero reseteando a la posicion anterior
            Hero.ReturnToSafePosition();
            Map.Draw();
        }```

Alirio Alejandro Angel Arenas

student•

por alguna razon ahora no veo el otro mensaje que explicaba el error de los movimientos ajaja pero bueno el punto es que si el movimiento es EFECTIVO hay que mover LastX o LastY a ese movimiento. lo hice a traves de un setter en el main si era aprobado el movimiento.

David Felipe Toro Cuervo

student•

Realice varios Test en diferentes colisiones dentro del código que ha pasado Eri y como todo juego en ciertos lugares se presentas bugs, que inexplicablemente solo suceden en esos lugares y al colisionar en esas coordenadas exactas, creo que acá empieza el desafío en los juegos ya que se debe probar todo para evitar estos fallos.

Leonardo Ernesto Solórzano Carrasquero

student•

Finalizando con el codigo del profesor, si intentas pasar una pared varias veces en el eje X, y luego mueves hacia el eje Y, vas a correr dos espacios, por que pasa esto?

María Teresa Samudio

student•

Fíjate en este comentario, está la solución

Jesús Sánchez González

student•

Si llegan a presentar un error en el cuál el "héroe" sigue contando las posiciones y no se queda en la última; pueden probar esto para solucionarlo.

Con el seguir contando posiciones me refiero a que, por ejemplo; al llegar a un límite en el eje X, el jugador no debería ser capaz de avanzar. Sin embargo, al seguir intentando, notarás que iniciará al final de la fila anterior.

Oscar Jaramillo

student•

Interesante

Jose Eduardo Miranda Valderrama

student•

Tengan cuidado al colocar el if del IsBlocked, debe ser como puso el profe Eri:

if(!cells[PlayerY][PlayerX].IsBlocked())

El primer índice es de columnas y el segundo es de filas, perdí un par de horas por ese error tonto pero ahora comprendo mejor el código xD

Kenny Raquec

student•

La manera en la que implemente las colisiones fue mediante dos switch en el archivo de Player.cpp en la funcion de Player::CallInput()

switch(x){
        case 0: x += 1;
            break;
        case 9: x -= 1;
            break;
    }           
    switch(y){
        case 1: y += 1;
            break;
        case 14: y -= 1;
            break;
    }```

pedro albenis parrado vargas

student•

como se hace para que salgan varios mapas aleatorios?

Sergio Brandon De Lucio Chavero

student•

Seria interesante hacer una matriz de nxn donde los inputs sean numeros aleatorios pero no tanto, es decir como en el juego que programo Freddy en Javascript y HTML

Sergio Brandon De Lucio Chavero

student•

Pero no sabría como condicionar que los caminos se unan :)

Wilson Erik Ramírez Franco

student•

Yo considero que se debería ir a la posición anterior para que continúe con la trayectoria inicial.

Juan Camilo Alvarez Jurado

student•

Creo que estoy de acuerdo con los aportes anteriores; lo haría desde el jugador, validando si se puede mover o no

Hugo Gomez Tinoco

student•

Cuando presiono "D" me bota del juego y no entiendo por qué, eso que ni siquiera colisiona con alguna pared

Leonardo Ernesto Solórzano Carrasquero

student•

Pienso que deberia resolverse de una 4ta forma: Deberiamos acceder al metodo IsBlocked publico para que asi se pueda acceder desde el player y evitar siquiera avanzar. Se ahorran recursos.

Jesus Daniel Martinez Bautista

student•

Hecho

`#include &lt;iostream&gt;
#include &quot;Player.h&quot;
#include &quot;Mapaceldas.h&quot;
#include &quot;Gamemapa.h&quot;

using namespace std;

int main()
{
 cout &lt;&lt; &quot;inicaia el juego&quot; &lt;&lt;endl;
    bool isGameOver = false;
    Player heroe;
    Gamemapa MAP;
    heroe.entrada();



     while(isGameOver==false)
    {
       // loop de nuestro juego. cada vuelta del loop de nuestro juego vamos aa llamar el heroe.
        heroe.entrada();
        //actulizado de informacion heroe a mapa
       if(MAP.setplayer(heroe.x , heroe.y))
       {
       //aqui dibujamos el mapa
        MAP.drawmap();
       }

       else
        { heroe.Reset();
          MAP.drawmap();}

    }



    return 0;
}````

Carlos Nassif Trejo Garcia

student•

Si vas a hacer lo mismo dentro de todas las condiciones, es mejor quitarlo. Don't repeat yourself:

#include &lt;iostream&gt;
#include &quot;Player.h&quot;
#include &quot;MapCell.h&quot;
#include &quot;GameMap.h&quot;

using namespace std;

int main()
{
    bool gameContinue = true;
    GameMap Map;
    Player hero;

    cout &lt;&lt; &quot;Inicia el juego:&quot; &lt;&lt; endl;
    while ( gameContinue ) {
        hero.CallInput();

        if ( !Map.setPlayerCell(hero.x, hero.y) ) {
            hero.resetToSafePosition();
        }

        Map.draw();
    }

    return 0;
}

void Player::CallInput()
{
    char UserInput = ' ';
    cin >> UserInput;

    lastY=y;
    lastX=x;

    UserInput = tolower(UserInput);
    switch(UserInput)
    {
    case 'w':
        y = ((y - 1)%15+15)%15;
	//Deberia solo ser: (y-1)%15. Pero al momento de ser negativo el operador módulo deja de funcionar en mi c++
        break;
    case 's':
        y = (y + 1)%15;
        break;
    case 'd':
        x = (x + 1)%10;
        break;
    case 'a':
        x = ((x - 1)%10+10)%10;
        break;
    }
}

void Player::callInput()
{
    char userInput = ' ';
    cin &gt;&gt; userInput;

    lastX = x;
    lastY = y;
    switch(userInput)
    {
        case 'w':
            x--;
            break;
        case 'a':
            y--;
            break;
        case 's':
            x++;
            break;
        case 'd':
            y++;
            break;
        default:
            break;
    }
}

#include <iostream>
#include "Player.h"
#include "MapCell.h"
#include "GameMap.h"

using namespace std;

int main()
{
    bool isGameOver = false;
    GameMap Map;
    Player Hero;

    while(isGameOver == false)
    {
        //Aqui es el loop de nuestro juego
        Hero.CallInput();
        //Actualizado de información
        if(Map.SetPlayerCell(Hero.x,Hero.y))
        {
            //Aqui dibujamos el mapa
            Map.Draw();
        }else{
            Hero.ResetToSafePosition();
            cout<<"Reseteado"<<endl;
            Map.Draw();
        }
    }
    return 0;
}

#include "Player.h"
#include <iostream>

using namespace std;

Player::Player()
{
    //ctor
}
void Player::CallInput()
{
    char UserInput = ' ';
    cin>>UserInput;
    lastY = y;
    lastX =x;
    switch(UserInput)
    {
    case 'a':
        y--;
        break;
    case 's':
        x++;
        break;
    case 'w':
        x--;
        break;
    case 'd':
        y++;
        break;
    }
}

void Player::ResetToSafePosition()
{
    x = lastX;
    y = lastY;
}

#ifndef PLAYER_H
#define PLAYER_H


class Player
{
    public:
        Player();

        void CallInput();
        void ResetToSafePosition();

        int x = 1,y = 1;

        int lastX, lastY;

    protected:

    private:
};

#endif // PLAYER_H

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

using namespace std;

GameMap::GameMap()
{
    //ctor
    PlayerCell = NULL;
    LoadMapFromFile();
}
void GameMap::Draw()
{
    for(int i = 0; i < 15 ; i++)
    {
        for(int p = 0;p < 10; p++)
        {
            cout<<cells[i][p].id;
        }
        cout<<endl;
    }
}

bool GameMap::SetPlayerCell(int PlayerX, int PlayerY)
{
    if(cells[PlayerY][PlayerX].IsBlocked() == false)
    {
        if(PlayerCell != NULL)
        {
            PlayerCell->id = ' ';
        }
        PlayerCell = &cells[PlayerX][PlayerY];
        PlayerCell->id = 'S';
        return true;
    }else{
        return false;
    }

    //cout<<"Las coordenadas del jugador son: "<<PlayerX<<","<<PlayerY<<endl;
}

void GameMap::LoadMapFromFile()
{
    /*ofstream FileCreated("Map.txt");

    if(FileCreated.is_open()){

    }else{
    cout<<"ERROR : MAP FILE COULD NOT BE CREATED"<<endl;
    }
    */
    string line;
    int row = 0;
    ifstream MyFile("Map.txt");

    if(MyFile.is_open())
    {
        while(getline(MyFile,line))
        {
            for(int p = 0;p<line.length();p++)
            {
                if(line[p] == '0')
                {
                    cells[row][p].id =' ';
                }else
                {
                    cells[row][p].id = line[p];
                }
            }

            row++;
        }
    }else{
        cout<<"ERROR : MAP FILE COULD NOT BE LOADED"<<endl;
    }
}

#ifndef GAMEMAP_H
#define GAMEMAP_H
#include "MapCell.h"

class GameMap
{
    public:
        GameMap();

        MapCell* PlayerCell;
        MapCell cells[15][10];
        //Draw the map
        void Draw();
        //coordenadas del jugador y actualiza el mapa
        bool SetPlayerCell( int PlayerX, int PlayerY);

    protected:

        void LoadMapFromFile();

    private:
};

#endif // GAMEMAP_H

#include "MapCell.h"
#include <iostream>

using namespace std;

MapCell::MapCell()
{
    id = 0;
}
bool MapCell::IsBlocked()
{

    if(id == '1')
    {
        cout<<"blocked"<<endl;
        return true;

    }
    else{

        return false;
    }
}

#include "MapCell.h"
#include <iostream>

using namespace std;

MapCell::MapCell()
{
    id = 0;
}
bool MapCell::IsBlocked()
{

    if(id == '1')
    {
        cout<<"blocked"<<endl;
        return true;

    }
    else{

        return false;
    }
}

bool GameMap::SetPlayerAxis(int *axis){

    if(cells[axis[1]][axis[0]].IsBlocked() == false){
        if(PlayerCell != NULL){
            PlayerCell->id = ' ';
        };
        PlayerCell = &cells[axis[1]][axis[0]];
        PlayerCell->id = '3';
        return true;
    }else{
        if(PlayerCell == NULL){
            PlayerCell = &cells[1][1];
            PlayerCell->id = '3';
        };
        std::cout << "WHOOPS!, te diste de frente contra una pared" <<std::endl;
        return false;
    }
    
};

        axis = Hero.GetAxis();
        if(Map.SetPlayerAxis(axis)){
            //Dibuja el mapa con el movimiento correcto
            Hero.SetLastX(axis[0]);
            Hero.SetLastY(axis[1]);
            Map.Draw();
        }else{
            //Dibuja el mapa pero reseteando a la posicion anterior
            Hero.ReturnToSafePosition();
            Map.Draw();
        }```

switch(x){
        case 0: x += 1;
            break;
        case 9: x -= 1;
            break;
    }           
    switch(y){
        case 1: y += 1;
            break;
        case 14: y -= 1;
            break;
    }```

`#include &lt;iostream&gt;
#include &quot;Player.h&quot;
#include &quot;Mapaceldas.h&quot;
#include &quot;Gamemapa.h&quot;

using namespace std;

int main()
{
 cout &lt;&lt; &quot;inicaia el juego&quot; &lt;&lt;endl;
    bool isGameOver = false;
    Player heroe;
    Gamemapa MAP;
    heroe.entrada();



     while(isGameOver==false)
    {
       // loop de nuestro juego. cada vuelta del loop de nuestro juego vamos aa llamar el heroe.
        heroe.entrada();
        //actulizado de informacion heroe a mapa
       if(MAP.setplayer(heroe.x , heroe.y))
       {
       //aqui dibujamos el mapa
        MAP.drawmap();
       }

       else
        { heroe.Reset();
          MAP.drawmap();}

    }



    return 0;
}````

#include &lt;iostream&gt;
#include &quot;Player.h&quot;
#include &quot;MapCell.h&quot;
#include &quot;GameMap.h&quot;

using namespace std;

int main()
{
    bool gameContinue = true;
    GameMap Map;
    Player hero;

    cout &lt;&lt; &quot;Inicia el juego:&quot; &lt;&lt; endl;
    while ( gameContinue ) {
        hero.CallInput();

        if ( !Map.setPlayerCell(hero.x, hero.y) ) {
            hero.resetToSafePosition();
        }

        Map.draw();
    }

    return 0;
}

Colisiones y restricciones de movimiento en mapas de juegos

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