JailDoctor/jdd_opendingux
1
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Issues Pull Requests Projects Releases Wiki Activity

Renombrado de variables

Browse Source
This commit is contained in:
Sergio
2022-08-29 18:16:14 +02:00
parent 822386c269
commit 9a20d5fc1b
11 changed files with 267 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
data/room/01.room
View File

@@ -1,10 +1,10 @@
name=void main name=void main
bg_color=black bgColor=black
tileset=standard.png tileset=standard.png
room_up=0 roomUp=0
room_down=0 roomDown=0
room_left=0 roomLeft=0
room_right=02.room roomRight=02.room
[tilemap] [tilemap]
01.tmx 01.tmx

10
data/room/02.room
View File

@@ -1,10 +1,10 @@
name=case switch name=case switch
bg_color=black bgColor=black
tileset=standard.png tileset=standard.png
room_up=0 roomUp=0
room_down=04.room roomDown=04.room
room_left=01.room roomLeft=01.room
room_right=03.room roomRight=03.room
[tilemap] [tilemap]
02.tmx 02.tmx

10
data/room/03.room
View File

@@ -1,10 +1,10 @@
name=the edge name=the edge
bg_color=light_black bgColor=light_black
tileset=standard.png tileset=standard.png
room_up=0 roomUp=0
room_down=0 roomDown=0
room_left=02.room roomLeft=02.room
room_right=0 roomRight=0
[tilemap] [tilemap]
03.tmx 03.tmx

10
data/room/04.room
View File

@@ -1,10 +1,10 @@
name=The Fridge name=The Fridge
bg_color=blue bgColor=blue
tileset=standard.png tileset=standard.png
room_up=02.room roomUp=02.room
room_down=0 roomDown=0
room_left=0 roomLeft=0
room_right=05.room roomRight=05.room
[tilemap] [tilemap]
04.tmx 04.tmx

10
data/room/05.room
View File

@@ -1,10 +1,10 @@
name=coruscant name=coruscant
bg_color=light_black bgColor=light_black
tileset=standard.png tileset=standard.png
room_up=03.room roomUp=03.room
room_down=0 roomDown=0
room_left=04.room roomLeft=04.room
room_right=0 roomRight=0
[tilemap] [tilemap]
05.tmx 05.tmx

240
source/game.cpp
View File

