ClientPrediction.h

Go to the documentation of this file.

 
#ifndef BOMBERMAN_NET_CLIENTPREDICTION_H
#define BOMBERMAN_NET_CLIENTPREDICTION_H
 
#include <array>
#include <cstddef>
#include <cstdint>
 
#include "Net/NetCommon.h"
#include "Sim/Movement.h"
 
namespace bomberman::net
{
    // ----- Constants and Types -----
 
    constexpr std::size_t kClientPredictionHistorySize = 128;
 
    static_assert((kClientPredictionHistorySize & (kClientPredictionHistorySize - 1u)) == 0u,
                  "kClientPredictionHistorySize must be a power of two");
 
    struct LocalPlayerState
    {
        sim::TilePos posQ{};
        uint8_t buttons = 0; 
        uint8_t playerFlags = 0; 
    };
 
    // ----- Diagnostics and Telemetry -----
 
    struct CorrectionReplayResult
    {
        bool ignoredStaleCorrection = false;         
        bool hadRetainedPredictedStateAtAck = false; 
        bool correctionMatchedRetainedPrediction = false; 
        bool recoveryTriggered = false;              
        bool recoveryRestarted = false;              
        bool recoveryResolved = false;               
        bool recoveryStillActive = false;            
 
        uint32_t replayedInputs = 0;                 
        uint32_t missingInputHistory = 0;            
        uint32_t remainingDeferredInputs = 0;        
        uint32_t recoveryCatchUpSeq = 0;             
        int32_t deltaXQ = 0;                         
        int32_t deltaYQ = 0;                         
        uint32_t deltaManhattanQ = 0;                
    };
 
    struct PredictionStats
    {
        uint32_t localInputsApplied = 0;          
        uint32_t localInputsDeferred = 0;         
        uint32_t rejectedLocalInputs = 0;         
 
        uint32_t correctionsApplied = 0;               
        uint32_t correctionsWithRetainedPredictedState = 0; 
        uint32_t correctionsMismatched = 0;            
 
        uint32_t totalCorrectionDeltaQ = 0;       
        uint32_t maxCorrectionDeltaQ = 0;         
 
        uint32_t totalReplayedInputs = 0;         
        uint32_t maxReplayedInputs = 0;           
 
        uint32_t replayTruncations = 0;           
        uint32_t totalMissingInputHistory = 0;    
        uint32_t maxMissingInputHistory = 0;      
        uint32_t recoveryActivations = 0;         
        uint32_t recoveryResolutions = 0;         
    };
 
    // ----- Client Prediction Helper -----
 
    class ClientPrediction
    {
      private:
        enum class PredictionPhase : uint8_t
        {
            AwaitingBaseline,
            Active,
            Recovering
        };
 
      public:
        ClientPrediction() = default;
 
        // ----- Public API -----
 
        void reset() noexcept;
        void suspend() noexcept;
 
        [[nodiscard]]
        bool isInitialized() const noexcept { return phase_ != PredictionPhase::AwaitingBaseline; }
 
        [[nodiscard]]
        const LocalPlayerState& currentState() const noexcept { return currentState_; }
 
        [[nodiscard]]
        const PredictionStats& stats() const noexcept { return stats_; }
 
        [[nodiscard]]
        uint32_t lastRecordedInputSeq() const noexcept { return lastRecordedInputSeq_; }
 
        bool applyLocalInput(uint32_t inputSeq, uint8_t buttons, const sim::TileMap& map) noexcept;
 
        [[nodiscard]]
        CorrectionReplayResult reconcileAndReplay(const MsgCorrection& correction, const sim::TileMap& map) noexcept;
 
      private:
        // ----- History entries -----
 
        struct InputHistoryEntry
        {
            uint32_t seq = 0;     
            uint8_t buttons = 0;  
            bool valid = false;   
        };
 
        struct StateHistoryEntry
        {
            uint32_t seq = 0;          
            LocalPlayerState state{};  
            bool valid = false;        
        };
 
        [[nodiscard]]
        static constexpr std::size_t historySlot(uint32_t seq) noexcept
        {
            return seq & (kClientPredictionHistorySize - 1u);
        }
 
