Registry.hpp

/*
** EPITECH PROJECT, 2023
** Registry.hpp
** File description:
** Registry.hpp
*/
 
#ifndef URANUS_REGISTRY_HPP
#define URANUS_REGISTRY_HPP
 
#include "Entity.hpp"
#include "SparseArray.hpp"
#include "uranus/Core.hpp"
#include "uranus/Exceptions.hpp"
#include <any>
#include <functional>
#include <list>
#include <stdexcept>
#include <typeindex>
#include <unordered_map>
 
namespace uranus::ecs {
    class Registry {
    public:
        template<class Component>
        SparseArray<Component> &registerComponent(std::function<void(const size_t &)> &);
 
        template<class Component>
        SparseArray<Component> &registerComponent(std::function<void(const size_t &)> &&);
 
        template<class Component>
        typename SparseArray<Component>::ReferenceType getComponent(const Entity &e);
 
        template<class Component>
        typename SparseArray<Component>::ConstReferenceType getComponent(const Entity &e) const;
 
        template<class Component>
        typename SparseArray<Component>::ReferenceType getComponent(const size_t &e);
 
        template<class Component>
        typename SparseArray<Component>::ConstReferenceType getComponent(const size_t &e) const;
 
        template<class Component>
        SparseArray<Component> &getComponents();
 
        template<class Component>
        SparseArray<Component> const &getComponents() const;
 
        Entity spawnEntity();
 
        Entity entityFromIndex(std::size_t idx) const;
 
        void killEntity(const Entity &e);
 
        void killEntity(const size_t &e);
 
        void killAllEntities();
 
        template<typename Component>
        typename SparseArray<Component>::ReferenceType addComponent(const Entity &to, Component &&c);
 
        template<typename Component, typename... Params>
        typename SparseArray<Component>::ReferenceType emplaceComponent(const Entity &to, Params &&...p);
 
        template<typename Component>
        void removeComponent(const Entity &from);
 
        template<typename Component>
        void removeComponent(const size_t &from);
 
        int entitiesAliveCount() const;
 
        size_t getEntityCounter() const;
 
    private:
        std::unordered_map<std::type_index, std::any> _componentsArrays; 
        std::unordered_map<std::type_index, std::function<void(size_t const &)>> _destroyArrays; 
        size_t _entityCounter = 0; 
        std::list<size_t> _freeIds; 
    };
 
    template<class Component>
    SparseArray<Component> &Registry::registerComponent(std::function<void(const size_t &)> &&deleteFunction)
    {
        auto const &typeIndex = std::type_index(typeid(Component)); // NOLINT
        if (_componentsArrays.find(typeIndex) != _componentsArrays.end()) throw std::runtime_error("Component already registered");
        if (_destroyArrays.find(typeIndex) != _destroyArrays.end()) throw std::runtime_error("Delete function already registered");
        _componentsArrays[typeIndex] = SparseArray<Component>();
        _destroyArrays[typeIndex] = deleteFunction;
        return std::any_cast<SparseArray<Component> &>(_componentsArrays[typeIndex]);
    }
 
    template<class Component>
    SparseArray<Component> &Registry::registerComponent(std::function<void(const size_t &)> &deleteFunction)
    {
        auto const &typeIndex = std::type_index(typeid(Component)); // NOLINT
        if (_componentsArrays.find(typeIndex) != _componentsArrays.end()) throw std::runtime_error("Component already registered");
        if (_destroyArrays.find(typeIndex) != _destroyArrays.end()) throw std::runtime_error("Delete function already registered");
        _componentsArrays[typeIndex] = SparseArray<Component>();
        _destroyArrays[typeIndex] = deleteFunction;
        return std::any_cast<SparseArray<Component> &>(_componentsArrays[typeIndex]);
    }
 
    template<class Component>
    typename SparseArray<Component>::ReferenceType Registry::getComponent(const Entity &e)
    {
        auto const &typeIndex = std::type_index(typeid(Component)); // NOLINT
        if (_componentsArrays.find(typeIndex) == _componentsArrays.end()) throw std::runtime_error("Component not registered");
        return std::any_cast<SparseArray<Component> &>(_componentsArrays[typeIndex])[e];
    }
 
    template<class Component>
    typename SparseArray<Component>::ReferenceType Registry::getComponent(const size_t &e)
    {
        auto const &typeIndex = std::type_index(typeid(Component)); // NOLINT
        if (_componentsArrays.find(typeIndex) == _componentsArrays.end()) throw std::runtime_error("Component not registered");
        return std::any_cast<SparseArray<Component> &>(_componentsArrays[typeIndex])[e];
    }
 
