C_networkType.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_NETWORKTYPE_HPP_INCLUDED
#define _FGE_C_NETWORKTYPE_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
#include "C_identity.hpp"
#include "C_packet.hpp"
#include "FastEngine/C_callback.hpp"
#include "FastEngine/C_dataAccessor.hpp"
#include "FastEngine/C_flag.hpp"
#include "FastEngine/C_propertyList.hpp"
#include <deque>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#define FGE_NET_WAITING_UPDATE_DELAY std::chrono::milliseconds(800)
 
namespace fge
{
 
class Scene;
class TagList;
 
namespace net
{
 
enum PerClientConfigs : uint32_t
{
    CLIENTCONFIG_MODIFIED_FLAG = 1 << 0,                
    CLIENTCONFIG_REQUIRE_EXPLICIT_UPDATE_FLAG = 1 << 1, 
 
    CLIENTCONFIG_CUSTOM_FLAG_START = 1 << 2, 
 
    CLIENTCONFIG_DEFAULT = 0
};
 
struct PerClientData
{
    inline constexpr PerClientData() = default;
    inline explicit constexpr PerClientData(fge::EnumFlags_t<PerClientConfigs> config) :
            _config(config)
    {}
 
    fge::EnumFlags<PerClientConfigs> _config{CLIENTCONFIG_DEFAULT};
    std::shared_ptr<void> _data{nullptr};
};
 
class ClientList;
 
class FGE_API PerClientSyncContext
{
public:
    using SyncTable = std::unordered_map<Identity, PerClientData, IdentityHash>;
 
    PerClientSyncContext() = default;
    PerClientSyncContext(PerClientSyncContext const&) = delete;
    PerClientSyncContext(PerClientSyncContext&&) noexcept = default;
    virtual ~PerClientSyncContext() = default;
 
    PerClientSyncContext& operator=(PerClientSyncContext const&) = delete;
    PerClientSyncContext& operator=(PerClientSyncContext&&) noexcept = default;
 
    void clear();
    void clientsCheckup(ClientList const& clients,
                        bool force,
                        fge::EnumFlags_t<PerClientConfigs> config = CLIENTCONFIG_DEFAULT);
 
    void setModificationFlag();
    bool setModificationFlag(Identity const& client);
    bool clearModificationFlag(Identity const& client);
    [[nodiscard]] bool isModified(Identity const& client) const;
 
    void setRequireExplicitUpdateFlag(Identity const& client);
    [[nodiscard]] bool isRequiringExplicitUpdate(Identity const& client) const;
 
    PerClientData& newClient(Identity const& client, fge::EnumFlags_t<PerClientConfigs> config = CLIENTCONFIG_DEFAULT);
    void delClient(Identity const& client);
 
    [[nodiscard]] bool hasClient(Identity const& client) const;
 
    [[nodiscard]] PerClientData const* getClientData(Identity const& client) const;
    [[nodiscard]] PerClientData* getClientData(Identity const& client);
 
    [[nodiscard]] SyncTable::const_iterator begin() const;
    [[nodiscard]] SyncTable::iterator begin();
    [[nodiscard]] SyncTable::const_iterator end() const;
    [[nodiscard]] SyncTable::iterator end();
 
protected:
    virtual void createClientData([[maybe_unused]] std::shared_ptr<void>& ptr) const {}
    virtual void applyClientData([[maybe_unused]] std::shared_ptr<void>& ptr) const {}
 
private:
    SyncTable g_syncTable; 
};

class FGE_API NetworkTypeBase : protected PerClientSyncContext
{
protected:
    NetworkTypeBase() = default;
 
public:
    ~NetworkTypeBase() override = default;

    virtual void const* getSource() const = 0;

    virtual bool applyData(Packet const& pck) = 0;
    virtual void packData(Packet& pck, Identity const& id) = 0;
    virtual void packData(Packet& pck) = 0;

