MultiplayerLevelScene.h

Go to the documentation of this file.

 
#ifndef BOMBERMAN_SCENES_MULTIPLAYER_LEVEL_SCENE_H
#define BOMBERMAN_SCENES_MULTIPLAYER_LEVEL_SCENE_H
 
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "Entities/Sound.h"
#include "Net/Client/ClientPrediction.h"
#include "Net/Client/NetClient.h"
#include "Net/NetCommon.h"
#include "Scenes/LevelScene.h"
 
namespace bomberman
{
    class Sprite;
    class Text;
 
    class MultiplayerLevelScene final : public LevelScene
    {
      public:
        // =============================================================================================================
        // ===== Construction and Scene Hooks ==========================================================================
        // =============================================================================================================
 
        MultiplayerLevelScene(Game* game, unsigned int stage, unsigned int prevScore,
                              std::optional<uint32_t> mapSeed = std::nullopt);
        MultiplayerLevelScene(Game* game, unsigned int stage, unsigned int prevScore,
                              const net::MsgLevelInfo& levelInfo);
 
        void onExit() override;
        void onNetInputQueued(uint32_t inputSeq, uint8_t buttons) override;
        [[nodiscard]]
        bool usesEventDrivenLocalMovement() const override { return false; }
        [[nodiscard]]
        bool wantsNetworkInputPolling() const override;
 
      protected:
        void updateLevel(unsigned int delta) override;
        void onKeyPressed(SDL_Scancode scancode) override;
        [[nodiscard]]
        bool supportsPause() const override { return false; }
 
      private:
        // =============================================================================================================
        // ===== Scene State ===========================================================================================
        // =============================================================================================================
 
        // ----- Local and Remote Snapshot State -----
 
        struct SnapshotSample
        {
            sim::TilePos posQ{};
            uint32_t serverTick = 0;
            bool valid = false;
        };
 
        struct RemotePlayerPresentation
        {
            std::shared_ptr<Player> playerSprite = nullptr;
            std::shared_ptr<Text> playerTag = nullptr;
            sim::TilePos authoritativePosQ{};
            SnapshotSample previousSnapshot{};
            SnapshotSample latestSnapshot{};
            MovementDirection facingDirection = MovementDirection::Right;
            float ticksSinceLatestSnapshot = 0.0f;
            bool receivedSnapshotThisUpdate = false; 
            uint8_t effectFlags = 0;
        };
 
        struct BombPresentation
        {
            std::shared_ptr<Sprite> bombSprite = nullptr;
            uint8_t ownerId = 0;
            uint8_t radius = 0;
        };
 
        struct PowerupPresentation
        {
            std::shared_ptr<Sprite> powerupSprite = nullptr;
            sim::PowerupType type = sim::PowerupType::SpeedBoost;
        };
 
        struct ExplosionPresentation
        {
            std::shared_ptr<Sprite> explosionSprite = nullptr;
            uint32_t remainingLifetimeMs = 0;
        };
 
        struct BombSparkPresentation
        {
            std::shared_ptr<Sprite> sparkSprite = nullptr;
            uint32_t remainingLifetimeMs = 0;
        };
 
        struct PendingLocalBombPlacement
        {
            uint16_t cellKey = 0;
            uint32_t remainingLifetimeMs = 0;
        };
 
        struct LivePredictionTelemetry
        {
            uint32_t lastAckedInputSeq = 0;
            uint32_t lastCorrectionServerTick = 0;
            uint32_t lastCorrectionDeltaQ = 0;
            uint32_t lastReplayCount = 0;
            uint32_t lastMissingInputs = 0;
            uint32_t lastRemainingDeferredInputs = 0;
            uint32_t maxPendingInputDepth = 0;
            uint32_t recoveryCatchUpSeq = 0;
            bool recoveryActive = false;
        };
 
        // =============================================================================================================
        // ===== Match Flow and Authority ==============================================================================
        // =============================================================================================================
 
        [[nodiscard]]
        net::NetClient* requireConnectedNetClient();
        void initializeMultiplayerScenePresentation();
        void ensureMatchLoadedAckSent(net::NetClient& netClient);
 
        [[nodiscard]]
        bool updatePreStartFlow(net::NetClient& netClient);
        void updateMatchStartFlow(net::NetClient& netClient);
        [[nodiscard]]
        bool updateLobbyReturnFlow(net::NetClient& netClient);
        void updateMatchResultFlow(net::NetClient& netClient);
 
