PUBLICALO EN ELHACKER.NET MOSTRANDO AVANCES, NO HACIENDO SPAM.

 
/*   ________
 *  /\    _  \_
 *  \ \  \  \  \  _______  ________  ________  ________   ________   ________
 *   \ \  \  \  \/\   ___\/\__     \/\   ____\/\__    _\ /\   __  \ /\   __  \
 *    \ \  \ _\  \ \   ___\/_/    /_\ \  \____\/__\   \__\ \  \_\  \\ \  \ \  \
 *     \ \_______\\ \______\/\_______\ \_______\/\_______\\ \__\ \__\\ \__\ \__\
 *      \/_______/ \/______/\/_______/\/_______/\/_______/ \/__/\/__/ \/__/\/__/
 *                                                    DEZCIAN LIB2D - GAME MAKER
 *
 *      Mini-libreria DEZCIAN 2D, funciones y utilidades complementarias para el
 *      desarrollo de videojuegos en 2D. Creado como proyecto personal, no inten
 *      ta competir contra motores de fisica y/o de videojuegos, simplemente son
 *      elementos necesario que voy ocupando con el tiempo y comparto por la red
 *      como agradecimiento. Ya que gracias a la misma han sido posibles algunos
 *      proyectos personales (incluyendo este).
 *
 *
 */
 

Esta es la primera revisión de mi pequeña librería (le queda muy grande el nombre), la cual actualmente incluye elementos muy básicos que he necesitado en el desarrollo de videojuegos. Cabe mencionar que no es una librería gráfica ni mucho menos y que utiliza sólo funciones propias de C++ nativo, por lo que su portabilidad es del 101%, por lo que se puede usar en cualquier sistema y con cualquier método gráfico que nos guste.

Aún es muy simple, pero con el paso del tiempo y lo que valla necesitando pienso agregar más utilidades. Seguiré subiendo avances muy seguido en este mismo post, no sé si este permitido en este foro, pero creo que sí, de cualquier manera, si no lo es, favor de hacérmelo saber .




No hay mucho que decir en esta parte, simplemente la escribí con el fin de no tener que hacerlo en cada nuevo proyecto, y tener un pequeño "estándar". Son simples definiciones de enteros que corresponden a la hora que marcarían las manecillas del reloj en esa dirección.

DIRECTION_UP
DIRECTION_DOWN
DIRECTION_LEFT
DIRECTION_RIGHT




NEW_OBJECT_ROOM(int LONGX, int LONGY)
Como en la mayoría de videojuegos. Corresponde a un mundo o mapa. Se declara escribiendo NEW_OBJECT_ROOM seguido de paréntesis y las dimensiones del mundo, posteriormente un espacio y el nombre del objeto.

Sus propiedades internas son las siguientes.

void SET_LONG_OBJECT(int LONG_OBJECT)
Establece el tamaño de los objetos estáticos del mundo, se usa principalmente para detectar de manera  correcta colisiones estáticas y útiles al momento de usar Allegro, SDL, etc.

void CLEAN_FULL()
No queda mucho que decir en esta parte, simplemente limpia todo el mundo, es decir, se borran todos los objetos estáticos.

void NEW_OBJECT_STATIC(int COORDX, int COORDY, char OBJECT_ID)
Su única función es situar algún objeto estático en el mundo, el OBJECT_ID es un carácter, por lo que va entre comillas simples.

int RET_LONGX()
Obtiene la longitud horizontal del mundo.

int RET_LONGY()
Obtiene la longitud vertical del mundo.

char RET_OBJECT(int COORDX, int COORDY)
Obtiene el objeto situado en las coordenadas dadas.

int RET_LONG_OBJECT()
Obtiene la longitud de cada objeto.




NEW_OBJECT_DYNAMIC(int COORDX, int COORDY, int LONGX, int LONGY)
El propósito de este tipo de objeto es crear algún personaje vivo (por decirlo de alguna manera), puede desplazarse, caer, morir, etc.

void CHANGE_VELOCITY(int NEW_VELOCITY)
Cambia la velocidad constante de movimiento.

bool DETECT_COLISION_DINAMIC(NEW_OBJECT_DINAMIC OBJECT)
Detecta colisión con otro objeto dinámico. Tipo bounding box.

void MOVE(int DIRECTION)
Desplaza de acuerdo a velocidad constante, y además, a la dirección que indiquemos con las direcciones de movimiento preestablecidas y gira el objeto a esa dirección.

