fix: player dashing into objects or outside the map (#70)

Co-authored-by: LoayAhmed304 <loayahmed304@gmail.com>

Author: OmarGamal10

src/game/systems/collision-system.cpp

@@ -296,6 +296,40 @@ namespace gameplay {
         return hitInfo;
     }
 
+    // On-demand function
+    HitInfo CollisionSystem::sphereCast(const glm::vec3& from, const glm::vec3& to, float radius,
+                                        short targetLayer) const {
+        HitInfo hitInfo;
+        if (!collisionWorld) return hitInfo;
+
+        btSphereShape sphere(radius);
+
+        btTransform fromT;
+        fromT.setIdentity();
+        fromT.setOrigin(glmToBtVec3(from));
+
+        btTransform toT;
+        toT.setIdentity();
+        toT.setOrigin(glmToBtVec3(to));
+
+        btCollisionWorld::ClosestConvexResultCallback callback(glmToBtVec3(from), glmToBtVec3(to));
+        callback.m_collisionFilterGroup = btBroadphaseProxy::AllFilter;
+        callback.m_collisionFilterMask = targetLayer;
+
+        collisionWorld->convexSweepTest(&sphere, fromT, toT, callback);
+
+        if (callback.hasHit()) {
+            hitInfo.hit = true;
+            hitInfo.point = btToGlmVec3(callback.m_hitPointWorld);
+            hitInfo.normal = btToGlmVec3(callback.m_hitNormalWorld);
+            hitInfo.entity = static_cast<our::Entity*>(callback.m_hitCollisionObject->getUserPointer());
+            float totalDistance = glm::length(to - from);
+            hitInfo.distance = callback.m_closestHitFraction * totalDistance;
+        }
+
+        return hitInfo;
+    }
+
     // On-demand function
     std::vector<our::Entity*> CollisionSystem::overlapSphere(const glm::vec3& center, float radius, short targetLayer) {
         std::vector<our::Entity*> results;

src/game/systems/collision-system.hpp

@@ -97,6 +97,10 @@ namespace gameplay {
         HitInfo raycast(const Ray& ray, float maxDistance,
                         const short targetLayer = CollisionLayer::LAYER_ENVIRONMENT) const;
 
+        // On-demand sphere sweep (convex cast) that sweeps a sphere from 'from' to 'to'.
+        HitInfo sphereCast(const glm::vec3& from, const glm::vec3& to, float radius,
+                           short targetLayer = CollisionLayer::LAYER_ENVIRONMENT) const;
+
         // On-demand overlap sphere function that can be used outside of the update loop
         std::vector<our::Entity*> overlapSphere(const glm::vec3& center, float radius, short targetLayer);
 

src/game/systems/player-movement-system.cpp

@@ -1,5 +1,7 @@
 #include "player-movement-system.hpp"
 
+#include <components/collider.hpp>
+
 #include "collision-system.hpp"
 
 namespace gameplay {
@@ -58,14 +60,42 @@ namespace gameplay {
     }
 
     void PlayerMovementSystem::handleDashing(PlayerMovementComponent* movement, glm::vec3& playerPosition,
-                                             our::Keyboard& keyboard, const glm::vec3& frontXZ) {
+                                             our::Keyboard& keyboard, const glm::vec3& frontXZ,
+                                             const glm::vec3& moveDir) {
         if (keyboard.justPressed(GLFW_KEY_Q) && movement->dashCooldownTimer <= 0) {
             glm::vec3 dashDirection = glm::normalize(frontXZ);
-            if (glm::length(movement->velocity) > 0.001f) {
-                // dash along moving direction if not stationary
-                dashDirection = glm::normalize(movement->velocity);
+            if (glm::length(moveDir) > 0.001f) {
+                // Dash along active WASD input direction (not velocity, which may still be decaying)
+                dashDirection = glm::normalize(moveDir);
             }
-            playerPosition += dashDirection * movement->dashDistance;
+
+            // Sphere sweep to prevent tunneling through walls
+            float actualDashDistance = movement->dashDistance;
+            if (collisionSystem) {
+                float capsuleRadius = 0.5f;
+                float capsuleHeight = 1.0f;
+                if (ColliderComponent* collider = movement->getOwner()->getComponent<ColliderComponent>()) {
+                    capsuleRadius = collider->radius;
+                    capsuleHeight = collider->height;
+                }
+
+                // Sweep from body center
+                glm::vec3 bodyCenter = playerPosition;
+                bodyCenter.y = movement->groundLevel + capsuleHeight * 0.5f;
+
+                glm::vec3 sweepEnd = bodyCenter + dashDirection * movement->dashDistance;
+
+                HitInfo hit =
+                    collisionSystem->sphereCast(bodyCenter, sweepEnd, capsuleRadius, CollisionLayer::LAYER_ENVIRONMENT);
+
+                if (hit.hit) {
+                    // Small skin width to avoid ending flush against the wall (which would cause push-back)
+                    constexpr float SKIN_WIDTH = 0.05f;
+                    actualDashDistance = glm::max(0.0f, hit.distance - SKIN_WIDTH);
+                }
+            }
+
+            playerPosition += dashDirection * actualDashDistance;
             movement->dashCooldownTimer = movement->dashCooldown;
             movement->dashTriggeredThisFrame = true;
         }
@@ -176,7 +206,7 @@ namespace gameplay {
 
         playerPosition += movement->velocity * deltaTime;
 
-        handleDashing(movement, playerPosition, keyboard, frontXZ);
+        handleDashing(movement, playerPosition, keyboard, frontXZ, moveDir);
         handleJumpingAndGravity(movement, playerPosition, keyboard, deltaTime);
         handleHeightInterpolation(movement, playerPosition, deltaTime);
     }

src/game/systems/player-movement-system.hpp

@@ -18,7 +18,7 @@ namespace gameplay {
                                        const glm::vec3& moveDir, float deltaTime, float slideStartSpeed);
         void handleGroundedMovement(PlayerMovementComponent* movement, const glm::vec3& moveDir, float deltaTime);
         void handleDashing(PlayerMovementComponent* movement, glm::vec3& playerPosition, our::Keyboard& keyboard,
-                           const glm::vec3& frontXZ);
+                           const glm::vec3& frontXZ, const glm::vec3& moveDir);
         void handleJumpingAndGravity(PlayerMovementComponent* movement, glm::vec3& playerPosition,
                                      our::Keyboard& keyboard, float deltaTime);
         void handleHeightInterpolation(PlayerMovementComponent* movement, glm::vec3& playerPosition, float deltaTime);