Fase 2: Refactorización de Room - Extracción del sistema de colisiones

## Cambios principales

### Nuevo componente: CollisionMap
- **collision_map.hpp/cpp**: Nueva clase que encapsula toda la lógica de detección de colisiones
- Responsabilidades extraídas de Room:
  - Determinación de tipos de tile (getTile)
  - Generación de geometría de colisión (superficies, rampas, conveyor belts)
  - Queries de colisión para Player y entidades
  - 14 métodos de detección de colisión
  - Getters para visualización debug

### Modificaciones en Room
- **room.hpp**:
  - Añadido CollisionMap como miembro (unique_ptr)
  - Removidos 7 vectores de geometría de colisión
  - Removidos 13 métodos privados de generación de geometría
  - Añadido getTile(int index) para soporte de animated tiles
  - Añadido destructor explícito (necesario para unique_ptr con forward declaration)

- **room.cpp**:
  - Constructor: Inicializa CollisionMap con tile_map, tile_set_width, conveyor_belt_direction
  - Delegación: Todos los métodos de colisión ahora llaman a collision_map_
  - Restaurados métodos de animated tiles (openTheJail, setAnimatedTiles, updateAnimatedTiles, renderAnimatedTiles)
  - Actualizado openTheJail() para usar enemy_manager_ en lugar de enemies_
  - Debug visualization actualizada para usar getters de CollisionMap

### Build system
- **CMakeLists.txt**: Añadido collision_map.cpp a las fuentes del proyecto

## Métricas
- **Código eliminado de Room**: ~465 líneas de lógica de colisión
- **Nuevo CollisionMap**: 487 líneas (collision_map.cpp)
- **Reducción neta en room.cpp**: Significativa mejora en cohesión

## Verificación
- ✅ Compilación exitosa sin errores
- ✅ Juego inicia y carga recursos correctamente
- ✅ clang-tidy: Sin warnings en código de usuario
- ✅ cppcheck: Sin issues reales (solo false positive en utils.hpp)

## Próximos pasos
- Fase 3: Extracción del sistema de renderizado de tilemap
- Fase 4: Extracción del parseo de archivos
- Fase 5: Limpieza final y reducción de Room a coordinador ligero

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

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

CMakeLists.txt

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

source/game/gameplay/collision_map.cpp

