Implemented namespace system, added ItemDropEvent and cleaned up a little bit

src/port/hooks/Events.h

@@ -1,3 +1,4 @@
 #pragma once
 
-#include "list/PlayerShotEvent.h"
+#include "list/EngineEvent.h"
+#include "list/ItemEvent.h"

src/port/hooks/impl/EventSystem.cpp

@@ -1,35 +1,42 @@
 #include "EventSystem.h"
 #include <stdexcept>
+#include <algorithm>
 
 EventSystem* EventSystem::Instance = new EventSystem();
 
 ListenerID EventSystem::RegisterListener(EventID id, EventCallback callback, EventPriority priority) {
-    if(std::find_if(this->mEventListeners[id].begin(), this->mEventListeners[id].end(), [callback](EventListener listener) {
+    auto& listeners = this->mEventListeners[(uint8_t)((id >> 16) & 0xFF)][(uint16_t)(id & 0xFFFF)];
+
+    if(std::find_if(listeners.begin(), listeners.end(), [callback](EventListener listener) {
         return listener.function == callback;
-    }) != this->mEventListeners[id].end()) {
+    }) != listeners.end()) {
         throw std::runtime_error("Listener already registered");
     }
 
-    this->mEventListeners[id].push_back({ priority, callback });
+    listeners.push_back({ priority, callback });
 
     // Sort by priority
-    std::sort(this->mEventListeners[id].begin(), this->mEventListeners[id].end(), [](EventListener a, EventListener b) {
+    std::sort(listeners.begin(), listeners.end(), [](EventListener a, EventListener b) {
         return a.priority < b.priority;
     });
 
-    return this->mEventListeners[id].size() - 1;
+    return listeners.size() - 1;
 }
 
-void EventSystem::UnregisterListener(EventID ev, ListenerID id) {
-    this->mEventListeners[ev].erase(this->mEventListeners[ev].begin() + id);
+void EventSystem::UnregisterListener(EventID id, ListenerID listenerId) {
+    auto& listeners = this->mEventListeners[(uint8_t)((id >> 16) & 0xFF)][(uint16_t)(id & 0xFFFF)];
+
+    listeners.erase(listeners.begin() + listenerId);
 }
 
 void EventSystem::CallEvent(EventID id, IEvent* event) {
-    if (this->mEventListeners[id].empty()) {
+    auto& listeners = this->mEventListeners[(uint8_t)((id >> 16) & 0xFF)][(uint16_t)(id & 0xFFFF)];
+
+    if (listeners.empty()) {
         return;
     }
 
-    for (auto& listener : this->mEventListeners[id]) {
+    for (auto& listener : listeners) {
         listener.function(event);
     }
 }

src/port/hooks/impl/EventSystem.h

@@ -5,6 +5,7 @@
 #include <stddef.h>
 
 typedef uint16_t EventID;
+typedef uint16_t NamespaceID;
 typedef uint32_t ListenerID;
 
 typedef enum {
@@ -29,13 +30,32 @@ typedef struct {
     EventCallback function;
 } EventListener;
 
-// ID              Type
-// 000000000000000 0
-#define EVENT_ID(id, type) ((id << 1) | type)
+// Namespace        ID              Type
+// 00000000XXXXXXXX 000000000000000 0
+#define EVENT_ID(namespace_, id_, type_) ((((uint32_t)(namespace_) & 0xFFFF) << 16) | (((uint32_t)(id_) & 0x7FFF) << 1) | ((uint32_t)(type_) & 0x1))
+
+#define INTERNAL_EVENT_ID(id, type) EVENT_ID(0, id, type)
+#define DEFINE_EVENT(id, eventName, type, ...) \
+    typedef struct { \
+        IEvent event; \
+        __VA_ARGS__ \
+    } eventName; \
+    \
+    static uint32_t eventName##_ID = INTERNAL_EVENT_ID(id, type);
+
+#define CALL_EVENT(eventType, ...) \
+    eventType eventType##_ = { {false}, __VA_ARGS__ }; \
+    EventSystem_CallEvent(eventType##_ID, &eventType##_);
+
+#define CALL_CANCELLABLE_EVENT(eventType, ...) \
+    eventType eventType##_ = { {false}, __VA_ARGS__ }; \
+    EventSystem_CallEvent(eventType##_ID, &eventType##_); \
+    if (!eventType##_.event.cancelled)
 
 #ifdef __cplusplus
 #include <array>
 #include <vector>
+#include <unordered_map>
 
 class EventSystem {
 public:
@@ -44,7 +64,7 @@ public:
     void UnregisterListener(EventID ev, ListenerID id);
     void CallEvent(EventID id, IEvent* event);
 private:
-    std::array<std::vector<EventListener>, 0xFFFF> mEventListeners;
+    std::unordered_map<NamespaceID, std::unordered_map<EventID, std::vector<EventListener>>> mEventListeners;
 };
 #else
 extern ListenerID EventSystem_RegisterListener(EventID id, EventCallback callback, EventPriority priority);

src/port/hooks/list/EngineEvent.h

@@ -2,8 +2,8 @@
 
 #include "port/hooks/impl/EventSystem.h"
 
-#define DISPLAY_UPDATE_EVENT_PRE  EVENT_ID(1, EVENT_TYPE_PRE)
-#define DISPLAY_UPDATE_EVENT_POST EVENT_ID(1, EVENT_TYPE_POST)
+#define DISPLAY_UPDATE_EVENT_PRE  INTERNAL_EVENT_ID(1, EVENT_TYPE_PRE)
+#define DISPLAY_UPDATE_EVENT_POST INTERNAL_EVENT_ID(1, EVENT_TYPE_POST)
 
-#define GAME_UPDATE_EVENT_PRE  EVENT_ID(2, EVENT_TYPE_PRE)
-#define GAME_UPDATE_EVENT_POST EVENT_ID(2, EVENT_TYPE_POST)
+#define GAME_UPDATE_EVENT_PRE  INTERNAL_EVENT_ID(2, EVENT_TYPE_PRE)
+#define GAME_UPDATE_EVENT_POST INTERNAL_EVENT_ID(2, EVENT_TYPE_POST)

src/port/hooks/list/ItemEvent.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "gfx.h"
+#include "sf64object.h"
+#include "port/hooks/impl/EventSystem.h"
+
+DEFINE_EVENT(3, ItemDropEvent, EVENT_TYPE_PRE, 
+    Item* item;
+);