event.h

#pragma once
#include<string>
#include<unordered_map>
#include<vector>
 
#include"../utils/hashSet.h"
 
namespace Aire {
    struct Event {
    public:
        Event(const std::string& eventType): type(eventType) {}
        std::string type;
    };
 
    struct GameObject {
        virtual void onEvent(const Event& e) = 0;
 
        virtual ~GameObject();
    };
 
    struct StagedEvent {
        Event* event;
        float timer;
        bool destroy;
        ~StagedEvent() {
            if (destroy) delete event;
        }
    };
 
    struct EventManager {
        static void registerForEvent(GameObject* obj, std::string eventType) {      
            if (!obj) return;
 
            // If this is the first object registered for the event, create a new object list.
            auto itEvent = eventMap.find(eventType);
            if (itEvent == eventMap.end()) {
                itEvent = eventMap.emplace(eventType, HashSet<GameObject*>()).first;
            }
 
            // Regiser the object for the event type
            auto& objSet = itEvent->second;
            objSet.insert(obj);
 
            // If this is the first event this object is registered for, create a new event list.
            auto itObj = objMap.find(obj);
            if (itObj == objMap.end()) {
                itObj = objMap.emplace(obj, HashSet<std::string>()).first;
            }
 
            // Add the event to the object's list of registered events
            auto& eventSet = itObj->second;
            eventSet.insert(eventType);
        }
 
        static void unregisterFromEvent(GameObject* obj, std::string eventType) {
            if (!obj) return;
 
            // Remove the object from the event's list of objects registered to it
            auto itEvent = eventMap.find(eventType);
            if (itEvent != eventMap.end()) {
                auto& objSet = itEvent->second;
                objSet.erase(obj);
                // If this was the last object, remove the event entirely
                if (objSet.empty()) {
                    eventMap.erase(itEvent);
                }
            }
 
            // Remove the event from the object's list of events it is registered for
            auto itObj = objMap.find(obj);
            if (itObj != objMap.end()) {
                auto& eventSet = itObj->second;
                eventSet.erase(eventType);
                // If this was the last event, remove the object from the list entirely
                if (eventSet.empty()) {
                    objMap.erase(itObj);
                }
            }
        }
 
        static void unregisterFromAllEvents(GameObject* obj) {
            if (!obj) return;
 
            auto itObj = objMap.find(obj);
            if (itObj != objMap.end()) {
                // Traverse the set of event this object is registered for and
                // unregister it from every event in the set.
                auto& eventSet = itObj->second;
                for (auto it = eventSet.begin(); it!=eventSet.end(); ++it) {
                    // Remove the object from the event's list of objects registered to it
                    auto itEvent = eventMap.find(*it);
                    if (itEvent != eventMap.end()) {
                        auto& objSet = itEvent->second;
                        objSet.erase(obj);
                        // If this was the last object, remove the event entirely
                        if (objSet.empty()) {
                            eventMap.erase(itEvent);
                        }
                    }
                }
 
                // Remove the object from the object list
                eventSet.clear();
                objMap.erase(itObj);
            }
        }
 
        static void dispatchEvent(const Event& eventInstance) {
            auto it = eventMap.find(eventInstance.type);
            if (it != eventMap.end()) {
                // Walk through all objects registered for this event and trigger their event handler
                auto& objSet = it->second;
                for (auto objIt = objSet.begin(); objIt!=objSet.end(); ++objIt) {
                    (*objIt)->onEvent(eventInstance);
                }
            }
        }
 
        static StagedEvent* stageEvent(Event* eventToStage, float timer, bool destroyWhenDone) {
            if (!eventToStage) {
                return nullptr;
            }
            if (timer>0.0001f) {
                // Dynamically grow the array to avoid re-allocation on every insertion.
                // The capacity of the array is doubled.
                if (stagedEvents.size()==stagedEvents.capacity()) {
                    size_t newSize = std::max(stagedEvents.size(), size_t(1)) * 2;
                    stagedEvents.reserve(newSize);
                }
                stagedEvents.push_back(new StagedEvent{ eventToStage, timer, destroyWhenDone });
                return stagedEvents.back();
            }
        }
 
        static void updateEventTimer(float dt) {
            for (size_t i=0; i<stagedEvents.size(); ) {
                StagedEvent* e = stagedEvents[i];
                if (!e) continue;
                e->timer-=dt;
                if (e->timer<=0.f) {
                    // Activate the event and remove it from the list
                    if (e->event) {
                        dispatchEvent(*(e->event));
                        delete e;
                    }
 
                    // Swap the element with the last element in the array and then pop.
                    std::swap(stagedEvents[i], stagedEvents.back());
                    stagedEvents.pop_back();
                } else {
                    // Move to next position only if there was no swap performed.
                    i++;
                }
            }
        }
 
        static const HashSet<GameObject*>& getAllRegisteredObjects(const std::string& eventType) {
            auto it = eventMap.find(eventType);
            if (it != eventMap.end()) {
                return it->second;
            } else {
                return emptyObjSet;
            }
        }
 
        static const HashSet<std::string>& getAllRegiteredEvents(GameObject* obj) {
            auto it = objMap.find(obj);
            if (it != objMap.end()) {
                return it->second;
            } else {
                return emptyEventSet;
            }
        }
 
        static void freeMem() {
            std::unordered_map<std::string, HashSet<GameObject*>> emptyEventMap;
            std::unordered_map<GameObject*, HashSet<std::string>> emptyObjMap;
            std::swap(eventMap, emptyEventMap);
            std::swap(objMap, emptyObjMap);
            emptyObjSet.freeMem();
            emptyEventSet.freeMem();
            for (auto it = stagedEvents.begin(); it!=stagedEvents.end(); it++) {
                if (*it) {
                    delete *it;
                }
            }
            std::vector<StagedEvent*> emptyStagedEvents;
            std::swap(stagedEvents, emptyStagedEvents);
        }
 
    private:
        // Although it is sufficient to store only an event map (eventType->registered objects),
        // we maintain an object map as well (obj->events it is registered for). This allows
        // unregistering the object from all events it is registered for when it is destroyed.
 
        static std::unordered_map<std::string, HashSet<GameObject*>> eventMap;
 
        static std::unordered_map<GameObject*, HashSet<std::string>> objMap;
 
        static HashSet<GameObject*> emptyObjSet;
 
        static HashSet<std::string> emptyEventSet;
 
        static std::vector<StagedEvent*> stagedEvents;
    };
 
    // Game object destructor ensures that on deletion, the object if unregistered from all events.
    inline GameObject::~GameObject() {
        EventManager::unregisterFromAllEvents(this);
    }
 
    // Static member definitions
    std::unordered_map<std::string, HashSet<GameObject*>> EventManager::eventMap;
    std::unordered_map<GameObject*, HashSet<std::string>> EventManager::objMap;
    std::vector<StagedEvent*> EventManager::stagedEvents;
}