@@ -0,0 +1,486 @@
+#include "collision_map.hpp"
+
+#include <algorithm>  // Para std::ranges::any_of
+
+#include "../../core/system/debug.hpp"  // Para Debug
+#include "../../utils/defines.hpp"      // Para Collision
+
+// Constructor
+CollisionMap::CollisionMap(std::vector<int> tile_map, int tile_set_width, int conveyor_belt_direction)
+    : tile_map_(std::move(tile_map))
+    , tile_set_width_(tile_set_width)
+    , conveyor_belt_direction_(conveyor_belt_direction) {
+    // Inicializa todas las superficies de colisión
+    initializeSurfaces();
+}
+
+// Inicializa todas las superficies de colisión
+void CollisionMap::initializeSurfaces() {
+    setBottomSurfaces();
+    setTopSurfaces();
+    setLeftSurfaces();
+    setRightSurfaces();
+    setLeftSlopes();
+    setRightSlopes();
+    setAutoSurfaces();
+}
+
+// Devuelve el tipo de tile que hay en ese pixel
+auto CollisionMap::getTile(SDL_FPoint point) -> Tile {
+    const int POS = ((point.y / TILE_SIZE) * MAP_WIDTH) + (point.x / TILE_SIZE);
+    return getTile(POS);
+}
+
+// Devuelve el tipo de tile que hay en ese indice
+auto CollisionMap::getTile(int index) -> Tile {
+    const bool ON_RANGE = (index > -1) && (index < (int)tile_map_.size());
+
+    if (ON_RANGE) {
+        // Las filas 0-8 son de tiles t_wall
+        if ((tile_map_[index] >= 0) && (tile_map_[index] < 9 * tile_set_width_)) {
+            return Tile::WALL;
+        }
+
+        // Las filas 9-17 son de tiles t_passable
+        if ((tile_map_[index] >= 9 * tile_set_width_) && (tile_map_[index] < 18 * tile_set_width_)) {
+            return Tile::PASSABLE;
+        }
+
+        // Las filas 18-20 es de tiles t_animated
+        if ((tile_map_[index] >= 18 * tile_set_width_) && (tile_map_[index] < 21 * tile_set_width_)) {
+            return Tile::ANIMATED;
+        }
+
+        // La fila 21 es de tiles t_slope_r
+        if ((tile_map_[index] >= 21 * tile_set_width_) && (tile_map_[index] < 22 * tile_set_width_)) {
+            return Tile::SLOPE_R;
+        }
+
+        // La fila 22 es de tiles t_slope_l
+        if ((tile_map_[index] >= 22 * tile_set_width_) && (tile_map_[index] < 23 * tile_set_width_)) {
+            return Tile::SLOPE_L;
+        }
+
+        // La fila 23 es de tiles t_kill
+        if ((tile_map_[index] >= 23 * tile_set_width_) && (tile_map_[index] < 24 * tile_set_width_)) {
+            return Tile::KILL;
+        }
+    }
+
+    return Tile::EMPTY;
+}
+
+// Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
+auto CollisionMap::getSlopeHeight(SDL_FPoint p, Tile slope) -> int {
+    // Calcula la base del tile
+    int base = ((p.y / TILE_SIZE) * TILE_SIZE) + TILE_SIZE;
+#ifdef _DEBUG
+    Debug::get()->add("BASE = " + std::to_string(base));
+#endif
+
+    // Calcula cuanto se ha entrado en el tile horizontalmente
+    const int POS = (static_cast<int>(p.x) % TILE_SIZE);  // Esto da un valor entre 0 y 7
+#ifdef _DEBUG
+    Debug::get()->add("POS = " + std::to_string(POS));
+#endif
+
+    // Se resta a la base la cantidad de pixeles pos en funcion de la rampa
+    if (slope == Tile::SLOPE_R) {
+        base -= POS + 1;
+#ifdef _DEBUG
+        Debug::get()->add("BASE_R = " + std::to_string(base));
+#endif
+    } else {
+        base -= (TILE_SIZE - POS);
+#ifdef _DEBUG
+        Debug::get()->add("BASE_L = " + std::to_string(base));
+#endif
+    }
+
+    return base;
+}
+
+// === Queries de colisión ===
+
+// Comprueba las colisiones con paredes derechas
+auto CollisionMap::checkRightSurfaces(SDL_FRect& rect) -> int {
+    for (const auto& s : right_walls_) {
+        if (checkCollision(s, rect)) {
+            return s.x;
+        }
+    }
+    return Collision::NONE;
+}
+
+// Comprueba las colisiones con paredes izquierdas
+auto CollisionMap::checkLeftSurfaces(SDL_FRect& rect) -> int {
+    for (const auto& s : left_walls_) {
+        if (checkCollision(s, rect)) {
+            return s.x;
+        }
+    }
+    return Collision::NONE;
+}
+
+// Comprueba las colisiones con techos
+auto CollisionMap::checkTopSurfaces(SDL_FRect& rect) -> int {
+    for (const auto& s : top_floors_) {
+        if (checkCollision(s, rect)) {
+            return s.y;
+        }
+    }
+    return Collision::NONE;
+}
+
+// Comprueba las colisiones punto con techos
+auto CollisionMap::checkTopSurfaces(SDL_FPoint& p) -> bool {
+    return std::ranges::any_of(top_floors_, [&](const auto& s) {
+        return checkCollision(s, p);
+    });
+}
+
+// Comprueba las colisiones con suelos
+auto CollisionMap::checkBottomSurfaces(SDL_FRect& rect) -> int {
+    for (const auto& s : bottom_floors_) {
+        if (checkCollision(s, rect)) {
+            return s.y;
+        }
+    }
+    return Collision::NONE;
+}
+
+// Comprueba las colisiones con conveyor belts
+auto CollisionMap::checkAutoSurfaces(SDL_FRect& rect) -> int {
+    for (const auto& s : conveyor_belt_floors_) {
+        if (checkCollision(s, rect)) {
+            return s.y;
+        }
+    }
+    return Collision::NONE;
+}
+
+// Comprueba las colisiones punto con conveyor belts
+auto CollisionMap::checkConveyorBelts(SDL_FPoint& p) -> bool {
+    return std::ranges::any_of(conveyor_belt_floors_, [&](const auto& s) {
+        return checkCollision(s, p);
+    });
+}
+
+// Comprueba las colisiones línea con rampas izquierdas
+auto CollisionMap::checkLeftSlopes(const LineVertical& line) -> int {
+    for (const auto& slope : left_slopes_) {
+        const auto P = checkCollision(slope, line);
+        if (P.x != -1) {
+            return P.y;
+        }
+    }
+    return Collision::NONE;
+}
+
+// Comprueba las colisiones punto con rampas izquierdas
+auto CollisionMap::checkLeftSlopes(SDL_FPoint& p) -> bool {
+    return std::ranges::any_of(left_slopes_, [&](const auto& slope) {
+        return checkCollision(p, slope);
+    });
+}
+
+// Comprueba las colisiones línea con rampas derechas
+auto CollisionMap::checkRightSlopes(const LineVertical& line) -> int {
+    for (const auto& slope : right_slopes_) {
+        const auto P = checkCollision(slope, line);
+        if (P.x != -1) {
+            return P.y;
+        }
+    }
+    return Collision::NONE;
+}
+
+// Comprueba las colisiones punto con rampas derechas
+auto CollisionMap::checkRightSlopes(SDL_FPoint& p) -> bool {
+    return std::ranges::any_of(right_slopes_, [&](const auto& slope) {
+        return checkCollision(p, slope);
+    });
+}
+
+// === Helpers para recopilar tiles ===
+
+// Helper: recopila tiles inferiores (muros sin muro debajo)
+auto CollisionMap::collectBottomTiles() -> std::vector<int> {
+    std::vector<int> tile;
+
+    // Busca todos los tiles de tipo muro que no tengan debajo otro muro
+    // Hay que recorrer la habitación por filas (excepto los de la última fila)
+    for (int i = 0; i < (int)tile_map_.size() - MAP_WIDTH; ++i) {
+        if (getTile(i) == Tile::WALL && getTile(i + MAP_WIDTH) != Tile::WALL) {
+            tile.push_back(i);
+
+            // Si llega al final de la fila, introduce un separador
+            if (i % MAP_WIDTH == MAP_WIDTH - 1) {
+                tile.push_back(-1);
+            }
+        }
+    }
+
+    // Añade un terminador
+    tile.push_back(-1);
+    return tile;
+}
+
+// Helper: recopila tiles superiores (muros o pasables sin muro encima)
+auto CollisionMap::collectTopTiles() -> std::vector<int> {
+    std::vector<int> tile;
+
+    // Busca todos los tiles de tipo muro o pasable que no tengan encima un muro
+    // Hay que recorrer la habitación por filas (excepto los de la primera fila)
+    for (int i = MAP_WIDTH; i < (int)tile_map_.size(); ++i) {
+        if ((getTile(i) == Tile::WALL || getTile(i) == Tile::PASSABLE) && getTile(i - MAP_WIDTH) != Tile::WALL) {
+            tile.push_back(i);
+
+            // Si llega al final de la fila, introduce un separador
+            if (i % MAP_WIDTH == MAP_WIDTH - 1) {
+                tile.push_back(-1);
+            }
+        }
+    }
+
+    // Añade un terminador
+    tile.push_back(-1);
+    return tile;
+}
+
+// Helper: recopila tiles animados (para superficies automaticas/conveyor belts)
+auto CollisionMap::collectAnimatedTiles() -> std::vector<int> {
+    std::vector<int> tile;
+
+    // Busca todos los tiles de tipo animado
+    // Hay que recorrer la habitación por filas (excepto los de la primera fila)
+    for (int i = MAP_WIDTH; i < (int)tile_map_.size(); ++i) {
+        if (getTile(i) == Tile::ANIMATED) {
+            tile.push_back(i);
+
+            // Si llega al final de la fila, introduce un separador
+            if (i % MAP_WIDTH == MAP_WIDTH - 1) {
+                tile.push_back(-1);
+            }
+        }
+    }
+
+    // Añade un terminador si hay tiles
+    if (!tile.empty()) {
+        tile.push_back(-1);
+    }
+
+    return tile;
+}
+
+// Helper: construye lineas horizontales a partir de tiles consecutivos
+void CollisionMap::buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface) {
+    if (tiles.size() <= 1) {
+        return;
+    }
+
+    int i = 0;
+    while (i < (int)tiles.size() - 1) {
+        LineHorizontal line;
+        line.x1 = (tiles[i] % MAP_WIDTH) * TILE_SIZE;
+
+        // Calcula Y segun si es superficie inferior o superior
+        if (is_bottom_surface) {
+            line.y = ((tiles[i] / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
+        } else {
+            line.y = (tiles[i] / MAP_WIDTH) * TILE_SIZE;
+        }
+
+        int last_one = i;
+        i++;
+
+        // Encuentra tiles consecutivos
+        if (i < (int)tiles.size()) {
+            while (tiles[i] == tiles[i - 1] + 1) {
+                last_one = i;
+                i++;
+                if (i >= (int)tiles.size()) {
+                    break;
+                }
+            }
+        }
+
+        line.x2 = ((tiles[last_one] % MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
+        lines.push_back(line);
+
+        // Salta separadores
+        if (i < (int)tiles.size() && tiles[i] == -1) {
+            i++;
+        }
+    }
+}
+
+// === Métodos de generación de geometría ===
+
+// Calcula las superficies inferiores
+void CollisionMap::setBottomSurfaces() {
+    std::vector<int> tile = collectBottomTiles();
+    buildHorizontalLines(tile, bottom_floors_, true);
+}
+
+// Calcula las superficies superiores
+void CollisionMap::setTopSurfaces() {
+    std::vector<int> tile = collectTopTiles();
+    buildHorizontalLines(tile, top_floors_, false);
+}
+
+// Calcula las superficies laterales izquierdas
+void CollisionMap::setLeftSurfaces() {
+    std::vector<int> tile;
+
+    // Busca todos los tiles de tipo muro que no tienen a su izquierda un tile de tipo muro
+    // Hay que recorrer la habitación por columnas (excepto los de la primera columna)
+    for (int i = 1; i < MAP_WIDTH; ++i) {
+        for (int j = 0; j < MAP_HEIGHT; ++j) {
+            const int POS = ((j * MAP_WIDTH) + i);
+            if (getTile(POS) == Tile::WALL && getTile(POS - 1) != Tile::WALL) {
+                tile.push_back(POS);
+            }
+        }
+    }
+
+    // Añade un terminador
+    tile.push_back(-1);
+
+    // Recorre el vector de tiles buscando tiles consecutivos
+    // (Los tiles de la misma columna, la diferencia entre ellos es de mapWidth)
+    // para localizar las superficies
+    if ((int)tile.size() > 1) {
+        int i = 0;
+        do {
+            LineVertical line;
+            line.x = (tile[i] % MAP_WIDTH) * TILE_SIZE;
+            line.y1 = ((tile[i] / MAP_WIDTH) * TILE_SIZE);
+            while (tile[i] + MAP_WIDTH == tile[i + 1]) {
+                if (i == (int)tile.size() - 1) {
+                    break;
+                }
+                i++;
+            }
+            line.y2 = ((tile[i] / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
+            left_walls_.push_back(line);
+            i++;
+        } while (i < (int)tile.size() - 1);
+    }
+}
+
+// Calcula las superficies laterales derechas
+void CollisionMap::setRightSurfaces() {
+    std::vector<int> tile;
+
+    // Busca todos los tiles de tipo muro que no tienen a su derecha un tile de tipo muro
+    // Hay que recorrer la habitación por columnas (excepto los de la última columna)
+    for (int i = 0; i < MAP_WIDTH - 1; ++i) {
+        for (int j = 0; j < MAP_HEIGHT; ++j) {
+            const int POS = ((j * MAP_WIDTH) + i);
+            if (getTile(POS) == Tile::WALL && getTile(POS + 1) != Tile::WALL) {
+                tile.push_back(POS);
+            }
+        }
+    }
+
+    // Añade un terminador
+    tile.push_back(-1);
+
+    // Recorre el vector de tiles buscando tiles consecutivos
+    // (Los tiles de la misma columna, la diferencia entre ellos es de mapWidth)
+    // para localizar las superficies
+    if ((int)tile.size() > 1) {
+        int i = 0;
+        do {
+            LineVertical line;
+            line.x = ((tile[i] % MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
+            line.y1 = ((tile[i] / MAP_WIDTH) * TILE_SIZE);
+            while (tile[i] + MAP_WIDTH == tile[i + 1]) {
+                if (i == (int)tile.size() - 1) {
+                    break;
+                }
+                i++;
+            }
+            line.y2 = ((tile[i] / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
+            right_walls_.push_back(line);
+            i++;
+        } while (i < (int)tile.size() - 1);
+    }
+}
+
+// Encuentra todas las rampas que suben hacia la izquierda
+void CollisionMap::setLeftSlopes() {
+    // Recorre la habitación entera por filas buscando tiles de tipo t_slope_l
+    std::vector<int> found;
+    for (int i = 0; i < (int)tile_map_.size(); ++i) {
+        if (getTile(i) == Tile::SLOPE_L) {
+            found.push_back(i);
+        }
+    }
+
+    // El primer elemento es el inicio de una rampa. Se añade ese elemento y se buscan los siguientes,
+    // que seran i + mapWidth + 1. Conforme se añaden se eliminan y se vuelve a escudriñar el vector de
+    // tiles encontrados hasta que esté vacío
+
+    while (!found.empty()) {
+        LineDiagonal line;
+        line.x1 = (found[0] % MAP_WIDTH) * TILE_SIZE;
+        line.y1 = (found[0] / MAP_WIDTH) * TILE_SIZE;
+        int looking_for = found[0] + MAP_WIDTH + 1;
+        int last_one_found = found[0];
+        found.erase(found.begin());
+        for (int i = 0; i < (int)found.size(); ++i) {
+            if (found[i] == looking_for) {
+                last_one_found = looking_for;
+                looking_for += MAP_WIDTH + 1;
+                found.erase(found.begin() + i);
+                i--;
+            }
+        }
+        line.x2 = ((last_one_found % MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
+        line.y2 = ((last_one_found / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
+        left_slopes_.push_back(line);
+    }
+}
+
+// Encuentra todas las rampas que suben hacia la derecha
+void CollisionMap::setRightSlopes() {
+    // Recorre la habitación entera por filas buscando tiles de tipo t_slope_r
+    std::vector<int> found;
+    for (int i = 0; i < (int)tile_map_.size(); ++i) {
+        if (getTile(i) == Tile::SLOPE_R) {
+            found.push_back(i);
+        }
+    }
+
+    // El primer elemento es el inicio de una rampa. Se añade ese elemento y se buscan los siguientes,
+    // que seran i + mapWidth - 1. Conforme se añaden se eliminan y se vuelve a escudriñar el vector de
+    // tiles encontrados hasta que esté vacío
+
+    while (!found.empty()) {
+        LineDiagonal line;
+        line.x1 = ((found[0] % MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
+        line.y1 = (found[0] / MAP_WIDTH) * TILE_SIZE;
+        int looking_for = found[0] + MAP_WIDTH - 1;
+        int last_one_found = found[0];
+        found.erase(found.begin());
+        for (int i = 0; i < (int)found.size(); ++i) {
+            if (found[i] == looking_for) {
+                last_one_found = looking_for;
+                looking_for += MAP_WIDTH - 1;
+                found.erase(found.begin() + i);
+                i--;
+            }
+        }
+        line.x2 = (last_one_found % MAP_WIDTH) * TILE_SIZE;
+        line.y2 = ((last_one_found / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
+        right_slopes_.push_back(line);
+    }
+}
+
+// Calcula las superficies automaticas (conveyor belts)
+void CollisionMap::setAutoSurfaces() {
+    std::vector<int> tile = collectAnimatedTiles();
+    buildHorizontalLines(tile, conveyor_belt_floors_, false);
+}

source/game/gameplay/collision_map.hpp

@@ -0,0 +1,120 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <vector>  // Para vector
+
+#include "../../utils/utils.hpp"  // Para LineHorizontal, LineDiagonal, LineVertical
+
+/**
+ * @brief Mapa de colisiones de una habitación
+ *
+ * Responsabilidades:
+ * - Almacenar la geometría de colisión (superficies, rampas, conveyor belts)
+ * - Generar geometría a partir del tilemap
+ * - Proporcionar queries de colisión para Player y otras entidades
+ * - Determinar tipo de tile en posiciones específicas
+ */
+class CollisionMap {
+    public:
+        // Enumeración de tipos de tile (para colisiones)
+        enum class Tile {
+            EMPTY,
+            WALL,
+            PASSABLE,
+            SLOPE_L,
+            SLOPE_R,
+            KILL,
+            ANIMATED
+        };
+
+        /**
+         * @brief Constructor
+         * @param tile_map Vector con índices de tiles de la habitación
+         * @param tile_set_width Ancho del tileset en tiles (para calcular tipo de tile)
+         * @param conveyor_belt_direction Dirección de las cintas transportadoras (-1, 0, +1)
+         */
+        CollisionMap(std::vector<int> tile_map, int tile_set_width, int conveyor_belt_direction);
+        ~CollisionMap() = default;
+
+        // Prohibir copia y movimiento
+        CollisionMap(const CollisionMap&) = delete;
+        auto operator=(const CollisionMap&) -> CollisionMap& = delete;
+        CollisionMap(CollisionMap&&) = delete;
+        auto operator=(CollisionMap&&) -> CollisionMap& = delete;
+
+        // === Queries de tipo de tile ===
+        auto getTile(SDL_FPoint point) -> Tile;  // Devuelve el tipo de tile en un punto (pixel)
+        auto getTile(int index) -> Tile;         // Devuelve el tipo de tile en un índice del tilemap
+
+        // === Queries de colisión con superficies ===
+        auto checkRightSurfaces(SDL_FRect& rect) -> int;   // Colisión con paredes derechas (retorna X)
+        auto checkLeftSurfaces(SDL_FRect& rect) -> int;    // Colisión con paredes izquierdas (retorna X)
+        auto checkTopSurfaces(SDL_FRect& rect) -> int;     // Colisión con techos (retorna Y)
+        auto checkTopSurfaces(SDL_FPoint& p) -> bool;      // Colisión punto con techos
+        auto checkBottomSurfaces(SDL_FRect& rect) -> int;  // Colisión con suelos (retorna Y)
+
+        // === Queries de colisión con superficies automáticas (conveyor belts) ===
+        auto checkAutoSurfaces(SDL_FRect& rect) -> int;     // Colisión con conveyor belts (retorna Y)
+        auto checkConveyorBelts(SDL_FPoint& p) -> bool;     // Colisión punto con conveyor belts
+
+        // === Queries de colisión con rampas ===
+        auto checkLeftSlopes(const LineVertical& line) -> int;  // Colisión línea con rampas izquierdas (retorna Y)
+        auto checkLeftSlopes(SDL_FPoint& p) -> bool;            // Colisión punto con rampas izquierdas
+        auto checkRightSlopes(const LineVertical& line) -> int; // Colisión línea con rampas derechas (retorna Y)
+        auto checkRightSlopes(SDL_FPoint& p) -> bool;           // Colisión punto con rampas derechas
+
+        // === Métodos estáticos ===
+        static auto getTileSize() -> int { return TILE_SIZE; }                    // Tamaño del tile en pixels
+        static auto getSlopeHeight(SDL_FPoint p, Tile slope) -> int;              // Altura de rampa en un punto
+
+        // === Getters ===
+        [[nodiscard]] auto getConveyorBeltDirection() const -> int { return conveyor_belt_direction_; }
+
+        // Getters para debug visualization
+        [[nodiscard]] auto getBottomFloors() const -> const std::vector<LineHorizontal>& { return bottom_floors_; }
+        [[nodiscard]] auto getTopFloors() const -> const std::vector<LineHorizontal>& { return top_floors_; }
+        [[nodiscard]] auto getLeftWalls() const -> const std::vector<LineVertical>& { return left_walls_; }
+        [[nodiscard]] auto getRightWalls() const -> const std::vector<LineVertical>& { return right_walls_; }
+        [[nodiscard]] auto getLeftSlopes() const -> const std::vector<LineDiagonal>& { return left_slopes_; }
+        [[nodiscard]] auto getRightSlopes() const -> const std::vector<LineDiagonal>& { return right_slopes_; }
+        [[nodiscard]] auto getConveyorBeltFloors() const -> const std::vector<LineHorizontal>& { return conveyor_belt_floors_; }
+
+    private:
+        // === Constantes ===
+        static constexpr int TILE_SIZE = 8;   // Tamaño del tile en pixels
+        static constexpr int MAP_WIDTH = 32;  // Ancho del mapa en tiles
+        static constexpr int MAP_HEIGHT = 16; // Alto del mapa en tiles
+
+        // === Datos de la habitación ===
+        std::vector<int> tile_map_;          // Índices de tiles de la habitación
+        int tile_set_width_;                 // Ancho del tileset en tiles
+        int conveyor_belt_direction_;        // Dirección de conveyor belts
+
+        // === Geometría de colisión ===
+        std::vector<LineHorizontal> bottom_floors_;         // Superficies inferiores (suelos)
+        std::vector<LineHorizontal> top_floors_;            // Superficies superiores (techos)
+        std::vector<LineVertical> left_walls_;              // Paredes izquierdas
+        std::vector<LineVertical> right_walls_;             // Paredes derechas
+        std::vector<LineDiagonal> left_slopes_;             // Rampas que suben hacia la izquierda
+        std::vector<LineDiagonal> right_slopes_;            // Rampas que suben hacia la derecha
+        std::vector<LineHorizontal> conveyor_belt_floors_;  // Superficies automáticas (conveyor belts)
+
+        // === Métodos privados de generación de geometría ===
+        void initializeSurfaces();  // Inicializa todas las superficies de colisión
+
+        // Helpers para recopilar tiles
+        auto collectBottomTiles() -> std::vector<int>;    // Tiles con superficie inferior
+        auto collectTopTiles() -> std::vector<int>;       // Tiles con superficie superior
+        auto collectAnimatedTiles() -> std::vector<int>;  // Tiles animados (conveyor belts)
+
+        // Construcción de geometría
+        static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface);
+        void setBottomSurfaces();   // Calcula superficies inferiores
+        void setTopSurfaces();      // Calcula superficies superiores
+        void setLeftSurfaces();     // Calcula paredes izquierdas
+        void setRightSurfaces();    // Calcula paredes derechas
+        void setLeftSlopes();       // Calcula rampas izquierdas
+        void setRightSlopes();      // Calcula rampas derechas
+        void setAutoSurfaces();     // Calcula conveyor belts
+};

source/game/gameplay/room.cpp

@@ -14,6 +14,7 @@
 #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/collision_map.hpp"     // Para CollisionMap
 #include "game/gameplay/enemy_manager.hpp"     // Para EnemyManager
 #include "game/gameplay/item_manager.hpp"      // Para ItemManager
 #include "game/gameplay/item_tracker.hpp"      // Para ItemTracker
@@ -33,8 +34,10 @@ Room::Room(const std::string& room_path, std::shared_ptr<Scoreboard::Data> data)
 
     initializeRoom(*room);
 
+    // Crea el mapa de colisiones (necesita tile_map_, tile_set_width_, conveyor_belt_direction_)
+    collision_map_ = std::make_unique<CollisionMap>(tile_map_, tile_set_width_, conveyor_belt_direction_);
+
     openTheJail();                                                                // Abre la Jail si se da el caso
-    initRoomSurfaces();                                                           // Inicializa las superficies de colision
     setAnimatedTiles();                                                           // Busca los tiles animados
     map_surface_ = std::make_shared<Surface>(PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT);  // Crea la textura para el mapa de tiles de la habitación
     fillMapTexture();                                                             // Pinta el mapa de la habitación en la textura
@@ -86,6 +89,26 @@ void Room::initializeRoom(const Data& room) {
     }
 }
 
+// Abre la jail para poder entrar
+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 (!enemy_manager_->isEmpty()) {
+            enemy_manager_->removeLastEnemy();
+        }
+
+        // Abre las puertas
+        constexpr int TILE_A = 16 + (13 * 32);
+        constexpr int TILE_B = 16 + (14 * 32);
+        if (TILE_A < tile_map_.size()) {
+            tile_map_[TILE_A] = -1;
+        }
+        if (TILE_B < tile_map_.size()) {
+            tile_map_[TILE_B] = -1;
+        }
+    }
+}
+
 // Crea la textura con el mapeado de la habitación
 void Room::fillMapTexture() {
     const Uint8 COLOR = stringToColor(bg_color_);
@@ -119,49 +142,49 @@ void Room::fillMapTexture() {
 
         // BottomSurfaces
         {
-            for (auto l : bottom_floors_) {
+            for (auto l : collision_map_->getBottomFloors()) {
                 surface->drawLine(l.x1, l.y, l.x2, l.y, static_cast<Uint8>(PaletteColor::BLUE));
             }
         }
 
         // TopSurfaces
         {
-            for (auto l : top_floors_) {
+            for (auto l : collision_map_->getTopFloors()) {
                 surface->drawLine(l.x1, l.y, l.x2, l.y, static_cast<Uint8>(PaletteColor::RED));
             }
         }
 
         // LeftSurfaces
         {
-            for (auto l : left_walls_) {
+            for (auto l : collision_map_->getLeftWalls()) {
                 surface->drawLine(l.x, l.y1, l.x, l.y2, static_cast<Uint8>(PaletteColor::GREEN));
             }
         }
 
         // RightSurfaces
         {
-            for (auto l : right_walls_) {
+            for (auto l : collision_map_->getRightWalls()) {
                 surface->drawLine(l.x, l.y1, l.x, l.y2, static_cast<Uint8>(PaletteColor::MAGENTA));
             }
         }
 
         // LeftSlopes
         {
-            for (auto l : left_slopes_) {
+            for (auto l : collision_map_->getLeftSlopes()) {
                 surface->drawLine(l.x1, l.y1, l.x2, l.y2, static_cast<Uint8>(PaletteColor::CYAN));
             }
         }
 
         // RightSlopes
         {
-            for (auto l : right_slopes_) {
+            for (auto l : collision_map_->getRightSlopes()) {
                 surface->drawLine(l.x1, l.y1, l.x2, l.y2, static_cast<Uint8>(PaletteColor::YELLOW));
             }
         }
 
         // AutoSurfaces
         {
-            for (auto l : conveyor_belt_floors_) {
+            for (auto l : collision_map_->getConveyorBeltFloors()) {
                 surface->drawLine(l.x1, l.y, l.x2, l.y, static_cast<Uint8>(PaletteColor::WHITE));
             }
         }
@@ -223,396 +246,6 @@ void Room::setPaused(bool value) {
     item_manager_->setPaused(value);
 }
 
-// Devuelve la cadena del fichero de la habitación contigua segun el borde
-auto Room::getRoom(Border border) -> std::string {
-    switch (border) {
-        case Border::TOP:
-            return upper_room_;
-            break;
-
-        case Border::BOTTOM:
-            return lower_room_;
-            break;
-
-        case Border::RIGHT:
-            return right_room_;
-            break;
-
-        case Border::LEFT:
-            return left_room_;
-            break;
-
-        default:
-            break;
-    }
-    return "";
-}
-
-// Devuelve el tipo de tile que hay en ese pixel
-auto Room::getTile(SDL_FPoint point) -> Tile {
-    const int POS = ((point.y / TILE_SIZE) * MAP_WIDTH) + (point.x / TILE_SIZE);
-    return getTile(POS);
-}
-
-// Devuelve el tipo de tile que hay en ese indice
-auto Room::getTile(int index) -> Tile {
-    // const bool onRange = (index > -1) && (index < mapWidth * mapHeight);
-    const bool ON_RANGE = (index > -1) && (index < (int)tile_map_.size());
-
-    if (ON_RANGE) {
-        // Las filas 0-8 son de tiles t_wall
-        if ((tile_map_[index] >= 0) && (tile_map_[index] < 9 * tile_set_width_)) {
-            return Tile::WALL;
-        }
-
-        // Las filas 9-17 son de tiles t_passable
-        if ((tile_map_[index] >= 9 * tile_set_width_) && (tile_map_[index] < 18 * tile_set_width_)) {
-            return Tile::PASSABLE;
-        }
-
-        // Las filas 18-20 es de tiles t_animated
-        if ((tile_map_[index] >= 18 * tile_set_width_) && (tile_map_[index] < 21 * tile_set_width_)) {
-            return Tile::ANIMATED;
-        }
-
-        // La fila 21 es de tiles t_slope_r
-        if ((tile_map_[index] >= 21 * tile_set_width_) && (tile_map_[index] < 22 * tile_set_width_)) {
-            return Tile::SLOPE_R;
-        }
-
-        // La fila 22 es de tiles t_slope_l
-        if ((tile_map_[index] >= 22 * tile_set_width_) && (tile_map_[index] < 23 * tile_set_width_)) {
-            return Tile::SLOPE_L;
-        }
-
-        // La fila 23 es de tiles t_kill
-        if ((tile_map_[index] >= 23 * tile_set_width_) && (tile_map_[index] < 24 * tile_set_width_)) {
-            return Tile::KILL;
-        }
-    }
-
-    return Tile::EMPTY;
-}
-
-// Indica si hay colision con un enemigo a partir de un rectangulo
-auto Room::enemyCollision(SDL_FRect& rect) -> bool {
-    return enemy_manager_->checkCollision(rect);
-}
-
-// Indica si hay colision con un objeto a partir de un rectangulo
-auto Room::itemCollision(SDL_FRect& rect) -> bool {
-    return item_manager_->checkCollision(rect);
-}
-
-// Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
-auto Room::getSlopeHeight(SDL_FPoint p, Tile slope) -> int {
-    // Calcula la base del tile
-    int base = ((p.y / TILE_SIZE) * TILE_SIZE) + TILE_SIZE;
-#ifdef _DEBUG
-    Debug::get()->add("BASE = " + std::to_string(base));
-#endif
-
-    // Calcula cuanto se ha entrado en el tile horizontalmente
-    const int POS = (static_cast<int>(p.x) % TILE_SIZE);  // Esto da un valor entre 0 y 7
-#ifdef _DEBUG
-    Debug::get()->add("POS = " + std::to_string(POS));
-#endif
-
-    // Se resta a la base la cantidad de pixeles pos en funcion de la rampa
-    if (slope == Tile::SLOPE_R) {
-        base -= POS + 1;
-#ifdef _DEBUG
-        Debug::get()->add("BASE_R = " + std::to_string(base));
-#endif
-    } else {
-        base -= (TILE_SIZE - POS);
-#ifdef _DEBUG
-        Debug::get()->add("BASE_L = " + std::to_string(base));
-#endif
-    }
-
-    return base;
-}
-
-// Helper: recopila tiles inferiores (muros sin muro debajo)
-auto Room::collectBottomTiles() -> std::vector<int> {
-    std::vector<int> tile;
-
-    // Busca todos los tiles de tipo muro que no tengan debajo otro muro
-    // Hay que recorrer la habitación por filas (excepto los de la última fila)
-    for (int i = 0; i < (int)tile_map_.size() - MAP_WIDTH; ++i) {
-        if (getTile(i) == Tile::WALL && getTile(i + MAP_WIDTH) != Tile::WALL) {
-            tile.push_back(i);
-
-            // Si llega al final de la fila, introduce un separador
-            if (i % MAP_WIDTH == MAP_WIDTH - 1) {
-                tile.push_back(-1);
-            }
-        }
-    }
-
-    // Añade un terminador
-    tile.push_back(-1);
-    return tile;
-}
-
-// Helper: recopila tiles superiores (muros o pasables sin muro encima)
-auto Room::collectTopTiles() -> std::vector<int> {
-    std::vector<int> tile;
-
-    // Busca todos los tiles de tipo muro o pasable que no tengan encima un muro
-    // Hay que recorrer la habitación por filas (excepto los de la primera fila)
-    for (int i = MAP_WIDTH; i < (int)tile_map_.size(); ++i) {
-        if ((getTile(i) == Tile::WALL || getTile(i) == Tile::PASSABLE) && getTile(i - MAP_WIDTH) != Tile::WALL) {
-            tile.push_back(i);
-
-            // Si llega al final de la fila, introduce un separador
-            if (i % MAP_WIDTH == MAP_WIDTH - 1) {
-                tile.push_back(-1);
-            }
-        }
-    }
-
-    // Añade un terminador
-    tile.push_back(-1);
-    return tile;
-}
-
-// Helper: construye lineas horizontales a partir de tiles consecutivos
-void Room::buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface) {
-    if (tiles.size() <= 1) {
-        return;
-    }
-
-    int i = 0;
-    while (i < (int)tiles.size() - 1) {
-        LineHorizontal line;
-        line.x1 = (tiles[i] % MAP_WIDTH) * TILE_SIZE;
-
-        // Calcula Y segun si es superficie inferior o superior
-        if (is_bottom_surface) {
-            line.y = ((tiles[i] / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
-        } else {
-            line.y = (tiles[i] / MAP_WIDTH) * TILE_SIZE;
-        }
-
-        int last_one = i;
-        i++;
-
-        // Encuentra tiles consecutivos
-        if (i < (int)tiles.size()) {
-            while (tiles[i] == tiles[i - 1] + 1) {
-                last_one = i;
-                i++;
-                if (i >= (int)tiles.size()) {
-                    break;
-                }
-            }
-        }
-
-        line.x2 = ((tiles[last_one] % MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
-        lines.push_back(line);
-
-        // Salta separadores
-        if (i < (int)tiles.size() && tiles[i] == -1) {
-            i++;
-        }
-    }
-}
-
-// Calcula las superficies inferiores
-void Room::setBottomSurfaces() {
-    std::vector<int> tile = collectBottomTiles();
-    buildHorizontalLines(tile, bottom_floors_, true);
-}
-
-// Calcula las superficies superiores
-void Room::setTopSurfaces() {
-    std::vector<int> tile = collectTopTiles();
-    buildHorizontalLines(tile, top_floors_, false);
-}
-
-// Calcula las superficies laterales izquierdas
-void Room::setLeftSurfaces() {
-    std::vector<int> tile;
-
-    // Busca todos los tiles de tipo muro que no tienen a su izquierda un tile de tipo muro
-    // Hay que recorrer la habitación por columnas (excepto los de la primera columna)
-    for (int i = 1; i < MAP_WIDTH; ++i) {
-        for (int j = 0; j < MAP_HEIGHT; ++j) {
-            const int POS = ((j * MAP_WIDTH) + i);
-            if (getTile(POS) == Tile::WALL && getTile(POS - 1) != Tile::WALL) {
-                tile.push_back(POS);
-            }
-        }
-    }
-
-    // Añade un terminador
-    tile.push_back(-1);
-
-    // Recorre el vector de tiles buscando tiles consecutivos
-    // (Los tiles de la misma columna, la diferencia entre ellos es de mapWidth)
-    // para localizar las superficies
-    if ((int)tile.size() > 1) {
-        int i = 0;
-        do {
-            LineVertical line;
-            line.x = (tile[i] % MAP_WIDTH) * TILE_SIZE;
-            line.y1 = ((tile[i] / MAP_WIDTH) * TILE_SIZE);
-            while (tile[i] + MAP_WIDTH == tile[i + 1]) {
-                if (i == (int)tile.size() - 1) {
-                    break;
-                }
-                i++;
-            }
-            line.y2 = ((tile[i] / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
-            left_walls_.push_back(line);
-            i++;
-        } while (i < (int)tile.size() - 1);
-    }
-}
-
-// Calcula las superficies laterales derechas
-void Room::setRightSurfaces() {
-    std::vector<int> tile;
-
-    // Busca todos los tiles de tipo muro que no tienen a su derecha un tile de tipo muro
-    // Hay que recorrer la habitación por columnas (excepto los de la última columna)
-    for (int i = 0; i < MAP_WIDTH - 1; ++i) {
-        for (int j = 0; j < MAP_HEIGHT; ++j) {
-            const int POS = ((j * MAP_WIDTH) + i);
-            if (getTile(POS) == Tile::WALL && getTile(POS + 1) != Tile::WALL) {
-                tile.push_back(POS);
-            }
-        }
-    }
-
-    // Añade un terminador
-    tile.push_back(-1);
-
-    // Recorre el vector de tiles buscando tiles consecutivos
-    // (Los tiles de la misma columna, la diferencia entre ellos es de mapWidth)
-    // para localizar las superficies
-    if ((int)tile.size() > 1) {
-        int i = 0;
-        do {
-            LineVertical line;
-            line.x = ((tile[i] % MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
-            line.y1 = ((tile[i] / MAP_WIDTH) * TILE_SIZE);
-            while (tile[i] + MAP_WIDTH == tile[i + 1]) {
-                if (i == (int)tile.size() - 1) {
-                    break;
-                }
-                i++;
-            }
-            line.y2 = ((tile[i] / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
-            right_walls_.push_back(line);
-            i++;
-        } while (i < (int)tile.size() - 1);
-    }
-}
-
-// Encuentra todas las rampas que suben hacia la izquierda
-void Room::setLeftSlopes() {
-    // Recorre la habitación entera por filas buscando tiles de tipo t_slope_l
-    std::vector<int> found;
-    for (int i = 0; i < (int)tile_map_.size(); ++i) {
-        if (getTile(i) == Tile::SLOPE_L) {
-            found.push_back(i);
-        }
-    }
-
-    // El primer elemento es el inicio de una rampa. Se añade ese elemento y se buscan los siguientes,
-    // que seran i + mapWidth + 1. Conforme se añaden se eliminan y se vuelve a escudriñar el vector de
-    // tiles encontrados hasta que esté vacío
-
-    while (!found.empty()) {
-        LineDiagonal line;
-        line.x1 = (found[0] % MAP_WIDTH) * TILE_SIZE;
-        line.y1 = (found[0] / MAP_WIDTH) * TILE_SIZE;
-        int looking_for = found[0] + MAP_WIDTH + 1;
-        int last_one_found = found[0];
-        found.erase(found.begin());
-        for (int i = 0; i < (int)found.size(); ++i) {
-            if (found[i] == looking_for) {
-                last_one_found = looking_for;
-                looking_for += MAP_WIDTH + 1;
-                found.erase(found.begin() + i);
-                i--;
-            }
-        }
-        line.x2 = ((last_one_found % MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
-        line.y2 = ((last_one_found / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
-        left_slopes_.push_back(line);
-    }
-}
-
-// Encuentra todas las rampas que suben hacia la derecha
-void Room::setRightSlopes() {
-    // Recorre la habitación entera por filas buscando tiles de tipo t_slope_r
-    std::vector<int> found;
-    for (int i = 0; i < (int)tile_map_.size(); ++i) {
-        if (getTile(i) == Tile::SLOPE_R) {
-            found.push_back(i);
-        }
-    }
-
-    // El primer elemento es el inicio de una rampa. Se añade ese elemento y se buscan los siguientes,
-    // que seran i + mapWidth - 1. Conforme se añaden se eliminan y se vuelve a escudriñar el vector de
-    // tiles encontrados hasta que esté vacío
-
-    while (!found.empty()) {
-        LineDiagonal line;
-        line.x1 = ((found[0] % MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
-        line.y1 = (found[0] / MAP_WIDTH) * TILE_SIZE;
-        int looking_for = found[0] + MAP_WIDTH - 1;
-        int last_one_found = found[0];
-        found.erase(found.begin());
-        for (int i = 0; i < (int)found.size(); ++i) {
-            if (found[i] == looking_for) {
-                last_one_found = looking_for;
-                looking_for += MAP_WIDTH - 1;
-                found.erase(found.begin() + i);
-                i--;
-            }
-        }
-        line.x2 = (last_one_found % MAP_WIDTH) * TILE_SIZE;
-        line.y2 = ((last_one_found / MAP_WIDTH) * TILE_SIZE) + TILE_SIZE - 1;
-        right_slopes_.push_back(line);
-    }
-}
-
-// Calcula las superficies automaticas
-// Helper: recopila tiles animados (para superficies automaticas/conveyor belts)
-auto Room::collectAnimatedTiles() -> std::vector<int> {
-    std::vector<int> tile;
-
-    // Busca todos los tiles de tipo animado
-    // Hay que recorrer la habitación por filas (excepto los de la primera fila)
-    for (int i = MAP_WIDTH; i < (int)tile_map_.size(); ++i) {
-        if (getTile(i) == Tile::ANIMATED) {
-            tile.push_back(i);
-
-            // Si llega al final de la fila, introduce un separador
-            if (i % MAP_WIDTH == MAP_WIDTH - 1) {
-                tile.push_back(-1);
-            }
-        }
-    }
-
-    // Añade un terminador si hay tiles
-    if (!tile.empty()) {
-        tile.push_back(-1);
-    }
-
-    return tile;
-}
-
-void Room::setAutoSurfaces() {
-    std::vector<int> tile = collectAnimatedTiles();
-    buildHorizontalLines(tile, conveyor_belt_floors_, false);
-}
-
 // Localiza todos los tiles animados de la habitación
 void Room::setAnimatedTiles() {
     // Recorre la habitación entera por filas buscando tiles de tipo t_animated
@@ -664,141 +297,119 @@ void Room::renderAnimatedTiles() {
     }
 }
 
-// Comprueba las colisiones
+// Devuelve la cadena del fichero de la habitación contigua segun el borde
+auto Room::getRoom(Border border) -> std::string {
+    switch (border) {
+        case Border::TOP:
+            return upper_room_;
+            break;
+
+        case Border::BOTTOM:
+            return lower_room_;
+            break;
+
+        case Border::RIGHT:
+            return right_room_;
+            break;
+
+        case Border::LEFT:
+            return left_room_;
+            break;
+
+        default:
+            break;
+    }
+    return "";
+}
+
+// Devuelve el tipo de tile que hay en ese pixel
+auto Room::getTile(SDL_FPoint point) -> Tile {
+    // Delega a CollisionMap y convierte el resultado
+    const auto collision_tile = collision_map_->getTile(point);
+    return static_cast<Tile>(collision_tile);
+}
+
+// Devuelve el tipo de tile en un índice del tilemap
+auto Room::getTile(int index) -> Tile {
+    // Delega a CollisionMap y convierte el resultado
+    const auto collision_tile = collision_map_->getTile(index);
+    return static_cast<Tile>(collision_tile);
+}
+
+// Indica si hay colision con un enemigo a partir de un rectangulo
+auto Room::enemyCollision(SDL_FRect& rect) -> bool {
+    return enemy_manager_->checkCollision(rect);
+}
+
+// Indica si hay colision con un objeto a partir de un rectangulo
+auto Room::itemCollision(SDL_FRect& rect) -> bool {
+    return item_manager_->checkCollision(rect);
+}
+
+// Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
+auto Room::getSlopeHeight(SDL_FPoint p, Tile slope) -> int {
+    // Delega a CollisionMap (método estático)
+    const auto collision_tile = static_cast<CollisionMap::Tile>(slope);
+    return CollisionMap::getSlopeHeight(p, collision_tile);
+}
+
+// === Métodos de colisión (delegados a CollisionMap) ===
+
+// Comprueba las colisiones con paredes derechas
 auto Room::checkRightSurfaces(SDL_FRect& rect) -> int {
-    for (const auto& s : right_walls_) {
+    return collision_map_->checkRightSurfaces(rect);
-        if (checkCollision(s, rect)) {
-            return s.x;
-        }
-    }
-
-    return Collision::NONE;
 }
 
-// Comprueba las colisiones
+// Comprueba las colisiones con paredes izquierdas
 auto Room::checkLeftSurfaces(SDL_FRect& rect) -> int {
-    for (const auto& s : left_walls_) {
+    return collision_map_->checkLeftSurfaces(rect);
-        if (checkCollision(s, rect)) {
-            return s.x;
-        }
-    }
-
-    return Collision::NONE;
 }
 
-// Comprueba las colisiones
+// Comprueba las colisiones con techos
 auto Room::checkTopSurfaces(SDL_FRect& rect) -> int {
-    for (const auto& s : top_floors_) {
+    return collision_map_->checkTopSurfaces(rect);
-        if (checkCollision(s, rect)) {
-            return s.y;
-        }
-    }
-
-    return Collision::NONE;
 }
 
-// Comprueba las colisiones
+// Comprueba las colisiones punto con techos
-auto Room::checkBottomSurfaces(SDL_FRect& rect) -> int {
-    for (const auto& s : bottom_floors_) {
-        if (checkCollision(s, rect)) {
-            return s.y;
-        }
-    }
-
-    return Collision::NONE;
-}
-
-// Comprueba las colisiones
-auto Room::checkAutoSurfaces(SDL_FRect& rect) -> int {
-    for (const auto& s : conveyor_belt_floors_) {
-        if (checkCollision(s, rect)) {
-            return s.y;
-        }
-    }
-
-    return Collision::NONE;
-}
-
-// Comprueba las colisiones
 auto Room::checkTopSurfaces(SDL_FPoint& p) -> bool {
-    return std::ranges::any_of(top_floors_, [&](const auto& s) {
+    return collision_map_->checkTopSurfaces(p);
-        return checkCollision(s, p);
-    });
 }
 
-// Comprueba las colisiones
+// Comprueba las colisiones con suelos
+auto Room::checkBottomSurfaces(SDL_FRect& rect) -> int {
+    return collision_map_->checkBottomSurfaces(rect);
+}
+
+// Comprueba las colisiones con conveyor belts
+auto Room::checkAutoSurfaces(SDL_FRect& rect) -> int {
+    return collision_map_->checkAutoSurfaces(rect);
+}
+
+// Comprueba las colisiones punto con conveyor belts
 auto Room::checkConveyorBelts(SDL_FPoint& p) -> bool {
-    return std::ranges::any_of(conveyor_belt_floors_, [&](const auto& s) {
+    return collision_map_->checkConveyorBelts(p);
-        return checkCollision(s, p);
-    });
 }
 
-// Comprueba las colisiones
+// Comprueba las colisiones línea con rampas izquierdas
 auto Room::checkLeftSlopes(const LineVertical& line) -> int {
-    for (const auto& slope : left_slopes_) {
+    return collision_map_->checkLeftSlopes(line);
-        const auto P = checkCollision(slope, line);
-        if (P.x != -1) {
-            return P.y;
-        }
-    }
-
-    return Collision::NONE;
 }
 
-// Comprueba las colisiones
+// Comprueba las colisiones punto con rampas izquierdas
 auto Room::checkLeftSlopes(SDL_FPoint& p) -> bool {
-    return std::ranges::any_of(left_slopes_, [&](const auto& slope) {
+    return collision_map_->checkLeftSlopes(p);
-        return checkCollision(p, slope);
-    });
 }
 
-// Comprueba las colisiones
+// Comprueba las colisiones línea con rampas derechas
 auto Room::checkRightSlopes(const LineVertical& line) -> int {
-    for (const auto& slope : right_slopes_) {
+    return collision_map_->checkRightSlopes(line);
-        const auto P = checkCollision(slope, line);
-        if (P.x != -1) {
-            return P.y;
-        }
-    }
-
-    return Collision::NONE;
 }
 
-// Comprueba las colisiones
+// Comprueba las colisiones punto con rampas derechas
 auto Room::checkRightSlopes(SDL_FPoint& p) -> bool {
-    return std::ranges::any_of(right_slopes_, [&](const auto& slope) {
+    return collision_map_->checkRightSlopes(p);
-        return checkCollision(p, slope);
-    });
 }
 
-// Abre la Jail si se da el caso
-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)
-        enemy_manager_->removeLastEnemy();
-
-        // Abre las puertas
-        constexpr int TILE_A = 16 + (13 * 32);
-        constexpr int TILE_B = 16 + (14 * 32);
-        if (TILE_A < tile_map_.size()) {
-            tile_map_[TILE_A] = -1;
-        }
-        if (TILE_B < tile_map_.size()) {
-            tile_map_[TILE_B] = -1;
-        }
-    }
-}
-
-// Inicializa las superficies de colision
-void Room::initRoomSurfaces() {
-    setBottomSurfaces();
-    setTopSurfaces();
-    setLeftSurfaces();
-    setRightSurfaces();
-    setLeftSlopes();
-    setRightSlopes();
-    setAutoSurfaces();
-}
 
 // Asigna variables a una estructura RoomData
 auto Room::setRoom(Data& room, const std::string& key, const std::string& value) -> bool {

source/game/gameplay/room.hpp

@@ -14,6 +14,7 @@ class SurfaceSprite;                   // lines 12-12
 class Surface;                         // lines 13-13
 class EnemyManager;
 class ItemManager;
+class CollisionMap;
 
 class Room {
     public:
@@ -68,6 +69,7 @@ class Room {
         void update(float delta_time);                                                                         // Actualiza las variables y objetos de la habitación
         auto getRoom(Border border) -> std::string;                                                            // Devuelve la cadena del fichero de la habitación contigua segun el borde
         auto getTile(SDL_FPoint point) -> Tile;                                                                // Devuelve el tipo de tile que hay en ese pixel
+        auto getTile(int index) -> Tile;                                                                       // Devuelve el tipo de tile en un índice del tilemap
         auto enemyCollision(SDL_FRect& rect) -> bool;                                                          // Indica si hay colision con un enemigo a partir de un rectangulo
         auto itemCollision(SDL_FRect& rect) -> bool;                                                           // Indica si hay colision con un objeto a partir de un rectangulo
         static auto getTileSize() -> int { return TILE_SIZE; }                                                 // Obten el tamaño del tile
@@ -102,11 +104,12 @@ 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::unique_ptr<EnemyManager> enemy_manager_;  // Gestor de enemigos de 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::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::unique_ptr<CollisionMap> collision_map_;    // Mapa de colisiones de la habitación
-        std::shared_ptr<Surface> map_surface_;         // Textura para dibujar el mapa de la habitación
+        std::shared_ptr<Surface> surface_;               // Textura con los graficos de la habitación
-        std::shared_ptr<Scoreboard::Data> data_;       // Puntero a los datos del marcador
+        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
 
         // --- Variables ---
         std::string number_;                                // Numero de la habitación
@@ -121,40 +124,20 @@ class Room {
         std::string right_room_;                            // Identificador de la habitación que se encuentra a la derecha
         std::string tile_set_file_;                         // Imagen con los graficos para la habitación
         std::string tile_map_file_;                         // Fichero con el mapa de indices de tile
-        std::vector<int> tile_map_;                         // Indice de los tiles a dibujar en la habitación
+        std::vector<int> tile_map_;                  // Indice de los tiles a dibujar en la habitación
-        int conveyor_belt_direction_{0};                    // Sentido en el que arrastran las superficies automáticas de la habitación
+        int conveyor_belt_direction_{0};             // Sentido en el que arrastran las superficies automáticas de la habitación
-        std::vector<LineHorizontal> bottom_floors_;         // Lista con las superficies inferiores de la habitación
+        float time_accumulator_{0.0F};               // Acumulador de tiempo para animaciones (time-based)
-        std::vector<LineHorizontal> top_floors_;            // Lista con las superficies superiores de la habitación
+        bool is_paused_{false};                      // Indica si el mapa esta en modo pausa
-        std::vector<LineVertical> left_walls_;              // Lista con las superficies laterales de la parte izquierda de la habitación
+        std::vector<AnimatedTile> animated_tiles_;   // Vector con los indices de tiles animados
-        std::vector<LineVertical> right_walls_;             // Lista con las superficies laterales de la parte derecha de la habitación
+        int tile_set_width_{0};                      // Ancho del tileset en tiles
-        std::vector<LineDiagonal> left_slopes_;             // Lista con todas las rampas que suben hacia la izquierda
-        std::vector<LineDiagonal> right_slopes_;            // Lista con todas las rampas que suben hacia la derecha
-        float time_accumulator_{0.0F};                      // Acumulador de tiempo para animaciones (time-based)
-        bool is_paused_{false};                             // Indica si el mapa esta en modo pausa
-        std::vector<AnimatedTile> animated_tiles_;          // Vector con los indices de tiles animados
-        std::vector<LineHorizontal> conveyor_belt_floors_;  // Lista con las superficies automaticas de la habitación
-        int tile_set_width_{0};                             // Ancho del tileset en tiles
 
         // --- Funciones ---
-        void initializeRoom(const Data& room);                                                                                        // Inicializa los valores
+        void initializeRoom(const Data& room);  // Inicializa los valores
-        void fillMapTexture();                                                                                                        // Pinta el mapa de la habitación en la textura
+        void fillMapTexture();                  // Pinta el mapa de la habitación en la textura
-        auto collectBottomTiles() -> std::vector<int>;                                                                                // Helper para recopilar tiles inferiores
+        void setAnimatedTiles();                // Localiza todos los tiles animados de la habitación
-        auto collectTopTiles() -> std::vector<int>;                                                                                   // Helper para recopilar tiles superiores
+        void updateAnimatedTiles();             // Actualiza los tiles animados
-        auto collectAnimatedTiles() -> std::vector<int>;                                                                              // Helper para recopilar tiles animados (para superficies automaticas)
+        void renderAnimatedTiles();             // Pinta los tiles animados en pantalla
-        static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface);  // Helper para construir lineas horizontales a partir de tiles consecutivos
+        void openTheJail();                     // Abre la jail para poder entrar
-        void setBottomSurfaces();                                                                                                     // Calcula las superficies inferiores
-        void setTopSurfaces();                                                                                                        // Calcula las superficies superiores
-        void setLeftSurfaces();                                                                                                       // Calcula las superficies laterales izquierdas
-        void setRightSurfaces();                                                                                                      // Calcula las superficies laterales derechas
-        void setLeftSlopes();                                                                                                         // Encuentra todas las rampas que suben hacia la izquierda
-        void setRightSlopes();                                                                                                        // Encuentra todas las rampas que suben hacia la derecha
-        void setAutoSurfaces();                                                                                                       // Calcula las superficies automaticas
-        void setAnimatedTiles();                                                                                                      // Localiza todos los tiles animados de la habitación
-        void updateAnimatedTiles();                                                                                                   // Actualiza los tiles animados
-        void renderAnimatedTiles();                                                                                                   // Pinta los tiles animados en pantalla
-        auto getTile(int index) -> Tile;                                                                                              // Devuelve el tipo de tile que hay en ese indice
-        void openTheJail();                                                                                                           // Abre la jail para poder entrar
-        void initRoomSurfaces();                                                                                                      // Inicializa las superficies de colision
         static auto setRoom(Data& room, const std::string& key, const std::string& value) -> bool;                                    // Asigna variables a una estructura RoomData
         static auto setEnemy(Enemy::Data& enemy, const std::string& key, const std::string& value) -> bool;                           // Asigna variables a una estructura EnemyData
         static auto setItem(Item::Data& item, const std::string& key, const std::string& value) -> bool;                              // Asigna variables a una estructura ItemData