C_scene.hpp

/*
 * Copyright 2025 Guillaume Guillet
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _FGE_C_SCENE_HPP_INCLUDED
#define _FGE_C_SCENE_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
 
#include "FastEngine/C_callback.hpp"
#include "FastEngine/C_commandHandler.hpp"
#include "FastEngine/C_propertyList.hpp"
#include "FastEngine/graphic/C_renderTarget.hpp"
#include "FastEngine/network/C_identity.hpp"
#include "FastEngine/object/C_object.hpp"
#include <memory>
#include <queue>
#include <string>
#include <unordered_map>
 
#define FGE_SCENE_PLAN_HIDE_BACK (FGE_SCENE_PLAN_MIDDLE - 4)
#define FGE_SCENE_PLAN_BACK (FGE_SCENE_PLAN_MIDDLE - 2)
#define FGE_SCENE_PLAN_MIDDLE                                                                                          \
    fge::ObjectPlan                                                                                                    \
    {                                                                                                                  \
        100                                                                                                            \
    }
#define FGE_SCENE_PLAN_TOP (FGE_SCENE_PLAN_MIDDLE + 2)
#define FGE_SCENE_PLAN_GUI (FGE_SCENE_PLAN_MIDDLE + 4)
#define FGE_SCENE_PLAN_HIGH_TOP (FGE_SCENE_PLAN_MIDDLE + 6)
#define FGE_SCENE_PLAN_DEFAULT FGE_SCENE_PLAN_MIDDLE
 
#define FGE_SCENE_BAD_SID std::numeric_limits<fge::ObjectSid>::max()
#define FGE_SCENE_BAD_PLANDEPTH std::numeric_limits<fge::ObjectPlanDepth>::max()
#define FGE_SCENE_BAD_PLAN std::numeric_limits<fge::ObjectPlan>::max()
 
#define FGE_SCENE_LIMIT_NAMESIZE 200
 
#define FGE_NEWOBJECT(objectType_, ...)                                                                                \
    fge::ObjectPtr                                                                                                     \
    {                                                                                                                  \
        new objectType_                                                                                                \
        {                                                                                                              \
            __VA_ARGS__                                                                                                \
        }                                                                                                              \
    }
#define FGE_NEWOBJECT_PTR(objectPtr_)                                                                                  \
    fge::ObjectPtr                                                                                                     \
    {                                                                                                                  \
        objectPtr_                                                                                                     \
    }
 
namespace fge
{
 
namespace net
{
 
class ClientList;
 
} // namespace net
 
class Scene;
 
using ObjectPlanDepth = uint32_t;
using ObjectPlan = uint16_t;
using ObjectSid = uint32_t;
using ObjectPtr = std::unique_ptr<fge::Object>;
 
struct CallbackContext
{
    fge::Event* _event;
    fge::GuiElementHandler* _guiElementHandler;
};

struct SceneNetEvent
{
    enum class Events : uint8_t
    {
        OBJECT_DELETED = 0,
        OBJECT_CREATED,
        OBJECT_SIGNALED,
 
        LAST_ENUM_
    };
    using Events_t = std::underlying_type_t<Events>;
 
    Events _event;
    ObjectSid _sid;
    int8_t _signal{0};
};

enum class ObjectTypes : uint8_t
{
    INVALID = 0,
 
    OBJECT,
    DECAY,
    GUI,
 
    _MAX_
};
using ObjectTypes_t = std::underlying_type_t<ObjectTypes>;
 
static_assert(sizeof(fge::ObjectSid) == sizeof(uint32_t), "fge::ObjectSid must be the same size as uint32_t");
static_assert(static_cast<ObjectTypes_t>(ObjectTypes::_MAX_) <= 4,
              "Too many ObjectTypes, DefaultSIDRanges must change");
enum class DefaultSIDRanges : ObjectSid
{
    MASK_SIZE = 2,
    MASK_POS = 30,
    MASK = ObjectSid{0x3} << MASK_POS,
 
    POS_NULL = ObjectSid{static_cast<ObjectTypes_t>(ObjectTypes::INVALID)} << MASK_POS,
    POS_OBJECT = ObjectSid{static_cast<ObjectTypes_t>(ObjectTypes::OBJECT)} << MASK_POS,
    POS_DECAY = ObjectSid{static_cast<ObjectTypes_t>(ObjectTypes::DECAY)} << MASK_POS,
    POS_GUI = ObjectSid{static_cast<ObjectTypes_t>(ObjectTypes::GUI)} << MASK_POS
};
using DefaultSIDRanges_t = std::underlying_type_t<DefaultSIDRanges>;
 
enum ObjectContextFlags : uint32_t
{
    OBJ_CONTEXT_NETWORK = 1 << 0,  
    OBJ_CONTEXT_DETACHED = 1 << 1, 
 
    OBJ_CONTEXT_NONE = 0,
    OBJ_CONTEXT_DEFAULT = OBJ_CONTEXT_NONE
};

class ObjectData
{
public:
    inline ObjectData() :
            g_boundScene(nullptr),
 
            g_object(nullptr),
            g_sid(FGE_SCENE_BAD_SID),
            g_plan(FGE_SCENE_PLAN_DEFAULT),
            g_type(fge::ObjectTypes::INVALID),
 
            g_planDepth(FGE_SCENE_BAD_PLANDEPTH),
            g_requireForceClientsCheckup(true)
    {}
    inline ObjectData(fge::Scene* boundScene,
                      fge::ObjectPtr&& newObj,
                      fge::ObjectSid newSid = FGE_SCENE_BAD_SID,
                      fge::ObjectPlan newPlan = FGE_SCENE_PLAN_DEFAULT,
                      fge::ObjectTypes newType = fge::ObjectTypes::OBJECT) :
            g_boundScene(boundScene),
 
            g_object(std::move(newObj)),
            g_sid(newSid),
            g_plan(newPlan),
            g_type(newType),
 
            g_planDepth(FGE_SCENE_BAD_PLANDEPTH),
            g_requireForceClientsCheckup(true)
    {}

    [[nodiscard]] inline fge::Object* releaseObject() { return this->g_object.release(); }

    [[nodiscard]] inline fge::Scene* getScene() const { return this->g_boundScene; }
    [[nodiscard]] inline fge::Object* getObject() const { return this->g_object.get(); }
    template<class TObject>
    [[nodiscard]] inline TObject* getObject() const
    {
        return reinterpret_cast<TObject*>(this->g_object.get());
    }

    [[nodiscard]] inline fge::ObjectSid getSid() const { return this->g_sid; }
    [[nodiscard]] inline fge::ObjectPlan getPlan() const { return this->g_plan; }
    [[nodiscard]] inline fge::ObjectTypes getType() const { return this->g_type; }

    inline void setPlanDepth(fge::ObjectPlanDepth depth) const { this->g_planDepth = depth; }
    [[nodiscard]] inline fge::ObjectPlanDepth getPlanDepth() const { return this->g_planDepth; }

    inline void setParent(fge::ObjectDataShared const& object) const
    {
        if (object)
        {
            this->g_parent = object;
        }
    }

    inline void clearParent() const { this->g_parent.reset(); }
    [[nodiscard]] inline fge::ObjectDataWeak getParent() const { return this->g_parent; }

    [[nodiscard]] inline bool isBound() const { return this->g_boundScene != nullptr; }

    [[nodiscard]] inline bool isClass(std::string_view const className) const
    {
        return this->g_object->getClassName() == className;
    }
 
    [[nodiscard]] inline fge::EnumFlags<ObjectContextFlags>& getContextFlags() const { return this->g_contextFlags; }

    [[nodiscard]] inline bool operator==(fge::ObjectSid const& sid) const { return this->g_sid == sid; }
    [[nodiscard]] inline bool operator==(fge::Object const* ptr) const { return this->g_object.get() == ptr; }

    [[nodiscard]] static inline bool isValid(fge::ObjectDataShared const& data) { return data && data->isBound(); }

    [[nodiscard]] static inline fge::ObjectDataShared isValid(fge::ObjectDataWeak const& data)
    {
        if (auto dataShared = data.lock())
        {
            return dataShared->isBound() ? dataShared : nullptr;
        }
        return nullptr;
    }
 
private:
    fge::Scene* g_boundScene;
 
    fge::ObjectPtr g_object;
    fge::ObjectSid g_sid;
    fge::ObjectPlan g_plan;
    fge::ObjectTypes g_type;
 
    //Dynamic data (not saved, local only)
    mutable fge::ObjectPlanDepth g_planDepth;
    mutable fge::ObjectDataWeak g_parent;
    mutable fge::EnumFlags<ObjectContextFlags> g_contextFlags; //TODO: make it uneditable ?
 
    bool g_requireForceClientsCheckup;
 
    friend class fge::Scene;
    friend class fge::ChildObjectsAccessor;
};
 
using ObjectDataWeak = std::weak_ptr<fge::ObjectData>;
using ObjectDataShared = std::shared_ptr<fge::ObjectData>;
using ObjectContainer = std::list<fge::ObjectDataShared>;
using ObjectPlanDataMap = std::map<fge::ObjectPlan, fge::ObjectContainer::iterator>;

class FGE_API ObjectContainerHashMap
{
public:
    using Map = std::unordered_map<ObjectSid, ObjectContainer::iterator>;
 
    ObjectContainerHashMap() = default;
    explicit ObjectContainerHashMap(ObjectContainer& objects);
    ObjectContainerHashMap(ObjectContainerHashMap const& r) = delete;
    ObjectContainerHashMap(ObjectContainerHashMap&& r) noexcept = default;
    ~ObjectContainerHashMap() = default;
 
    ObjectContainerHashMap& operator=(ObjectContainerHashMap const& r) = delete;
    ObjectContainerHashMap& operator=(ObjectContainerHashMap&& r) noexcept = default;
 
    void clear();
    void reMap(ObjectContainer& objects);

    [[nodiscard]] bool newSid(ObjectSid oldSid, ObjectSid newSid);
    [[nodiscard]] bool newObject(ObjectSid sid, ObjectContainer::iterator it);
    void delObject(ObjectSid sid);
 
    [[nodiscard]] std::optional<ObjectContainer::iterator> find(ObjectSid sid);
    [[nodiscard]] std::optional<ObjectContainer::const_iterator> find(ObjectSid sid) const;
    [[nodiscard]] fge::ObjectContainer::value_type retrieve(ObjectSid sid) const;
    [[nodiscard]] bool contains(ObjectSid sid) const;
 
    [[nodiscard]] std::size_t size() const;
 
private:
    Map g_objectMap;
};

class FGE_API Scene : public fge::CommandHandler, public fge::OwnView
{
public:
    using NetworkEventQueue = std::queue<fge::SceneNetEvent>;
    using UpdateCount = uint16_t;
    struct UpdateCountRange
    {
        UpdateCount _last;
        UpdateCount _now;
    };
 
    enum UpdateFlags : uint32_t
    {
        NONE = 0,
        INCREMENT_UPDATE_COUNT = 1 << 0
    };
 
    Scene();
    explicit Scene(std::string sceneName);
    Scene(Scene const& r);
    Scene(Scene&& r) noexcept = delete; //TODO: implement move constructor
    virtual ~Scene();
 
    Scene& operator=(Scene const& r);
    Scene& operator=(Scene&& r) noexcept = delete; //TODO: implement move operator
 
    // Scene
    inline std::string const& getName() const { return this->g_name; }
    inline void setName(std::string name)
    {
        if (name.size() <= FGE_SCENE_LIMIT_NAMESIZE)
        {
            this->g_name = std::move(name);
        }
    }

#ifdef FGE_DEF_SERVER
    void update(fge::Event& event,
                fge::DeltaTime const& deltaTime,
                std::underlying_type_t<UpdateFlags> flags = UpdateFlags::INCREMENT_UPDATE_COUNT);
#else
    void update(fge::RenderTarget& target,
                fge::Event& event,
                fge::DeltaTime const& deltaTime,
                std::underlying_type_t<UpdateFlags> flags = UpdateFlags::NONE);
#endif
    [[nodiscard]] uint16_t getUpdateCount() const;

#ifndef FGE_DEF_SERVER
    void draw(fge::RenderTarget& target, fge::RenderStates const& states = fge::RenderStates{}) const;
#endif //FGE_DEF_SERVER

    fge::ObjectPlanDepth updatePlanDepth(fge::ObjectSid sid);
    void updateAllPlanDepth(fge::ObjectPlan plan);
    void updateAllPlanDepth();

    void clear();
 
    // Object

    struct NewObjectParameters
    {
        fge::ObjectPlan _plan{FGE_SCENE_PLAN_DEFAULT};
        fge::ObjectSid _sid{FGE_SCENE_BAD_SID};
        fge::ObjectTypes _type{fge::ObjectTypes::OBJECT};
        bool _silent{false};
        fge::EnumFlags<ObjectContextFlags> _contextFlags{OBJ_CONTEXT_DEFAULT};
    };

    fge::ObjectDataShared newObject(fge::ObjectPtr&& newObject,
                                    fge::ObjectPlan plan = FGE_SCENE_PLAN_DEFAULT,
                                    fge::ObjectSid sid = FGE_SCENE_BAD_SID,
                                    fge::ObjectTypes type = fge::ObjectTypes::OBJECT,
                                    bool silent = false,
                                    fge::EnumFlags<ObjectContextFlags> contextFlags = OBJ_CONTEXT_DEFAULT);
 
    template<class TObject, class... TArgs>
    inline TObject* newObject(NewObjectParameters const& parameters, TArgs&&... args)
    {
        static_assert(std::is_base_of_v<fge::Object, TObject>, "TObject must be a child of fge::Object");
        auto object = this->newObject(std::make_unique<TObject>(std::forward<TArgs>(args)...), parameters._plan,
                                      parameters._sid, parameters._type, parameters._silent, parameters._contextFlags);
        return object ? object->template getObject<TObject>() : nullptr;
    }
    template<class TObject, class... TArgs>
    inline TObject* newObject(TArgs&&... args)
    {
        static_assert(std::is_base_of_v<fge::Object, TObject>, "TObject must be a child of fge::Object");
        auto object = this->newObject(std::make_unique<TObject>(std::forward<TArgs>(args)...));
        return object ? object->template getObject<TObject>() : nullptr;
    }
    template<class TObject>
    inline TObject* newObject()
    {
        static_assert(std::is_base_of_v<fge::Object, TObject>, "TObject must be a child of fge::Object");
        auto object = this->newObject(std::make_unique<TObject>());
        return object ? object->template getObject<TObject>() : nullptr;
    }
    fge::ObjectDataShared newObject(fge::ObjectDataShared const& objectData, bool silent = false);

    fge::ObjectDataShared duplicateObject(fge::ObjectSid sid, fge::ObjectSid newSid = FGE_SCENE_BAD_SID);

    fge::ObjectDataShared transferObject(fge::ObjectSid sid, fge::Scene& newScene);

    void delUpdatedObject();
    bool delObject(fge::ObjectSid sid);
    std::size_t delAllObject(bool ignoreGuiObject);

    bool setObjectSid(fge::ObjectSid sid, fge::ObjectSid newSid);
    bool setObject(fge::ObjectSid sid, fge::ObjectPtr&& newObject);
    bool setObjectPlan(fge::ObjectSid sid, fge::ObjectPlan newPlan);
    bool setObjectPlanTop(fge::ObjectSid sid);
    bool setObjectPlanBot(fge::ObjectSid sid);

    fge::ObjectDataShared getObject(fge::ObjectSid sid) const;
    fge::ObjectDataShared getObject(fge::Object const* ptr) const;
    fge::Object* getObjectPtr(fge::ObjectSid sid) const;
    fge::ObjectDataShared getUpdatedObject() const;

    inline std::size_t getObjectSize() const { return this->g_objects.size(); }
 
    // Search function
    std::size_t getAllObj_ByPosition(fge::Vector2f const& pos, fge::ObjectContainer& buff) const;
    std::size_t getAllObj_ByZone(fge::RectFloat const& zone, fge::ObjectContainer& buff) const;
 
#ifndef FGE_DEF_SERVER
    std::size_t getAllObj_ByLocalPosition(fge::Vector2i const& pos,
                                          fge::RenderTarget const& target,
                                          fge::ObjectContainer& buff) const;
    std::size_t
    getAllObj_ByLocalZone(fge::RectInt const& zone, fge::RenderTarget const& target, fge::ObjectContainer& buff) const;
    std::size_t getAllObj_FromLocalPosition(fge::Vector2i const& pos,
                                            fge::RenderTarget const& target,
                                            fge::ObjectContainer& buff) const;
    std::size_t getAllObj_FromLocalZone(fge::RectInt const& zone,
                                        fge::RenderTarget const& target,
                                        fge::ObjectContainer& buff) const;
#endif //FGE_DEF_SERVER

    std::size_t getAllObj_ByClass(std::string_view class_name, fge::ObjectContainer& buff) const;
    std::size_t getAllObj_ByTag(std::string_view tag_name, fge::ObjectContainer& buff) const;

    fge::ObjectDataShared getFirstObj_ByPosition(fge::Vector2f const& pos) const;
    fge::ObjectDataShared getFirstObj_ByZone(fge::RectFloat const& zone) const;
 
#ifndef FGE_DEF_SERVER
    fge::ObjectDataShared getFirstObj_ByLocalPosition(fge::Vector2i const& pos, fge::RenderTarget const& target) const;
    fge::ObjectDataShared getFirstObj_ByLocalZone(fge::RectInt const& zone, fge::RenderTarget const& target) const;
    fge::ObjectDataShared getFirstObj_FromLocalPosition(fge::Vector2i const& pos,
                                                        fge::RenderTarget const& target) const;
    fge::ObjectDataShared getFirstObj_FromLocalZone(fge::RectInt const& zone, fge::RenderTarget const& target) const;
#endif //FGE_DEF_SERVER
 
    fge::ObjectDataShared getFirstObj_ByClass(std::string_view class_name) const;
    fge::ObjectDataShared getFirstObj_ByTag(std::string_view tag_name) const;
 
    // Static id
    fge::ObjectSid getSid(fge::Object const* ptr) const;

    inline bool isValid(fge::ObjectSid sid) const { return this->find(sid) != this->g_objects.cend(); }

    virtual fge::ObjectSid generateSid(fge::ObjectSid wanted_sid, fge::ObjectTypes type) const;
 
    // Network
    void signalObject(fge::ObjectSid sid, int8_t signal);

    void pack(fge::net::Packet& pck, fge::net::Identity const& id);
    std::optional<fge::net::Error> unpack(fge::net::Packet const& pck, bool clearObjects = true);
    void packModification(fge::net::Packet& pck, fge::net::Identity const& id);
    std::optional<fge::net::Error>
    unpackModification(fge::net::Packet const& pck, UpdateCountRange& range, bool ignoreUpdateCount = false);

    void packNeededUpdate(fge::net::Packet& pck);
    std::optional<fge::net::Error> unpackNeededUpdate(fge::net::Packet const& pck, fge::net::Identity const& id);

    void forceCheckClient(fge::net::Identity const& id);
    void forceUncheckClient(fge::net::Identity const& id);

    void clientsCheckup(fge::net::ClientList const& clients, bool force = false);
 
    // SceneNetEvent
    void pushEvent(fge::SceneNetEvent const& netEvent);
    bool pushEvent(fge::SceneNetEvent const& netEvent, fge::net::Identity const& id);
    void watchEvent(bool on);
    bool isWatchingEvent() const;

    void clearNetEventsQueue(fge::net::Identity const& id);
    void clearNetEventsQueue();
    void clearPerClientSyncData();

    void packWatchedEvent(fge::net::Packet& pck, fge::net::Identity const& id);
    std::optional<fge::net::Error> unpackWatchedEvent(fge::net::Packet const& pck);
 
    // Operator
    inline fge::ObjectDataShared operator[](fge::ObjectSid sid) const { return this->getObject(sid); }
 
    // Linked renderTarget
    void setLinkedRenderTarget(fge::RenderTarget* target);
    fge::RenderTarget const* getLinkedRenderTarget() const;
    fge::RenderTarget* getLinkedRenderTarget();

    [[nodiscard]] fge::View const* getRelatedView() const;

    void setCallbackContext(fge::CallbackContext context);
    fge::CallbackContext getCallbackContext() const;
 
    // Save/Load in file
    virtual void saveCustomData([[maybe_unused]] nlohmann::json& jsonObject) {};
    virtual void loadCustomData([[maybe_unused]] nlohmann::json& jsonObject) {};

    bool saveInFile(std::filesystem::path const& path);
    bool loadFromFile(std::filesystem::path const& path);
 
    // Iterator
    inline fge::ObjectContainer::const_iterator begin() const { return this->g_objects.begin(); }
    inline fge::ObjectContainer::const_iterator end() const { return this->g_objects.end(); }
    inline fge::ObjectContainer::const_reverse_iterator rbegin() const { return this->g_objects.rbegin(); }
    inline fge::ObjectContainer::const_reverse_iterator rend() const { return this->g_objects.rend(); }

    fge::ObjectContainer::const_iterator find(fge::ObjectSid sid) const;
    fge::ObjectContainer::const_iterator find(fge::Object const* ptr) const;
    fge::ObjectContainer::const_iterator findPlan(fge::ObjectPlan plan) const;
 
    // Network type
    fge::net::NetworkTypeHandler _netList;
 
    // Properties
    fge::PropertyList _properties;
 
    // Event
    mutable fge::CallbackHandler<fge::Scene const&, fge::RenderTarget&> _onDraw;

    mutable fge::CallbackHandler<fge::Scene&, fge::ObjectDataShared const&> _onObjectAdded;
    mutable fge::CallbackHandler<fge::Scene&, fge::ObjectDataShared const&> _onObjectRemoved;

    mutable fge::CallbackHandler<fge::Scene&, fge::ObjectPlan> _onPlanUpdate;

    mutable fge::CallbackHandler<fge::Scene&> _onDelayedUpdate;
 
private:
    struct PerClientSync
    {
        inline explicit PerClientSync(UpdateCount updateCount) :
                _lastUpdateCount(updateCount)
        {}
 
        UpdateCount _lastUpdateCount;
        NetworkEventQueue _networkEvents;
    };
    using PerClientSyncMap = std::unordered_map<fge::net::Identity, PerClientSync, fge::net::IdentityHash>;
 
    void hash_updatePlanDataMap(fge::ObjectPlan plan, fge::ObjectContainer::iterator whoIterator, bool isLeaving);
    fge::ObjectContainer::iterator hash_getInsertionIteratorFromPlanDataMap(fge::ObjectPlan plan);
 
    std::string g_name;
 
    NetworkEventQueue g_sceneNetworkEvents;
    PerClientSyncMap g_perClientSyncs;
    bool g_enableNetworkEventsFlag;
 
    //std::shared_ptr<fge::View> g_customView;
    fge::RenderTarget* g_linkedRenderTarget;
 
    uint16_t g_updateCount;
    bool g_deleteMe;                                        //Delete an object while updating flag
    fge::ObjectContainer::iterator g_updatedObjectIterator; //The iterator of the updated object
 
    fge::ObjectContainer g_objects;
    fge::ObjectContainerHashMap g_objectsHashMap;
    fge::ObjectPlanDataMap g_planDataMap;
 
    fge::CallbackContext g_callbackContext;
};
 
} // namespace fge
 
#endif // _FGE_C_SCENE_HPP_INCLUDED