fix(bullet): col·lisió swept, sense grace_timer, mor al border visual

source/core/physics/collision.hpp

@@ -3,30 +3,62 @@
 
 #pragma once
 
+#include <algorithm>
+
 #include "core/entities/entity.hpp"
 #include "core/types.hpp"
 
 namespace Physics {
 
-// Comprobación genèrica de colisión entre dues entidades
-inline auto checkCollision(const Entities::Entity& a, const Entities::Entity& b, float amplifier = 1.0F) -> bool {
-    // Comprovar si ambdós són col·lisionables
-    if (!a.isCollidable() || !b.isCollidable()) {
-        return false;
+    // Comprobación genèrica de colisión entre dues entidades
+    inline auto checkCollision(const Entities::Entity& a, const Entities::Entity& b, float amplifier = 1.0F) -> bool {
+        // Comprovar si ambdós són col·lisionables
+        if (!a.isCollidable() || !b.isCollidable()) {
+            return false;
+        }
+
+        // Calcular radi combinat (con amplificador per hitbox generós)
+        float suma_radis = (a.getCollisionRadius() + b.getCollisionRadius()) * amplifier;
+        float suma_radis_sq = suma_radis * suma_radis;
+
+        // Comprobación distancia al cuadrado (sin sqrt)
+        const Vec2& pos_a = a.getCenter();
+        const Vec2& pos_b = b.getCenter();
+        float dx = pos_a.x - pos_b.x;
+        float dy = pos_a.y - pos_b.y;
+        float dist_sq = (dx * dx) + (dy * dy);
+
+        return dist_sq <= suma_radis_sq;
     }
 
-    // Calcular radi combinat (con amplificador per hitbox generós)
-    float suma_radis = (a.getCollisionRadius() + b.getCollisionRadius()) * amplifier;
-    float suma_radis_sq = suma_radis * suma_radis;
-
-    // Comprobación distancia al cuadrado (sin sqrt)
-    const Vec2& pos_a = a.getCenter();
-    const Vec2& pos_b = b.getCenter();
-    float dx = pos_a.x - pos_b.x;
-    float dy = pos_a.y - pos_b.y;
-    float dist_sq = (dx * dx) + (dy * dy);
-
-    return dist_sq <= suma_radis_sq;
-}
+    // Swept collision: una entitat mòbil (radi r_a) s'ha desplaçat de p0 a p1 aquest
+    // frame. Comprova si el segment expandit pel radi conjunt (r_a + radi de b, amb
+    // amplificador) toca el cercle de l'entity b. Equival al check discrete quan
+    // p0 == p1 (sense moviment). Evita tunneling a velocitats altes.
+    inline auto checkCollisionSwept(const Vec2& p0, const Vec2& p1, float r_a, const Entities::Entity& b, float amplifier = 1.0F) -> bool {
+        if (!b.isCollidable()) {
+            return false;
+        }
+        const float SUM_R = (r_a + b.getCollisionRadius()) * amplifier;
+        const float SUM_R_SQ = SUM_R * SUM_R;
+        const Vec2& center_b = b.getCenter();
+        const float DX_SEG = p1.x - p0.x;
+        const float DY_SEG = p1.y - p0.y;
+        const float LEN_SQ = (DX_SEG * DX_SEG) + (DY_SEG * DY_SEG);
+        // Degenerat: punt-cercle (frame de spawn, o entitat parada).
+        if (LEN_SQ <= 0.0F) {
+            const float DX = p0.x - center_b.x;
+            const float DY = p0.y - center_b.y;
+            return ((DX * DX) + (DY * DY)) <= SUM_R_SQ;
+        }
+        // Projecció del centre sobre la recta del segment, clamp a [0,1] per acotar al segment.
+        const float T_RAW = (((center_b.x - p0.x) * DX_SEG) + ((center_b.y - p0.y) * DY_SEG)) / LEN_SQ;
+        const float T_CLAMPED = std::clamp(T_RAW, 0.0F, 1.0F);
+        const float CLOSEST_X = p0.x + (DX_SEG * T_CLAMPED);
+        const float CLOSEST_Y = p0.y + (DY_SEG * T_CLAMPED);
+        const float DX = CLOSEST_X - center_b.x;
+        const float DY = CLOSEST_Y - center_b.y;
+        return ((DX * DX) + (DY * DY)) <= SUM_R_SQ;
+    }
 
 }  // namespace Physics