collision event added, multiple callbacks working, id trigger working

7 files changed, 138 insertions, 56 deletions

diff --git a/mwe/events/include/customTypes.h b/mwe/events/include/customTypes.h
new file mode 100644
index 0000000..7217f8a
--- /dev/null
+++ b/mwe/events/include/customTypes.h
@@ -0,0 +1,39 @@
+#pragma once
+#include <cmath>
+struct Vector2 {
+    float x; // X component of the vector
+    float y; // Y component of the vector
+
+    // Vector subtraction
+    Vector2 operator-(const Vector2& other) const {
+        return {x - other.x, y - other.y};
+    }
+
+    // Vector addition
+    Vector2 operator+(const Vector2& other) const {
+        return {x + other.x, y + other.y};
+    }
+
+    // Scalar multiplication
+    Vector2 operator*(float scalar) const {
+        return {x * scalar, y * scalar};
+    }
+
+    // Normalize the vector
+    Vector2 normalize() const {
+        float length = std::sqrt(x * x + y * y);
+        if (length == 0) return {0, 0}; // Prevent division by zero
+        return {x / length, y / length};
+    }
+};
+struct Collision {
+    int objectIdA;          // ID of the first object
+    int objectIdB;          // ID of the second object
+    Vector2 contactPoint;   // Point of contact
+    Vector2 contactNormal;  // Normal vector at the contact point
+
+    // Constructor to initialize a Collision
+    Collision(int idA, int idB, const Vector2& point, const Vector2& normal, float depth)
+        : objectIdA(idA), objectIdB(idB), contactPoint(point), contactNormal(normal) {}
+
+};
diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h
index 802140c..d060faa 100644
--- a/mwe/events/include/event.h
+++ b/mwe/events/include/event.h
@@ -5,6 +5,7 @@
 #include <unordered_map>
 #include <variant>
 #include "keyCodes.h"
+#include "customTypes.h"
 
 class UUIDGenerator {
 public:
@@ -85,3 +86,15 @@ private:
     int mouseX = 0;
     int mouseY = 0;
 };
+class CollisionEvent : public Event {
+public:
+    CollisionEvent(Collision);
+
+    REGISTER_EVENT_TYPE(CollisionEvent)
+
+    Collision getCollisionData() const;
+
+private:
+   	Collision collisionData;
+    
+};
diff --git a/mwe/events/include/eventManager.h b/mwe/events/include/eventManager.h
index 709796a..b8abccc 100644
--- a/mwe/events/include/eventManager.h
+++ b/mwe/events/include/eventManager.h
@@ -26,9 +26,9 @@ public:
 
 private:
     EventManager() = default;
-    std::vector<std::pair<std::unique_ptr<Event>, int>> m_eventsQueue;
-    std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> m_subscribers;
-    std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>> m_subscribersByEventId;
+    std::vector<std::pair<std::unique_ptr<Event>, int>> eventsQueue;
+    std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> subscribers;
+    std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>> subscribersByEventId;
 };
 
 
diff --git a/mwe/events/include/userevent.h b/mwe/events/include/userevent.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/mwe/events/include/userevent.h
diff --git a/mwe/events/src/event.cpp b/mwe/events/src/event.cpp
index fecae76..e4c046f 100644
--- a/mwe/events/src/event.cpp
+++ b/mwe/events/src/event.cpp
@@ -54,3 +54,13 @@ MousePressedEvent::MousePressedEvent(int mouseX, int mouseY)
 std::pair<int, int> MousePressedEvent::getMousePosition() const {
     return {mouseX, mouseY};
 }
