Registry.hpp

Go to the documentation of this file.

#pragma once
 
#include <unordered_map>
#include <typeindex>
#include <any>
#include <vector>
#include <functional>
 
#include "EventDispatcher.hpp"
#include "Queue.hpp"
#include "ComponentContainer.hpp"
#include "Entity.hpp"
#include "Systems.hpp"
#include "SyncingSystem.hpp"
 
class Registry {
public:
    template<typename Component>
    using reference = typename ComponentContainer<Component>::reference;
 
    using eraseFunc = std::function<void(Entity const&)>;
 
    Registry(EventDispatcher *_dispatcher, Queue *_queue);
 
    template <typename... Components, typename Function>
    void add_system(Function&& f) {
        auto system = [f = std::forward<Function>(f), r = this]() {
            auto component_arrays = r->get_component_array<Components...>();
            std::apply([&](auto&&... args) {
                f(*r, std::forward<decltype(args)>(args)...);
            }, component_arrays);
        };
 
        _systems.push_back(system);
    }
 
    void run_systems();
 
    std::vector<GameMessage> sync_game();
 
    template <class Component>
    ComponentContainer<Component>& register_component() {
        auto type_index = std::type_index(typeid(Component));
 
        auto erase_function = [&](Entity const& entity) {
            auto &container = this->get_components<Component>();
            container.erase(entity);
        };
 
        _erase_functions[type_index] = erase_function;
 
        auto &arr = _components[type_index];
        if (!arr.has_value()) {
            arr = std::make_any<ComponentContainer<Component>>();
        }
 
        return std::any_cast<ComponentContainer<Component> &>(arr);
    }
 
    template <typename... Components>
    std::tuple<ComponentContainer<Components>&...> get_component_array() {
        return std::tie(get_components<Components>()...);
    }
 
    template <class Component>
    ComponentContainer<Component>& get_components() {
        return std::any_cast<ComponentContainer<Component>&>(_components[typeid(Component)]);
    }
 
    template <typename Component>
    reference<Component> add_component(const Entity& entity, Component&& component) {
        auto& array = get_components<Component>();
        array.insert_at(entity.getID(), std::forward<Component>(component));
        return array[entity];
    }
 
    template <typename Component, typename... Params>
    reference<Component> emplace_component(const Entity& entity, Params&&... params) {
        auto& array = get_components<Component>();
        array.emplace_at(entity.getID(), std::forward<Params>(params)...);
        return array[entity];
    }
 
    template <typename Component>
    void remove_component(const Entity& entity) {
        auto& array = get_components<Component>();
        array.erase(entity.getID());
    }
 
    Entity spawn_entity();
 
    Entity entity_from_index(std::size_t idx) const;
 
    void kill_entity(const Entity& entity);
 
public:
    EventDispatcher *dispatcher;
    Queue *queue;
 
private:
    std::unordered_map<std::type_index, std::any> _components; 
    std::size_t _next_entity_id; 
    std::vector<std::size_t> _entities; 
    std::unordered_map<std::type_index, eraseFunc> _erase_functions; 
    std::vector<std::function<void()>> _systems; 
};