system.hpp

#pragma once
 
#include "types.hpp"
 
#include <cassert>
#include <memory>
#include <string>
#include <vector>
#include <unordered_map>
 
namespace acheron::ecs {
    class World;

 

    struct SystemStage {
        SystemStageID id;
        std::string name;
 
        bool operator==(const SystemStage& other) const noexcept {
            return id == other.id;
        }
    };

    class System {
        public:
        std::unordered_set<Entity> entities;

        virtual void Update(World& world, double dt) {}
    };

    class SystemManager {
        public:

        template<typename T>
        std::shared_ptr<T> RegisterSystem(std::string stage)  {
            auto typeName = typeid(T).name();
            static_assert(std::is_base_of<System, T>::value, "Trying to register system that doesnt inherit System");
 
            assert(systems.find(typeName) == systems.end() && "Duplicate system registration");
 
            auto system = std::make_shared<T>();
            systems[typeName] = system;
            stageSystems[nameToID[stage]].push_back(system);
 
            return system;
        }

        template<typename T>
        void SetSignature(Signature signature)  {
            auto typeName = typeid(T).name();
 
            assert(systems.find(typeName) != systems.end() && "System used before registration");
 
            signatures[typeName] = signature;
        }

        void EntityDespawned(Entity entity);

        SystemStageID GetOrCreateStage(const std::string& name);

        SystemStageID GetStageOrFail(const std::string& name);

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

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

        void PopulateStages();

        void EntitySignatureChanged(Entity entity, Signature signature);
 
        std::unordered_map<std::string, SystemStageID> nameToID; 
        std::unordered_map<SystemStageID, std::vector<SystemStageID>> edges; 
        std::vector<SystemStage> stages; 
        std::vector<SystemStageID> orderedStages; 
 
        std::unordered_map<SystemStageID, std::vector<std::shared_ptr<System>>> stageSystems;
        std::unordered_map<std::string, std::shared_ptr<System>> systems; 
        std::unordered_map<std::string, Signature> signatures; 
 
        SystemStageID counter;
 
        bool per_entity = true;
    };
}