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

source/game/entities/bullet.cpp

@@ -3,7 +3,6 @@
 
 #include "game/entities/bullet.hpp"
 
-#include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <iostream>
@@ -43,8 +42,8 @@ void Bullet::init() {
     // Inicialment inactiva
     is_active_ = false;
     center_ = {.x = 0.0F, .y = 0.0F};
+    prev_position_ = {.x = 0.0F, .y = 0.0F};
     angle_ = 0.0F;
-    grace_timer_ = 0.0F;
 
     // Reset del cuerpo físico
     body_.position = Vec2{};
@@ -61,11 +60,9 @@ void Bullet::disparar(const Vec2& position, float angle, uint8_t owner_id) {
     // Almacenar propietario (0=P1, 1=P2)
     owner_id_ = owner_id;
 
-    // Activar grace period (prevents instant self-collision)
-    grace_timer_ = Defaults::Game::BULLET_GRACE_PERIOD;
-
     // Posición y orientación iniciales = ship
     center_ = position;
+    prev_position_ = position;  // Al spawn no hi ha moviment encara: swept degenera a punt-cercle
     angle_ = angle;
 
     // Sincronizar el body físico: posición + velocidad cartesiana
@@ -82,37 +79,34 @@ void Bullet::disparar(const Vec2& position, float angle, uint8_t owner_id) {
     Audio::get()->playSound(Defaults::Sound::LASER, Audio::Group::GAME);
 }
 
-void Bullet::update(float delta_time) {
+void Bullet::update(float /*delta_time*/) {
     if (!is_active_) {
         return;
     }
 
-    // Decrementar grace timer
-    if (grace_timer_ > 0.0F) {
-        grace_timer_ -= delta_time;
-        grace_timer_ = std::max(grace_timer_, 0.0F);
-    }
-
     // El movimiento real lo hace PhysicsWorld::update() (integración).
-    // Aquí solo lógica de estado: detectar salida del PLAYAREA y desactivar.
+    // Aquí solo lógica de estado: detectar salida del PLAYAREA i desactivar.
+    // Sense marge de seguretat: la bala mor quan la seva aresta toca el border visual
+    // (centre a BULLET_RADIUS del límit). El MARGE_SEGURETAT de getSafePlayAreaBounds
+    // és per a spawn d'enemics, no per a desactivació de bales.
     float min_x;
     float max_x;
     float min_y;
     float max_y;
-    Constants::getSafePlayAreaBounds(Defaults::Entities::BULLET_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
+    Constants::getPlayAreaBounds(min_x, max_x, min_y, max_y);
+    constexpr float R = Defaults::Entities::BULLET_RADIUS;
 
-    if (body_.position.x < min_x || body_.position.x > max_x ||
-        body_.position.y < min_y || body_.position.y > max_y) {
+    if (body_.position.x < min_x + R || body_.position.x > max_x - R ||
+        body_.position.y < min_y + R || body_.position.y > max_y - R) {
         desactivar();
     }
 }
 
 void Bullet::postUpdate(float /*delta_time*/) {
-    // Sincronizar mirror desde body_ tras la integración del world.
+    // Captura la posició al final del frame anterior abans de sobreescriure center_;
+    // així el sistema de col·lisions pot fer swept (segment-vs-cercle) entre prev_position_
+    // i la nova center_, evitant tunneling a velocitats altes.
+    prev_position_ = center_;
     center_ = body_.position;
     // angle_ no cambia (las balas no rotan visualmente).
 }

source/game/entities/bullet.hpp

@@ -11,38 +11,39 @@
 #include "core/types.hpp"
 
 class Bullet : public Entities::Entity {
-    public:
-        Bullet()
-            : Entity(nullptr) {}
-        explicit Bullet(Rendering::Renderer* renderer);
+   public:
+    Bullet()
+        : Entity(nullptr) {}
+    explicit Bullet(Rendering::Renderer* renderer);
 
-        void init() override;
-        void disparar(const Vec2& position, float angle, uint8_t owner_id);
-        void update(float delta_time) override;
-        void postUpdate(float delta_time) override;
-        void draw() const override;
+    void init() override;
+    void disparar(const Vec2& position, float angle, uint8_t owner_id);
+    void update(float delta_time) override;
+    void postUpdate(float delta_time) override;
+    void draw() const override;
 
-        // Override: Interfaz de Entity
-        [[nodiscard]] auto isActive() const -> bool override { return is_active_; }
+    // Override: Interfaz de Entity
+    [[nodiscard]] auto isActive() const -> bool override { return is_active_; }
 
-        // Override: Interfaz de colisión (gameplay-level: PLAYAREA bounds-check)
-        [[nodiscard]] auto getCollisionRadius() const -> float override {
-            return Defaults::Entities::BULLET_RADIUS;
-        }
-        [[nodiscard]] auto isCollidable() const -> bool override {
-            return is_active_ && grace_timer_ <= 0.0F;
-        }
+    // Override: Interfaz de colisión (gameplay-level: PLAYAREA bounds-check)
+    [[nodiscard]] auto getCollisionRadius() const -> float override {
+        return Defaults::Entities::BULLET_RADIUS;
+    }
+    [[nodiscard]] auto isCollidable() const -> bool override {
+        return is_active_;
+    }
 
-        // Getters (API pública sin cambios)
-        [[nodiscard]] auto getOwnerId() const -> uint8_t { return owner_id_; }
-        [[nodiscard]] auto getGraceTimer() const -> float { return grace_timer_; }
-        void desactivar();
+    // Getters (API pública sin cambios)
+    [[nodiscard]] auto getOwnerId() const -> uint8_t { return owner_id_; }
+    // Posició al final del frame anterior, per a CCD segment-vs-cercle.
+    [[nodiscard]] auto getPrevPosition() const -> const Vec2& { return prev_position_; }
+    void desactivar();
 
-    private:
-        // Miembros específicos de Bullet (heredados: renderer_, shape_, center_, angle_, brightness_, body_).
-        // Inicializados en la declaración para que tanto el ctor por defecto como el que toma renderer
-        // dejen el objeto en estado coherente (proyectil inactivo, sin owner, sin grace timer).
-        bool is_active_{false};
-        uint8_t owner_id_{0};   // 0=P1, 1=P2
-        float grace_timer_{0.0F};  // Grace period timer (0.0 = vulnerable)
+   private:
+    // Miembros específicos de Bullet (heredados: renderer_, shape_, center_, angle_, brightness_, body_).
+    // Inicializados en la declaración para que tanto el ctor por defecto como el que toma renderer
+    // dejen el objeto en estado coherente (proyectil inactivo, sin owner).
+    bool is_active_{false};
+    uint8_t owner_id_{0};   // 0=P1, 1=P2
+    Vec2 prev_position_{};  // Posició al final del frame anterior (per a swept collision)
 };