Colisiones y restricciones de movimiento en mapas de juegos

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

Colisiones y restricciones de movimiento en mapas de juegos

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.

Sergio Brandon De Lucio Chavero

Estudiante

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

Estudiante

Tengo el mismo problema, ¿Pudiste solucionarlo?

Jose Eduardo Miranda Valderrama

Estudiante

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

Youssef Abarca

GERARDO EMMANUEL ALONSO CELIS

Francisco González Ortiz

Adan Natanael Segura Galicia

Luis Javier Jaramillo García

Danelia Sanchez Sanchez

Juan Castro

Profesor

Antonio Mesa Casares

Jose Antonio Rojas Ollarves

Alirio Alejandro Angel Arenas

David Felipe Toro Cuervo

Leonardo Ernesto Solórzano Carrasquero

María Teresa Samudio

Jesús Sánchez González

Oscar Jaramillo

Kenny Raquec

pedro albenis parrado vargas

Wilson Erik Ramírez Franco

Juan Camilo Alvarez Jurado

Hugo Gomez Tinoco

Jesus Daniel Martinez Bautista

Carlos Nassif Trejo Garcia

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 C++

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

Resumen