NetClient.h

Go to the documentation of this file.

 
#ifndef BOMBERMAN_NET_NETCLIENT_H
#define BOMBERMAN_NET_NETCLIENT_H
 
#include <memory>
#include <optional>
#include <string>
#include <string_view>
 
#include "Net/NetCommon.h"
 
namespace bomberman::net
{
    class ClientDiagnostics;
 
    // ----- Connection state -----
 
    enum class EConnectState : uint8_t
    {
        Disconnected,    
        Connecting,      
        Handshaking,     
        Connected,       
        Disconnecting,   
        FailedResolve,   
        FailedConnect,   
        FailedHandshake, 
        FailedProtocol,  
        FailedInit,      
    };
 
    [[nodiscard]] constexpr bool isFailedState(EConnectState state)
    {
        return state >= EConnectState::FailedResolve;
    }
 
    constexpr std::string_view connectStateName(EConnectState state)
    {
        switch (state)
        {
            using enum EConnectState;
 
            case Disconnected:      return "Disconnected";
            case Connecting:        return "Connecting";
            case Handshaking:       return "Handshaking";
            case Connected:         return "Connected";
            case Disconnecting:     return "Disconnecting";
            case FailedResolve:     return "FailedResolve";
            case FailedConnect:     return "FailedConnect";
            case FailedHandshake:   return "FailedHandshake";
            case FailedProtocol:    return "FailedProtocol";
            case FailedInit:        return "FailedInit";
            default:                return "Unknown";
        }
    }
 
    class NetClient
    {
    public:
        struct ClientLiveStats
        {
            uint32_t rttMs = 0;
            uint32_t rttVarianceMs = 0;
            uint32_t lossPermille = 0;
            uint32_t lastSnapshotTick = 0;
            uint32_t lastCorrectionTick = 0;
            uint32_t snapshotAgeMs = 0;
            uint32_t gameplaySilenceMs = 0;
 
            bool predictionActive = false;
            bool recoveryActive = false;
            uint32_t correctionCount = 0;
            uint32_t mismatchCount = 0;
            uint32_t lastCorrectionDeltaQ = 0;
            uint32_t maxPendingInputDepth = 0;
        };
 
        NetClient();
 
        ~NetClient() noexcept;
 
        NetClient(const NetClient&) = delete;
        NetClient& operator=(const NetClient&) = delete;
 
        NetClient(NetClient&&) = delete;
        NetClient& operator=(NetClient&&) = delete;
 
        // ----- Connection lifecycle -----
 
        void beginConnect(const std::string& host, uint16_t port, std::string_view playerName);
 
        bool disconnectBlocking();
 
        void disconnectAsync();
 
        void cancelConnect();
 
        // ----- Runtime API -----
 
        void pumpNetwork(uint16_t timeoutMs = 0);
 
        [[nodiscard]]
        std::optional<uint32_t> sendInput(uint8_t buttons);
 
        [[nodiscard]]
        bool sendLobbyReady(bool ready);
 
        [[nodiscard]]
        bool sendMatchLoaded(uint32_t matchId);
 
        void flushOutgoing() const;
 
        [[nodiscard]]
        bool isConnected() const { return state_ == EConnectState::Connected; }
 
        [[nodiscard]]
        EConnectState connectState() const { return state_; }
 
        [[nodiscard]]
        const std::optional<MsgReject::EReason>& lastRejectReason() const { return lastRejectReason_; }
 
        void setDiagnosticsConfig(bool enabled, bool predictionEnabled, bool remoteSmoothingEnabled);
 
        [[nodiscard]]
        ClientDiagnostics& clientDiagnostics();
        [[nodiscard]]
        const ClientDiagnostics& clientDiagnostics() const;
 
        void updateLiveTransportStats(uint32_t rttMs,
                                      uint32_t rttVarianceMs,
                                      uint32_t lossPermille,
                                      uint32_t lastSnapshotTick,
                                      uint32_t lastCorrectionTick,
                                      uint32_t snapshotAgeMs,
                                      uint32_t gameplaySilenceMs);
 
        void updateLivePredictionStats(bool predictionActive,
                                       bool recoveryActive,
                                       uint32_t correctionCount,
                                       uint32_t mismatchCount,
                                       uint32_t lastCorrectionDeltaQ,
                                       uint32_t maxPendingInputDepth);
 
        [[nodiscard]]
        const ClientLiveStats& liveStats() const;
 
        [[nodiscard]]
        uint8_t playerId() const { return playerId_; }
 
        static constexpr uint8_t kInvalidPlayerId = 0xFF;
 
        [[nodiscard]]
        uint16_t serverTickRate() const { return serverTickRate_; }
 
        [[nodiscard]]
        bool tryGetLatestLobbyState(MsgLobbyState& out) const;
 
