Registry.hpp

/*
** EPITECH PROJECT, 2022
** r-type
** File description:
** Registry
*/
 
#ifndef REGISTRY_HPP_
    #define REGISTRY_HPP_
 
    #include <map>
    #include <any>
    #include <typeindex>
    #include <functional>
 
    #include "SparseArray.hpp"
    #include "Entity.hpp"
 
class Registry
{
    public:
        explicit Registry() = default;
 
        explicit Registry(std::size_t nbEntities) : _nbEntities(nbEntities) {};
 
        virtual ~Registry() = default;
 
        template <class Component>
        Sparse_array<Component> &register_component()
        {
 
            auto [it, ok] = _componentsArrays.try_emplace(std::type_index(typeid(Component)), std::make_any<Sparse_array<Component>>(_nbEntities));
 
            if (ok) {
                _erasers.emplace_back([](Registry &registry, Entity const &entity) {
                    registry.remove_component<Component>(entity);
                });
            } else {
                throw std::invalid_argument("Component already registered");
            }
            return std::any_cast<Sparse_array<Component> &>(it->second);
        };
 
        template <class Component>
        Sparse_array<Component> &get_components()
        {
            return std::any_cast<Sparse_array<Component> &>(_componentsArrays.at(std::type_index(typeid(Component))));
        };
 
        template <class Component>
        Sparse_array<Component> const &get_components() const
        {
            return std::any_cast<Sparse_array<Component> &>(_componentsArrays.at(std::type_index(typeid(Component))));
        };
 
        Entity spawn_entity()
        {
            _nbEntities += 1;
 
            return Entity(_nbEntities - 1);
        };
 
        template <class ...Components>
        Entity spawn_entity_with(Components && ...components) {
            Entity e = spawn_entity();
 
            (add_component(e, std::forward<Components>(components)), ...);
            return e;
        }
 
        Entity entity_from_index(std::size_t idx) const
        {
            if (idx >= _nbEntities) {
                throw std::out_of_range("At this index, entity doesn't exist !");
            }
            return Entity(idx);
        };
 
        void kill_entity(Entity const &e)
        {
            for (auto &&it : _erasers)
                it(*this, e);
        };
 
        template <typename Component>
        typename Sparse_array<Component>::reference_type add_component(Entity const &e, Component &&c)
        {
            if (_componentsArrays.find(std::type_index(typeid(Component))) == _componentsArrays.end())
                throw std::invalid_argument("Component not registered !");
            Sparse_array<Component> &sparseArray = std::any_cast<Sparse_array<Component> &>(_componentsArrays.at(std::type_index(typeid(Component))));
 
            if (e > sparseArray.size()) {
                sparseArray.extend((size_t) e - sparseArray.size());
            }
            return sparseArray.insert_at(e, c);
        };
 
        template <typename Component, typename ...Params>
        typename Sparse_array<Component>::reference_type emplace_component(Entity const &to, Params &&...p)
        {
            Sparse_array<Component> sparseArray = std::any_cast<Sparse_array<Component> &>(_componentsArrays.at(std::type_index(typeid(Component))));
            return sparseArray.emplaceAt(to, p...);
        };
 
        template <typename Component>
        void remove_component(Entity const &from)
        {
            Sparse_array<Component> &sparseArray = std::any_cast<Sparse_array<Component> &>(_componentsArrays.at(std::type_index(typeid(Component))));
 
            if (sparseArray.size() > from) {
                sparseArray.erase(from);
            }
        };
 
        template <class ...Component, typename Function>
        void add_system(Function &&f) {
            _listOfSystems.push_back([&f](Registry &registry) -> void {
                f(registry, registry.get_components<Component>()...);
            });
        }
 
        template <class ...Component, typename Function>
        void add_system(Function const &f) {
            _listOfSystems.push_back([&f](Registry &registry) -> void {
                f(registry, registry.get_components<Component>()...);
            });
        }
 
        void run_systems() {
            for (auto &function : _listOfSystems)
                function(*this);
        }
 
    private:
        std::vector<std::function<void (Registry &, Entity const &)>> _erasers; 
 
        std::map<std::type_index, std::any> _componentsArrays; 
 
        std::size_t _nbEntities = 0; 
 
        std::vector<Entity> _killedEntities; 
 
        std::vector<std::function<void(Registry &)>> _listOfSystems; 
};
 
#endif /* !REGISTRY_HPP_ */