    virtual bool clientsCheckup(ClientList const& clients, bool force);

    virtual bool checkClient(Identity const& id) const;
    virtual void forceCheckClient(Identity const& id);
    virtual void forceUncheckClient(Identity const& id);
    virtual void requireExplicitUpdateClient(Identity const& id);

    virtual bool check() const = 0;
    virtual void forceCheck() = 0;
    virtual void forceUncheck() = 0;
    [[nodiscard]] bool isForced() const;
 
    void clearExplicitUpdateFlag();
    void needExplicitUpdate();
    bool isNeedingExplicitUpdate() const;
 
    void clearWaitingUpdateFlag();
    void waitingUpdate();
    bool isWaitingUpdate() const;
 
    [[nodiscard]] std::chrono::microseconds getLastUpdateTime() const;
    void setLastUpdateTime();

    fge::CallbackHandler<> _onApplied;
 
protected:
    bool _g_needExplicitUpdate{false};
    bool _g_waitingUpdate{false};
    bool _g_force{false};
    std::chrono::microseconds _g_lastUpdateTime{0};
};

template<class T>
class NetworkType : public NetworkTypeBase
{
public:
    NetworkType(fge::DataAccessor<T> source);
    ~NetworkType() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
private:
    T g_typeCopy;
    fge::DataAccessor<T> g_typeSource;
};

class FGE_API NetworkTypeScene : public NetworkTypeBase
{
public:
    NetworkTypeScene(fge::Scene* source);
    ~NetworkTypeScene() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    bool clientsCheckup(ClientList const& clients, bool force) override;
 
    bool checkClient(Identity const& id) const override;
    void forceCheckClient(Identity const& id) override;
    void forceUncheckClient(Identity const& id) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
private:
    fge::Scene* g_typeSource;
};

class FGE_API NetworkTypeTag : public NetworkTypeBase
{
public:
    NetworkTypeTag(fge::TagList* source, std::string tag);
    ~NetworkTypeTag() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
private:
    fge::TagList* g_typeSource;
    std::string g_tag;
};

class FGE_API NetworkTypeSmoothVec2Float : public NetworkTypeBase
{
public:
    NetworkTypeSmoothVec2Float(fge::DataAccessor<fge::Vector2f> source, float errorRange);
    ~NetworkTypeSmoothVec2Float() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
    fge::Vector2f const& getCache() const;
    void setErrorRange(float range);
    float getErrorRange() const;
 
private:
    fge::Vector2f g_typeCopy;
    fge::DataAccessor<fge::Vector2f> g_typeSource;
    float g_errorRange;
};

class FGE_API NetworkTypeSmoothFloat : public NetworkTypeBase
{
public:
    NetworkTypeSmoothFloat(fge::DataAccessor<float> source, float errorRange);
    ~NetworkTypeSmoothFloat() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
    float getCache() const;
    void setErrorRange(float range);
    float getErrorRange() const;
 
private:
    float g_typeCopy;
    fge::DataAccessor<float> g_typeSource;
    float g_errorRange;
};

template<class T>
class NetworkTypeProperty : public NetworkTypeBase
{
public:
    NetworkTypeProperty(fge::Property* source);
    ~NetworkTypeProperty() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
private:
    fge::Property* g_typeSource;
};

template<class T>
class NetworkTypePropertyList : public NetworkTypeBase
{
public:
    NetworkTypePropertyList(fge::PropertyList* source, std::string const& vname);
    ~NetworkTypePropertyList() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
    std::string const& getValueName() const;
 
private:
    fge::PropertyList* g_typeSource;
    std::string g_vname;
};

template<class T>
class NetworkTypeManual : public NetworkTypeBase
{
public:
    NetworkTypeManual(T* source);
    ~NetworkTypeManual() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
    void trigger();
 
private:
    T* g_typeSource;
    bool g_trigger;
};
 
template<class T>
class RecordedVector;
 
template<class T>
Packet& operator<<(Packet& pck, RecordedVector<T> const& vec);
template<class T>
Packet const& operator>>(Packet const& pck, RecordedVector<T>& vec);
 
enum class RecordedEventTypes : uint8_t
{
    ADD,
    REMOVE,
    REMOVE_ALL,
    MODIFY
};
struct RecordedEvent
{
    RecordedEventTypes _type;
    SizeType _index;
};
 
inline Packet& operator<<(Packet& pck, RecordedEvent const& event);
inline Packet const& operator>>(Packet const& pck, RecordedEvent& event);
 
template<class T>
class RecordedVector
{
public:
    using const_iterator = typename std::vector<T>::const_iterator;
    using iterator = typename std::vector<T>::iterator;
    using const_reverse_iterator = typename std::vector<T>::const_reverse_iterator;
    using const_reference = typename std::vector<T>::const_reference;
    using reference = typename std::vector<T>::reference;
 