        [[nodiscard]]
        uint32_t lobbySilenceMs() const;
 
        [[nodiscard]]
        bool consumePendingLevelInfo(MsgLevelInfo& out);
 
        [[nodiscard]]
        bool tryGetLatestSnapshot(MsgSnapshot& out) const;
 
        [[nodiscard]]
        uint32_t lastSnapshotTick() const;
 
        [[nodiscard]]
        bool tryGetLatestCorrection(MsgCorrection& out) const;
 
        [[nodiscard]]
        uint32_t lastCorrectionTick() const;
 
        struct GameplayEvent
        {
            enum class EType : uint8_t
            {
                BombPlaced,
                ExplosionResolved
            };
 
            [[nodiscard]]
            static GameplayEvent fromBombPlaced(const MsgBombPlaced& bombPlaced)
            {
                GameplayEvent event{};
                event.type = EType::BombPlaced;
                event.bombPlaced = bombPlaced;
                return event;
            }
 
            [[nodiscard]]
            static GameplayEvent fromExplosionResolved(const MsgExplosionResolved& explosionResolved)
            {
                GameplayEvent event{};
                event.type = EType::ExplosionResolved;
                event.explosionResolved = explosionResolved;
                return event;
            }
 
            EType type = EType::BombPlaced;
            MsgBombPlaced bombPlaced{};
            MsgExplosionResolved explosionResolved{};
        };
 
        [[nodiscard]]
        bool tryDequeueGameplayEvent(GameplayEvent& out);
 
        [[nodiscard]]
        bool hasBrokenGameplayEventStream() const;
 
        [[nodiscard]]
        uint32_t gameplaySilenceMs() const;
 
        [[nodiscard]]
        bool tryGetLatestMatchStart(MsgMatchStart& out) const;
 
        [[nodiscard]]
        bool hasMatchStarted(uint32_t matchId) const;
 
        [[nodiscard]]
        bool isMatchCancelled(uint32_t matchId) const;
 
        [[nodiscard]]
        bool tryGetLatestMatchResult(MsgMatchResult& out) const;
 
        [[nodiscard]]
        bool tryGetMapSeed(uint32_t& outSeed) const;
 
    private:
        // ----- Private state -----
 
        struct Impl;
        std::unique_ptr<Impl> impl_;
 
        bool initialized_ = false;
        EConnectState state_ = EConnectState::Disconnected;
 
        uint8_t playerId_ = kInvalidPlayerId; 
        uint16_t serverTickRate_ = 0; 
        std::optional<MsgReject::EReason> lastRejectReason_; 
 
        // ----- ENet lifecycle -----
 
        bool initializeENet();
        void shutdownENet();
 
        void finalizeDiagnosticsSession(EConnectState finalState);
 
        // ----- Disconnect helpers -----
 
        [[nodiscard]]
        bool drainGracefulDisconnect();
 
        void startGracefulDisconnect();
 
        void destroyTransport();
 
        void resetLocalInputStream();
 
        void resetLocalMatchBootstrapState();
 
        void resetCurrentMatchSession();
 
        void resetSessionState(bool clearRejectReason = true);
 
        void failConnection(EConnectState failureState, bool clearRejectReason = true);
 
        void transitionToDisconnected();
 
        void resetState();
 
        // ----- Protocol handlers -----
 
        void handleWelcome(const uint8_t* payload, std::size_t payloadSize);
        void handleReject(const uint8_t* payload, std::size_t payloadSize);
        void handleLevelInfo(const uint8_t* payload, std::size_t payloadSize);
        void handleLobbyState(const uint8_t* payload, std::size_t payloadSize);
        void handleMatchStart(const uint8_t* payload, std::size_t payloadSize);
        void handleMatchCancelled(const uint8_t* payload, std::size_t payloadSize);
        void handleMatchResult(const uint8_t* payload, std::size_t payloadSize);
        void handleSnapshot(const uint8_t* payload, std::size_t payloadSize);
        void handleCorrection(const uint8_t* payload, std::size_t payloadSize);
        void handleBombPlaced(const uint8_t* payload, std::size_t payloadSize);
        void handleExplosionResolved(const uint8_t* payload, std::size_t payloadSize);
        void enqueueGameplayEvent(const GameplayEvent& event);
 
        // ----- pumpNetwork() helpers -----
 
        bool checkConnectTimeouts();
        bool checkDisconnectTimeout();
 
        bool handleConnectEvent();
 
        bool handleReceiveEvent(const uint8_t* data, std::size_t dataLength, uint8_t channelID);
 
        void handleDisconnectEvent();
    };
 
} // namespace bomberman::net
 
#endif // BOMBERMAN_NET_NETCLIENT_H