collision tile

source/game/gameplay/collision_map.cpp

@@ -10,7 +10,8 @@
 // Constructor
 CollisionMap::CollisionMap(std::vector<int> collision_tile_map, int conveyor_belt_direction)
     : collision_tile_map_(std::move(collision_tile_map)),
-      conveyor_belt_direction_(conveyor_belt_direction) {
+      conveyor_belt_direction_(conveyor_belt_direction),
+      tile_collider_(collision_tile_map_) {
     // Inicializa todas las superficies de colisión
     initializeSurfaces();
 }
@@ -41,13 +42,20 @@ auto CollisionMap::getTile(int index) const -> Tile {
     }
 
     switch (collision_tile_map_[index]) {
-        case 1: return Tile::WALL;
-        case 2: return Tile::PASSABLE;
-        case 3: return Tile::SLOPE_L;
-        case 4: return Tile::SLOPE_R;
-        case 5: return Tile::KILL;
-        case 6: return Tile::ANIMATED;
-        default: return Tile::EMPTY;
+        case 1:
+            return Tile::WALL;
+        case 2:
+            return Tile::PASSABLE;
+        case 3:
+            return Tile::SLOPE_L;
+        case 4:
+            return Tile::SLOPE_R;
+        case 5:
+            return Tile::KILL;
+        case 6:
+            return Tile::ANIMATED;
+        default:
+            return Tile::EMPTY;
     }
 }
 

source/game/gameplay/collision_map.hpp

@@ -4,8 +4,9 @@
 
 #include <vector>  // Para vector
 
