Hola a todos
Bienvenidos a un nuevo capitulo de como crear tu propio game engine.
En el último capitulo mostramos como rotar e invertir imagenes y animaciones, con lo que conseguiamos darle movimiento a nuestro personaje, pero... para que sirve que el personaje se mueva si no tiene donde ir?? Es por ello que el capitulo de hoy se encarga de explicar el TileManager, o lo que es lo mismo el gestor de escenarios 2D basados en reticulas(tilemaps).
Un tilemap no es más que un conjunto de gráficos "prefabricados" que nos ayuden a componer graficamente el escenario. Por internet encontrareis más información y ejemplos de lo que yo realmente os podria mostrar.
La función de nuestro TileManager no es mas que la de cargar los materiales ( basicamente gráficos y caracteristicas como si es atravesable o no ) que conformarán el tilemap y los niveles por donde jugaremos. Ahora por ahora hay imlpementada la carga sencilla de materiales, la carga de mapas y el pintado de estos, en entregas posteriores iremos puliendo este modulo para que nos acepte animaciones, físicas, scroll, etc...
Que hemos modificado??
- Hemos generado un nuevo archivo de loading llamado LoadMaterials.txt que por ahora solo nos define que gráfico ya cargado está asociado a que material.
- Hemos creado la carpeta levels donde iremos introduciendo los niveles de nuestro juego (el ejemplo que voy ha hacer va a ser un plataformero de disparos, ya os aviso)
- Dentro de esta carpeta hemos creado un fichero llamado level01.txt que contiene la información del tilemap de nuestro ejemplillo.
111111111111111111
11______________11
11______________11
11______________11
11______________11
1133333_________11
11____________2211
11___________22211
11_________2222211
11______2222222211
11___2222222222211
111111111111111111
- Código... hemos cambiado relativamente poco.. se ha incluido el moduglo TileManager y se ha cambiado el código de juego para cargar y pintar el mapa. Aparte de eso se ha ampliado el número de tareas gráficas a poder realizar por el Graphics2DEngine a 4000, ya que 256 tareas se habían quedado cortas para poder pintar todo el mapa.
TileManager.cpp (no ponemos el .h por que es lo de siempre):
/**************************************************************************************************/
// Código creado por F.Bordas (LordPakus) como ejemplo de creación de un game engine
// para el blog LordPakus (http://lordpakus.blogspot.com/).
// Prohibida la distribución fuera de este blog sin el permiso expreso del autor
/**************************************************************************************************/
/**************************************************************************************************/
// TileManager.h : Código de la parte de tile manager del game engine
// Caracteristicas especiales: Esta clase implementa un singleton, es decir, solo podrá existir un objeto de esta clase en todo el proyecto
/**************************************************************************************************/
#include "TileManager.h"
#include "Core.h"
#include "TextureManager.h"
#include <iostream> //Usada para imprimir por consola
using namespace std;
//Instancia única del tile manager
TileManager TileManager::instance;
TileManager::TileManager()
{
}
TileManager::~TileManager()
{
}
//Devolvemos el puntero al singleton
TileManager& TileManager::singleton()
{
return instance;
}
//Sounds functions
void TileManager::Init(int* argc, char* argv[])
{
int num_id = 0;
char cad[256]; //Cadena donde guardaremos cada linea que leamos
cout << "Inicializamos el tile manager\n";
filemanager.Init("Data\\LoadMaterials.txt");
map = NULL;
//Todo este código tendrá que ir al filemanager, pero por el momento lo dejamos aquí
//Leemos cada linea del archivo
while( filemanager.GetLine(cad) )
{
sprintf( loaded[ num_id ] ,"%s" , cad ); //Nos guardamos la referencia al recurso
cout << "Cargamos material " << cad << " con identificador " << num_id << "\n";
num_id++;
}
}
void TileManager::DeInit()
{
cout << "Desinicializamos el Tile manager\n";
filemanager.DeInit();
}
//Leemos un mapa de tiles. Se carga en tiempo de juego ya que no podriamos cargar todos los mapas del juego a la vez.
void TileManager::LoadMap(char cad[])
{
int i,j;
int out = 0;
char tile;
FILE *fd;
cout << "Intentamos cargar mapa de tiles con ruta: " << cad <<"\n";
fd = fopen(cad,"r");
if (fd == NULL )
return;
cout << "Archivo de mapa accesible\n";
if (map != NULL)
{
free(map);
map = NULL;
}
map_width = 0;
map_height = 0;
//Calculamos el ancho y largo del mapa
while(!out)
{
fscanf(fd,"%c",&tile);
if(tile == '\n')
{
out = 1;
map_height = 1;
}
else
map_width++;
}
out = 0;
while(!out)
{
fscanf(fd,"%c",&tile);
if(feof(fd))
{
out = 1;
}
else
{
if(tile == '\n')
map_height++;
}
}
cout << "Cargamos mapa con dimensiones " << map_width << "x" << map_height << "\n";
rewind(fd);
//Dinamic memory for the map
map = (int *) malloc(map_height * map_width * sizeof(int));
//Cuando llegamos aqui ya tenemos la zona de memoria reservada para guardar el mapa y sabemos que dimensiones tiene el mapa.
//Ahora nos dedicamos a leer el mapa y ponerlo en memoria
for( j = map_height-1 ; j >= 0 ; j-- )
{
for( i = 0 ; i < map_width ; i++ )
{
fscanf(fd,"%c",&tile);
switch(tile)
{
//Material
case '1':
case '2':
case '3':
map[(j*map_width)+i] = tile-'0';
break;
default:
map[(j*map_width)+i]=0;
break;
}
}
fscanf(fd,"%c",&tile); //pass enter
}
fclose(fd);
cout << "Mapa cargado\n";
}
void TileManager::DrawMap()
{
int i,j;
float x,y,t;
int tile;
//cout << "Iniciamos pintado de mapa\n";
for( i = 0 ; i < map_height ; i++ )
{
//cout << "Fila: " << i << "\n";
for( j = 0 ; j < map_width ; j++ )
{
tile = map[ (i*map_width + j) ];
//Si no tenemos tile, no pintamos nada
if(!tile)
continue;
tile--;
//cout << j << " ";
t = TextureManager::singleton().GetWidth(loaded[ tile ],0);
x = j*t;
y = i*t;
//cout << tile << " " << x << " " << y << " " << t << " " << loaded[ tile ] << "\n";
Core::singleton().DrawSprite(x,y,loaded[ tile],0);
}
//cout << "\n";
}
}
Código de juego:
//ARCHIVO DE JUEGO
#ifndef __PlayState__
#define __PlayState__
#include "MyGL.h"
#include <cstdlib>
#include <stdio.h>
#include <math.h>
#include "TileManager.h"
#define PI 3.14159265
class PlayState
: public State
{
public:
PlayState() {}
public:
void enter()
{
TileManager::singleton().LoadMap("Data\\Levels\\level01.txt");
}
void leave()
{
}
void update()
{
}
void draw ()
{
static bool right = true;
static int angle = 0;
int x,y;
TileManager::singleton().DrawMap(); //Pintamos el mapa cargado
if ( LPE.KeyBoardRight() )
right = true;
if ( LPE.KeyBoardLeft() )
right = false;
if ( right )
LPE.DisableFlag("INVX");
else
LPE.EnableFlag("INVX");
//Personaje
LPE.DrawAnim(300,260,"RUN");
//Pintamos el arma
LPE.GetMousePosition(&x,&y);
angle = atan2( (double)(y - 230), (double)( 290 - x) ) * 180/PI + 180;
angle %= 360;
if(right)
LPE.DrawCenterRotate(290,230,angle,"PLAYER",3);
else
LPE.DrawCenterRotate(240,230,angle,"PLAYER",3);
//Cuando hemos acabado de pintar lo que queremos tener girado, desactivamos los flips de x
LPE.DisableFlag("INVX");
//Pintado de textos
LPE.DrawText("SYSTEM",200,350,"ANIMACIONES 2D");
}
};
#endif // __PlayState__
Si os fijais en el código de juego solo hacen falta dos lineas para gestionar el tilemap, una para cargar y otra para pintar, simplificando enormemente la creación de videojuegos. Todavía no he encapsulado el TileManager dentro del Core pero estoy esperando a nuevos cambios que me podrían afectar a esta parte, no os preocupeis que en próximas entregas ya lo tendremos arreglado.
En la siguiente imagen tenéis un ejemplo de como os debería quedar:
Ya para finalizar, recordad que el código y el ejecutable de ejemplo lo tenemos en la zona de descargas y añadir que no os preocupeis ahora mismo por cosas como el rendimiento o que queda mejor o peor, esto son items que abordaremos en próximos capitulos.
Espero que os lo hayaís pasado bien y hayaís aprendido,
nos vemosss
0 comentarios :
Publicar un comentario