jailers/jaildoctors_dilemma
5
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Pull Requests 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
bg_color=black
bgColor=black
tileset=standard.png
room_up=0
room_down=0
room_left=0
room_right=02.room
roomUp=0
roomDown=0
roomLeft=0
roomRight=02.room
[tilemap]
01.tmx

10
data/room/02.room
View File

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

10
data/room/03.room
View File

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

10
data/room/04.room
View File

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

10
data/room/05.room
View File

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

32
source/game.h
View File

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

12
source/item_tracker.cpp
View File

@@ -1,18 +1,18 @@
#include "item_tracker.h"
// Constructor
Item_tracker::Item_tracker()
ItemTracker::ItemTracker()
{
}
// Destructor
Item_tracker::~Item_tracker()
ItemTracker::~ItemTracker()
{
list.clear();
}
// 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;
@@ -31,7 +31,7 @@ bool Item_tracker::hasBeenPicked(std::string name, SDL_Point pos)
}
// 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
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
int Item_tracker::findByName(std::string name)
int ItemTracker::findByName(std::string name)
{
const int c = -1;
@@ -71,7 +71,7 @@ int Item_tracker::findByName(std::string name)
}
// 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;

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
};
// Clase Item_tracker
class Item_tracker
// Clase ItemTracker
class ItemTracker
{
private:
std::vector<item_tracker_t> list; // Lista con todos los objetos recogidos
@@ -27,10 +27,10 @@ private:
public:
// Constructor
Item_tracker();
ItemTracker();
// Destructor
~Item_tracker();
~ItemTracker();
// Comprueba si el objeto ya ha sido cogido
bool hasBeenPicked(std::string name, SDL_Point pos);

172
source/room.cpp
View File

@@ -4,22 +4,22 @@
#include <sstream>
// 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
asset = _asset;
renderer = _renderer;
item_tracker = _item_tracker;
this->asset = asset;
this->renderer = renderer;
this->itemTracker = itemTracker;
// Crea los objetos
texture = new LTexture();
load(_file_path);
load(file_path);
loadTextureFromFile(texture, asset->get(tileset), renderer);
// 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);
if (map_texture == NULL)
printf("Error: map_texture could not be created!\nSDL Error: %s\n", SDL_GetError());
mapTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
if (mapTexture == NULL)
printf("Error: mapTexture could not be created!\nSDL Error: %s\n", SDL_GetError());
// Pinta el mapa de la habitación en la textura
fillMapTexture();
@@ -33,20 +33,20 @@ Room::~Room()
delete texture;
texture = nullptr;
SDL_DestroyTexture(map_texture);
map_texture = nullptr;
SDL_DestroyTexture(mapTexture);
mapTexture = nullptr;
for (auto enemy : enemy_list)
for (auto enemy : enemies)
{
delete enemy;
}
enemy_list.clear();
enemies.clear();
for (auto item : item_list)
for (auto item : items)
{
delete item;
}
item_list.clear();
items.clear();
}
// Carga las variables desde un fichero
@@ -88,7 +88,7 @@ bool Room::load(std::string _file_path)
} while (line != "[enemy-end]");
// 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
@@ -166,9 +166,9 @@ bool Room::load(std::string _file_path)
// Añade el item al vector de items
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
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
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
std::stringstream ss(_value);
std::stringstream ss(value);
std::string tmp;
while (getline(ss, tmp, ','))
{
tilemap.push_back(std::stoi(tmp));
}
}
else if (_var == "")
else if (var == "")
{
}
else
@@ -256,60 +256,60 @@ bool Room::setVars(std::string _var, std::string _value)
}
// 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
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
@@ -321,28 +321,28 @@ bool Room::setEnemy(enemy_t *enemy, std::string _var, std::string _value)
}
// 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
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
@@ -362,14 +362,14 @@ std::string Room::getName()
// Devuelve el color de la habitación
color_t Room::getBGColor()
{
return bg_color;
return bgColor;
}
// Crea la textura con el mapeado de la habitación
void Room::fillMapTexture()
{
SDL_SetRenderTarget(renderer, map_texture);
SDL_SetTextureBlendMode(map_texture, SDL_BLENDMODE_BLEND);
SDL_SetRenderTarget(renderer, mapTexture);
SDL_SetTextureBlendMode(mapTexture, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0x00);
SDL_RenderClear(renderer);
@@ -395,13 +395,13 @@ void Room::drawMap()
SDL_Rect rect = {0, 0, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT};
// 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
void Room::drawEnemies()
{
for (auto enemy : enemy_list)
for (auto enemy : enemies)
{
enemy->draw();
}
@@ -410,7 +410,7 @@ void Room::drawEnemies()
// Dibuja los objetos en pantalla
void Room::drawItems()
{
for (auto item : item_list)
for (auto item : items)
{
item->draw();
}
@@ -419,12 +419,12 @@ void Room::drawItems()
// Actualiza las variables y objetos de la habitación
void Room::update()
{
for (auto enemy : enemy_list)
for (auto enemy : enemies)
{
enemy->update();
}
for (auto item : item_list)
for (auto item : items)
{
item->update();
}
@@ -436,19 +436,19 @@ std::string Room::getRoom(int border)
switch (border)
{
case BORDER_TOP:
return room_up;
return roomUp;
break;
case BORDER_BOTTOM:
return room_down;
return roomDown;
break;
case BORDER_RIGHT:
return room_right;
return roomRight;
break;
case BORDER_LEFT:
return room_left;
return roomLeft;
break;
default:
@@ -492,7 +492,7 @@ bool Room::enemyCollision(SDL_Rect &rect)
{
bool collision = false;
for (auto enemy : enemy_list)
for (auto enemy : enemies)
{
collision |= checkCollision(rect, enemy->getCollider());
}
@@ -504,12 +504,12 @@ bool Room::enemyCollision(SDL_Rect &rect)
bool Room::itemCollision(SDL_Rect &rect)
{
bool collision = false;
for (auto item : item_list)
for (auto item : items)
{
if (checkCollision(rect, item->getCollider()))
{
item->pick();
item_tracker->addItem(name, item->getPos());
itemTracker->addItem(name, item->getPos());
collision = true;
}
}

28
source/room.h
View File

@@ -36,39 +36,39 @@ class Room
{
private:
std::string name; // Nombre de la habitación
color_t bg_color; // Color de fondo de la habitación
std::string room_up; // Identificador de la habitación que se encuentra arriba
std::string room_down; // 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 room_right; // Identificador de la habitación que se encuentra a la derecha
color_t bgColor; // Color de fondo de la habitación
std::string roomUp; // Identificador de la habitación que se encuentra arriba
std::string roomDown; // Identificador de la habitación que se encuentra abajp
std::string roomLeft; // Identificador de la habitación que se encuentra a la izquierda
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::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<Item *> item_list; // Listado con los items que hay en la habitación
std::vector<Enemy *> enemies; // Listado con los enemigos de 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
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_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
bool load(std::string _file_path);
bool load(std::string file_path);
// 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
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
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
void fillMapTexture();
public:
// 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
~Room();