Fase 1: Refactorización de Room - Extracción de gestión de entidades

Extraída la gestión de enemigos e items de Room a managers dedicados,
reduciendo las responsabilidades de la clase Room y mejorando la
separación de concernimientos.

Cambios principales:
- Creado EnemyManager para gestionar enemigos (creación, update, render, colisión)
- Creado ItemManager para gestionar items (creación, update, render, colisión, pickup)
- Room ahora delega toda la gestión de entidades a estos managers
- Room mantiene su interfaz pública sin cambios (retrocompatibilidad total)
- Eliminados vectores enemies_ e items_ de Room (reemplazados por managers)

Archivos nuevos:
- source/game/gameplay/enemy_manager.hpp/cpp
- source/game/gameplay/item_manager.hpp/cpp

Archivos modificados:
- source/game/gameplay/room.hpp/cpp
- CMakeLists.txt

Estado:
- Compilación exitosa
- Carga de assets verificada (325 assets OK)
- Linters ejecutados (clang-tidy y cppcheck)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.claude/settings.local.json

@@ -6,7 +6,9 @@
       "Bash(tools/linter/run_clang-tidy.sh:*)",
       "Bash(make resources.pack:*)",
       "Bash(tools/linter/run_cppcheck.sh:*)",
-      "Bash(cat:*)"
+      "Bash(cat:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)"
     ],
     "deny": [],
     "ask": []

CMakeLists.txt