@@ -4,102 +4,96 @@
Game::Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Lang *lang, Input *input) Game::Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Lang *lang, Input *input)
{ {
// Inicia variables // Inicia variables
mCurrentRoom = "01.room"; currentRoom = "01.room";
mSpawnPoint = {2 * BLOCK, 12 * BLOCK, 0, 0, 0, STATUS_STANDING, SDL_FLIP_NONE}; spawnPoint = {2 * BLOCK, 12 * BLOCK, 0, 0, 0, STATUS_STANDING, SDL_FLIP_NONE};
mDebug = false; debug = false;
// Copia los punteros // Copia los punteros
mRenderer = renderer; this->renderer = renderer;
mAsset = asset; this->asset = asset;
mLang = lang; this->input = input;
mInput = input;
// Crea los objetos // Crea los objetos
mScreen = new Screen(window, renderer); screen = new Screen(window, renderer);
mItemTracker = new Item_tracker(); itemTracker = new ItemTracker();
mRoom = new Room(mAsset->get(mCurrentRoom), mRenderer, mAsset, mItemTracker); room = new Room(asset->get(currentRoom), renderer, asset, itemTracker);
mPlayer = new Player(mSpawnPoint, mAsset->get("player01.png"), mRenderer, mAsset, mInput, mRoom); player = new Player(spawnPoint, asset->get("player01.png"), renderer, asset, input, room);
mEventHandler = new SDL_Event(); eventHandler = new SDL_Event();
mText = new Text(mAsset->get("smb2.png"), mAsset->get("smb2.txt"), renderer); text = new Text(asset->get("smb2.png"), asset->get("smb2.txt"), renderer);
mFade = new Fade(renderer);
// Inicializa variables // Inicializa variables
mTicks = 0; ticks = 0;
mTicksSpeed = 15; ticksSpeed = 15;
mSection.name = SECTION_PROG_GAME; section.name = SECTION_PROG_GAME;
mSection.subsection = SECTION_GAME_PLAY; section.subsection = SECTION_GAME_PLAY;
} }
Game::~Game() Game::~Game()
{ {
// Borra las referencias a los punteros // Borra las referencias a los punteros
mRenderer = nullptr; renderer = nullptr;
mAsset = nullptr; asset = nullptr;
mLang = nullptr; input = nullptr;
mInput = nullptr;
// Libera la memoria de los objetos // Libera la memoria de los objetos
delete mScreen; delete screen;
mScreen = nullptr; screen = nullptr;
delete mItemTracker; delete itemTracker;
mItemTracker = nullptr; itemTracker = nullptr;
delete mRoom; delete room;
mRoom = nullptr; room = nullptr;
delete mPlayer; delete player;
mPlayer = nullptr; player = nullptr;
delete mEventHandler; delete eventHandler;
mEventHandler = nullptr; eventHandler = nullptr;
delete mText; delete text;
mText = nullptr; text = nullptr;
delete mFade;
mFade = nullptr;
} }
// Bucle para el juego // Bucle para el juego
section_t Game::run() section_t Game::run()
{ {
while (mSection.name == SECTION_PROG_GAME) while (section.name == SECTION_PROG_GAME)
{ {
// Sección juego jugando // Sección juego jugando
if (mSection.subsection == SECTION_GAME_PLAY) if (section.subsection == SECTION_GAME_PLAY)
{ {
update(); update();
draw(); draw();
} }
} }
return mSection; return section;
} }
// Actualiza el juego, las variables, comprueba la entrada, etc. // Actualiza el juego, las variables, comprueba la entrada, etc.
void Game::update() void Game::update()
{ {
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego // Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - mTicks > mTicksSpeed) if (SDL_GetTicks() - ticks > ticksSpeed)
{ {
// Actualiza el contador de ticks // Actualiza el contador de ticks
mTicks = SDL_GetTicks(); ticks = SDL_GetTicks();
// Comprueba los eventos que hay en la cola // Comprueba los eventos que hay en la cola
while (SDL_PollEvent(mEventHandler) != 0) while (SDL_PollEvent(eventHandler) != 0)
{ {
// Evento de salida de la aplicación // Evento de salida de la aplicación
if (mEventHandler->type == SDL_QUIT) if (eventHandler->type == SDL_QUIT)
{ {
mSection.name = SECTION_PROG_QUIT; section.name = SECTION_PROG_QUIT;
break; break;
} }
} }
mRoom->update(); room->update();
mPlayer->update(); player->update();
checkPlayerAndWalls(); // Debe ir detras del player update, por si se ha metido en algun muro checkPlayerAndWalls(); // Debe ir detras del player update, por si se ha metido en algun muro
checkPlayerOnBorder(); checkPlayerOnBorder();
checkPlayerOnFloor(); checkPlayerOnFloor();
@@ -113,44 +107,44 @@ void Game::update()
void Game::draw() void Game::draw()
{ {
// Prepara para dibujar el frame // Prepara para dibujar el frame
mScreen->start(); screen->start();
mScreen->clean(mRoom->getBGColor()); screen->clean(room->getBGColor());
mRoom->drawMap(); room->drawMap();
mRoom->drawEnemies(); room->drawEnemies();
mRoom->drawItems(); room->drawItems();
mPlayer->draw(); player->draw();
// Texto en el centro de la pantalla // Texto en el centro de la pantalla
SDL_Rect rect = {0, 16 * 8, PLAY_AREA_RIGHT, 8}; SDL_Rect rect = {0, 16 * 8, PLAY_AREA_RIGHT, 8};
color_t color = stringToColor("light_black"); color_t color = stringToColor("light_black");
SDL_SetRenderDrawColor(mRenderer, color.r, color.g, color.b, 0xFF); SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
SDL_RenderFillRect(mRenderer, &rect); SDL_RenderFillRect(renderer, &rect);
mText->writeCentered(GAMECANVAS_CENTER_X, 16 * 8, mRoom->getName()); text->writeCentered(GAMECANVAS_CENTER_X, 16 * 8, room->getName());
// Debug info // Debug info
if (mDebug) if (debug)
{ {
std::string text; std::string text;
text = "status: " + std::to_string(mPlayer->status); text = "status: " + std::to_string(player->status);
mText->write(0, 17 * 8, text); this->text->write(0, 17 * 8, text);
text = "foot: " + std::to_string((int)mPlayer->getLeftFoot().y); text = "foot: " + std::to_string((int)player->getLeftFoot().y);
mText->write(0, 18 * 8, text); this->text->write(0, 18 * 8, text);
const int a = (mPlayer->lastPosition.y + 16) / 8; const int a = (player->lastPosition.y + 16) / 8;
const int b = mPlayer->getLeftFoot().y / 8; const int b = player->getLeftFoot().y / 8;
text = "tile: " + std::to_string(a) + " - " + std::to_string(b); text = "tile: " + std::to_string(a) + " - " + std::to_string(b);
mText->write(0, 19 * 8, text); this->text->write(0, 19 * 8, text);
const bool collision = checkPlayerAndEnemies(); const bool collision = checkPlayerAndEnemies();
text = "collision: " + std::to_string(collision); text = "collision: " + std::to_string(collision);
mText->write(0, 20 * 8, text); this->text->write(0, 20 * 8, text);
} }
// Actualiza la pantalla // Actualiza la pantalla
mScreen->blit(); screen->blit();
} }
// Comprueba la entrada // Comprueba la entrada
@@ -158,21 +152,21 @@ void Game::draw()
void Game::checkInput() void Game::checkInput()
{ {
/* /*
if (mInput->checkInput(INPUT_UP, REPEAT_FALSE)) if (input->checkInput(INPUT_UP, REPEAT_FALSE))
changeRoom(mRoom->getRoomUp()); changeRoom(room->getRoomUp());
if (mInput->checkInput(INPUT_DOWN, REPEAT_FALSE)) if (input->checkInput(INPUT_DOWN, REPEAT_FALSE))
changeRoom(mRoom->getRoomDown()); changeRoom(room->getRoomDown());
if (mInput->checkInput(INPUT_LEFT, REPEAT_FALSE)) if (input->checkInput(INPUT_LEFT, REPEAT_FALSE))
changeRoom(mRoom->getRoomLeft()); changeRoom(room->getRoomLeft());
if (mInput->checkInput(INPUT_RIGHT, REPEAT_FALSE)) if (input->checkInput(INPUT_RIGHT, REPEAT_FALSE))
changeRoom(mRoom->getRoomRight()); changeRoom(room->getRoomRight());
*/ */
if (mInput->checkInput(INPUT_BUTTON_2, REPEAT_FALSE)) if (input->checkInput(INPUT_BUTTON_2, REPEAT_FALSE))
mDebug = !mDebug; debug = !debug;
} }
// Cambia de habitación // Cambia de habitación
@@ -183,14 +177,14 @@ bool Game::changeRoom(std::string file)
// En las habitaciones los limites tienen la cadena del fichero o un 0 en caso de no limitar con nada // En las habitaciones los limites tienen la cadena del fichero o un 0 en caso de no limitar con nada
if (file != "0") if (file != "0")
// Verifica que exista el fichero que se va a cargar // Verifica que exista el fichero que se va a cargar
if (mAsset->get(file) != "") if (asset->get(file) != "")
{ {
// Elimina la habitación actual // Elimina la habitación actual
delete mRoom; delete room;
mRoom = nullptr; room = nullptr;
// Crea un objeto habitación nuevo a partir del fichero // Crea un objeto habitación nuevo a partir del fichero
mRoom = new Room(mAsset->get(file), mRenderer, mAsset, mItemTracker); room = new Room(asset->get(file), renderer, asset, itemTracker);
success = true; success = true;
} }
@@ -201,14 +195,14 @@ bool Game::changeRoom(std::string file)
// Comprueba si el jugador esta en el borde de la pantalla // Comprueba si el jugador esta en el borde de la pantalla
void Game::checkPlayerOnBorder() void Game::checkPlayerOnBorder()
{ {
if (mPlayer->getOnBorder()) if (player->getOnBorder())
{ {
const std::string room_name = mRoom->getRoom(mPlayer->getBorder()); const std::string room_name = room->getRoom(player->getBorder());
if (changeRoom(room_name)) if (changeRoom(room_name))
{ {
mPlayer->switchBorders(); player->switchBorders();
mCurrentRoom = room_name; currentRoom = room_name;
mSpawnPoint = mPlayer->getSpawnParams(); spawnPoint = player->getSpawnParams();
} }
} }
} }
@@ -228,37 +222,37 @@ void Game::checkPlayerOnFloor()
// *** PARECE RESUELTO // *** PARECE RESUELTO
const int a = (mPlayer->lastPosition.y + 16) / 8; const int a = (player->lastPosition.y + 16) / 8;
const int b = mPlayer->getLeftFoot().y / 8; const int b = player->getLeftFoot().y / 8;
const bool tile_change = a != b; const bool tile_change = a != b;
const bool is_not_going_up = mPlayer->getVelY() >= 0; const bool is_not_going_up = player->getVelY() >= 0;
const bool is_tile_aligned = mPlayer->getLeftFoot().y % 8 == 0; const bool is_tile_aligned = player->getLeftFoot().y % 8 == 0;
if (((is_not_going_up) && (is_tile_aligned)) || ((is_not_going_up) && (tile_change))) if (((is_not_going_up) && (is_tile_aligned)) || ((is_not_going_up) && (tile_change)))
{ {
bool test = false; bool test = false;
test |= (mRoom->getTile(mPlayer->getLeftFoot()) == TILE_SOLID); test |= (room->getTile(player->getLeftFoot()) == TILE_SOLID);
test |= (mRoom->getTile(mPlayer->getRightFoot()) == TILE_SOLID); test |= (room->getTile(player->getRightFoot()) == TILE_SOLID);
test |= (mRoom->getTile(mPlayer->getLeftFoot()) == TILE_TRAVESSABLE); test |= (room->getTile(player->getLeftFoot()) == TILE_TRAVESSABLE);
test |= (mRoom->getTile(mPlayer->getRightFoot()) == TILE_TRAVESSABLE); test |= (room->getTile(player->getRightFoot()) == TILE_TRAVESSABLE);
// Tiene uno de los pies sobre una superficie // Tiene uno de los pies sobre una superficie
if (test) if (test)
{ {
mPlayer->setStatus(STATUS_STANDING); player->setStatus(STATUS_STANDING);
// Si ha habido un cambio de tile, hay que recolocarlo // Si ha habido un cambio de tile, hay que recolocarlo
if (tile_change) if (tile_change)
{ {
int offset = (int)mPlayer->sprite->getPosY() % 8; int offset = (int)player->sprite->getPosY() % 8;
mPlayer->sprite->setPosY((int)mPlayer->sprite->getPosY() - offset); player->sprite->setPosY((int)player->sprite->getPosY() - offset);
} }
} }
// Tiene ambos pies sobre el vacío // Tiene ambos pies sobre el vacío
else if (mPlayer->getStatus() != STATUS_JUMPING) else if (player->getStatus() != STATUS_JUMPING)
{ {
mPlayer->setStatus(STATUS_FALLING); player->setStatus(STATUS_FALLING);
} }
} }
} }
@@ -267,7 +261,7 @@ void Game::checkPlayerOnFloor()
void Game::checkPlayerAndWalls() void Game::checkPlayerAndWalls()
{ {
// Obtiene los ocho puntos de colisión del jugador // Obtiene los ocho puntos de colisión del jugador
const SDL_Rect rect = mPlayer->getRect(); const SDL_Rect rect = player->getRect();
const SDL_Point p1 = {rect.x, rect.y}; const SDL_Point p1 = {rect.x, rect.y};
const SDL_Point p2 = {rect.x + 7, rect.y}; const SDL_Point p2 = {rect.x + 7, rect.y};
const SDL_Point p3 = {rect.x + 7, rect.y + 7}; const SDL_Point p3 = {rect.x + 7, rect.y + 7};
@@ -279,32 +273,32 @@ void Game::checkPlayerAndWalls()
// Comprueba si ha colisionado con un muro // Comprueba si ha colisionado con un muro
bool wall = false; bool wall = false;
wall |= (mRoom->getTile(p1) == TILE_SOLID); wall |= (room->getTile(p1) == TILE_SOLID);
wall |= (mRoom->getTile(p2) == TILE_SOLID); wall |= (room->getTile(p2) == TILE_SOLID);
wall |= (mRoom->getTile(p3) == TILE_SOLID); wall |= (room->getTile(p3) == TILE_SOLID);
wall |= (mRoom->getTile(p4) == TILE_SOLID); wall |= (room->getTile(p4) == TILE_SOLID);
wall |= (mRoom->getTile(p5) == TILE_SOLID); wall |= (room->getTile(p5) == TILE_SOLID);
wall |= (mRoom->getTile(p6) == TILE_SOLID); wall |= (room->getTile(p6) == TILE_SOLID);
wall |= (mRoom->getTile(p7) == TILE_SOLID); wall |= (room->getTile(p7) == TILE_SOLID);
wall |= (mRoom->getTile(p8) == TILE_SOLID); wall |= (room->getTile(p8) == TILE_SOLID);
if (wall) if (wall)
{ {
// Si hay colisión, deshace el movimiento y lo pone en modo caída // Si hay colisión, deshace el movimiento y lo pone en modo caída
mPlayer->undoLastMove(); player->undoLastMove();
mPlayer->setStatus(STATUS_FALLING); player->setStatus(STATUS_FALLING);
} }
// Comprueba si ha colisionado con un tile de los que matan al jugador // Comprueba si ha colisionado con un tile de los que matan al jugador
bool death = false; bool death = false;
death |= (mRoom->getTile(p1) == TILE_KILL); death |= (room->getTile(p1) == TILE_KILL);
death |= (mRoom->getTile(p2) == TILE_KILL); death |= (room->getTile(p2) == TILE_KILL);
death |= (mRoom->getTile(p3) == TILE_KILL); death |= (room->getTile(p3) == TILE_KILL);
death |= (mRoom->getTile(p4) == TILE_KILL); death |= (room->getTile(p4) == TILE_KILL);
death |= (mRoom->getTile(p5) == TILE_KILL); death |= (room->getTile(p5) == TILE_KILL);
death |= (mRoom->getTile(p6) == TILE_KILL); death |= (room->getTile(p6) == TILE_KILL);
death |= (mRoom->getTile(p7) == TILE_KILL); death |= (room->getTile(p7) == TILE_KILL);
death |= (mRoom->getTile(p8) == TILE_KILL); death |= (room->getTile(p8) == TILE_KILL);
if (death) if (death)
{ {
@@ -315,7 +309,7 @@ void Game::checkPlayerAndWalls()
// Comprueba las colisiones del jugador con los enemigos // Comprueba las colisiones del jugador con los enemigos
bool Game::checkPlayerAndEnemies() bool Game::checkPlayerAndEnemies()
{ {
const bool death = mRoom->enemyCollision(mPlayer->getCollider()); const bool death = room->enemyCollision(player->getCollider());
if (death) if (death)
{ {
killPlayer(); killPlayer();
@@ -326,17 +320,17 @@ bool Game::checkPlayerAndEnemies()
// Comprueba las colisiones del jugador con los objetos // Comprueba las colisiones del jugador con los objetos
void Game::checkPlayerAndItems() void Game::checkPlayerAndItems()
{ {
mRoom->itemCollision(mPlayer->getCollider()); room->itemCollision(player->getCollider());
} }
// Mata al jugador // Mata al jugador
void Game::killPlayer() void Game::killPlayer()
{ {
// Destruye la habitacion y el jugador // Destruye la habitacion y el jugador
delete mRoom; delete room;
delete mPlayer; delete player;
// Crea la nueva habitación y el nuevo jugador // Crea la nueva habitación y el nuevo jugador
mRoom = new Room(mAsset->get(mCurrentRoom), mRenderer, mAsset, mItemTracker); room = new Room(asset->get(currentRoom), renderer, asset, itemTracker);
mPlayer = new Player(mSpawnPoint, mAsset->get("player01.png"), mRenderer, mAsset, mInput, mRoom); player = new Player(spawnPoint, asset->get("player01.png"), renderer, asset, input, room);
} }

32
source/game.h
View File

@@ -24,23 +24,21 @@
class Game class Game
{ {
private: private:
SDL_Renderer *mRenderer; // El renderizador de la ventana SDL_Renderer *renderer; // El renderizador de la ventana
SDL_Event *mEventHandler; // Manejador de eventos SDL_Event *eventHandler; // Manejador de eventos
Screen *mScreen; // Objeto encargado de manejar el renderizador Screen *screen; // Objeto encargado de manejar el renderizador
Room *mRoom; // Objeto encargado de gestionar cada habitación del juego Room *room; // Objeto encargado de gestionar cada habitación del juego
Player *mPlayer; // Objeto con el jugador Player *player; // Objeto con el jugador
Item_tracker *mItemTracker; // Lleva el control de los objetos recogidos ItemTracker *itemTracker; // Lleva el control de los objetos recogidos
Asset *mAsset; // Objeto con la ruta a todos los ficheros de recursos Asset *asset; // Objeto con la ruta a todos los ficheros de recursos
Lang *mLang; // Objeto para gestionar los textos en diferentes idiomas Input *input; // Objeto pata gestionar la entrada
Input *mInput; // Objeto pata gestionar la entrada Text *text; // Objeto para los textos del juego
Text *mText; // Objeto para los textos del juego int ticks; // Contador de ticks para ajustar la velocidad del programa
Fade *mFade; // Objeto para renderizar fades int ticksSpeed; // Velocidad a la que se repiten los bucles del programa
int mTicks; // Contador de ticks para ajustar la velocidad del programa section_t section; // Seccion actual dentro del juego
int mTicksSpeed; // Velocidad a la que se repiten los bucles del programa std::string currentRoom; // Fichero de la habitación actual
section_t mSection; // Seccion actual dentro del juego player_t spawnPoint; // Lugar de la habitación donde aparece el jugador
std::string mCurrentRoom; // Fichero de la habitación actual bool debug; // Indica si el modo debug está activo
player_t mSpawnPoint; // Lugar de la habitación donde aparece el jugador
bool mDebug; // Indica si el modo debug está activo
// Actualiza el juego, las variables, comprueba la entrada, etc. // Actualiza el juego, las variables, comprueba la entrada, etc.
void update(); void update();

12
source/item_tracker.cpp
View File

@@ -1,18 +1,18 @@
#include "item_tracker.h" #include "item_tracker.h"
// Constructor // Constructor
Item_tracker::Item_tracker() ItemTracker::ItemTracker()
{ {
} }
// Destructor // Destructor
Item_tracker::~Item_tracker() ItemTracker::~ItemTracker()
{ {
list.clear(); list.clear();
} }
// Comprueba si el objeto ya ha sido cogido // Comprueba si el objeto ya ha sido cogido
bool Item_tracker::hasBeenPicked(std::string name, SDL_Point pos) bool ItemTracker::hasBeenPicked(std::string name, SDL_Point pos)
{ {
bool success = false; bool success = false;
@@ -31,7 +31,7 @@ bool Item_tracker::hasBeenPicked(std::string name, SDL_Point pos)
} }
// Añade el objeto a la lista de objetos cogidos // Añade el objeto a la lista de objetos cogidos
void Item_tracker::addItem(std::string name, SDL_Point pos) void ItemTracker::addItem(std::string name, SDL_Point pos)
{ {
// Comprueba si el objeto no ha sido recogido con anterioridad // Comprueba si el objeto no ha sido recogido con anterioridad
if (!hasBeenPicked(name, pos)) if (!hasBeenPicked(name, pos))
@@ -55,7 +55,7 @@ void Item_tracker::addItem(std::string name, SDL_Point pos)
} }
// Busca una entrada en la lista por nombre // Busca una entrada en la lista por nombre
int Item_tracker::findByName(std::string name) int ItemTracker::findByName(std::string name)
{ {
const int c = -1; const int c = -1;
@@ -71,7 +71,7 @@ int Item_tracker::findByName(std::string name)
} }
// Busca una entrada en la lista por posición // Busca una entrada en la lista por posición
int Item_tracker::findByPos(int index, SDL_Point pos) int ItemTracker::findByPos(int index, SDL_Point pos)
{ {
const int c = -1; const int c = -1;

8
source/item_tracker.h
View File

@@ -13,8 +13,8 @@ struct item_tracker_t
std::vector<SDL_Point> pos; // Lista de objetos cogidos de la habitación std::vector<SDL_Point> pos; // Lista de objetos cogidos de la habitación
}; };
// Clase Item_tracker // Clase ItemTracker
class Item_tracker class ItemTracker
{ {
private: private:
std::vector<item_tracker_t> list; // Lista con todos los objetos recogidos std::vector<item_tracker_t> list; // Lista con todos los objetos recogidos
@@ -27,10 +27,10 @@ private:
public: public:
// Constructor // Constructor
Item_tracker(); ItemTracker();
// Destructor // Destructor
~Item_tracker(); ~ItemTracker();
// Comprueba si el objeto ya ha sido cogido // Comprueba si el objeto ya ha sido cogido
bool hasBeenPicked(std::string name, SDL_Point pos); bool hasBeenPicked(std::string name, SDL_Point pos);

172
source/room.cpp
View File

@@ -4,22 +4,22 @@
#include <sstream> #include <sstream>
// Constructor // Constructor
Room::Room(std::string _file_path, SDL_Renderer *_renderer, Asset *_asset, Item_tracker *_item_tracker) Room::Room(std::string file_path, SDL_Renderer *renderer, Asset *asset, ItemTracker *itemTracker)
{ {
// Copia los punteros a objetos // Copia los punteros a objetos
asset = _asset; this->asset = asset;
renderer = _renderer; this->renderer = renderer;
item_tracker = _item_tracker; this->itemTracker = itemTracker;
// Crea los objetos // Crea los objetos
texture = new LTexture(); texture = new LTexture();
load(_file_path); load(file_path);
loadTextureFromFile(texture, asset->get(tileset), renderer); loadTextureFromFile(texture, asset->get(tileset), renderer);
// Crea la textura para el mapa de tiles de la habitación // Crea la textura para el mapa de tiles de la habitación
map_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT); mapTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
if (map_texture == NULL) if (mapTexture == NULL)
printf("Error: map_texture could not be created!\nSDL Error: %s\n", SDL_GetError()); printf("Error: mapTexture could not be created!\nSDL Error: %s\n", SDL_GetError());
// Pinta el mapa de la habitación en la textura // Pinta el mapa de la habitación en la textura
fillMapTexture(); fillMapTexture();
@@ -33,20 +33,20 @@ Room::~Room()
delete texture; delete texture;
texture = nullptr; texture = nullptr;
SDL_DestroyTexture(map_texture); SDL_DestroyTexture(mapTexture);
map_texture = nullptr; mapTexture = nullptr;
for (auto enemy : enemy_list) for (auto enemy : enemies)
{ {
delete enemy; delete enemy;
} }
enemy_list.clear(); enemies.clear();
for (auto item : item_list) for (auto item : items)
{ {
delete item; delete item;
} }
item_list.clear(); items.clear();
} }
// Carga las variables desde un fichero // Carga las variables desde un fichero
@@ -88,7 +88,7 @@ bool Room::load(std::string _file_path)
} while (line != "[enemy-end]"); } while (line != "[enemy-end]");
// Añade el enemigo al vector de enemigos // Añade el enemigo al vector de enemigos
enemy_list.push_back(new Enemy(enemy)); enemies.push_back(new Enemy(enemy));
} }
// Si la linea contiene el texto [tilemap] se realiza el proceso de carga del fichero tmx // Si la linea contiene el texto [tilemap] se realiza el proceso de carga del fichero tmx
@@ -166,9 +166,9 @@ bool Room::load(std::string _file_path)
// Añade el item al vector de items // Añade el item al vector de items
const SDL_Point itemPos = {item.x, item.y}; const SDL_Point itemPos = {item.x, item.y};
if (!item_tracker->hasBeenPicked(name, itemPos)) if (!itemTracker->hasBeenPicked(name, itemPos))
{ {
item_list.push_back(new Item(item)); items.push_back(new Item(item));
} }
} }
@@ -201,50 +201,50 @@ bool Room::load(std::string _file_path)
} }
// Asigna variables a partir de dos cadenas // Asigna variables a partir de dos cadenas
bool Room::setVars(std::string _var, std::string _value) bool Room::setVars(std::string var, std::string value)
{ {
// Indicador de éxito en la asignación // Indicador de éxito en la asignación
bool success = true; bool success = true;
if (_var == "name") if (var == "name")
{ {
name = _value; name = value;
} }
else if (_var == "bg_color") else if (var == "bgColor")
{ {
bg_color = stringToColor(_value); bgColor = stringToColor(value);
} }
else if (_var == "tileset") else if (var == "tileset")
{ {
tileset = _value; tileset = value;
} }
else if (_var == "room_up") else if (var == "roomUp")
{ {
room_up = _value; roomUp = value;
} }
else if (_var == "room_down") else if (var == "roomDown")
{ {
room_down = _value; roomDown = value;
} }
else if (_var == "room_left") else if (var == "roomLeft")
{ {
room_left = _value; roomLeft = value;
} }
else if (_var == "room_right") else if (var == "roomRight")
{ {
room_right = _value; roomRight = value;
} }
else if (_var == "tilemap") else if (var == "tilemap")
{ {
// Se introducen los valores separados por comas en un vector // Se introducen los valores separados por comas en un vector
std::stringstream ss(_value); std::stringstream ss(value);
std::string tmp; std::string tmp;
while (getline(ss, tmp, ',')) while (getline(ss, tmp, ','))
{ {
tilemap.push_back(std::stoi(tmp)); tilemap.push_back(std::stoi(tmp));
} }
} }
else if (_var == "") else if (var == "")
{ {
} }
else else
@@ -256,60 +256,60 @@ bool Room::setVars(std::string _var, std::string _value)
} }
// Asigna variables a una estructura enemy_t // Asigna variables a una estructura enemy_t
bool Room::setEnemy(enemy_t *enemy, std::string _var, std::string _value) bool Room::setEnemy(enemy_t *enemy, std::string var, std::string value)
{ {
// Indicador de éxito en la asignación // Indicador de éxito en la asignación
bool success = true; bool success = true;
if (_var == "tileset") if (var == "tileset")
{ {
enemy->tileset = _value; enemy->tileset = value;
} }
else if (_var == "width") else if (var == "width")
{ {
enemy->w = std::stof(_value); enemy->w = std::stof(value);
} }
else if (_var == "height") else if (var == "height")
{ {
enemy->h = std::stof(_value); enemy->h = std::stof(value);
} }
else if (_var == "x") else if (var == "x")
{ {
enemy->x = std::stof(_value) * BLOCK; enemy->x = std::stof(value) * BLOCK;
} }
else if (_var == "y") else if (var == "y")
{ {
enemy->y = std::stof(_value) * BLOCK; enemy->y = std::stof(value) * BLOCK;
} }
else if (_var == "vx") else if (var == "vx")
{ {
enemy->vx = std::stof(_value); enemy->vx = std::stof(value);
} }
else if (_var == "vy") else if (var == "vy")
{ {
enemy->vy = std::stof(_value); enemy->vy = std::stof(value);
} }
else if (_var == "x1") else if (var == "x1")
{ {
enemy->x1 = std::stoi(_value) * BLOCK; enemy->x1 = std::stoi(value) * BLOCK;
} }
else if (_var == "x2") else if (var == "x2")
{ {
enemy->x2 = std::stoi(_value) * BLOCK; enemy->x2 = std::stoi(value) * BLOCK;
} }
else if (_var == "y1") else if (var == "y1")
{ {
enemy->y1 = std::stoi(_value) * BLOCK; enemy->y1 = std::stoi(value) * BLOCK;
} }
else if (_var == "y2") else if (var == "y2")
{ {
enemy->y2 = std::stoi(_value) * BLOCK; enemy->y2 = std::stoi(value) * BLOCK;
} }
else if (_var == "color") else if (var == "color")
{ {
enemy->color = stringToColor(_value); enemy->color = stringToColor(value);
} }
else if (_var == "[enemy-end]") else if (var == "[enemy-end]")
{ {
} }
else else
@@ -321,28 +321,28 @@ bool Room::setEnemy(enemy_t *enemy, std::string _var, std::string _value)
} }
// Asigna variables a una estructura item_t // Asigna variables a una estructura item_t
bool Room::setItem(item_t *item, std::string _var, std::string _value) bool Room::setItem(item_t *item, std::string var, std::string value)
{ {
// Indicador de éxito en la asignación // Indicador de éxito en la asignación
bool success = true; bool success = true;
if (_var == "tileset") if (var == "tileset")
{ {
item->tileset = _value; item->tileset = value;
} }
else if (_var == "x") else if (var == "x")
{ {
item->x = std::stof(_value) * BLOCK; item->x = std::stof(value) * BLOCK;
} }
else if (_var == "y") else if (var == "y")
{ {
item->y = std::stof(_value) * BLOCK; item->y = std::stof(value) * BLOCK;
} }
else if (_var == "tile") else if (var == "tile")
{ {
item->tile = std::stof(_value); item->tile = std::stof(value);
} }
else if (_var == "[item-end]") else if (var == "[item-end]")
{ {
} }
else else
@@ -362,14 +362,14 @@ std::string Room::getName()
// Devuelve el color de la habitación // Devuelve el color de la habitación
color_t Room::getBGColor() color_t Room::getBGColor()
{ {
return bg_color; return bgColor;
} }
// Crea la textura con el mapeado de la habitación // Crea la textura con el mapeado de la habitación
void Room::fillMapTexture() void Room::fillMapTexture()
{ {
SDL_SetRenderTarget(renderer, map_texture); SDL_SetRenderTarget(renderer, mapTexture);
SDL_SetTextureBlendMode(map_texture, SDL_BLENDMODE_BLEND); SDL_SetTextureBlendMode(mapTexture, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0x00); SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0x00);
SDL_RenderClear(renderer); SDL_RenderClear(renderer);
@@ -395,13 +395,13 @@ void Room::drawMap()
SDL_Rect rect = {0, 0, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT}; SDL_Rect rect = {0, 0, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT};
// Dibuja la textura con el mapa en pantalla // Dibuja la textura con el mapa en pantalla
SDL_RenderCopy(renderer, map_texture, &rect, NULL); SDL_RenderCopy(renderer, mapTexture, &rect, NULL);
} }
// Dibuja los enemigos en pantalla // Dibuja los enemigos en pantalla
void Room::drawEnemies() void Room::drawEnemies()
{ {
for (auto enemy : enemy_list) for (auto enemy : enemies)
{ {
enemy->draw(); enemy->draw();
} }
@@ -410,7 +410,7 @@ void Room::drawEnemies()
// Dibuja los objetos en pantalla // Dibuja los objetos en pantalla
void Room::drawItems() void Room::drawItems()
{ {
for (auto item : item_list) for (auto item : items)
{ {
item->draw(); item->draw();
} }
@@ -419,12 +419,12 @@ void Room::drawItems()
// Actualiza las variables y objetos de la habitación // Actualiza las variables y objetos de la habitación
void Room::update() void Room::update()
{ {
for (auto enemy : enemy_list) for (auto enemy : enemies)
{ {
enemy->update(); enemy->update();
} }
for (auto item : item_list) for (auto item : items)
{ {
item->update(); item->update();
} }
@@ -436,19 +436,19 @@ std::string Room::getRoom(int border)
switch (border) switch (border)
{ {
case BORDER_TOP: case BORDER_TOP:
return room_up; return roomUp;
break; break;
case BORDER_BOTTOM: case BORDER_BOTTOM:
return room_down; return roomDown;
break; break;
case BORDER_RIGHT: case BORDER_RIGHT:
return room_right; return roomRight;
break; break;
case BORDER_LEFT: case BORDER_LEFT:
return room_left; return roomLeft;
break; break;
default: default:
@@ -492,7 +492,7 @@ bool Room::enemyCollision(SDL_Rect &rect)
{ {
bool collision = false; bool collision = false;
for (auto enemy : enemy_list) for (auto enemy : enemies)
{ {
collision |= checkCollision(rect, enemy->getCollider()); collision |= checkCollision(rect, enemy->getCollider());
} }
@@ -504,12 +504,12 @@ bool Room::enemyCollision(SDL_Rect &rect)
bool Room::itemCollision(SDL_Rect &rect) bool Room::itemCollision(SDL_Rect &rect)
{ {
bool collision = false; bool collision = false;
for (auto item : item_list) for (auto item : items)
{ {
if (checkCollision(rect, item->getCollider())) if (checkCollision(rect, item->getCollider()))
{ {
item->pick(); item->pick();
item_tracker->addItem(name, item->getPos()); itemTracker->addItem(name, item->getPos());
collision = true; collision = true;
} }
} }

28
source/room.h
View File

@@ -36,39 +36,39 @@ class Room
{ {
private: private:
std::string name; // Nombre de la habitación std::string name; // Nombre de la habitación
color_t bg_color; // Color de fondo de la habitación color_t bgColor; // Color de fondo de la habitación
std::string room_up; // Identificador de la habitación que se encuentra arriba std::string roomUp; // Identificador de la habitación que se encuentra arriba
std::string room_down; // Identificador de la habitación que se encuentra abajp std::string roomDown; // Identificador de la habitación que se encuentra abajp
std::string room_left; // Identificador de la habitación que se encuentra a la izquierda std::string roomLeft; // Identificador de la habitación que se encuentra a la izquierda
std::string room_right; // Identificador de la habitación que se encuentra a la derecha std::string roomRight; // Identificador de la habitación que se encuentra a la derecha
std::string tileset; // Imagen con los graficos para la habitación std::string tileset; // Imagen con los graficos para la habitación
std::vector<int> tilemap; // Indice de los tiles a dibujar en la habitación std::vector<int> tilemap; // Indice de los tiles a dibujar en la habitación
std::vector<Enemy *> enemy_list; // Listado con los enemigos de la habitación std::vector<Enemy *> enemies; // Listado con los enemigos de la habitación
std::vector<Item *> item_list; // Listado con los items que hay en la habitación std::vector<Item *> items; // Listado con los items que hay en la habitación
LTexture *texture; // Textura con los graficos de la habitación LTexture *texture; // Textura con los graficos de la habitación
Asset *asset; // Objeto con la ruta a todos los ficheros de recursos Asset *asset; // Objeto con la ruta a todos los ficheros de recursos
Item_tracker *item_tracker; // Lleva el control de los objetos recogidos ItemTracker *itemTracker; // Lleva el control de los objetos recogidos
SDL_Renderer *renderer; // El renderizador de la ventana SDL_Renderer *renderer; // El renderizador de la ventana
SDL_Texture *map_texture; // Textura para dibujar el mapa de la habitación SDL_Texture *mapTexture; // Textura para dibujar el mapa de la habitación
// Carga las variables desde un fichero // Carga las variables desde un fichero
bool load(std::string _file_path); bool load(std::string file_path);
// Asigna variables a partir de dos cadenas // Asigna variables a partir de dos cadenas
bool setVars(std::string _var, std::string _value); bool setVars(std::string var, std::string value);
// Asigna variables a una estructura enemy_t // Asigna variables a una estructura enemy_t
bool setEnemy(enemy_t *enemy, std::string _var, std::string _value); bool setEnemy(enemy_t *enemy, std::string var, std::string value);
// Asigna variables a una estructura item_t // Asigna variables a una estructura item_t
bool setItem(item_t *item, std::string _var, std::string _value); bool setItem(item_t *item, std::string var, std::string value);
// Pinta el mapa de la habitación en la textura // Pinta el mapa de la habitación en la textura
void fillMapTexture(); void fillMapTexture();
public: public:
// Constructor // Constructor
Room(std::string _file_path, SDL_Renderer *_renderer, Asset *_asset, Item_tracker *_item_tracker); Room(std::string file_path, SDL_Renderer *renderer, Asset *asset, ItemTracker *item_tracker);
// Destructor // Destructor
~Room(); ~Room();