scene.h

#pragma once
 
#include "pixelbullet/core/assert.h"
#include "pixelbullet/scene/component_storage.h"
#include "pixelbullet/scene/entity_id.h"
 
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
namespace pixelbullet
{
class SceneSerializer;
 
class Scene
{
public:
    Scene();
 
    EntityId CreateEntity();
    void DestroyEntity(EntityId entityId);
 
    [[nodiscard]] bool IsAlive(EntityId entityId) const
    {
        return entityId.Index() < entities_.size() && entities_[entityId.Index()] == entityId;
    }
 
    [[nodiscard]] std::vector<EntityId> GetEntities() const
    {
        std::vector<EntityId> entities;
        entities.reserve(entities_.size());
        for (const EntityId entity : entities_)
        {
            if (entity)
            {
                entities.push_back(entity);
            }
        }
        return entities;
    }
 
    template <typename T, typename... Args>
    T& AddComponent(EntityId entityId, Args&&... args)
    {
        ASSERT(IsAlive(entityId), "Cannot add component to stale or invalid entity");
        auto storage = GetOrCreateComponentStorage<T>();
        T component{ std::forward<Args>(args)... };
        storage->set.Insert(entityId.Index(), component);
        return storage->set.Get(entityId.Index());
    }
 
    template <typename T>
    void RemoveComponent(EntityId entityId)
    {
        ASSERT(IsAlive(entityId), "Cannot remove component from stale or invalid entity");
        auto storage = GetOrCreateComponentStorage<T>();
        storage->set.Erase(entityId.Index());
    }
 
    template <typename T>
    bool HasComponent(EntityId entityId) const
    {
        if (!IsAlive(entityId))
        {
            return false;
        }
 
        const auto typeId = std::type_index(typeid(T));
        auto it = component_storage_.find(typeId);
        if (it != component_storage_.end())
        {
            const auto* storage = static_cast<const ComponentStorage<T>*>(it->second.get());
            return storage->set.Has(entityId.Index());
        }
        return false;
    }
 
    template <typename T>
    void RegisterComponent(std::string_view serializationName)
    {
        RegisterComponentType(
            std::type_index(typeid(T)), std::string(serializationName), []() { return std::make_unique<ComponentStorage<T>>(); }, true);
    }
 
    template <typename T>
    T& GetComponent(EntityId entityId)
    {
        ASSERT(IsAlive(entityId), "Cannot get component from stale or invalid entity");
        auto storage = GetOrCreateComponentStorage<T>();
        return storage->set.Get(entityId.Index());
    }
 
    template <typename T>
    const T& GetComponent(EntityId entityId) const
    {
        ASSERT(IsAlive(entityId), "Cannot get component from stale or invalid entity");
        const auto* storage = TryGetComponentStorage<T>();
        ASSERT(storage, "Component not found");
        return storage->set.Get(entityId.Index());
    }
 
    template <typename T>
    const SparseSet<T>& GetComponentSet() const
    {
        const auto typeId = std::type_index(typeid(T));
        auto it = component_storage_.find(typeId);
        if (it != component_storage_.end())
        {
            const auto* storage = static_cast<const ComponentStorage<T>*>(it->second.get());
            return storage->set;
        }
        throw std::runtime_error("Component not found");
    }
 
    template <typename T, typename Func>
    void Each(Func&& func)
    {
        auto* storage = TryGetComponentStorage<T>();
        if (!storage)
        {
            return;
        }
 
        for (const auto& entry : storage->set)
        {
            if (entry.id >= entities_.size())
            {
                continue;
            }
 
            const EntityId entity = entities_[entry.id];
            if (!entity)
            {
                continue;
            }
 
            func(entity, storage->set.Get(entry.id));
        }
    }
 
    template <typename T, typename Func>
    void Each(Func&& func) const
    {
        const auto* storage = TryGetComponentStorage<T>();
        if (!storage)
        {
            return;
        }
 
        for (const auto& entry : storage->set)
        {
            if (entry.id >= entities_.size())
            {
                continue;
            }
 
            const EntityId entity = entities_[entry.id];
            if (!entity)
            {
                continue;
            }
 
            func(entity, storage->set.Get(entry.id));
        }
    }
 
    template <typename T, typename U, typename Func>
    void Each(Func&& func)
    {
        auto* primary = TryGetComponentStorage<T>();
        auto* secondary = TryGetComponentStorage<U>();
        if (!primary || !secondary)
        {
            return;
        }
 
        if (secondary->set.Size() < primary->set.Size())
        {
            for (const auto& entry : secondary->set)
            {
                if (entry.id >= entities_.size())
                {
                    continue;
                }
 
                const EntityId entity = entities_[entry.id];
                if (!entity || !primary->set.Has(entry.id))
                {
                    continue;
                }
 
                func(entity, primary->set.Get(entry.id), secondary->set.Get(entry.id));
            }
            return;
        }
 
        for (const auto& entry : primary->set)
        {
            if (entry.id >= entities_.size())
            {
                continue;
            }
 
            const EntityId entity = entities_[entry.id];
            if (!entity || !secondary->set.Has(entry.id))
            {
                continue;
            }
 
            func(entity, primary->set.Get(entry.id), secondary->set.Get(entry.id));
        }
    }
 