        // ----- Correction helpers -----
 
        void setCurrentAuthoritativeState(sim::TilePos posQ,
                                          uint8_t buttons = 0,
                                          uint8_t playerFlags = 0) noexcept;
        void enterRecoveryFromReplayFailure(sim::TilePos authoritativePosQ,
                                            uint32_t lastProcessedInputSeq,
                                            uint8_t authoritativePlayerFlags,
                                            CorrectionReplayResult& result,
                                            bool wasRecovering) noexcept;
        [[nodiscard]]
        bool replayFromAuthoritativeBaseline(uint32_t lastProcessedInputSeq,
                                             sim::TilePos authoritativePosQ,
                                             uint8_t authoritativeButtons,
                                             uint8_t authoritativePlayerFlags,
                                             const sim::TileMap& map,
                                             CorrectionReplayResult& result) noexcept;
        void handleAwaitingBaselineCorrection(uint32_t lastProcessedInputSeq,
                                              sim::TilePos authoritativePosQ,
                                              uint8_t authoritativePlayerFlags,
                                              const sim::TileMap& map,
                                              CorrectionReplayResult& result) noexcept;
        void handleRecoveringCorrection(uint32_t lastProcessedInputSeq,
                                        sim::TilePos authoritativePosQ,
                                        uint8_t authoritativePlayerFlags,
                                        const sim::TileMap& map,
                                        CorrectionReplayResult& result) noexcept;
        void handleActiveCorrection(uint32_t lastProcessedInputSeq,
                                    sim::TilePos authoritativePosQ,
                                    uint8_t authoritativeButtons,
                                    uint8_t authoritativePlayerFlags,
                                    const sim::TileMap& map,
                                    CorrectionReplayResult& result) noexcept;
        void measureCorrectionAtAck(uint32_t lastProcessedInputSeq,
                                    sim::TilePos authoritativePosQ,
                                    uint8_t& predictedButtonsAtAck,
                                    CorrectionReplayResult& result) noexcept;
        [[nodiscard]]
        bool tryGetPredictedStateAtSeq(uint32_t inputSeq, LocalPlayerState& outState) const noexcept;
 
        // ----- History storage -----
 
        void clearHistory() noexcept;
        void storeInputHistory(uint32_t seq, uint8_t buttons) noexcept;
        void storeStateHistory(uint32_t seq, const LocalPlayerState& state) noexcept;
        void invalidateStateHistoryRange(uint32_t firstSeq, uint32_t lastSeq) noexcept;
        void discardAcknowledgedHistory(uint32_t lastProcessedInputSeq) noexcept;
        [[nodiscard]]
        uint32_t countRetainedInputSuffixAfter(uint32_t inputSeq) const noexcept;
        [[nodiscard]]
        bool replayRetainedInputSuffixAfter(uint32_t lastProcessedInputSeq,
                                            const sim::TileMap& map,
                                            CorrectionReplayResult& result) noexcept;
 
        // ----- Ring lookups and simulation -----
 
        [[nodiscard]]
        const InputHistoryEntry* findInputHistory(uint32_t seq) const noexcept;
 
        [[nodiscard]]
        const StateHistoryEntry* findStateHistory(uint32_t seq) const noexcept;
 
        [[nodiscard]]
        LocalPlayerState simulateNextStateFromInput(const LocalPlayerState& baseState,
                                                    uint8_t buttons,
                                                    const sim::TileMap& map) const noexcept;
 
        // ----- State -----
 
        std::array<InputHistoryEntry, kClientPredictionHistorySize> inputHistory_{};
        std::array<StateHistoryEntry, kClientPredictionHistorySize> stateHistory_{};
 
        LocalPlayerState currentState_{};  
        PredictionStats stats_{};
        uint32_t lastRecordedInputSeq_ = 0; 
        uint32_t lastAuthoritativeInputSeq_ = 0; 
        uint32_t recoveryCatchUpSeq_ = 0;   
        PredictionPhase phase_ = PredictionPhase::AwaitingBaseline; 
    };
 
} // namespace bomberman::net
 
#endif // BOMBERMAN_NET_CLIENTPREDICTION_H