        void consumeAuthoritativeNetState(net::NetClient& netClient);
        void applyLatestCorrectionIfAvailable(const net::NetClient& netClient);
 
        void collectPendingGameplayEvents(net::NetClient& netClient);
        void applyNextPendingGameplayEvent();
 
        [[nodiscard]]
        bool allowsLocalGameplayInput() const;
        void finalizeFrameUpdate(unsigned int delta);
 
        void applySnapshot(const net::MsgSnapshot& snapshot);
        [[nodiscard]]
        bool shouldApplyGameplayEvent(uint32_t gameplayEventTick, const char* gameplayEventName) const;
 
        void applyExplosionResolvedTiles(const net::MsgExplosionResolved& explosion);
        void ensureLocalPresentation(uint8_t localId);
        void seedLocalSpawnFromAssignedPlayerId();
        void applyAuthoritativeCorrection(const net::MsgCorrection& correction);
        static void logCorrectionReplayOutcome(const net::MsgCorrection& correction,
                                               const net::CorrectionReplayResult& replayResult);
        void storeCorrectionTelemetry(const net::MsgCorrection& correction,
                                      const net::CorrectionReplayResult& replayResult);
        void applyBootstrapLocalSnapshot(const net::MsgSnapshot::PlayerEntry& entry);
        void updateLocalPresentationFromInputButtons(uint8_t buttons);
        void syncLocalPresentationFromOwnedState(const net::LocalPlayerState& localState);
        void updateSceneObjects(unsigned int delta);
 
        // =============================================================================================================
        // ===== Presentation and Diagnostics ==========================================================================
        // =============================================================================================================
 
        void updateGameplayConnectionHealth(const net::NetClient& netClient);
        void setGameplayConnectionDegraded(bool degraded, uint32_t silenceMs = 0);
        void logLivePredictionTelemetry(unsigned int delta);
        void updateMaxPendingInputDepth();
        [[nodiscard]]
        uint32_t pendingInputDepth() const;
        void logPredictionSummary() const;
        [[nodiscard]]
        bool shouldProcessOwnerPrediction() const;
        [[nodiscard]]
        bool shouldOwnLocalStateFromPrediction() const;
        [[nodiscard]]
        uint32_t currentAuthoritativeGameplayTick(const net::NetClient& netClient) const;
 
        void showCenterBanner(std::string_view message, SDL_Color color);
        void showCenterBanner(std::string_view mainMessage, std::string_view detailMessage, SDL_Color color);
        void hideCenterBanner();
 
        void applyAuthoritativeLocalSnapshot(const net::MsgSnapshot::PlayerEntry& entry);
        void updateDeathBannerFlow();
        void setLocalPlayerAlivePresentation(bool alive);
        void setLocalPlayerInputLock(bool locked);
        void updateLocalPlayerTagPosition();
        void updatePowerupEffectPresentations(unsigned int delta);
        void ensureDebugHudPresentations();
        void updateDebugHud(unsigned int delta);
        void removeDebugHudPresentations();
        void removeRemotePlayerPresentation(uint8_t playerId);
 
        // ----- Remote Player Presentation -----
 
        void applySnapshotToRemotePlayers(const net::MsgSnapshot& snapshot, uint8_t localId);
        void applySnapshotBombs(const net::MsgSnapshot& snapshot);
        void applySnapshotPowerups(const net::MsgSnapshot& snapshot);
        void updateOrCreateRemotePlayer(uint8_t playerId, int16_t xQ, int16_t yQ, uint32_t snapshotTick, uint8_t flags);
        void updateOrCreateBombPresentation(const net::MsgSnapshot::BombEntry& entry);
        void updateOrCreatePowerupPresentation(const net::MsgSnapshot::PowerupEntry& entry);
        void pruneMissingRemotePlayers(const std::unordered_set<uint8_t>& seenRemoteIds);
        void pruneMissingBombPresentations(const std::unordered_set<uint16_t>& seenBombCells);
        void pruneMissingPowerupPresentations(const std::unordered_set<uint16_t>& seenPowerupCells);
        void removeAllRemotePlayers();
        void removeAllSnapshotBombs();
        void removeAllSnapshotPowerups();
        void applyBombPlacedEvent(const net::MsgBombPlaced& bombPlaced);
        void applyExplosionResolvedEvent(const net::MsgExplosionResolved& explosion);
        void destroyBrickPresentation(uint8_t col, uint8_t row);
        void removeBombPresentation(uint8_t col, uint8_t row);
        [[nodiscard]]
        bool canSpawnLocalBombSparkPresentation() const;
        void spawnLocalBombSparkPresentation();
        void spawnExplosionPresentation(const net::MsgCell& cell);
        void updatePendingLocalBombPlacements(unsigned int delta);
        void updateLocalBombSparkPresentations(unsigned int delta);
        void updateExplosionPresentations(unsigned int delta);
        void removeAllLocalBombSparkPresentations();
        void removeAllExplosionPresentations();
 
