The Registry class serves as the central manager for entities and their associated components in an Entity-Component-System (ECS) architecture.

It handles the registration, retrieval, and management of components, entities, and systems.

namespace ecs {
    class Registry {
      public:
        template <class Component>
        SparseArray<Component> &register_component()
        {
            auto type = std::type_index(typeid(SparseArray<Component>));
            if (_componentsArrays.find(type) == _componentsArrays.end()) {
                _componentsArrays[type] = SparseArray<Component>();
            }
            return std::any_cast<SparseArray<Component> &>(_componentsArrays[type]);
        }

        template <class Component>
        SparseArray<Component> &get_components()
        {
            return std::any_cast<SparseArray<Component> &>(
                _componentsArrays[std::type_index(typeid(SparseArray<Component>))]
            );
        }

        template <class Component>
        SparseArray<Component> &register_if_not_exist()
        {
            auto type = std::type_index(typeid(SparseArray<Component>));
            if (_componentsArrays.find(type) == _componentsArrays.end()) {
                return register_component<Component>();
            }
            return std::any_cast<SparseArray<Component> &>(_componentsArrays[type]);
        }

        Entity spawn_entity()
        {
            return Entity(_entityCount++);
        }

        void remove_component(Entity const &from)
        {
            std::size_t idx = 0;

            for (const auto &i : _componentsArrays) {
                if (from.getId() == idx) {
                    _componentsArrays.erase(i.first);
                    break;
                }
                idx += 1;
            }
        }

        void erase(const std::size_t &entityIdx)
        {
            auto &positions = register_component<ecs::component::Position>();
            auto &drawable = register_component<ecs::component::Drawable>();
            auto &sprite = register_component<ecs::component::Sprite>();
            auto &animation = register_component<ecs::component::Animations>();
            auto &parallax = register_component<ecs::component::Parallax>();
            auto &size = register_component<ecs::component::Size>();

            positions.erase(entityIdx);
            drawable.erase(entityIdx);
            sprite.erase(entityIdx);
            animation.erase(entityIdx);
            parallax.erase(entityIdx);
            size.erase(entityIdx);
            _entitys.erase(entityIdx);
        }

        template <typename Function>
        void add_system(Function &&f)
        {
            _systems.push_back(f);
        }

        void run_systems()
        {
            for (auto &system : _systems) {
                system(*this);
            }
        }

        EntityManager _entitys;

      private:
        std::vector<std::function<void(Registry &)>> _systems;
        std::unordered_map<std::type_index, std::any> _componentsArrays;
        std::size_t _entityCount = 0;
    };
} // namespace ecs

Public Methods:

• template <class Component> SparseArray<Component> &register_component()
  • Registers a new component type in the ECS system.
  • If the component type is not already registered, it creates a SparseArray for that component type and stores it.
  • Returns a reference to the SparseArray for the registered component type.
• template <class Component> SparseArray<Component> &get_components()
  • Retrieves the SparseArray of the specified component type.
  • Assumes the component type has already been registered.
  • Returns a reference to the SparseArray of the specified component.
• template <class Component> SparseArray<Component> &register_if_not_exist()
  • Registers a component type if it hasn't been registered yet.
  • If already registered, it simply returns the existing SparseArray for that component.
  • Useful for ensuring that a component type exists without duplicating registration.
• Entity spawn_entity()
  • Spawns a new entity in the ECS system.
  • Returns an Entity object, which is a unique identifier for each entity.
  • Increments an internal counter to ensure unique entity IDs.
• void remove_component(Entity const &from)
  • Removes all components associated with a specific entity.
  • Iterates through the stored component arrays and removes the components for the entity with the matching ID.
• void erase(const std::size_t &entityIdx)
  • Erases all components and the entity itself from the system based on the entity's index.
  • Calls erase() on the relevant component arrays to clean up components.
  • Removes the entity from the _entitys (entity manager).
• template <typename Function> void add_system(Function &&f)
  • Adds a system (a function or lambda) to the list of systems that will be run.
  • Systems operate on components and are invoked during run_systems().
• void run_systems()
  • Executes all the systems stored in the registry.
  • Iterates through the list of systems and applies them to the current state of the registry.
• EntityManager _entitys
  • Manages the list of entities within the ECS system.

Private Members:

• std::vector<std::function<void(Registry &)>> _systems
  • Stores a list of systems (functions) to be executed.
  • Each system is responsible for processing components.
• std::unordered_map<std::type_index, std::any> _componentsArrays
  • Stores the component arrays for each registered component type.
  • Uses std::any to store the arrays, allowing different component types to be handled generically.