-#include "utils/defines.hpp"  // Para Tile::SIZE, Map::WIDTH, Map::HEIGHT
-#include "utils/utils.hpp"    // Para LineHorizontal, LineDiagonal, LineVertical
+#include "game/gameplay/tile_collider.hpp"  // Para TileCollider
+#include "utils/defines.hpp"                // Para Tile::SIZE, Map::WIDTH, Map::HEIGHT
+#include "utils/utils.hpp"                  // Para LineHorizontal, LineDiagonal, LineVertical
 
 /**
  * @brief Mapa de colisiones de una habitación
@@ -71,6 +72,7 @@ class CollisionMap {
 
     // --- Getters ---
     [[nodiscard]] auto getConveyorBeltDirection() const -> int { return conveyor_belt_direction_; }
+    [[nodiscard]] auto getTileCollider() const -> const TileCollider& { return tile_collider_; }
 
     // Getters para debug visualization
     [[nodiscard]] auto getBottomFloors() const -> const std::vector<LineHorizontal>& { return bottom_floors_; }
@@ -90,6 +92,7 @@ class CollisionMap {
     // --- Datos de la habitación ---
     std::vector<int> collision_tile_map_;  // Mapa de colisiones por tile
     int conveyor_belt_direction_;          // Dirección de conveyor belts
+    TileCollider tile_collider_;           // Sistema de colisión por tiles
 
     // --- Geometría de colisión ---
     std::vector<LineHorizontal> bottom_floors_;         // Superficies inferiores (suelos)

source/game/gameplay/room.cpp

@@ -161,6 +161,10 @@ void Room::setPaused(bool value) {
     item_manager_->setPaused(value);
 }
 
+auto Room::getTileCollider() const -> const TileCollider& {
+    return collision_map_->getTileCollider();
+}
+
 // Devuelve la cadena del fichero de la habitación contigua segun el borde
 auto Room::getRoom(Border border) -> std::string {  // NOLINT(readability-convert-member-functions-to-static)
     switch (border) {

source/game/gameplay/room.hpp

@@ -16,6 +16,7 @@ class Surface;                           // lines 13-13
 class EnemyManager;
 class ItemManager;
 class CollisionMap;
+class TileCollider;
 class TilemapRenderer;
 
 class Room {
@@ -102,6 +103,7 @@ class Room {
     [[nodiscard]] auto getSlopeAtPoint(const SDL_FPoint& p) const -> const LineDiagonal*;            // Obtiene puntero a slope en un punto
     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
+    [[nodiscard]] auto getTileCollider() const -> const TileCollider&;
 
     // Método de carga de archivos YAML (delegado a RoomLoader)
     static auto loadYAML(const std::string& file_path, bool verbose = false) -> Data;  // Carga habitación desde archivo YAML unificado

source/game/gameplay/tile_collider.cpp

@@ -0,0 +1,182 @@
+#include "game/gameplay/tile_collider.hpp"
+
+#include <algorithm>  // Para std::min, std::max
+#include <cmath>      // Para std::ceil
+
+#include "utils/defines.hpp"
+
+TileCollider::TileCollider(const std::vector<int>& collision_tile_map)
+    : tile_map_(collision_tile_map) {}
+
+// --- Queries básicas ---
+
+auto TileCollider::getTileAt(int tile_x, int tile_y) const -> Tile {
+    if (tile_x < 0 || tile_x >= MW || tile_y < 0 || tile_y >= MH) {
+        return Tile::EMPTY;
+    }
+    int value = tile_map_[tile_y * MW + tile_x];
+    if (value >= 0 && value <= 4) {
+        return static_cast<Tile>(value);
+    }
+    return Tile::EMPTY;
+}
+
+auto TileCollider::isSolid(int tile_x, int tile_y) const -> bool {
+    return getTileAt(tile_x, tile_y) == Tile::WALL;
+}
+
+auto TileCollider::getSlopeY(int tile_x, int tile_y, float px) const -> float {
+    float tile_bottom = static_cast<float>((tile_y + 1) * TS - 1);
+    float x_in_tile = px - static_cast<float>(tile_x * TS);
+    x_in_tile = std::clamp(x_in_tile, 0.0F, static_cast<float>(TS - 1));
+
+    auto tile = getTileAt(tile_x, tile_y);
+    if (tile == Tile::SLOPE_L) {
+        // \ descendente de izquierda a derecha
+        return tile_bottom - (static_cast<float>(TS - 1) - x_in_tile);
+    }
+    if (tile == Tile::SLOPE_R) {
+        // / descendente de derecha a izquierda
+        return tile_bottom - x_in_tile;
+    }
+    return tile_bottom;
+}
+
+// --- Colisión con paredes ---
+
+auto TileCollider::checkWallLeft(float x, float y, float w, float h) const -> float {
+    (void)w;
+    int col = toTile(static_cast<int>(x) - 1);
+    int top_row = toTile(static_cast<int>(y));
+    int bot_row = toTile(static_cast<int>(y + h - 2));
+
+    for (int row = top_row; row <= bot_row; ++row) {
+        if (isSolid(col, row)) {
+            return static_cast<float>((col + 1) * TS);
+        }
+    }
+    return Collision::NONE;
+}
+
+auto TileCollider::checkWallRight(float x, float y, float w, float h) const -> float {
+    int col = toTile(static_cast<int>(x + w));
+    int top_row = toTile(static_cast<int>(y));
+    int bot_row = toTile(static_cast<int>(y + h - 2));
+
+    for (int row = top_row; row <= bot_row; ++row) {
+        if (isSolid(col, row)) {
+            return static_cast<float>(col * TS);
+        }
+    }
+    return Collision::NONE;
+}
+
+// --- Colisión con techo ---
+
+auto TileCollider::checkCeiling(float x, float y, float w) const -> float {
+    int top_row = toTile(static_cast<int>(y));
+    int left_col = toTile(static_cast<int>(x));
+    int right_col = toTile(static_cast<int>(x + w - 1));
+
+    for (int col = left_col; col <= right_col; ++col) {
+        if (isSolid(col, top_row)) {
+            return static_cast<float>((top_row + 1) * TS);
+        }
+    }
+    return Collision::NONE;
+}
+
+// --- Colisión con suelo (landing) ---
+
+auto TileCollider::checkFloor(float x, float foot_y_current, float w, float foot_y_new) const -> FloorHit {
+    int start_row = toTile(static_cast<int>(foot_y_current));
+    int end_row = toTile(static_cast<int>(foot_y_new));
+    int left_col = toTile(static_cast<int>(x));
+    int right_col = toTile(static_cast<int>(x + w - 1));
+
+    FloorHit best;
+
+    for (int row = start_row; row <= end_row; ++row) {
+        for (int col = left_col; col <= right_col; ++col) {
+            auto tile = getTileAt(col, row);
+            float floor_y = Collision::NONE;
+
+            if (tile == Tile::WALL) {
+                floor_y = static_cast<float>(row * TS);
+            } else if (tile == Tile::PASSABLE) {
+                float tile_top = static_cast<float>(row * TS);
+                // Solo cuenta como suelo si los pies estaban por encima antes del movimiento
+                if (foot_y_current <= tile_top) {
+                    floor_y = tile_top;
+                }
+            } else if (tile == Tile::SLOPE_L || tile == Tile::SLOPE_R) {
+                float check_x = (tile == Tile::SLOPE_L) ? x : x + w - 1;
+                float slope_y = getSlopeY(col, row, check_x);
+                if (foot_y_new >= slope_y && foot_y_current <= slope_y + TS) {
+                    floor_y = slope_y;
+                }
+            }
+
+            if (floor_y != Collision::NONE && (best.y == Collision::NONE || floor_y < best.y)) {
+                best = {floor_y, tile, col, row};
+            }
+        }
+    }
+
+    return best;
+}
+
+// --- Detección de suelo debajo ---
+
+auto TileCollider::hasGroundBelow(float x, float foot_y, float w) const -> bool {
+    int row = toTile(static_cast<int>(foot_y));
+    int left_col = toTile(static_cast<int>(x));
+    int right_col = toTile(static_cast<int>(x + w - 1));
+
+    for (int col = left_col; col <= right_col; ++col) {
+        auto tile = getTileAt(col, row);
+        if (tile == Tile::WALL || tile == Tile::PASSABLE) {
+            return true;
+        }
+        if (tile == Tile::SLOPE_L || tile == Tile::SLOPE_R) {
+            float check_x = (tile == Tile::SLOPE_L) ? x : x + w - 1;
+            float slope_y = getSlopeY(col, row, check_x);
+            if (slope_y <= foot_y + 1) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+// --- Detección de slope debajo (transición ground→slope) ---
+
+auto TileCollider::checkSlopeBelow(float x, float foot_y, float w) const -> SlopeInfo {
+    int foot_row = toTile(static_cast<int>(foot_y));
+    int left_col = toTile(static_cast<int>(x));
+    int right_col = toTile(static_cast<int>(x + w - 1));
+
+    // Comprobar la fila de los pies Y la fila de arriba
+    // (la slope entry puede estar un tile arriba del nivel de la plataforma)
+    for (int row = foot_row - 1; row <= foot_row; ++row) {
+        for (int col = left_col; col <= right_col; ++col) {
+            auto tile = getTileAt(col, row);
+            if (tile == Tile::SLOPE_L) {
+                float foot_x = (col == left_col) ? x : x + w - 1;
+                float slope_y = getSlopeY(col, row, foot_x);
+                if (slope_y <= foot_y && slope_y >= foot_y - TS) {
+                    return {true, Tile::SLOPE_L, col, row, slope_y};
+                }
+            }
+            if (tile == Tile::SLOPE_R) {
+                float foot_x = (col == right_col) ? x + w - 1 : x;
+                float slope_y = getSlopeY(col, row, foot_x);
+                if (slope_y <= foot_y && slope_y >= foot_y - TS) {
+                    return {true, Tile::SLOPE_R, col, row, slope_y};
+                }
+            }
+        }
+    }
+
+    return {};
+}

source/game/gameplay/tile_collider.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <vector>
+
+#include "utils/defines.hpp"
+
+class TileCollider {
+   public:
+    enum class Tile : int {
+        EMPTY = 0,
+        WALL = 1,
+        PASSABLE = 2,
+        SLOPE_L = 3,
+        SLOPE_R = 4
+    };
+
+    struct FloorHit {
+        float y{-1};
+        Tile type{Tile::EMPTY};
+        int tile_x{0};
+        int tile_y{0};
+    };
+
+    struct SlopeInfo {
+        bool on_slope{false};
+        Tile type{Tile::EMPTY};
+        int tile_x{0};
+        int tile_y{0};
+        float surface_y{0};
+    };
+
+    explicit TileCollider(const std::vector<int>& collision_tile_map);
+
+    // Queries básicas
+    [[nodiscard]] auto getTileAt(int tile_x, int tile_y) const -> Tile;
+    [[nodiscard]] auto isSolid(int tile_x, int tile_y) const -> bool;
+    [[nodiscard]] auto getSlopeY(int tile_x, int tile_y, float px) const -> float;
+
+    // Colisión para el Player
+    [[nodiscard]] auto checkWallLeft(float x, float y, float w, float h) const -> float;
+    [[nodiscard]] auto checkWallRight(float x, float y, float w, float h) const -> float;
+    [[nodiscard]] auto checkCeiling(float x, float y, float w) const -> float;
+    [[nodiscard]] auto checkFloor(float x, float foot_y_current, float w, float foot_y_new) const -> FloorHit;
+    [[nodiscard]] auto hasGroundBelow(float x, float foot_y, float w) const -> bool;
+    [[nodiscard]] auto checkSlopeBelow(float x, float foot_y, float w) const -> SlopeInfo;
+
+   private:
+    static constexpr int TS = ::Tile::SIZE;
+    static constexpr int MW = ::Map::WIDTH;
+    static constexpr int MH = ::Map::HEIGHT;
+
+    const std::vector<int>& tile_map_;
+
+    [[nodiscard]] static auto toTile(int px) -> int { return px / TS; }
+};