merge `loek/scripts` into `loek/collision-system`

1 files changed, 30 insertions, 65 deletions

diff --git a/src/crepe/api/EventManager.cpp b/src/crepe/api/EventManager.cpp
index e881d49..20f0dd3 100644
--- a/src/crepe/api/EventManager.cpp
+++ b/src/crepe/api/EventManager.cpp
@@ -1,6 +1,7 @@
 #include "EventManager.h"
 
 using namespace crepe;
+using namespace std;
 
 EventManager & EventManager::get_instance() {
 	static EventManager instance;
@@ -8,74 +9,38 @@ EventManager & EventManager::get_instance() {
 }
 
 void EventManager::dispatch_events() {
-	for (std::vector<std::tuple<std::unique_ptr<Event>, int,
-								std::type_index>>::iterator event_it
-		 = this->events_queue.begin();
-		 event_it != this->events_queue.end();) {
-		std::unique_ptr<Event> & event = std::get<0>(*event_it);
-		int channel = std::get<1>(*event_it);
-		std::type_index event_type = std::get<2>(*event_it);
+	for (auto & event : this->events_queue) {
+		this->handle_event(event.type, event.channel, *event.event.get());
+	}
+	this->events_queue.clear();
+}
 
-		bool event_handled = false;
+void EventManager::handle_event(type_index type, event_channel_t channel, const Event & data) {
+	auto handlers_it = this->subscribers.find(type);
+	if (handlers_it == this->subscribers.end()) return;
 
-		if (channel) {
-			std::unordered_map<
-				std::type_index,
-				std::unordered_map<
-					int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
-				iterator handlers_it
-				= subscribers_by_event_id.find(event_type);
-			if (handlers_it != subscribers_by_event_id.end()) {
-				std::unordered_map<
-					int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
-					handlers_map
-					= handlers_it->second;
-				std::unordered_map<
-					int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::
-					iterator handlers
-					= handlers_map.find(channel);
-				if (handlers != handlers_map.end()) {
-					std::vector<std::unique_ptr<IEventHandlerWrapper>> &
-						callbacks
-						= handlers->second;
-					for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::
-							 iterator handler_it
-						 = callbacks.begin();
-						 handler_it != callbacks.end(); ++handler_it) {
-						if ((*handler_it)->exec(*event)) {
-							event_it = events_queue.erase(event_it);
-							event_handled = true;
-							break;
-						}
-					}
-				}
-			}
-		} else {
-			// Handle event for all channels
-			std::unordered_map<
-				std::type_index,
-				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-				handlers_it
-				= this->subscribers.find(event_type);
-			if (handlers_it != this->subscribers.end()) {
-				std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
-					= handlers_it->second;
-				for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::
-						 iterator handler_it
-					 = handlers.begin();
-					 handler_it != handlers.end(); ++handler_it) {
-					// remove event from queue since and continue when callback returns true
-					if ((*handler_it)->exec(*event)) {
-						event_it = this->events_queue.erase(event_it);
-						event_handled = true;
-						break;
-					}
-				}
-			}
-		}
+	vector<CallbackEntry> & handlers = handlers_it->second;
+	for (auto & handler : handlers) {
+		bool check_channel = handler.channel != CHANNEL_ALL || channel != CHANNEL_ALL;
+		if (check_channel && handler.channel != channel) continue;
+
+		bool handled = handler.callback->exec(data);
+		if (handled) return;
+	}
+}
+
+void EventManager::clear() {
+	this->subscribers.clear();
+	this->events_queue.clear();
+}
 
-		if (!event_handled) {
-			++event_it;
+void EventManager::unsubscribe(subscription_t id) {
+	for (auto & [event_type, handlers] : this->subscribers) {
+		for (auto it = handlers.begin(); it != handlers.end(); it++) {
+			// find listener with subscription id
+			if ((*it).id != id) continue;
+			it = handlers.erase(it);
+			return;
 		}
 	}
 }