GameObject.h

// Wykonane przez Piotra Chudzińskiego w dniu 13.04.2025
#pragma once
 
#include <foundation/Common.h>
#include <foundation/Random.h>
#include <iostream>
#include <nlohmann/json.hpp>
#include <ranges>
#include <utility>
 
#include "StreamUtils.h"
 
 
// stream.write(reinterpret_cast<const char *>(&m_Value), sizeof(type));
// stream.read(reinterpret_cast<char *>(&m_Value), sizeof(type));
#define INT_BASED_PARAMETER(name, type)                                                                                \
    class name : public IParameter<type>                                                                               \
    {                                                                                                                  \
    public:                                                                                                            \
        name(const String &paramName, const type &defaultValue) : IParameter<type>(paramName, defaultValue) {}         \
                                                                                                                       \
        int32 Write(nlohmann::json &target) const override                                                             \
        {                                                                                                              \
            target["value"] = m_Value;                                                                                 \
            return sizeof(type);                                                                                       \
        }                                                                                                              \
                                                                                                                       \
        int32 Read(nlohmann::json &target) override                                                                    \
        {                                                                                                              \
            m_Value = target["value"].get<type>();                                                                     \
            return sizeof(type);                                                                                       \
        }                                                                                                              \
                                                                                                                       \
        type IncrementAndGet()                                                                                         \
        {                                                                                                              \
            SetValue(GetValue() + 1);                                                                                  \
            return GetValue();                                                                                         \
        };                                                                                                             \
                                                                                                                       \
        type GetAndIncrement()                                                                                         \
        {                                                                                                              \
            type value = GetValue();                                                                                   \
            SetValue(GetValue() + 1);                                                                                  \
            return value;                                                                                              \
        };                                                                                                             \
                                                                                                                       \
        type DecrementAndGet()                                                                                         \
        {                                                                                                              \
            SetValue(GetValue() - 1);                                                                                  \
            return GetValue();                                                                                         \
        };                                                                                                             \
                                                                                                                       \
        type GetAndDecrement()                                                                                         \
        {                                                                                                              \
            type value = GetValue();                                                                                   \
            SetValue(GetValue() - 1);                                                                                  \
            return value;                                                                                              \
        };                                                                                                             \
    };
 
 
namespace Phosphorus
{
    class IBaseParameter
    {
    public:
        virtual ~IBaseParameter() = default;

        virtual int32 Write(nlohmann::json &target) const = 0;

        virtual int32 Read(nlohmann::json &target) = 0;
 
        virtual void SetDisplayName(const String &name) = 0;

        [[nodiscard]] virtual String GetName() const = 0;

        [[nodiscard]] virtual String GetDisplayName() const = 0;
    };

    template<typename T>
    class IParameter : public IBaseParameter
    {
    protected:
        T m_Value;
        String m_Name;
        String m_DisplayName;
 
    public:
        IParameter(const String &name, const T &defaultValue) : m_Value(defaultValue), m_Name(name), m_DisplayName(name)
        {
        }
 
        ~IParameter() override = default;

        void SetValue(const T &value) { m_Value = value; }

        [[nodiscard]] T GetValue() const { return m_Value; }
 
        void SetDisplayName(const String &name) override { m_DisplayName = name; }

        [[nodiscard]] String GetName() const override { return m_Name; }

        [[nodiscard]] String GetDisplayName() const override { return m_DisplayName; }
    };
 
    INT_BASED_PARAMETER(Int8Parameter, int8);
    INT_BASED_PARAMETER(IntParameter, int32);
    INT_BASED_PARAMETER(Int64Parameter, int64);
    INT_BASED_PARAMETER(BoolParameter, bool);
 
 
#define WIDEN2(x) L##x
#define WIDEN(x) WIDEN2(x)
#define DEFINE_ENUM_VALUE(parameter, Tenum, value, ...) parameter.Bind(Tenum::value, WIDEN(#value));

    class BaseEnumParameter : public IParameter<int32>
    {
    protected:
        std::unordered_map<int32, WideString> m_Bindings;
 
        BaseEnumParameter(const String &name, int32 defaultValue) : IParameter(name, defaultValue) {}

        int32 Write(nlohmann::json &target) const override
        {
            target["value"] = m_Value;
            return sizeof(int32);
        }

        int32 Read(nlohmann::json &target) override
        {
            m_Value = target["value"];
            return sizeof(int32);
        }
 
    public:
        WideString GetBinding(int32 index) const { return m_Bindings.at(index); }

        int32 GetBindingCount() const { return m_Bindings.size(); }
    };

    template<typename T>
    class EnumParameter : public BaseEnumParameter
    {
    public:
        EnumParameter(const String &name, const T &defaultValue) :
            BaseEnumParameter(name, static_cast<int32>(defaultValue))
        {
        }