    template<class Component>
    typename SparseArray<Component>::ConstReferenceType Registry::getComponent(const Entity &e) const
    {
        auto const &typeIndex = std::type_index(typeid(Component)); // NOLINT
        if (_componentsArrays.find(typeIndex) == _componentsArrays.end()) throw std::runtime_error("Component not registered");
        return std::any_cast<SparseArray<Component> const &>(_componentsArrays.at(typeIndex))[e];
    }
 
    template<class Component>
    typename SparseArray<Component>::ConstReferenceType Registry::getComponent(const size_t &e) const
    {
        auto const &typeIndex = std::type_index(typeid(Component)); // NOLINT
        if (_componentsArrays.find(typeIndex) == _componentsArrays.end()) throw std::runtime_error("Component not registered");
        return std::any_cast<SparseArray<Component> const &>(_componentsArrays.at(typeIndex))[e];
    }
 
    template<class Component>
    SparseArray<Component> &Registry::getComponents()
    {
        auto const &typeIndex = std::type_index(typeid(Component)); // NOLINT
        if (_componentsArrays.find(typeIndex) == _componentsArrays.end()) throw std::runtime_error("Component not registered");
        return std::any_cast<SparseArray<Component> &>(_componentsArrays[typeIndex]);
    }
 
    template<class Component>
    SparseArray<Component> const &Registry::getComponents() const
    {
        auto const &typeIndex = std::type_index(typeid(Component)); // NOLINT
        if (_componentsArrays.find(typeIndex) == _componentsArrays.end()) throw std::runtime_error("Component not registered");
        return std::any_cast<SparseArray<Component> const &>(_componentsArrays.at(typeIndex));
    }
 
    inline Entity Registry::spawnEntity()
    {
        if (_freeIds.empty()) return Entity(_entityCounter++);
        const size_t id = _freeIds.back();
        _freeIds.pop_back();
//        spdlog::info("popped: {}", id);
        return Entity(id);
    }
 
    inline Entity Registry::entityFromIndex(std::size_t idx) const
    {
        if (idx >= _entityCounter) throw ex::InvalidEntityIndex("Entity index out of range");
        if (std::find(_freeIds.begin(), _freeIds.end(), idx) != _freeIds.end()) throw ex::InvalidEntityIndex("Entity index is not valid");
        return Entity(idx);
    }
 
    inline void Registry::killEntity(const Entity &e)
    {
        if (std::find(_freeIds.begin(), _freeIds.end(), e) != _freeIds.end()) return;
        _freeIds.push_back(e._id);
        for (auto &i : _destroyArrays)
            i.second(e._id);
    }
 
    inline void Registry::killEntity(const size_t &e)
    {
        if (std::find(_freeIds.begin(), _freeIds.end(), e) != _freeIds.end()) return;
        _freeIds.push_back(e);
        for (auto &i : _destroyArrays)
            i.second(e);
//        spdlog::info("entity delete: {}", e);
    }
 
    inline void Registry::killAllEntities()
    {
        for (size_t i = 0; i < _entityCounter; i++)
            killEntity(i);
        _freeIds.clear();
        _entityCounter = 0;
    }
 
    template<typename Component>
    typename SparseArray<Component>::ReferenceType Registry::addComponent(const Entity &to, Component &&c)
    {
        auto &components = getComponents<Component>();
        return components.insertAt(to, std::forward<Component>(c));
    }
 
    template<typename Component, typename... Params>
    typename SparseArray<Component>::ReferenceType Registry::emplaceComponent(const Entity &to, Params &&...p)
    {
        auto &components = getComponents<Component>();
        return components.emplaceAt(to, std::forward<Params>(p)...);
    }
 
    template<typename Component>
    void Registry::removeComponent(const Entity &from)
    {
        auto &components = getComponents<Component>();
        components.erase(from);
    }
 
    template<typename Component>
    void Registry::removeComponent(const size_t &from)
    {
        auto &components = getComponents<Component>();
        components.erase(from);
    }
 
    inline int Registry::entitiesAliveCount() const
    {
        return static_cast<int>(_entityCounter - _freeIds.size());
    }
 
    inline size_t Registry::getEntityCounter() const
    {
        return _entityCounter;
    }
 
} // namespace uranus::ecs
 
#endif // URANUS_REGISTRY_HPP