C_client.hpp

/*
 * Copyright 2024 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_CLIENT_HPP_INCLUDED
#define _FGE_C_CLIENT_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
#include "C_identity.hpp"
#include "C_packet.hpp"
#include "FastEngine/C_event.hpp"
#include "FastEngine/C_propertyList.hpp"
#include "FastEngine/network/C_protocol.hpp"
#include <array>
#include <chrono>
#include <memory>
#include <mutex>
#include <queue>
#include <vector>
 
#define FGE_NET_BAD_SKEY 0
#define FGE_NET_DEFAULT_LATENCY 20
#define FGE_NET_CLIENT_TIMESTAMP_MODULO 65536
#define FGE_NET_BAD_LATENCY std::numeric_limits<fge::net::Latency_ms>::max()
#define FGE_NET_LATENCY_PLANNER_MEAN 6
#define FGE_NET_DEFAULT_lOST_PACKET_THRESHOLD 15
 
namespace fge::net
{
 
using Skey = uint32_t; 
 
using Timestamp = uint16_t;          
using FullTimestamp = uint64_t;      
using FullTimestampOffset = int64_t; 
using Latency_ms = uint16_t; 
 
class FluxPacket;
class Client;
 
class FGE_API TransmissionPacket
{
public:
    enum class Options
    {
        UPDATE_TIMESTAMP,         
        UPDATE_FULL_TIMESTAMP,    
        UPDATE_CORRECTION_LATENCY 
    };
 
    struct Option
    {
        constexpr explicit Option(Options option, std::size_t argument = 0) :
                _option(option),
                _argument(argument)
        {}
 
        Options _option;       
        std::size_t _argument; 
    };
 
    [[nodiscard]] static inline std::shared_ptr<TransmissionPacket>
    create(ProtocolPacket::Header header = FGE_NET_BAD_HEADERID);
    [[nodiscard]] static inline std::shared_ptr<TransmissionPacket> create(Packet&& packet);
 
    TransmissionPacket(TransmissionPacket const& r) = delete;
    TransmissionPacket(TransmissionPacket&& r) noexcept = delete;
    ~TransmissionPacket() = default;
 
    TransmissionPacket& operator=(TransmissionPacket const& r) = delete;
    TransmissionPacket& operator=(TransmissionPacket&& r) noexcept = delete;
 
    [[nodiscard]] inline ProtocolPacket const& packet() const;
    [[nodiscard]] inline ProtocolPacket& packet();
    [[nodiscard]] inline std::vector<Option> const& options() const;
    [[nodiscard]] inline std::vector<Option>& options();
 
    inline TransmissionPacket& doNotDiscard();
    inline TransmissionPacket& doNotReorder();
 
    void applyOptions(Client const& client);
    void applyOptions();
 
private:
    inline explicit TransmissionPacket(ProtocolPacket::Header header,
                                       ProtocolPacket::Realm realmId,
                                       ProtocolPacket::CountId countId);
    inline explicit TransmissionPacket(ProtocolPacket&& packet);
 
    ProtocolPacket g_packet;
    std::vector<Option> g_options;
};
 
using TransmissionPacketPtr = std::shared_ptr<TransmissionPacket>;
 
class FGE_API OneWayLatencyPlanner
{
public:
    OneWayLatencyPlanner() = default;
 
    enum Stats : uint8_t
    {
        HAVE_EXTERNAL_TIMESTAMP = 1 << 0
    };
 
    void pack(TransmissionPacketPtr& tPacket);
    void unpack(FluxPacket* packet, Client& client);
 
    [[nodiscard]] std::optional<FullTimestampOffset> getClockOffset() const;
    [[nodiscard]] std::optional<Latency_ms> getLatency() const;
    [[nodiscard]] std::optional<Latency_ms> getOtherSideLatency() const;
    [[nodiscard]] std::optional<Latency_ms> getRoundTripTime() const;
 
private:
    std::optional<Latency_ms> g_latency;
    std::optional<Latency_ms> g_otherSideLatency;
 
    std::optional<FullTimestampOffset> g_meanClockOffset;
    std::array<FullTimestampOffset, FGE_NET_LATENCY_PLANNER_MEAN> g_clockOffsets{};
    std::size_t g_clockOffsetCount{0};
 
    std::optional<Latency_ms> g_roundTripTime;
 
    Timestamp g_externalStoredTimestamp{0};
    std::underlying_type_t<Stats> g_syncStat{0};
};
 
class FGE_API Client
{
public:
    Client();
    explicit Client(Latency_ms CTOSLatency, Latency_ms STOCLatency);
 
    static Skey GenerateSkey();
    void setSkey(Skey key);
    Skey getSkey() const;
 
    void setCTOSLatency_ms(Latency_ms latency);
    void setSTOCLatency_ms(Latency_ms latency);
    Latency_ms getCTOSLatency_ms() const;
    Latency_ms getSTOCLatency_ms() const;
    Latency_ms getPing_ms() const;
 
    void setCorrectorTimestamp(Timestamp timestamp);
    std::optional<Timestamp> getCorrectorTimestamp() const;
    std::optional<Latency_ms> getCorrectorLatency() const;
 
    void resetLastPacketTimePoint();
    Latency_ms getLastPacketElapsedTime() const;
 
    static Timestamp getTimestamp_ms();
    static Timestamp getTimestamp_ms(FullTimestamp fullTimestamp);
    static FullTimestamp getFullTimestamp_ms();
    static Latency_ms computeLatency_ms(Timestamp const& sentTimestamp, Timestamp const& receivedTimestamp);
 
    void clearPackets();
    void pushPacket(TransmissionPacketPtr pck);
    TransmissionPacketPtr popPacket();
    bool isPendingPacketsEmpty() const;
 
    [[nodiscard]] ProtocolPacket::Realm getCurrentRealm() const;
    [[nodiscard]] std::chrono::milliseconds getLastRealmChangeElapsedTime() const;
    void setCurrentRealm(ProtocolPacket::Realm realm);
    ProtocolPacket::Realm advanceCurrentRealm();
 
    [[nodiscard]] ProtocolPacket::CountId getCurrentPacketCountId() const;
    ProtocolPacket::CountId advanceCurrentPacketCountId();
    void setCurrentPacketCountId(ProtocolPacket::CountId countId);
 
    [[nodiscard]] ProtocolPacket::CountId getClientPacketCountId() const;
    ProtocolPacket::CountId advanceClientPacketCountId();
    void setClientPacketCountId(ProtocolPacket::CountId countId);
 
    [[nodiscard]] PacketReorderer& getPacketReorderer();
    [[nodiscard]] PacketReorderer const& getPacketReorderer() const;
 
    void clearLostPacketCount();
    uint32_t advanceLostPacketCount();
    void setLostPacketThreshold(uint32_t threshold);
    [[nodiscard]] uint32_t getLostPacketThreshold() const;
    [[nodiscard]] uint32_t getLostPacketCount() const;
 
    CallbackHandler<Client&> _onThresholdLostPacket;
 
    Event _event;                         
    PropertyList _data;                   
    OneWayLatencyPlanner _latencyPlanner; 
 
private:
    mutable std::optional<Timestamp> g_correctorTimestamp;
    Latency_ms g_CTOSLatency_ms;
    Latency_ms g_STOCLatency_ms;
    std::chrono::steady_clock::time_point g_lastPacketTimePoint;
 
    std::queue<TransmissionPacketPtr> g_pendingTransmitPackets;
    mutable std::recursive_mutex g_mutex;
 
    Skey g_skey;
 
    std::chrono::steady_clock::time_point g_lastRealmChangeTimePoint;
    ProtocolPacket::Realm g_currentRealm;
    ProtocolPacket::CountId g_currentPacketCountId;
    ProtocolPacket::CountId g_clientPacketCountId;
 
    PacketReorderer g_packetReorderer;
    uint32_t g_lostPacketCount{0};
    uint32_t g_lostPacketThreshold{FGE_NET_DEFAULT_lOST_PACKET_THRESHOLD};
};
 
} // namespace fge::net
 
#include "C_client.inl"
 
#endif // _FGE_C_CLIENT_HPP_INCLUDED