ECSWorld.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** rtype
** File description:
** ECSWorld - High-level wrapper for the ECS Registry
*/
 
#pragma once
 
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include "../ECS/Registry.hpp"
#include "../ECS/Systems/ISystem.hpp"
 
namespace ecs::wrapper {
 
    enum class SystemId { Movement, Collision, Health, Spawn, AI, Projectile, Boundary, Weapon };
 
    std::string_view systemIdToName(SystemId id);
 
    class Entity {
       private:
        Address _address;
        Registry *_registry;
 
       public:
        Entity(Address address, Registry *registry);
 
        Address getAddress() const;
 
        template <typename T>
        Entity &with(const T &component);
 
        template <typename T>
        T &get();
 
        template <typename T>
        const T &get() const;
 
        template <typename T>
        bool has() const;
 
        template <typename T>
        Entity &remove();
 
        bool isValid() const;
 
        operator Address() const;
    };
 
    class ECSWorld {
       private:
        std::unique_ptr<Registry> _registry;
        std::unordered_map<std::string, std::unique_ptr<ISystem>> _systems;
        std::vector<std::string> _systemsOrder;
 
       public:
        ECSWorld();
 
        ~ECSWorld();
 
        // Entity Management
 
        Entity createEntity();
 
        std::vector<Entity> createEntities(size_t count);
 
        Entity getEntity(Address address);
 
        void destroyEntity(const Entity &entity);
 
        void destroyEntity(Address address);
 
        // Component Queries
 
        template <typename... Components>
        std::vector<Entity> query();
 
        template <typename... Components>
        void forEach(std::function<void(Entity, Components &...)> callback);
 
        // System Management
 
        template <typename T>
        void registerSystem(const std::string &name, std::unique_ptr<T> system);
 
        template <typename T, typename... Args>
        void createSystem(const std::string &name, Args &&...args);
 
        template <typename T, typename... Args>
        void createSystem(SystemId id, Args &&...args);
 
        template <typename T>
        T *getSystem(const std::string &name);
 
        template <typename T>
        T *getSystem(SystemId id);
 
        void removeSystem(const std::string &name);
 
        void removeSystem(SystemId id);
 
        void update(float deltaTime);
 
        bool updateSystem(const std::string &name, float deltaTime);
 
        bool updateSystem(SystemId id, float deltaTime);
 
        // Direct Registry Access (for advanced usage)
 
        Registry &getRegistry();
 
        const Registry &getRegistry() const;
 
        bool startingEvent = false;
 
        void clear();
 
        size_t getSystemCount() const;
    };
 
}  // namespace ecs::wrapper
 
#include "ECSWorld.tpp"