        static void recordSnapshotSample(RemotePlayerPresentation& presentation,
                                         int16_t xQ,
                                         int16_t yQ,
                                         uint32_t serverTick);
        [[nodiscard]]
        static uint32_t gameplayEventServerTick(const net::NetClient::GameplayEvent& gameplayEvent);
        static void updateRemoteAnimationFromSnapshotDelta(RemotePlayerPresentation& presentation);
        void updateRemotePlayerPresentations(unsigned int delta);
        [[nodiscard]]
        sim::TilePos computeRemotePresentedPosition(const RemotePlayerPresentation& presentation) const;
        static void updateRemotePlayerTagPosition(RemotePlayerPresentation& presentation);
        [[nodiscard]]
        static std::string formatPlayerTag(uint8_t playerId);
        void returnToMenu(bool disconnectClient, std::string_view reason);
        void returnToLobby(std::string_view reason);
        void onCollisionObjectSpawned(Tile tile, const std::shared_ptr<Object>& object) override;
 
        // =============================================================================================================
        // ===== Owned Runtime State ===================================================================================
        // =============================================================================================================
 
        uint32_t lastAppliedSnapshotTick_ = 0;
        uint32_t lastAppliedCorrectionTick_ = 0;
        std::optional<uint8_t> localPlayerId_{};
        uint32_t matchId_ = 0;
        uint32_t matchBootstrapStartedMs_ = 0;
        bool matchStarted_ = true;
        bool gameplayUnlocked_ = true; 
        bool matchLoadedAckSent_ = true;
        uint32_t goBannerHideTick_ = 0;
        std::optional<net::MsgMatchStart> currentMatchStart_{};
        std::optional<net::MsgMatchResult> currentMatchResult_{};
        std::shared_ptr<Text> localPlayerTag_ = nullptr;
        std::shared_ptr<Text> gameplayStatusText_ = nullptr;
        std::shared_ptr<Text> centerBannerText_ = nullptr;
        std::shared_ptr<Text> centerBannerDetailText_ = nullptr;
        std::shared_ptr<Text> debugHudNetText_ = nullptr;
        std::shared_ptr<Text> debugHudPredictionText_ = nullptr;
        std::shared_ptr<Text> debugHudSimulationText_ = nullptr;
        net::ClientPrediction localPrediction_{}; 
        LivePredictionTelemetry livePredictionTelemetry_{};
        MovementDirection localFacingDirection_ = MovementDirection::Right;
        uint32_t livePredictionLogAccumulatorMs_ = 0;
        uint32_t debugHudRefreshAccumulatorMs_ = 0;
        uint32_t lastAppliedGameplayEventTick_ = 0; 
        bool localPlayerAlive_ = true;
        bool localPlayerInputLocked_ = false;
        bool localBombHeldOnLastQueuedInput_ = false; 
        uint8_t localPlayerEffectFlags_ = 0;
        uint32_t powerupBlinkAccumulatorMs_ = 0;
        std::shared_ptr<Sound> explosionSound_ = nullptr;
 
        std::unordered_map<uint8_t, RemotePlayerPresentation> remotePlayerPresentations_;
        std::unordered_map<uint16_t, BombPresentation> bombPresentations_;
        std::unordered_map<uint16_t, PowerupPresentation> powerupPresentations_;
        std::unordered_map<uint16_t, std::shared_ptr<Object>> brickPresentations_;
        std::vector<BombSparkPresentation> bombSparkPresentations_;
        std::vector<PendingLocalBombPlacement> pendingLocalBombPlacements_; 
        std::vector<ExplosionPresentation> explosionPresentations_;
        std::deque<net::NetClient::GameplayEvent> pendingGameplayEvents_;
        bool gameplayConnectionDegraded_ = false;
        bool exited_ = false;
        bool returningToMenu_ = false; 
    };
} // namespace bomberman
 
#endif // BOMBERMAN_SCENES_MULTIPLAYER_LEVEL_SCENE_H