    using EventQueue = std::vector<RecordedEvent>;
 
    RecordedVector() = default;
    ~RecordedVector() = default;
 
    [[nodiscard]] const_reference at(SizeType index) const;
    [[nodiscard]] const_reference operator[](SizeType index) const;
    [[nodiscard]] const_reference front() const;
    [[nodiscard]] const_reference back() const;
    [[nodiscard]] T const* data() const;
 
    [[nodiscard]] const_iterator begin() const;
    [[nodiscard]] const_iterator end() const;
    [[nodiscard]] const_iterator cbegin() const;
    [[nodiscard]] const_iterator cend() const;
    [[nodiscard]] const_reverse_iterator rbegin() const;
    [[nodiscard]] const_reverse_iterator rend() const;
    [[nodiscard]] const_reverse_iterator crbegin() const;
    [[nodiscard]] const_reverse_iterator crend() const;
 
    [[nodiscard]] SizeType size() const;
    [[nodiscard]] bool empty() const;
 
    void reserve(SizeType n);
 
    void clear();
    iterator insert(const_iterator pos, T const& value);
    iterator insert(const_iterator pos, T&& value);
    template<class... TArgs>
    iterator emplace(const_iterator pos, TArgs&&... value);
    template<class TArg>
    void push_back(TArg&& arg);
    template<class... TArgs>
    reference emplace_back(TArgs&&... arg);
    const_iterator erase(const_iterator pos);
    void pop_back();
 
    [[nodiscard]] reference modify(SizeType index);
    [[nodiscard]] reference modify(const_iterator pos);
 
    void clearEvents();
    [[nodiscard]] SizeType eventsSize() const;
    [[nodiscard]] EventQueue const& getEventQueue() const;
    [[nodiscard]] bool isRegisteringEvents() const;
    void registerEvents(bool enable);
 
private:
    void pushEvent(RecordedEvent event);
 
    std::vector<T> g_container;
    EventQueue g_events;
#ifdef FGE_DEF_SERVER
    bool g_registerEvents{true};
#else
    bool g_registerEvents{false};
#endif
 
    friend Packet& operator<< <T>(Packet& pck, RecordedVector const& vec);
    friend Packet const& operator>> <T>(Packet const& pck, RecordedVector& vec);
};

template<class T>
class NetworkTypeVector : public NetworkTypeBase
{
public:
    NetworkTypeVector(RecordedVector<T>* source);
    ~NetworkTypeVector() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    void forceCheckClient(Identity const& id) override;
    void forceUncheckClient(Identity const& id) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
private:
    void createClientData(std::shared_ptr<void>& ptr) const override;
    void applyClientData(std::shared_ptr<void>& ptr) const override;
 
    struct DataDeleter
    {
        inline void operator()(void* ptr) const { delete static_cast<typename RecordedVector<T>::EventQueue*>(ptr); }
    };
 
    enum class PackTypes : uint8_t
    {
        FULL,
        PARTIAL
    };
 