    template <typename T, typename U, typename Func>
    void Each(Func&& func) const
    {
        const auto* primary = TryGetComponentStorage<T>();
        const auto* secondary = TryGetComponentStorage<U>();
        if (!primary || !secondary)
        {
            return;
        }
 
        if (secondary->set.Size() < primary->set.Size())
        {
            for (const auto& entry : secondary->set)
            {
                if (entry.id >= entities_.size())
                {
                    continue;
                }
 
                const EntityId entity = entities_[entry.id];
                if (!entity || !primary->set.Has(entry.id))
                {
                    continue;
                }
 
                func(entity, primary->set.Get(entry.id), secondary->set.Get(entry.id));
            }
            return;
        }
 
        for (const auto& entry : primary->set)
        {
            if (entry.id >= entities_.size())
            {
                continue;
            }
 
            const EntityId entity = entities_[entry.id];
            if (!entity || !secondary->set.Has(entry.id))
            {
                continue;
            }
 
            func(entity, primary->set.Get(entry.id), secondary->set.Get(entry.id));
        }
    }
 
    friend Node& operator<<(Node& node, const Scene& scene);
    friend const Node& operator>>(const Node& node, Scene& scene);
    friend class SceneSerializer;
 
private:
    using ComponentTypeId = std::type_index;
    using ComponentStorageFactory = std::function<std::unique_ptr<ComponentStorageBase>()>;
 
    struct ComponentRegistration
    {
        std::string name;
        ComponentStorageFactory factory;
        bool is_explicit = false;
    };
 
    void Serialize(Node& node) const;
    void Deserialize(const Node& node);
    void ClearSceneState();
    void RegisterBuiltInComponents();
    void RegisterComponentType(ComponentTypeId typeId, std::string serializationName, ComponentStorageFactory factory,
                               bool explicitRegistration);
    ComponentStorageBase* FindOrCreateStorage(ComponentTypeId typeId, std::string_view serializationName);
    [[nodiscard]] const ComponentRegistration* FindComponentRegistration(ComponentTypeId typeId) const;
 
private:
    std::vector<EntityId> entities_;
    std::vector<uint8_t> entity_versions_;
    std::vector<uint32_t> free_entities_;
    std::unordered_map<ComponentTypeId, std::unique_ptr<ComponentStorageBase>> component_storage_;
    std::unordered_map<ComponentTypeId, ComponentRegistration> component_registrations_;
    std::unordered_map<std::string, ComponentTypeId> component_types_by_name_;
    std::unordered_map<std::string, ComponentStorageFactory> component_storage_factories_by_name_;
 
private:
    template <typename T>
    ComponentStorage<T>* GetOrCreateComponentStorage()
    {
        EnsureComponentRegistered<T>();
 
        const auto typeId = std::type_index(typeid(T));
        auto it = component_storage_.find(typeId);
        if (it != component_storage_.end())
        {
            return static_cast<ComponentStorage<T>*>(it->second.get());
        }
        else
        {
            auto storage = std::make_unique<ComponentStorage<T>>();
            ComponentStorage<T>* ptr = storage.get();
            component_storage_[typeId] = std::move(storage);
            return ptr;
        }
    }
 
    template <typename T>
    ComponentStorage<T>* TryGetComponentStorage()
    {
        const auto typeId = std::type_index(typeid(T));
        auto it = component_storage_.find(typeId);
        if (it == component_storage_.end())
        {
            return nullptr;
        }
        return static_cast<ComponentStorage<T>*>(it->second.get());
    }
 
    template <typename T>
    const ComponentStorage<T>* TryGetComponentStorage() const
    {
        const auto typeId = std::type_index(typeid(T));
        auto it = component_storage_.find(typeId);
        if (it == component_storage_.end())
        {
            return nullptr;
        }
        return static_cast<const ComponentStorage<T>*>(it->second.get());
    }
 
    template <typename T>
    void EnsureComponentRegistered()
    {
        const auto typeId = std::type_index(typeid(T));
        if (component_registrations_.find(typeId) != component_registrations_.end())
        {
            return;
        }
 
        RegisterComponentType(
            typeId, typeid(T).name(), []() { return std::make_unique<ComponentStorage<T>>(); }, false);
    }
};
 
} // namespace pixelbullet