void GRAVITY_RUN()
Se usa simplemente para aplicar la función de gravedad en el objeto.

void CLEAN_GRAVITY_VELOCITY()
Después de usar GRAVITY_RUN(), se llama esta función para perder la velocidad.

void SET_LIVES(int LIVES)
Se establece el número de vidas.

void UP_LIVES(int LIVES)
Se aumentan las vidas que queramos.

void DOWN_LIVES(int LIVES)
Se disminuyen las vidas que queramos.

int RET_COORDX()
Obtiene posición o coordenada horizontal.

int RET_COORDY()
Obtiene posición o coordenada vertical.

int RET_DIRECTION()
Obtiene dirección actual.

int RET_LIVES()
Obtiene vidas restantes.




NEW_OBJECT_CAMERA
Complemento simple pero muy útil si es que deseamos mostrar solo un pedazo de mapa.

void FOLLOW_OBJECT_DINAMIC(NEW_OBJECT_DINAMIC OBJECT, NEW_OBJECT_ROOM ROOM, int WINDOW_LONGX, int WINDOW_LONGY)




Por el momento es lo único que agrega ya que es lo único que se me ha ocurrido agregar, como ya dije, con el paso del tiempo y conforme necesite nuevas cosas, las iré agregando, de cualquier manera todo tipo de ayuda, consejo, sugerencia es totalmente bienvenido.

---

Aun no comento el código, para cualquier duda esta el primer post.

#ifndef DEZCIAN_LIB2D_H
#define DEZCIAN_LIB2D_H
 
 
#define DIRECTION_UP   12
#define DIRECTION_DOWN  6
#define DIRECTION_LEFT  9
#define DIRECTION_RIGHT 3
 
 
class NEW_OBJECT_ROOM
{
private:
    int longX, longY, longObject;
    char **universe;
 
public:
 
    NEW_OBJECT_ROOM(int LONGX, int LONGY)
    {
        longX = LONGX;
        longY = LONGY;
 
        universe = new char *[longX];
        for (int i = 0; i < longX; i++)
            universe[i] = new char [longY];
 
        for (int y = 0; y < longY; y++)
        {
            for (int x = 0; x < longX; x++)
                universe[x][y] = ' ';
        }
    }
 
    void SET_LONG_OBJECT(int LONG_OBJECT)
    {
        longObject = LONG_OBJECT;
    }
 
    void CLEAN_FULL()
    {
        for (int y = 0; y < longY; y++)
        {
            for (int x = 0; x < longX; x++)
                universe[x][y] = ' ';
        }
    }
 
    void NEW_OBJECT_STATIC(int COORDX, int COORDY, char OBJECT_ID)
    {
        universe[COORDX][COORDY] = OBJECT_ID;
    }
 
    int RET_LONGX()
    {
        return longX;
    }
 
    int RET_LONGY()
    {
        return longY;
    }
 
    char RET_OBJECT(int COORDX, int COORDY)
    {
        return universe[COORDX][COORDY];
    }
 
    int RET_LONG_OBJECT()
    {
        return longObject;
    }
};
 
 
class NEW_OBJECT_DYNAMIC
{
private:
	int coordX, coordY, longX, longY, lives, velocity, velocityGravity, direction;
 
public:
	NEW_OBJECT_DYNAMIC(int COORDX, int COORDY, int LONGX, int LONGY)
	{
		coordX = COORDX;
		coordY = COORDY;
		longX = LONGX;
		longY = LONGY;
		velocity = 2;
		velocityGravity = velocity;
		direction = DIRECTION_DOWN;
	}
 
	void CHANGE_VELOCITY(int NEW_VELOCITY)
	{
	    velocity = NEW_VELOCITY;
	}
 
	bool DETECT_COLISION_DYNAMIC(NEW_OBJECT_DINAMIC OBJECT)
	{
	    if ((coordX > OBJECT.coordX + OBJECT.longX - 1) ||
            (coordY > OBJECT.coordY + OBJECT.longY - 1) ||
            (OBJECT.coordX > coordX + longX - 1) ||
            (OBJECT.coordY > coordY + longY - 1))
            return false;
        return true;
	}
 
	void MOVE(int DIRECTION)
	{
	    if (DIRECTION == 12)
            coordY -= velocity;
        else if (DIRECTION == 3)
            coordX += velocity;
        else if (DIRECTION == 6)
            coordY += velocity;
        else if (DIRECTION == 9)
            coordX -= velocity;
        direction = DIRECTION;
	}
 
