[#6] Implement collision resolution

engine/include/velos/actions/actions.h

@@ -20,15 +20,15 @@ namespace velos {
     public:
         static void bind(Key key, const ActionId& action, ActionType type = ActionType::Press, float holdThreshold = 0.f);
         static void on(const ActionId& action, std::function<void(float)> callback);
-        static void trigger(Key key, float dt);
+        static void trigger(ActionId actionId, float dt);
 
-        static std::unordered_map<Key, ActionBinding>& getKeyBindings() { return s_keyBindings; }
+        static std::unordered_map<Key, std::vector<ActionBinding>>& getKeyBindings() { return s_keyBindings; }
 
         static float getHoldTime(Key key) {return s_keyHoldTime[key]; }
         static void addHoldTime(Key key, float dt) { s_keyHoldTime[key] += dt; }
         static void resetHoldTime(Key key) { s_keyHoldTime[key] = 0.f; }
     private:
-        inline static std::unordered_map<Key, ActionBinding> s_keyBindings;
+        inline static std::unordered_map<Key, std::vector<ActionBinding>> s_keyBindings;
         inline static std::unordered_map<ActionId, std::vector<std::function<void(float)>>> s_callbacks;
         inline static std::unordered_map<Key, float> s_keyHoldTime;
     };

engine/include/velos/entity/entity.h

@@ -1,53 +1,41 @@
 #pragma once
 #include <vector>
 #include <memory>
-#include <functional>
 #include "../graphics/shapes/shape.h"
-#include "../physics/collider.h"
 #include "../graphics/renderer.h"
 #include "../math/transform.h"
 
 namespace velos {
+    class Collider;
+
     class Entity {
     public:
         Entity() = default;
         virtual ~Entity() = default;
 
-        virtual void update(float dt) { updateColliders(); }
+        virtual void update(float dt);
         virtual void render(Renderer& renderer);
 
-        using CollisionCallback = std::function<void(Entity&)>;
-
-        virtual void onCollisionEnter(Entity& other) {};
-        virtual void onCollisionStay(Entity& other) {};
-        virtual void onCollisionExit(Entity& other) {};
-
-        void setOnCollisionEnter(CollisionCallback cb) { m_onEnter = std::move(cb); }
-        void setOnCollisionStay(CollisionCallback cb) { m_onStay = std::move(cb); }
-        void setOnCollisionExit(CollisionCallback cb) { m_onExit = std::move(cb); }
-
-        void dispatchCollisionEnter(Entity& other);
-        void dispatchCollisionStay(Entity& other);
-        void dispatchCollisionExit(Entity& other);
-
         void debugRender(Renderer& renderer);
         bool containsPoint(const Vec2& worldPos) const;
 
         void addShape(std::shared_ptr<Shape> shape) { m_shapes.push_back(shape); }
-        void move(float dx, float dy);
 
         void addCollider(std::unique_ptr<Collider> collider);
         const std::vector<std::unique_ptr<Collider>>& colliders() const;
         void updateColliders();
 
+        void setVelocity(Vec2 velocity) { m_velocity = velocity; }
+        void setVelocityX(float velocityX) { m_velocity.x = velocityX; }
+        void setVelocityY(float velocityY) { m_velocity.y = velocityY; }
+        Vec2& velocity() { return m_velocity; }
+
         Transform& transform() { return m_transform; }
     private:
+        Vec2 m_velocity;
+
         Transform m_transform;
         std::vector<std::shared_ptr<Shape>> m_shapes;
         std::vector<std::unique_ptr<Collider>> m_colliders;
-
-        CollisionCallback m_onEnter;
-        CollisionCallback m_onStay;
-        CollisionCallback m_onExit;
     };
 }

engine/include/velos/math/transform.h

@@ -13,6 +13,16 @@ namespace velos {
             return { x + o.x, y + o.y };
         }
 
+        void operator+=(const Vec2& o) {
+            x += o.x;
+            y += o.y;
+        }
+
+        void operator-=(const Vec2& o) {
+            x -= o.x;
+            y -= o.y;
+        }
+
         Vec2 operator*(float s) const {
             return { x * s, y * s };
         }

engine/include/velos/physics/collider.h

@@ -1,6 +1,9 @@
 #pragma once
 #include "../math/transform.h"
 #include "../graphics/renderer.h"
+#include <functional>
+
+class Entity;
 
 namespace velos {
     enum class ColliderType {
@@ -17,7 +20,35 @@ namespace velos {
         virtual bool containsPoint(const Vec2& worldPoint) const = 0;
 
         virtual void debugRender(Renderer& renderer) const = 0;
+
+        void setSolidCollision(bool state) { m_isSolid = state; }
+        bool isSolidCollision() { return m_isSolid; }
+
+        Entity* owner() const { return m_owner; }
+        void setOwner(Entity* owner) { m_owner = owner; }
+
+        using CollisionCallback = std::function<void(Collider&)>;
+
+        virtual void onCollisionEnter(Collider& other) {};
+        virtual void onCollisionStay(Collider& other) {};
+        virtual void onCollisionExit(Collider& other) {};
+
+        void setOnCollisionEnter(CollisionCallback cb) { m_onEnter = std::move(cb); m_isSolid = false;}
+        void setOnCollisionStay(CollisionCallback cb) { m_onStay = std::move(cb); m_isSolid = false; }
+        void setOnCollisionExit(CollisionCallback cb) { m_onExit = std::move(cb); m_isSolid = false; }
+
+        void dispatchCollisionEnter(Collider& other);
+        void dispatchCollisionStay(Collider& other);
+        void dispatchCollisionExit(Collider& other);
+
     protected:
         Vec2 m_worldPosition{0.f, 0.f};
+        bool m_isSolid = true;
+
+        Entity* m_owner = nullptr;
+
+        CollisionCallback m_onEnter;
+        CollisionCallback m_onStay;
+        CollisionCallback m_onExit;
     };
 }

engine/include/velos/physics/collision_manifold.h

@@ -0,0 +1,14 @@
+#pragma once
+#include "../math/transform.h"
+#include "collider.h"
+
+namespace velos {
+    struct CollisionManifold {
+        bool isColliding = false;
+        float depth = 0.f;
+        Vec2 normal = Vec2{0.f, 0.f};
+
+        Collider* c1 = nullptr;
+        Collider* c2 = nullptr;
+    };
+}

engine/include/velos/physics/physics_system.h

@@ -7,24 +7,26 @@
 #include "aabb_collider.h"
 #include "circle_collider.h"
 #include "collider.h"
+#include "collision_manifold.h"
 
 namespace velos {
     class PhysicsSystem {
     public:
         void update(const std::vector<std::shared_ptr<Entity>>& entities);
 
     private:
-        using CollisionPair = std::pair<Entity*, Entity*>;
+        using CollisionPair = std::pair<Collider*, Collider*>;
 
         std::set<CollisionPair> m_previous;
         std::set<CollisionPair> m_current;
+        std::vector<CollisionManifold> m_manifolds;
 
-        bool checkCollision(Entity& e1, Entity& e2);
-        static CollisionPair makeOrderedPair(Entity* e1, Entity* e2);
+        void checkCollision(Entity& e1, Entity& e2);
+        static CollisionPair makeOrderedPair(Collider* c1, Collider* c2);
 
-        bool intersects(const Collider& c1, const Collider& c2);
-        bool aabbVsAabb(const AABBCollider& c1, const AABBCollider& c2);
-        bool circleVsCircle(const CircleCollider& c1, const CircleCollider& c2);
-        bool aabbVsCircle(const AABBCollider& c1, const CircleCollider& c2);
+        CollisionManifold intersects(Collider& c1, Collider& c2);
+        CollisionManifold aabbVsAabb(AABBCollider& c1, AABBCollider& c2);
+        CollisionManifold circleVsCircle(CircleCollider& c1, CircleCollider& c2);
+        CollisionManifold aabbVsCircle(AABBCollider& c1, CircleCollider& c2);
     };
 }

engine/src/actions/actions.cpp

@@ -2,21 +2,16 @@
 
 namespace velos {
     void Actions::bind(Key key, const ActionId& action, ActionType type, float holdThreshold) {
-        s_keyBindings[key] = ActionBinding{action, type, holdThreshold};
+        s_keyBindings[key].push_back(ActionBinding{action, type, holdThreshold});
         s_keyHoldTime[key] = 0.f;
     }
 
     void Actions::on(const ActionId& action, std::function<void(float)> callback) {
         s_callbacks[action].push_back(std::move(callback));
     }
 
-    void Actions::trigger(Key key, float dt) {
-        auto binding = s_keyBindings.find(key);
-        if (binding == s_keyBindings.end())
-            return;
-
-        const ActionId& action = binding->second.action;
-        auto callbacks = s_callbacks.find(action);
+    void Actions::trigger(ActionId actionId, float dt) {
+        auto callbacks = s_callbacks.find(actionId);
         if (callbacks == s_callbacks.end())
             return;
 

engine/src/app/engine.cpp

@@ -60,26 +60,31 @@ namespace velos {
     }
 
     void Engine::processActions(float dt) {
-        for (auto& [key, binding]: Actions::getKeyBindings()) {
+        for (auto& [key, bindings]: Actions::getKeyBindings()) {
             bool pressed = velos::Input::isKeyPressed(key);
 
-            if (pressed) {
+            if (pressed)
                 Actions::addHoldTime(key, dt);
 
-                if (binding.type == ActionType::Press && Actions::getHoldTime(key) <= dt)
-                    Actions::trigger(key, dt);
-                if (binding.type == ActionType::Hold && Actions::getHoldTime(key) >= binding.holdThreshold)
-                    Actions::trigger(key, dt);
-                if (binding.type == ActionType::HoldCompleted && !binding.completed && Actions::getHoldTime(key) >= binding.holdThreshold) {
-                    Actions::trigger(key, dt);
-                    binding.completed = true;
+            for (auto& binding: bindings) {
+                if (pressed) {
+                    if (binding.type == ActionType::Press && Actions::getHoldTime(key) <= dt)
+                        Actions::trigger(binding.action, dt);
+                    if (binding.type == ActionType::Hold && Actions::getHoldTime(key) >= binding.holdThreshold)
+                        Actions::trigger(binding.action, dt);
+                    if (binding.type == ActionType::HoldCompleted && !binding.completed && Actions::getHoldTime(key) >= binding.holdThreshold) {
+                        Actions::trigger(binding.action, dt);
+                        binding.completed = true;
+                    }
+                } else {
+                    if (binding.type == ActionType::Release && Actions::getHoldTime(key) > 0.f)
+                        Actions::trigger(binding.action, dt);
+                    binding.completed = false;
                 }
-            } else {
-                if (binding.type == ActionType::Release && Actions::getHoldTime(key) > 0.f)
-                    Actions::trigger(key, dt);
-                Actions::resetHoldTime(key);
-                binding.completed = false;
             }
+
+            if (!pressed)
+                Actions::resetHoldTime(key);
         }
     }
 

engine/src/entity/entity.cpp

@@ -1,6 +1,12 @@
 #include "velos/entity/entity.h"
+#include "velos/physics/collider.h"
 
 namespace velos {
+    void Entity::update(float dt) {
+        updateColliders();
+        m_transform.position += m_velocity * dt;
+    }
+
     void Entity::render(Renderer& renderer) {
         for (auto& shape: m_shapes)
             shape->render(renderer, m_transform);
@@ -20,12 +26,8 @@ namespace velos {
         return false;
     }
 
-    void Entity::move(float dx, float dy) {
-        m_transform.position.x += dx;
-        m_transform.position.y += dy;
-    }
-
     void Entity::addCollider(std::unique_ptr<Collider> collider) {
+        collider->setOwner(this);
         m_colliders.push_back(std::move(collider));
     }
 
@@ -37,22 +39,4 @@ namespace velos {
         for (auto& collider: m_colliders)
             collider->computeWorld(m_transform);
     }
-
-    void Entity::dispatchCollisionEnter(Entity& other) {
-        onCollisionEnter(other);
-        if (m_onEnter)
-            m_onEnter(other);
-    }
-
-    void Entity::dispatchCollisionStay(Entity& other) {
-        onCollisionStay(other);
-        if (m_onStay)
-            m_onStay(other);
-    }
-
-    void Entity::dispatchCollisionExit(Entity& other) {
-        onCollisionExit(other);
-        if (m_onExit)
-            m_onExit(other);
-    }
 }

engine/src/physics/collider.cpp

@@ -0,0 +1,21 @@
+#include "velos/physics/collider.h"
+
+namespace velos {
+    void Collider::dispatchCollisionEnter(Collider& other) {
+        onCollisionEnter(other);
+        if (m_onEnter)
+            m_onEnter(other);
+    }
+
+    void Collider::dispatchCollisionStay(Collider& other) {
+        onCollisionStay(other);
+        if (m_onStay)
+            m_onStay(other);
+    }
+
+    void Collider::dispatchCollisionExit(Collider& other) {
+        onCollisionExit(other);
+        if (m_onExit)
+            m_onExit(other);
+    }
+}