@@ -77,6 +77,8 @@ set(APP_SOURCES
 
     # Game - Gameplay
     source/game/gameplay/cheevos.cpp
+    source/game/gameplay/enemy_manager.cpp
+    source/game/gameplay/item_manager.cpp
     source/game/gameplay/item_tracker.cpp
     source/game/gameplay/room.cpp
     source/game/gameplay/room_tracker.cpp

source/game/gameplay/enemy_manager.cpp

@@ -0,0 +1,49 @@
+#include "enemy_manager.hpp"
+
+#include <algorithm>  // Para std::ranges::any_of
+
+#include "../../utils/utils.hpp"  // Para checkCollision
+#include "../entities/enemy.hpp"  // Para Enemy
+
+// Añade un enemigo a la colección
+void EnemyManager::addEnemy(std::shared_ptr<Enemy> enemy) {
+    enemies_.push_back(std::move(enemy));
+}
+
+// Elimina todos los enemigos
+void EnemyManager::clear() {
+    enemies_.clear();
+}
+
+// Elimina el último enemigo de la colección
+void EnemyManager::removeLastEnemy() {
+    if (!enemies_.empty()) {
+        enemies_.pop_back();
+    }
+}
+
+// Comprueba si no hay enemigos
+auto EnemyManager::isEmpty() const -> bool {
+    return enemies_.empty();
+}
+
+// Actualiza todos los enemigos
+void EnemyManager::update(float delta_time) {
+    for (const auto& enemy : enemies_) {
+        enemy->update(delta_time);
+    }
+}
+
+// Renderiza todos los enemigos
+void EnemyManager::render() {
+    for (const auto& enemy : enemies_) {
+        enemy->render();
+    }
+}
+
+// Comprueba si hay colisión con algún enemigo
+auto EnemyManager::checkCollision(SDL_FRect& rect) -> bool {
+    return std::ranges::any_of(enemies_, [&rect](const auto& enemy) {
+        return ::checkCollision(rect, enemy->getCollider());
+    });
+}

source/game/gameplay/enemy_manager.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <memory>  // Para shared_ptr
+#include <vector>  // Para vector
+
+class Enemy;
+
+/**
+ * @brief Gestor de enemigos de una habitación
+ *
+ * Responsabilidades:
+ * - Almacenar y gestionar la colección de enemigos
+ * - Actualizar todos los enemigos
+ * - Renderizar todos los enemigos
+ * - Detectar colisiones con enemigos
+ */
+class EnemyManager {
+    public:
+        EnemyManager() = default;
+        ~EnemyManager() = default;
+
+        // Prohibir copia y movimiento para evitar duplicación accidental
+        EnemyManager(const EnemyManager&) = delete;
+        EnemyManager& operator=(const EnemyManager&) = delete;
+        EnemyManager(EnemyManager&&) = delete;
+        EnemyManager& operator=(EnemyManager&&) = delete;
+
+        // Gestión de enemigos
+        void addEnemy(std::shared_ptr<Enemy> enemy);  // Añade un enemigo a la colección
+        void clear();                                  // Elimina todos los enemigos
+        void removeLastEnemy();                        // Elimina el último enemigo de la colección
+        auto isEmpty() const -> bool;                  // Comprueba si no hay enemigos
+
+        // Actualización y renderizado
+        void update(float delta_time);  // Actualiza todos los enemigos
+        void render();                  // Renderiza todos los enemigos
+
+        // Detección de colisiones
+        auto checkCollision(SDL_FRect& rect) -> bool;  // Comprueba si hay colisión con algún enemigo
+
+    private:
+        std::vector<std::shared_ptr<Enemy>> enemies_;  // Colección de enemigos
+};

source/game/gameplay/item_manager.cpp

@@ -0,0 +1,69 @@
+#include "item_manager.hpp"
+
+#include "../../core/audio/audio.hpp"        // Para Audio
+#include "../../utils/utils.hpp"             // Para checkCollision
+#include "../entities/item.hpp"              // Para Item
+#include "item_tracker.hpp"                  // Para ItemTracker
+#include "scoreboard.hpp"                    // Para Scoreboard::Data
+#include "../options.hpp"                    // Para Options
+
+// Constructor
+ItemManager::ItemManager(std::string room_name, std::shared_ptr<Scoreboard::Data> scoreboard_data)
+    : room_name_(std::move(room_name))
+    , data_(std::move(scoreboard_data)) {
+}
+
+// Añade un item a la colección
+void ItemManager::addItem(std::shared_ptr<Item> item) {
+    items_.push_back(std::move(item));
+}
+
+// Elimina todos los items
+void ItemManager::clear() {
+    items_.clear();
+}
+
+// Actualiza todos los items
+void ItemManager::update(float delta_time) {
+    for (const auto& item : items_) {
+        item->update(delta_time);
+    }
+}
+
+// Renderiza todos los items
+void ItemManager::render() {
+    for (const auto& item : items_) {
+        item->render();
+    }
+}
+
+// Pausa/despausa todos los items
+void ItemManager::setPaused(bool paused) {
+    for (const auto& item : items_) {
+        item->setPaused(paused);
+    }
+}
+
+// Comprueba si hay colisión con algún item
+auto ItemManager::checkCollision(SDL_FRect& rect) -> bool {
+    for (int i = 0; i < static_cast<int>(items_.size()); ++i) {
+        if (::checkCollision(rect, items_.at(i)->getCollider())) {
+            // Registra el item como recogido
+            ItemTracker::get()->addItem(room_name_, items_.at(i)->getPos());
+
+            // Elimina el item de la colección
+            items_.erase(items_.begin() + i);
+
+            // Reproduce el sonido de pickup
+            Audio::get()->playSound("item.wav", Audio::Group::GAME);
+
+            // Actualiza el scoreboard y estadísticas
+            data_->items++;
+            Options::stats.items = data_->items;
+
+            return true;
+        }
+    }
+
+    return false;
+}

source/game/gameplay/item_manager.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <memory>  // Para shared_ptr
+#include <string>  // Para string
+#include <vector>  // Para vector
+
+#include "scoreboard.hpp"  // Para Scoreboard::Data
+
+class Item;
+
+/**
+ * @brief Gestor de items de una habitación
+ *
+ * Responsabilidades:
+ * - Almacenar y gestionar la colección de items
+ * - Actualizar todos los items
+ * - Renderizar todos los items
+ * - Detectar colisiones con items y gestionar pickup
+ * - Integración con ItemTracker, Scoreboard y Audio
+ */
+class ItemManager {
+    public:
+        /**
+         * @brief Constructor
+         * @param room_name Nombre de la habitación (para ItemTracker)
+         * @param scoreboard_data Puntero compartido a los datos del scoreboard
+         */
+        ItemManager(std::string room_name, std::shared_ptr<Scoreboard::Data> scoreboard_data);
+        ~ItemManager() = default;
+
+        // Prohibir copia y movimiento para evitar duplicación accidental
+        ItemManager(const ItemManager&) = delete;
+        ItemManager& operator=(const ItemManager&) = delete;
+        ItemManager(ItemManager&&) = delete;
+        ItemManager& operator=(ItemManager&&) = delete;
+
+        // Gestión de items
+        void addItem(std::shared_ptr<Item> item);  // Añade un item a la colección
+        void clear();                               // Elimina todos los items
+
+        // Actualización y renderizado
+        void update(float delta_time);  // Actualiza todos los items
+        void render();                  // Renderiza todos los items
+
+        // Estado
+        void setPaused(bool paused);  // Pausa/despausa todos los items
+
+        // Detección de colisiones
+        /**
+         * @brief Comprueba si hay colisión con algún item
+         *
+         * Si hay colisión:
+         * - Añade el item a ItemTracker
+         * - Elimina el item de la colección
+         * - Reproduce el sonido de pickup
+         * - Actualiza el scoreboard y estadísticas
+         *
+         * @param rect Rectángulo de colisión
+         * @return true si hubo colisión, false en caso contrario
+         */
+        auto checkCollision(SDL_FRect& rect) -> bool;
+
+    private:
+        std::vector<std::shared_ptr<Item>> items_;    // Colección de items
+        std::string room_name_;                       // Nombre de la habitación
+        std::shared_ptr<Scoreboard::Data> data_;      // Datos del scoreboard
+};

source/game/gameplay/room.cpp

@@ -14,6 +14,8 @@
 #include "core/resources/resource_cache.hpp"   // Para Resource
 #include "core/resources/resource_helper.hpp"  // Para ResourceHelper
 #include "core/system/debug.hpp"               // Para Debug
+#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/scoreboard.hpp"        // Para Scoreboard::Data
 #include "game/options.hpp"                    // Para Options, OptionsStats, options
@@ -24,6 +26,11 @@
 Room::Room(const std::string& room_path, std::shared_ptr<Scoreboard::Data> data)
     : data_(std::move(std::move(data))) {
     auto room = Resource::Cache::get()->getRoom(room_path);
+
+    // Crea los managers de enemigos e items
+    enemy_manager_ = std::make_unique<EnemyManager>();
+    item_manager_ = std::make_unique<ItemManager>(room->name, data_);
+
     initializeRoom(*room);
 
     openTheJail();                                                                // Abre la Jail si se da el caso
@@ -34,6 +41,9 @@ Room::Room(const std::string& room_path, std::shared_ptr<Scoreboard::Data> data)
     Screen::get()->setBorderColor(stringToColor(border_color_));                  // Establece el color del borde
 }
 
+// Destructor
+Room::~Room() = default;
+
 void Room::initializeRoom(const Data& room) {
     // Asignar valores a las variables miembro
     number_ = room.number;
@@ -55,12 +65,12 @@ void Room::initializeRoom(const Data& room) {
     is_paused_ = false;
     time_accumulator_ = 0.0F;
 
-    // Crear los enemigos
+    // Crear los enemigos usando el manager
     for (const auto& enemy_data : room.enemies) {
-        enemies_.emplace_back(std::make_shared<Enemy>(enemy_data));
+        enemy_manager_->addEnemy(std::make_shared<Enemy>(enemy_data));
     }
 
-    // Crear los items
+    // Crear los items usando el manager
     for (const auto& item : room.items) {
         const SDL_FPoint ITEM_POS = {item.x, item.y};
 
@@ -71,7 +81,7 @@ void Room::initializeRoom(const Data& room) {
             item_copy.color2 = stringToColor(item_color2_);
 
             // Crear el objeto Item usando la copia modificada
-            items_.emplace_back(std::make_shared<Item>(item_copy));
+            item_manager_->addItem(std::make_shared<Item>(item_copy));
         }
     }
 }
@@ -179,16 +189,12 @@ void Room::renderMap() {
 
 // Dibuja los enemigos en pantalla
 void Room::renderEnemies() {
-    for (const auto& enemy : enemies_) {
-        enemy->render();
-    }
+    enemy_manager_->render();
 }
 
 // Dibuja los objetos en pantalla
 void Room::renderItems() {
-    for (const auto& item : items_) {
-        item->render();
-    }
+    item_manager_->render();
 }
 
 // Actualiza las variables y objetos de la habitación
@@ -204,15 +210,17 @@ void Room::update(float delta_time) {
     // Actualiza los tiles animados
     updateAnimatedTiles();
 
-    for (const auto& enemy : enemies_) {
-        // Actualiza los enemigos
-        enemy->update(delta_time);
-    }
+    // Actualiza los enemigos usando el manager
+    enemy_manager_->update(delta_time);
 
-    for (const auto& item : items_) {
-        // Actualiza los items
-        item->update(delta_time);
-    }
+    // Actualiza los items usando el manager
+    item_manager_->update(delta_time);
+}
+
+// Pone el mapa en modo pausa
+void Room::setPaused(bool value) {
+    is_paused_ = value;
+    item_manager_->setPaused(value);
 }
 
 // Devuelve la cadena del fichero de la habitación contigua segun el borde
@@ -288,25 +296,12 @@ auto Room::getTile(int index) -> Tile {
 
 // Indica si hay colision con un enemigo a partir de un rectangulo
 auto Room::enemyCollision(SDL_FRect& rect) -> bool {
-    return std::ranges::any_of(enemies_, [&rect](const auto& enemy) {
-        return checkCollision(rect, enemy->getCollider());
-    });
+    return enemy_manager_->checkCollision(rect);
 }
 
 // Indica si hay colision con un objeto a partir de un rectangulo
 auto Room::itemCollision(SDL_FRect& rect) -> bool {
-    for (int i = 0; i < static_cast<int>(items_.size()); ++i) {
-        if (checkCollision(rect, items_.at(i)->getCollider())) {
-            ItemTracker::get()->addItem(name_, items_.at(i)->getPos());
-            items_.erase(items_.begin() + i);
-            Audio::get()->playSound("item.wav", Audio::Group::GAME);
-            data_->items++;
-            Options::stats.items = data_->items;
-            return true;
-        }
-    }
-
-    return false;
+    return item_manager_->checkCollision(rect);
 }
 
 // Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
@@ -780,9 +775,7 @@ auto Room::checkRightSlopes(SDL_FPoint& p) -> bool {
 void Room::openTheJail() {
     if (data_->jail_is_open && name_ == "THE JAIL") {
         // Elimina el último enemigo (Bry debe ser el último enemigo definido en el fichero)
-        if (!enemies_.empty()) {
-            enemies_.pop_back();
-        }
+        enemy_manager_->removeLastEnemy();
 
         // Abre las puertas
         constexpr int TILE_A = 16 + (13 * 32);

source/game/gameplay/room.hpp

@@ -12,6 +12,8 @@
 #include "utils/utils.hpp"             // Para LineHorizontal, LineDiagonal, LineVertical
 class SurfaceSprite;                   // lines 12-12
 class Surface;                         // lines 13-13
+class EnemyManager;
+class ItemManager;
 
 class Room {
     public:
@@ -54,7 +56,7 @@ class Room {
 
         // Constructor y destructor
         Room(const std::string& room_path, std::shared_ptr<Scoreboard::Data> data);
-        ~Room() = default;
+        ~Room();  // Definido en .cpp para poder usar unique_ptr con forward declarations
 
         // --- Funciones ---
         [[nodiscard]] auto getName() const -> const std::string& { return name_; }                             // Devuelve el nombre de la habitación
@@ -81,7 +83,7 @@ class Room {
         auto checkLeftSlopes(SDL_FPoint& p) -> bool;                                                           // Comprueba las colisiones
         auto checkRightSlopes(const LineVertical& line) -> int;                                                // Comprueba las colisiones
         auto checkRightSlopes(SDL_FPoint& p) -> bool;                                                          // Comprueba las colisiones
-        void setPaused(bool value) { is_paused_ = value; };                                                    // Pone el mapa en modo pausa
+        void setPaused(bool value);                                                                            // Pone el mapa en modo pausa
         [[nodiscard]] auto getConveyorBeltDirection() const -> int { return conveyor_belt_direction_; }        // Obten la direccion de las superficies automaticas
         static auto loadRoomFile(const std::string& file_path, bool verbose = false) -> Data;                  // Carga las variables desde un fichero de mapa
         static auto loadRoomTileFile(const std::string& file_path, bool verbose = false) -> std::vector<int>;  // Carga las variables y texturas desde un fichero de mapa de tiles
@@ -100,8 +102,8 @@ class Room {
         static constexpr float CONVEYOR_FRAME_DURATION = 0.05F;  // Duración de cada frame de conveyor belt (3 frames @ 60fps)
 
         // Objetos y punteros
-        std::vector<std::shared_ptr<Enemy>> enemies_;  // Listado con los enemigos de la habitación
-        std::vector<std::shared_ptr<Item>> items_;     // Listado con los items que hay en la habitación
+        std::unique_ptr<EnemyManager> enemy_manager_;  // Gestor de enemigos de la habitación
+        std::unique_ptr<ItemManager> item_manager_;    // Gestor de items de la habitación
         std::shared_ptr<Surface> surface_;             // Textura con los graficos de la habitación
         std::shared_ptr<Surface> map_surface_;         // Textura para dibujar el mapa de la habitación
         std::shared_ptr<Scoreboard::Data> data_;       // Puntero a los datos del marcador

tools/linter/cppcheck-result-warning-style-performance.txt

@@ -0,0 +1,3 @@
+/home/sergio/gitea/jaildoctors_dilemma/source/utils/utils.hpp:8:1: error: syntax error [syntaxError]
+enum class PaletteColor : Uint8 {
+^