Scene.hpp

#pragma once
 
#include "PixelBullet/Filesystem/Resources/TypeInfo.hpp"
#include "PixelBullet/Math/ID.hpp"
#include "PixelBullet/Scene/ComponentStorage.hpp"
 
#include <fstream>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
namespace PixelBullet
{
    class Scene
    {
    public:
        ID CreateEntity()
        {
            ID id(static_cast<uint32_t>(m_Entities.size()), 0);
            m_Entities.push_back(id);
            return id;
        }
 
        void DestroyEntity(ID id)
        {
            if (id.Index() < m_Entities.size())
            {
                m_Entities[id.Index()] = ID::Invalid();
            }
            for (auto& pair : m_ComponentStorage)
            {
                pair.second->RemoveComponent(id.Index());
            }
        }
 
        template <typename T, typename... Args>
        T& AddComponent(ID id, Args&&... args)
        {
            auto storage = GetOrCreateComponentStorage<T>();
            T component{ std::forward<Args>(args)... };
            storage->Set.Insert(id.Index(), component);
            return storage->Set.Get(id.Index());
        }
 
        template <typename T>
        void RemoveComponent(ID id)
        {
            auto storage = GetOrCreateComponentStorage<T>();
            storage->Set.Erase(id.Index());
        }
 
        template <typename T>
        bool HasComponent(ID id) const
        {
            const TypeID typeId = TypeInfo<ComponentStorageBase>::template Get<ComponentStorage<T>>();
            auto it = m_ComponentStorage.find(typeId);
            if (it != m_ComponentStorage.end())
            {
                auto storage = static_cast<ComponentStorage<T>*>(it->second.get());
                return storage->Set.Has(id.Index());
            }
            return false;
        }
 
        template <typename T>
        T& GetComponent(ID id)
        {
            auto storage = GetOrCreateComponentStorage<T>();
            return storage->Set.Get(id.Index());
        }
 
        template <typename T>
        const SparseSet<T>& GetComponentSet() const
        {
            const TypeID typeId = TypeInfo<ComponentStorageBase>::template Get<ComponentStorage<T>>();
            auto it = m_ComponentStorage.find(typeId);
            if (it != m_ComponentStorage.end())
            {
                auto storage = static_cast<ComponentStorage<T>*>(it->second.get());
                return storage->Set;
            }
            throw std::runtime_error("Component not found");
        }
 
        void SaveToFile(const std::string& path) const
        {
            Node root;
            root["entities"] << m_Entities;
            Node comps;
            for (const auto& pair : m_ComponentStorage)
            {
                Node compNode;
                pair.second->Serialize(compNode);
                comps[pair.second->GetTypeName()] = compNode;
            }
            root["components"] = comps;
            std::ofstream ofs(path);
            if (!ofs)
            {
                throw std::runtime_error("Failed to open file for writing: " + path);
            }
            Node::WriteYAML(root, ofs);
        }
 
        void LoadFromFile(const std::string& path)
        {
            std::ifstream ifs(path);
            if (!ifs)
            {
                throw std::runtime_error("Failed to open file for reading: " + path);
            }
            std::stringstream buffer;
            buffer << ifs.rdbuf();
            Node root;
            if (!Node::ParseYAML(root, buffer.str()))
            {
                throw std::runtime_error("Failed to parse YAML");
            }
            root["entities"] >> m_Entities;
            Node comps = root["components"];
            for (const auto& [key, compNode] : comps.GetProperties())
            {
                for (auto& pair : m_ComponentStorage)
                {
                    if (pair.second->GetTypeName() == key)
                    {
                        pair.second->Deserialize(compNode);
                        break;
                    }
                }
            }
        }
 
        friend Node& operator<<(Node& node, const Scene& scene)
        {
            node["entities"] << scene.m_Entities;
            Node comps;
            for (const auto& pair : scene.m_ComponentStorage)
            {
                Node compNode;
                pair.second->Serialize(compNode);
                comps[pair.second->GetTypeName()] = compNode;
            }
            node["components"] = comps;
            return node;
        }
 
        friend const Node& operator>>(const Node& node, Scene& scene)
        {
            node["entities"] >> scene.m_Entities;
            Node comps = node["components"];
            for (const auto& [key, compNode] : comps.GetProperties())
            {
                for (auto& pair : scene.m_ComponentStorage)
                {
                    if (pair.second->GetTypeName() == key)
                    {
                        pair.second->Deserialize(compNode);
                        break;
                    }
                }
            }
            return node;
        }
 
    private:
        std::vector<ID> m_Entities;
        std::unordered_map<TypeID, std::unique_ptr<ComponentStorageBase>> m_ComponentStorage;
 
    private:
        template <typename T>
        ComponentStorage<T>* GetOrCreateComponentStorage()
        {
            const TypeID typeId = TypeInfo<ComponentStorageBase>::template Get<ComponentStorage<T>>();
            auto it = m_ComponentStorage.find(typeId);
            if (it != m_ComponentStorage.end())
            {
                return static_cast<ComponentStorage<T>*>(it->second.get());
            }
            else
            {
                auto storage = std::make_unique<ComponentStorage<T>>();
                ComponentStorage<T>* ptr = storage.get();
                m_ComponentStorage[typeId] = std::move(storage);
                return ptr;
            }
        }
    };
 
    inline Node& operator<<(Node& node, const ID& id)
    {
        node.SetValue(std::to_string(id.Raw()));
        node.SetType(NodeType::Integer);
        return node;
    }
 
    inline const Node& operator>>(const Node& node, ID& id)
    {
        uint32_t raw = static_cast<uint32_t>(std::stoul(node.GetValue()));
        id = ID::FromRaw(raw);
        return node;
    }
} // namespace PixelBullet