	void GRAVITY_RUN()
	{
	    coordY += velocityGravity;
	    velocityGravity += velocityGravity;
	}
 
	void CLEAN_GRAVITY_VELOCITY()
	{
	    velocityGravity = velocity;
	}
 
	void SET_LIVES(int LIVES)
	{
	    lives = LIVES;
	}
 
	void UP_LIVES(int LIVES)
	{
	    lives += LIVES;
	}
 
	void DOWN_LIVES(int LIVES)
	{
	    lives -= LIVES;
	}
 
	int RET_COORDX()
	{
	    return coordX;
	}
 
	int RET_COORDY()
	{
	    return coordY;
	}
 
	int RET_DIRECTION()
	{
	    return direction;
	}
 
	int RET_LIVES()
	{
	    return lives;
	}
};
 
 
class NEW_OBJECT_CAMERA
{
private:
    int coordX, coordY;
 
public:
    void FOLLOW_OBJECT_DINAMIC(NEW_OBJECT_DINAMIC OBJECT, NEW_OBJECT_ROOM ROOM, int WINDOW_LONGX, int WINDOW_LONGY)
    {
        coordX = OBJECT.RET_COORDX() - WINDOW_LONGX / 2;
        coordY = OBJECT.RET_COORDY() - WINDOW_LONGY / 2;
        if (coordX < 0) coordX = 0;
        if (coordY < 0) coordY = 0;
        if (coordX > (ROOM.RET_LONGX() * ROOM.RET_LONG_OBJECT()) - WINDOW_LONGX) coordX = (ROOM.RET_LONGX() * ROOM.RET_LONG_OBJECT()) - WINDOW_LONGX;
        if (coordY > (ROOM.RET_LONGY() * ROOM.RET_LONG_OBJECT()) - WINDOW_LONGX) coordY = (ROOM.RET_LONGY() * ROOM.RET_LONG_OBJECT()) - WINDOW_LONGY;
    }
};
 
 
#endif
 
 
 

Y por que mejor no usar mingw?

Tan solo hay que ejecutar el siguiente comando.


Realizar las modificaciones que sean necesarias y después para hacer el enlazado.

http://javiyu.blogspot.mx/2010/05/compilar-codigo-ensamblador-en-formato.html
http://www.iteramos.com/pregunta/14505/como-usas-gcc-para-generar-codigo-ensamblador-en-sintaxis-de-intel

Hablar es fácil, enseñame el código
#Linus Torvalds

No se hacen tareas amigo, mejor comentanos en que parte tienes dudas y muestranos tus avances.

Dependiendo de tu compilador existe alguna manera de generar el bytecode busca un poco en internet con el nombre de tu compilador, es muy fácil de encontrar esa información.

Amigo, no tienes mucha idea de lo que hablas XD... existen multiples proyectos muy buenos por internet que han desarrollado una o dos personas... Además... todo lo que dices suena a algo muy profesionar como un GTA 5 y para eso obviamente no será posible por uno sólo XD

[edito] Yo de hecho he desarrollado multiples videojuegos y en C++... Soy nuevo en el foro, pero mis próximos proyectos los compartiré aquí en este foro

Hola crack81! muchas gracias por tu ayuda, me ha servido mucho... Había intentado algo así pero me faltaba esta parte:

universo=new char*[longitudX]; //crear la primera dimension
   for(int i=0;i<longitudX;i++){
      universo[i]=new char[longitudY]; //<---- Esto me faltaba xD
   }

muchas gracias, doy el tema por solucionado

Jaja amigo! C y C++ es lo mejor para el desarrollo de videojuegos. Y más C++ por la compatibilidad con programacion orientada a objetos.

Podrá ser un remake o algo así, pero GTA San Andreas original estoy 101% seguro que no...

Luego de tanto blabla aqui mi duda... Como puedo hacer que una matriz declarada dentro de una clase obtenga sus dimensiones el metodo constructor (o de que otra forma lo puedo hacer)... No tengo mucha idea de esto, nunca lo habia intentado... Tengo algo como esto y no funciona (como era de esperarse XD)

#include <iostream>
 
using namespace std;
 
class MiClase {
private:
      const int longitudX, longitudY;
      char universo[longitudX][longitudY];
 
public:
      MiClase(int lx, int ly) {
            longitudX = lx;
            longitudY = ly;
      }
}
 
int main() {
    MiClase(4,5);
    return 0;
}