From 9a20d5fc1bf61b408ae9e8d2e74ffdc7727418d0 Mon Sep 17 00:00:00 2001 From: Sergio Valor Date: Mon, 29 Aug 2022 18:16:14 +0200 Subject: [PATCH] Renombrado de variables --- data/room/01.room | 10 +- data/room/02.room | 10 +- data/room/03.room | 10 +- data/room/04.room | 10 +- data/room/05.room | 10 +- source/game.cpp | 240 ++++++++++++++++++++-------------------- source/game.h | 32 +++--- source/item_tracker.cpp | 12 +- source/item_tracker.h | 8 +- source/room.cpp | 172 ++++++++++++++-------------- source/room.h | 28 ++--- 11 files changed, 267 insertions(+), 275 deletions(-) diff --git a/data/room/01.room b/data/room/01.room index f510098..4b1fda5 100644 --- a/data/room/01.room +++ b/data/room/01.room @@ -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 diff --git a/data/room/02.room b/data/room/02.room index f474a14..8793ad8 100644 --- a/data/room/02.room +++ b/data/room/02.room @@ -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 diff --git a/data/room/03.room b/data/room/03.room index 74f1d36..e4a7c1f 100644 --- a/data/room/03.room +++ b/data/room/03.room @@ -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 diff --git a/data/room/04.room b/data/room/04.room index f0f9cb4..1054e07 100644 --- a/data/room/04.room +++ b/data/room/04.room @@ -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 diff --git a/data/room/05.room b/data/room/05.room index e637fb5..f429698 100644 --- a/data/room/05.room +++ b/data/room/05.room @@ -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 diff --git a/source/game.cpp b/source/game.cpp index 5face83..091ec14 100644 --- a/source/game.cpp +++ b/source/game.cpp @@ -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); } \ No newline at end of file diff --git a/source/game.h b/source/game.h index a46ee80..73b32c8 100644 --- a/source/game.h +++ b/source/game.h @@ -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(); diff --git a/source/item_tracker.cpp b/source/item_tracker.cpp index 2196ea9..ba4072f 100644 --- a/source/item_tracker.cpp +++ b/source/item_tracker.cpp @@ -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; diff --git a/source/item_tracker.h b/source/item_tracker.h index 2072f09..9c456e3 100644 --- a/source/item_tracker.h +++ b/source/item_tracker.h @@ -13,8 +13,8 @@ struct item_tracker_t std::vector pos; // Lista de objetos cogidos de la habitación }; -// Clase Item_tracker -class Item_tracker +// Clase ItemTracker +class ItemTracker { private: std::vector 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); diff --git a/source/room.cpp b/source/room.cpp index a46aeba..4c7a1bf 100644 --- a/source/room.cpp +++ b/source/room.cpp @@ -4,22 +4,22 @@ #include // 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; } } diff --git a/source/room.h b/source/room.h index 509690f..49f30dd 100644 --- a/source/room.h +++ b/source/room.h @@ -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 tilemap; // Indice de los tiles a dibujar en la habitación - std::vector enemy_list; // Listado con los enemigos de la habitación - std::vector item_list; // Listado con los items que hay en la habitación + std::vector enemies; // Listado con los enemigos de la habitación + std::vector 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();