treballant en sistema de portes i claus

source/game/gameplay/room.cpp

@@ -6,9 +6,13 @@
 #include "core/resources/resource_cache.hpp"   // Para Resource
 #include "game/defaults.hpp"                   // Para Defaults::Game
 #include "game/gameplay/collision_map.hpp"     // Para CollisionMap
+#include "game/gameplay/door_manager.hpp"      // Para DoorManager
+#include "game/gameplay/door_tracker.hpp"      // Para DoorTracker
 #include "game/gameplay/enemy_manager.hpp"     // Para EnemyManager
 #include "game/gameplay/item_manager.hpp"      // Para ItemManager
 #include "game/gameplay/item_tracker.hpp"      // Para ItemTracker
+#include "game/gameplay/key_manager.hpp"       // Para KeyManager
+#include "game/gameplay/key_tracker.hpp"       // Para KeyTracker
 #include "game/gameplay/platform_manager.hpp"  // Para PlatformManager
 #include "game/gameplay/room_loader.hpp"       // Para RoomLoader
 #include "game/gameplay/scoreboard.hpp"        // Para Scoreboard::Data
@@ -21,18 +25,27 @@ Room::Room(const std::string& room_path, std::shared_ptr<Scoreboard::Data> data)
     : data_(std::move(data)) {
     auto room = Resource::Cache::get()->getRoom(room_path);
 
-    // Crea los managers de enemigos, items y plataformas
+    // Crea los managers de enemigos, items, plataformas y llaves
     enemy_manager_ = std::make_unique<EnemyManager>();
     item_manager_ = std::make_unique<ItemManager>(room->number, data_);
     platform_manager_ = std::make_unique<PlatformManager>();
+    key_manager_ = std::make_unique<KeyManager>(room->number);
 
-    initializeRoom(*room);
-    // Crea el mapa de colisiones desde el collision_tile_map
+    // Crea el mapa de colisiones desde el collision_tile_map (debe ir antes
+    // del DoorManager porque éste lo necesita para mutar tiles dinámicamente)
     collision_map_ = std::make_unique<CollisionMap>(room->collision_tile_map, conveyor_belt_direction_);
 
-    // Crea el renderizador del tilemap (necesita tile_map_, tile_set_width_, surface_, bg_color_, conveyor_belt_direction_)
+    // Crea el manager de puertas (necesita el CollisionMap para sincronizar muros)
+    door_manager_ = std::make_unique<DoorManager>(room->number, collision_map_.get());
+
+    initializeRoom(*room);
+
+    // Crea el renderizador del tilemap (necesita tile_map_, tile_set_width_, surface_, bg_color_, conveyor_belt_direction_).
+    // Se inicializa con el collision tile map ya modificado por las puertas (que han marcado sus
+    // celdas como WALL en el collision_map_, pero el renderer solo lo usa para detectar superficies
+    // de dibujo, no para colisión, así que pasamos la versión actualizada del collision_map_).
     tilemap_renderer_ = std::make_unique<TilemapRenderer>(tile_map_, tile_set_width_, surface_, bg_color_, conveyor_belt_direction_);
-    tilemap_renderer_->initialize(room->collision_tile_map);
+    tilemap_renderer_->initialize(collision_map_->getCollisionTileMap());
 }
 
 // Destructor
@@ -79,6 +92,23 @@ void Room::initializeRoom(const Data& room) {
             item_manager_->addItem(std::make_shared<Item>(item_copy));
         }
     }
+
+    // Crear las llaves usando el manager (saltar las ya recogidas)
+    for (const auto& key_data : room.keys) {
+        const SDL_FPoint KEY_POS{.x = key_data.x, .y = key_data.y};
+        if (!KeyTracker::get()->hasBeenPicked(room.number, KEY_POS)) {
+            key_manager_->addKey(std::make_shared<Key>(key_data));
+        }
+    }
+
+    // Crear las puertas usando el manager. Las que ya hayan sido abiertas
+    // antes (DoorTracker) se construyen directamente en estado OPENED y no
+    // pintan WALLs en el collision_map_.
+    for (const auto& door_data : room.doors) {
+        const SDL_FPoint DOOR_POS{.x = door_data.x, .y = door_data.y};
+        const bool ALREADY_OPENED = DoorTracker::get()->hasBeenOpened(room.number, DOOR_POS);
+        door_manager_->addDoor(std::make_shared<Door>(door_data, ALREADY_OPENED));
+    }
 }
 
 // Dibuja el mapa en pantalla
@@ -101,6 +131,16 @@ void Room::renderItems() {
     item_manager_->render();
 }
 
+// Dibuja las llaves en pantalla
+void Room::renderKeys() {
+    key_manager_->render();
+}
+
+// Dibuja las puertas en pantalla
+void Room::renderDoors() {
+    door_manager_->render();
+}
+
 #ifdef _DEBUG
 // Redibuja el mapa (para actualizar modo debug)
 void Room::redrawMap() {
@@ -202,6 +242,12 @@ void Room::update(float delta_time) {  // NOLINT(readability-make-member-functio
 
     // Actualiza los items usando el manager
     item_manager_->update(delta_time);
+
+    // Actualiza las llaves usando el manager
+    key_manager_->update(delta_time);
+
+    // Actualiza las puertas usando el manager (procesa transiciones a OPENED)
+    door_manager_->update(delta_time);
 }
 
 // Pone el mapa en modo pausa
@@ -209,6 +255,8 @@ void Room::setPaused(bool value) {
     is_paused_ = value;
     tilemap_renderer_->setPaused(value);
     item_manager_->setPaused(value);
+    key_manager_->setPaused(value);
+    door_manager_->setPaused(value);
 }
 
 auto Room::getTileCollider() const -> const TileCollider& {
@@ -247,6 +295,14 @@ auto Room::itemCollision(SDL_FRect& rect) -> bool {
     return item_manager_->checkCollision(rect);
 }
 
+auto Room::keyCollision(SDL_FRect& rect) -> bool {
+    return key_manager_->checkCollision(rect);
+}
+
+void Room::tryUnlockDoors(const SDL_FRect& player_rect) {
+    door_manager_->tryUnlock(player_rect);
+}
+
 auto Room::checkPlayerOnPlatform(const SDL_FRect& player_collider, float player_vy) -> MovingPlatform* {
     return platform_manager_->checkPlayerOnPlatform(player_collider, player_vy);
 }