event.hpp

#pragma once
 
#include "types.hpp"
 
#include <any>
#include <cassert>
#include <functional>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
namespace acheron::ecs {
    class World;

    class EventManager {
        public:
        template<typename T>
        using Callback = std::function<void(World&, const T&)>;

        template<typename T>
        void Subscribe(World& world, Callback<T> callback) {
            auto& vec = subscribers[typeid(T)];
            vec.push_back([&world, callback](const std::any& e) {
                callback(world, std::any_cast<const T&>(e));
            });
        }

        template<typename T>
        void Emit(const T& event) {
            events[typeid(T)].push_back(event);
        }

        void Dispatch() {
            for (auto& [type, vec] : events) {
                auto& subs = subscribers[type];
                for (auto& e : vec) {
                    for (auto& sub : subs) {
                        sub(e);
                    }
                }
            }
            events.clear();
        }
 
        private:
        std::unordered_map<std::type_index, std::vector<std::any>> events; 
        std::unordered_map<std::type_index, std::vector<std::function<void(const std::any&)>>> subscribers; 
    };

    template<typename T>
    struct ComponentAdded {
        Entity entity;
        T* component;
    };

    template<typename T>
    struct ComponentRemoved {
        Entity entity;
    };
 

    template<typename T>
    struct ComponentSet {
        Entity entity;
        T* component;
    };
}