component.hpp

#pragma once
 
#include "types.hpp"
#include "component_array.hpp"
 
#include <cassert>
#include <memory>
#include <print>
#include <unordered_map>
 
namespace acheron::ecs {
    template<typename T>
    struct ComponentType {
        static inline ComponentID ID = static_cast<ComponentID>(-1); // -1 means "unassigned"
    };

    class ComponentManager {
        public:
 
        ComponentManager() : nextComponentID(0) {}

        template<typename T>
        void RegisterComponent() {
            assert(ComponentType<T>::ID == static_cast<ComponentID>(-1) && "Duplicate registration");
 
            ComponentType<T>::ID = nextComponentID++;
            componentArrays[ComponentType<T>::ID] = std::make_shared<ComponentArray<T>>();
        }

        template<typename T>
        ComponentID GetComponentID() {
            assert(ComponentType<T>::ID != static_cast<ComponentID>(-1) && "Component not registered");
            return ComponentType<T>::ID;
        }

        template<typename T>
        void AddComponent(Entity entity, T component)  {
            GetComponentArray<T>()->InsertData(entity, component);
        }

        template<typename T>
        void RemoveComponent(Entity entity) {
            GetComponentArray<T>()->RemoveData(entity);
        }

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

        template<typename T>
        bool HasComponent(Entity entity) {
            return GetComponentArray<T>()->HasData(entity); // you’ll need a HasData function in ComponentArray
        }

        void EntityDespawned(Entity entity);
 
        private:
        std::unordered_map<const char*, ComponentID> componentTypes; 
        std::unordered_map<ComponentID, std::shared_ptr<IComponentArray>> componentArrays; 
        ComponentID nextComponentID; 

        template<typename T>
        std::shared_ptr<ComponentArray<T>> GetComponentArray() {
            ComponentID id = GetComponentID<T>();
            return std::static_pointer_cast<ComponentArray<T>>(componentArrays[id]);
        }
    };
}