    RecordedVector<T>* g_typeSource;
};

template<class TEnum, class TData = void>
class NetworkTypeEvents : public NetworkTypeBase
{
public:
    using Event = std::conditional_t<std::is_void_v<TData>, TEnum, std::pair<TEnum, TData>>;
 
    NetworkTypeEvents() = default;
    ~NetworkTypeEvents() override = default;
 
    void const* getSource() const override;
 
    bool applyData(Packet const& pck) override;
    void packData(Packet& pck, Identity const& id) override;
    void packData(Packet& pck) override;
 
    void forceCheckClient(Identity const& id) override;
    void forceUncheckClient(Identity const& id) override;
 
    bool check() const override;
    void forceCheck() override;
    void forceUncheck() override;
 
    void pushEvent(Event const& event);
    void pushEventIgnore(Event const& event, Identity const& ignoreId);
 
    fge::CallbackHandler<Event> _onEvent; 
 
private:
    void createClientData(std::shared_ptr<void>& ptr) const override;
    void applyClientData(std::shared_ptr<void>& ptr) const override;
 
    using EventQueue = std::deque<Event>;
 
    struct DataDeleter
    {
        inline void operator()(void* ptr) const { delete static_cast<EventQueue*>(ptr); }
    };
 
    bool g_modified{false}; 
};

class FGE_API NetworkTypeHandler
{
public:
    NetworkTypeHandler() = default;
    ~NetworkTypeHandler() = default;
 
    //Copy function that does nothing
    NetworkTypeHandler([[maybe_unused]] NetworkTypeHandler const& n) {}
    NetworkTypeHandler& operator=([[maybe_unused]] NetworkTypeHandler const& n) { return *this; }
 
    void clear();
 
    void clientsCheckup(ClientList const& clients, bool force = false) const;
    void forceCheckClient(Identity const& id) const;
    void forceUncheckClient(Identity const& id) const;
 
    NetworkTypeBase* push(std::unique_ptr<NetworkTypeBase>&& newNet);
    template<class T, class... TArgs>
    T* push(TArgs&&... args)
    {
        static_assert(std::is_base_of_v<NetworkTypeBase, T>, "T must inherit from NetworkTypeBase");
        return static_cast<T*>(this->push(std::make_unique<T>(std::forward<TArgs>(args)...)));
    }
    template<class T, class... TArgs>
    NetworkType<T>* pushTrivial(TArgs&&... args)
    {
        return static_cast<NetworkType<T>*>(
                this->push(std::make_unique<NetworkType<T>>(fge::DataAccessor<T>{std::forward<TArgs>(args)...})));
    }
 
    std::size_t packNeededUpdate(Packet& pck) const;
    void unpackNeededUpdate(Packet const& pck, Identity const& id) const;
 
    [[nodiscard]] inline std::size_t size() const { return this->g_data.size(); }
    [[nodiscard]] inline NetworkTypeBase* get(std::size_t index) const { return this->g_data[index].get(); }
    template<class T>
    [[nodiscard]] inline T* get(std::size_t index) const
    {
        static_assert(std::is_base_of_v<NetworkTypeBase, T>, "T must inherit from NetworkTypeBase");
        return static_cast<T*>(this->g_data[index].get());
    }
    [[nodiscard]] inline NetworkTypeBase* operator[](std::size_t index) const { return this->g_data[index].get(); }
 
    void ignoreClient(Identity const& id);
    void unignoreClient(Identity const& id);
    [[nodiscard]] bool isIgnored(Identity const& id) const;
    void clearIgnoredClients();
 
private:
    std::vector<std::unique_ptr<NetworkTypeBase>> g_data;
    std::unordered_set<Identity, IdentityHash> g_ignoredClients; 
};
 
} // namespace net
} // namespace fge
 
#include "C_networkType.inl"
 
#endif // _FGE_C_NETWORKTYPE_HPP_INCLUDED