world.hpp

#pragma once
 
#include "singleton.hpp"
#include "module.hpp"
#include "system_function.hpp"
#include "types.hpp"
#include "event.hpp"
#include "system.hpp"
#include "component.hpp"
#include "entity.hpp"
 
#include <memory>
 
namespace acheron::ecs {
    class World {
        public:
        World();

        Entity Spawn();

        void AddStageBefore(std::string name, std::string after);

        void AddStageAfter(std::string name, std::string before);

        template<typename... Cs, typename... Overrides>
        Entity SpawnWith(Overrides&&... overrides) {
            Entity e = Spawn();
 
            auto check_override = [](auto&& override_val) {
                using T = std::decay_t<decltype(override_val)>;
                static_assert((std::disjunction_v<std::is_same<T, Cs>...>),
                              "Override type not in component list!");
            };
 
            (check_override(overrides), ...);
            (void)check_override;
 
            (AddOrDefault<Cs>(e, std::forward<Overrides>(overrides)...), ...);
            return e;
        }

        void Despawn(Entity entity);

        template<typename T>
        void RegisterComponent() {
            componentManager->RegisterComponent<T>();
        }

        template<typename T>
        bool HasComponent(Entity entity) {
            return componentManager->HasComponent<T>(entity);
        }
 
        template<typename... Components, typename Func>
        void View(Func&& func) {
            Signature required = MakeSignature<Components...>();
 
            for (auto& [entity, sig] : entityManager->signatures) {
                bool match = std::includes(
                    sig.begin(), sig.end(),
                    required.begin(), required.end()
                );
 
                if (match) {
                    func(entity, GetComponent<Components>(entity)...);
                }
            }
        }

         template<typename T, typename... Args>
         void AddComponent(Entity entity, Args&&... args) {
            componentManager->AddComponent<T>(entity, T(std::forward<Args>(args)...));
 
            auto signature = entityManager->GetSignature(entity);
            signature.insert(componentManager->GetComponentID<T>());
            entityManager->SetSignature(entity, signature);
 
            systemManager->EntitySignatureChanged(entity, signature);
        }

        template<typename T>
        void RemoveComponent(Entity entity) {
            componentManager->RemoveComponent<T>(entity);
 
            auto signature = entityManager->GetSignature(entity);
            signature.erase(componentManager->GetComponentID<T>());
            entityManager->SetSignature(entity, signature);
 
            systemManager->EntitySignatureChanged(entity, signature);
        }

        template<typename T>
        T& GetComponent(Entity entity)  {
            return componentManager->GetComponent<T>(entity);
        }

        template<typename T>
        ComponentID GetComponentID() {
            return componentManager->GetComponentID<T>();
        }

        template<typename... Components>
        Signature MakeSignature() {
            Signature signature;
            (signature.insert(GetComponentID<Components>()), ...);
            return signature;
        }

        template<typename T>
        std::shared_ptr<T> RegisterSystem(Signature signature = {}, std::string stage = "Update") {
            auto system = systemManager->RegisterSystem<T>(stage);
            SetSystemSignature<T>(signature);
            return system;
        }

        template<typename Func>
        std::shared_ptr<System> RegisterSystemExplicit(Func&& func, Signature signature = {}, std::string stage = "Update") {
            using SystemType = SystemFunction<std::decay_t<Func>>;
            auto systemFunc = std::make_shared<SystemType>(std::forward<Func>(func));
 
            static int counter = 0;
            std::string typeName = "LambdaSystem_" + std::to_string(counter++);
 
            systemManager->systems[typeName] = systemFunc;
            if (!signature.empty()) {
                systemManager->signatures[typeName] = signature;
            }
            systemManager->stageSystems[systemManager->GetStageOrFail(stage)].push_back(systemFunc);
 
            return systemFunc;
        }

        template<typename... Components, typename Func>
        std::shared_ptr<System> RegisterSystem(Func&& func, std::string stage = "Update") {
            auto signature = MakeSignature<Components...>();
            return RegisterSystemExplicit(std::forward<Func>(func), signature, stage);
        }

        template<typename T>
        void SetSystemSignature(Signature signature) {
            systemManager->SetSignature<T>(signature);
        }

        template<typename T>
        void SetSingleton(T value) {
            SingletonStorage<T>::Set(std::move(value));
        }

        template<typename T>
        T& GetSingleton() {
            return SingletonStorage<T>::Get();
        }

        template<typename T>
        bool IsSingletonSet() {
            return SingletonStorage<T>::IsSet();
        }

        template<typename T>
        void Import() {
            static_assert(std::is_base_of<Module, T>::value, "Import must inherit from Module");
 
            auto module = T{};
            module.Register(*this);
        }

        template<typename T>
        void SubscribeEvent(EventManager::Callback<T> cb) {
            eventManager->Subscribe<T>(*this, cb);
        }

        template<typename T>
        void EmitEvent(const T& event) {
            eventManager->Emit<T>(event);
        }

        void DispatchEvents() {
            eventManager->Dispatch();
        }

        void Update(double dt = 0.0);
 
        private:

        template<typename C, typename... Overrides>
        void AddOrDefault(Entity entity, Overrides&&... overrides) {
            bool added = false;
            // just wanted to write this here
            // ooooo scary folding expressions ooo scary c++ :fearful:
            (
                [&] {
                    if constexpr(std::is_same_v<std::decay_t<Overrides>, C>) {
                        AddComponent<C>(entity, std::forward<Overrides>(overrides));
                        added = true;
                    }
                }(),
                ...
            );
 
            if (!added) AddComponent<C>(entity);
        }
 
        int counter = 0; 
        bool hasStarted = false; 
        std::unique_ptr<EntityManager> entityManager; 
        std::unique_ptr<ComponentManager> componentManager; 
        std::unique_ptr<SystemManager> systemManager; 
        std::unique_ptr<EventManager> eventManager; 
    };
}