        void Bind(const T &value, const WideString &text) { m_Bindings.emplace(static_cast<int32>(value), text); }

        void SetEnum(const T &value) { m_Value = static_cast<int32>(value); }

        T GetEnum() const { return static_cast<T>(m_Value); }
    };

    class StringParameter : public IParameter<String>
    {
    public:
        StringParameter(const String &name, const String &defaultValue) : IParameter(name, defaultValue) {}
 
        // @copydoc IBaseParameter::Write
        int32 Write(nlohmann::json &target) const override
        {
            target["value"] = m_Value.Get();
            return m_Value.GetLength();
        }
 
        // @copydoc IBaseParameter::Read
        int32 Read(nlohmann::json &target) override
        {
            m_Value = target["value"].get<std::string>();
            return m_Value.GetLength();
        }
    };

    class GameObject
    {
    public:
        virtual ~GameObject() = default;
 
    private:
        friend class GameSerializer;
        friend class GlobalGameObjectRepository;

        std::vector<IBaseParameter *> m_Parameters;
 
    protected:
        StringParameter m_Identifier;
 
        GameObject() : m_Identifier("Identifier", Random::RandString(16)) { addParameter(&m_Identifier); }
 
        GameObject(const String &identifier) : m_Identifier("Identifier", identifier) { addParameter(&m_Identifier); }

        void addParameter(IBaseParameter *parameter) { m_Parameters.push_back(parameter); };

        IBaseParameter *findParameter(const String &name)
        {
            const auto &iterator = std::ranges::find_if(m_Parameters, [&name](IBaseParameter *parameter)
                                                        { return parameter->GetName() == name; });
 
            if (iterator == m_Parameters.end())
            {
                ERR("GameObject::findParameter: Couldn't find parameter with name '{}'", name);
                return nullptr;
            }
            return iterator[0];
        }

        virtual GameObject *clone() = 0;

        [[nodiscard]] virtual String GetIdentifer() const = 0;

        virtual void onPostLoad() {};

        virtual void onPreSerialize() {};
 
    public:
        std::vector<IBaseParameter *> GetParameters() const { return m_Parameters; }

        [[nodiscard]] String GetUniqueId() const { return m_Identifier.GetValue(); }
    };

    class GameObjectRegistry
    {
        friend class GameSerializer;
 
    protected:
        std::unordered_map<String, GameObject *> m_GameObjects;
 
        std::unordered_map<String, GameObject *> &getMap() { return m_GameObjects; }
        const std::unordered_map<String, GameObject *> &getMap() const { return m_GameObjects; }
 
    public:
        virtual ~GameObjectRegistry() { Clear(); };

        GameObject *GetGameObject(const String &identifier)
        {
            GameObject *object = m_GameObjects.at(identifier);
            return object;
        }

        void Clear()
        {
            const int32 objects = static_cast<int32>(m_GameObjects.size());
            for (const auto &[key, object]: m_GameObjects)
            {
                if (key.StartsWith("Global::"))
                    continue;
 
                delete object;
            }
            m_GameObjects.clear();
 
            INFO("[GameObjectRegistry::Clear] Purged {} items", objects);
        }

        GameObject *GetGameObjectByUniqueId(const String &identifier)
        {
            auto it = std::find_if(m_GameObjects.begin(), m_GameObjects.end(),
                                   [identifier](const auto &pair) { return pair.second->GetUniqueId() == identifier; });
 
            if (it != m_GameObjects.end())
            {
                return it->second;
            }
 
            return nullptr;
        }

        void RegisterGameObject(const String &name, GameObject *object)
        {
            m_GameObjects.insert(std::make_pair(name, object));
        }
    };

    class ParentGameObject : public GameObject, protected std::vector<GameObject *>
    {
        friend class GameSerializer;
 
    public:
        ParentGameObject() : GameObject() {}
 
        explicit ParentGameObject(const String &identifier) : GameObject(identifier) {}

        virtual void Add(GameObject *object) { this->push_back(object); }
    };

    class GlobalGameObjectRepository
    {
    private:
        friend class GameSerializer;
        inline static std::unordered_map<String, GameObject *> m_Registry;
 
    public:
        static void Clear()
        {
            for (auto &object: m_Registry | std::views::values)
                delete object;
        }

        static void RegisterGameObject(GameObject *object)
        {
            m_Registry.insert(std::make_pair(object->GetIdentifer(), object));
        }

        static GameObject *CreateGameObjectInstance(const String &name)
        {
            if (m_Registry.find(name) == m_Registry.end())
            {
                ERR("GlobalGameObjectRepository::CreateGameObjectInstance: returned nullptr for name {}", name);
                return nullptr;
            }
 
            return m_Registry.find(name)->second->clone();
        }
    };
} // namespace Phosphorus