+
+//Collision event
+CollisionEvent::CollisionEvent(Collision collision) : collisionData(collision), Event("CollisionEvent") {
+
+}
+
+Collision CollisionEvent::getCollisionData() const
+{
+	return this->collisionData;
+}
diff --git a/mwe/events/src/eventManager.cpp b/mwe/events/src/eventManager.cpp
index ce8e940..c37dcb0 100644
--- a/mwe/events/src/eventManager.cpp
+++ b/mwe/events/src/eventManager.cpp
@@ -2,15 +2,15 @@
 
 void EventManager::shutdown()
 {
-    m_subscribers.clear();
+    subscribers.clear();
 }
 
 void EventManager::subscribe(int eventType, std::unique_ptr<IEventHandlerWrapper>&& handler, int eventId)
 {
     if (eventId) {
-        std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::iterator subscribers = m_subscribersByEventId.find(eventType);
+        std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::iterator subscribers = subscribersByEventId.find(eventType);
 
-        if (subscribers != m_subscribersByEventId.end()) {
+        if (subscribers != subscribersByEventId.end()) {
             std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>& handlersMap = subscribers->second;
             std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlers = handlersMap.find(eventId);
             if (handlers != handlersMap.end()) {
@@ -18,31 +18,20 @@ void EventManager::subscribe(int eventType, std::unique_ptr<IEventHandlerWrapper
                 return;
             }
         }
-        m_subscribersByEventId[eventType][eventId].emplace_back(std::move(handler));
+        subscribersByEventId[eventType][eventId].emplace_back(std::move(handler));
 
     } else {
-        std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator subscribers = m_subscribers.find(eventType);
-        if (subscribers != m_subscribers.end()) {
-            std::vector<std::unique_ptr<IEventHandlerWrapper>>& handlers = subscribers->second;
-            for (std::unique_ptr<IEventHandlerWrapper>& it : handlers) {
-                if (it->getType() == handler->getType()) {
-                    // log for double register
-                    return;
-                }
-            }
-            handlers.emplace_back(std::move(handler));
-        } else {
-            m_subscribers[eventType].emplace_back(std::move(handler));
-        }
+        auto& handlers = subscribers[eventType];
+    	handlers.emplace_back(std::move(handler));
     }
 }
 
 void EventManager::unsubscribe(int eventType, const std::string& handlerName, int eventId)
 {
     if (eventId) {
-        std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::iterator subscribers = m_subscribersByEventId.find(eventType);
-        if (subscribers != m_subscribersByEventId.end()) {
-            std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>& handlersMap = subscribers->second;
+        std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::iterator subscriberList = subscribersByEventId.find(eventType);
+        if (subscriberList != subscribersByEventId.end()) {
+            std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>& handlersMap = subscriberList->second;
             std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlers = handlersMap.find(eventId);
             if (handlers != handlersMap.end()) {
                 std::vector<std::unique_ptr<IEventHandlerWrapper>>& callbacks = handlers->second;
@@ -55,8 +44,8 @@ void EventManager::unsubscribe(int eventType, const std::string& handlerName, in
             }
         }
     } else {
-        std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlersIt = m_subscribers.find(eventType);
-        if (handlersIt != m_subscribers.end()) {
+        std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlersIt = subscribers.find(eventType);
+        if (handlersIt != subscribers.end()) {
             std::vector<std::unique_ptr<IEventHandlerWrapper>>& handlers = handlersIt->second;
             for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it = handlers.begin(); it != handlers.end(); ++it) {
                 if (it->get()->getType() == handlerName) {
@@ -70,38 +59,38 @@ void EventManager::unsubscribe(int eventType, const std::string& handlerName, in
 
 void EventManager::triggerEvent(const Event& event_, int eventId)
 {
-    std::vector<std::unique_ptr<IEventHandlerWrapper>>& handlers = m_subscribers[event_.getEventType()];
-    for (std::unique_ptr<IEventHandlerWrapper>& handler : handlers) {
-        handler->exec(event_);
-    }
-
-    std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>& handlersMap = m_subscribersByEventId[event_.getEventType()];
-    std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlersIt = handlersMap.find(eventId);
-    if (handlersIt != handlersMap.end()) {
-        std::vector<std::unique_ptr<IEventHandlerWrapper>>& callbacks = handlersIt->second;
-        for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it = callbacks.begin(); it != callbacks.end();) {
-            std::unique_ptr<IEventHandlerWrapper>& handler = *it;
-            handler->exec(event_);
-            if (handler->isDestroyOnSuccess()) {
-                it = callbacks.erase(it);
-            } else {
-                ++it;
+    if (eventId > 0) {
+        auto handlersIt = subscribersByEventId[event_.getEventType()].find(eventId);
+        if (handlersIt != subscribersByEventId[event_.getEventType()].end()) {
+            std::vector<std::unique_ptr<IEventHandlerWrapper>>& callbacks = handlersIt->second;
+            for (auto it = callbacks.begin(); it != callbacks.end();) {
+                (*it)->exec(event_);
+                if ((*it)->isDestroyOnSuccess()) {
+                    it = callbacks.erase(it);
+                } else {
+                    ++it;
+                }
             }
         }
+    } else {
+        auto& handlers = subscribers[event_.getEventType()];
+        for (std::unique_ptr<IEventHandlerWrapper>& handler : handlers) {
+            handler->exec(event_);
+        }
     }
 }
 
 void EventManager::queueEvent(std::unique_ptr<Event>&& event_, int eventId)
 {
-    m_eventsQueue.emplace_back(std::move(event_), eventId);
+    eventsQueue.emplace_back(std::move(event_), eventId);
 }
 
 void EventManager::dispatchEvents()
 {
-    for (std::vector<std::pair<std::unique_ptr<Event>, int>>::iterator eventIt = m_eventsQueue.begin(); eventIt != m_eventsQueue.end();) {
+    for (std::vector<std::pair<std::unique_ptr<Event>, int>>::iterator eventIt = eventsQueue.begin(); eventIt != eventsQueue.end();) {
         if (!eventIt->first.get()->getHandled()) {
             triggerEvent(*eventIt->first.get(), eventIt->second);
-            eventIt = m_eventsQueue.erase(eventIt);
+            eventIt = eventsQueue.erase(eventIt);
         } else {
             ++eventIt;
         }
diff --git a/mwe/events/src/main.cpp b/mwe/events/src/main.cpp
index 3940c60..21f2dbf 100644
--- a/mwe/events/src/main.cpp
+++ b/mwe/events/src/main.cpp
@@ -3,7 +3,7 @@
 #include <memory>
 #include "loopManager.h"
 #include "event.h"
-
+#include "customTypes.h"
 class PlayerDamagedEvent : public Event {
 public:
     PlayerDamagedEvent(int damage, int playerID)
@@ -13,7 +13,7 @@ public:
 
     int getDamage() const { return damage; }
     int getPlayerID() const { return playerID; }
-
+	
 private:
     int damage;
     int playerID;
@@ -22,10 +22,24 @@ void onPlayerDamaged(const PlayerDamagedEvent& e) {
     std::cout << "Player " << e.getPlayerID() << " took " << e.getDamage() << " damage." << std::endl;
 }
 
+void onKeyPressed1(const KeyPressedEvent& e)
+{
+   int keyCode = e.getKeyCode();
+	fprintf(stderr,"first function KeyCode %d\n",keyCode);
+}
 void onKeyPressed(const KeyPressedEvent& e)
 {
-   const int keyCode = e.getKeyCode();
-	fprintf(stderr,"KeyCode %d\n",keyCode);
+   int keyCode = e.getKeyCode();
+	fprintf(stderr,"second function KeyCode %d\n",keyCode);
+}
+void CollisionHandler(const CollisionEvent& e){
+	std::cout << "collision betwee object id: "<< e.getCollisionData().objectIdA << " and id: " << e.getCollisionData().objectIdB << std::endl;
+}
+void testCollisionEvent() {
+	Collision testCollision(1, 2, {3, 4}, {5, 6}, 7.8f);
+	subscribe<CollisionEvent>(CollisionHandler,1);
+	// EventHandler<PlayerDamagedEvent>
+	triggerEvent(CollisionEvent(testCollision), 1);
 }
 int main(int argc, char* args[]) {
 	LoopManager gameLoop;
@@ -34,17 +48,34 @@ int main(int argc, char* args[]) {
     //     onKeyPressed(e);
     // };
 	// custom event class poc
-	EventHandler<PlayerDamagedEvent> playerDamagedHandler = onPlayerDamaged;
-	subscribe<PlayerDamagedEvent>(playerDamagedHandler);
-
+	subscribe<PlayerDamagedEvent>(onPlayerDamaged);
 	triggerEvent(PlayerDamagedEvent(50, 1));
-	//EventHandler<KeyPressedEvent> callback = onKeyPressed;
-    //subscribe<KeyPressedEvent>(callback,false);
-	std::unique_ptr<Event> anotherKeyPressEvent = std::make_unique<KeyPressedEvent>(65);
-    queueEvent(std::move(anotherKeyPressEvent));
-    triggerEvent(KeyPressedEvent(42));
+    subscribe<KeyPressedEvent>(onKeyPressed,1,false);
+    subscribe<KeyPressedEvent>(onKeyPressed1,false);
+	// std::unique_ptr<Event> anotherKeyPressEvent = std::make_unique<KeyPressedEvent>(65);
+    // queueEvent(std::move(anotherKeyPressEvent));
+    triggerEvent(KeyPressedEvent(42), 1);
+	
 	EventManager::getInstance().dispatchEvents();
+	//collision event call
+	testCollisionEvent();
 	gameLoop.setup();
 	gameLoop.loop();
     return 0;
 }
+// void collisionUpdate(){
+// 	int count;
+// 	//iedere collision
+// 	for (int i = 0; i < count; i++)
+// 	{
+// 		//trigger object 1
+// 		//triger object 2
+// 		triggerEvent(CollisionEvent(1,2),1);
+// 		triggerEvent(CollisionEvent(1,2),2);
+// 	}
+	
+// }
+// int main(){
+	
+// 	return 0;
+// }