ServerState.h

Go to the documentation of this file.

 
#ifndef BOMBERMAN_SERVERSTATE_H
#define BOMBERMAN_SERVERSTATE_H
 
#include <array>
#include <optional>
#include <string>
#include <string_view>
 
#include <enet/enet.h>
 
#include "Net/NetCommon.h"
#include "Net/NetDiagnostics.h"
#include "Sim/Movement.h"
#include "Sim/PowerupConfig.h"
 
namespace bomberman::server
{
    // ----- Server session constants -----
 
    constexpr std::size_t kServerPeerSessionCapacity = net::kMaxPlayers + 4;
 
    // ----- Input buffering constants -----
 
    constexpr std::size_t kServerInputBufferSize = static_cast<std::size_t>(net::kMaxInputBatchSize) * 2u;
 
    constexpr uint32_t kMaxBufferedInputLead = kServerInputBufferSize - 1;
 
    // ----- Match gameplay-state constants -----
 
    constexpr std::size_t kServerBombCapacity = static_cast<std::size_t>(tileArrayWidth) *
                                                static_cast<std::size_t>(tileArrayHeight);
 
    constexpr std::size_t kServerPowerupCapacity = sim::kPowerupsPerRound;
 
    // ----- Server phase -----
 
    enum class ServerPhase : uint8_t
    {
        Lobby,         
        LobbyCountdown,
        StartingMatch, 
        InMatch,       
        EndOfMatch     
    };
 
    // ----- Accepted player metadata -----
 
    struct PlayerSlot
    {
        uint8_t playerId = 0;
        std::string playerName;
        bool ready = false;
        uint8_t wins = 0;
    };
 
    struct DisconnectedPlayerReclaim
    {
        std::string playerName;
        uint8_t wins = 0;
    };
 
    // ----- Live peer sessions -----
 
    struct PeerSession
    {
        ENetPeer* peer = nullptr;
        std::optional<uint8_t> playerId{};  
        uint32_t connectedServerTick = 0;
    };
 
    // ----- Match-only authoritative state -----
 
    struct InputRingEntry
    {
        uint32_t seq = 0;
        uint8_t buttons = 0;
        bool valid = false;        
        bool seenDirect = false;   
        bool seenBuffered = false; 
    };
 
    struct MatchPlayerState
    {
        uint8_t playerId = 0;
        sim::TilePos pos{};
        bool alive = true;
        bool inputLocked = false;
        uint8_t activeBombCount = 0;
        uint8_t maxBombs = sim::kDefaultPlayerMaxBombs;
        uint8_t bombRange = sim::kDefaultPlayerBombRange;
        uint32_t invincibleUntilTick = 0;
        uint32_t speedBoostUntilTick = 0;
        uint32_t bombRangeBoostUntilTick = 0;
        uint32_t maxBombsBoostUntilTick = 0;
 
        // ----- Input ring buffer -----
        std::array<InputRingEntry, kServerInputBufferSize> inputRing{}; 
        uint32_t lastReceivedInputSeq = 0;
        uint32_t lastProcessedInputSeq = 0;
 
        uint8_t lastAppliedButtons = 0; 
        uint8_t appliedButtons = 0;
        uint8_t previousTickButtons = 0;
 
        // ----- Consume timeline -----
        bool inputTimelineStarted = false;  
        uint32_t nextConsumeServerTick = 0;
 
        // ----- Warning throttles -----
        uint16_t consecutiveTooFarAheadBatches = 0;
        uint16_t consecutiveInputGaps = 0;
        uint32_t nextTooFarAheadWarnTick = 0;
        uint32_t nextGapWarnTick = 0;
    };
 
    struct BombCell
    {
        uint8_t col = 0;
        uint8_t row = 0;
    };
 
    struct BombState
    {
        uint8_t ownerId = 0;
        BombCell cell{};
        uint32_t placedTick = 0;
        uint32_t explodeTick = 0;
        uint8_t radius = 0; 
    };
 
    struct PowerupState
    {
        sim::PowerupType type = sim::PowerupType::SpeedBoost;
        BombCell cell{};
        bool revealed = false;     
        uint32_t revealedTick = 0;
    };
 
    // ----- Shared server session state -----
 
    struct ServerState
    {
        // ----- Session host and runtime config -----
 
        ENetHost* host = nullptr;               
        ServerPhase phase = ServerPhase::Lobby; 
        uint32_t serverTick = 0;                
 
        uint32_t inputLeadTicks = sim::kDefaultServerInputLeadTicks;
        uint32_t snapshotIntervalTicks = sim::kDefaultServerSnapshotIntervalTicks;
        bool powersEnabled = true; 
 
        // ----- Live transport sessions -----
 
        std::array<std::optional<PeerSession>, kServerPeerSessionCapacity> peerSessions{};
 
        // ----- Accepted players and lobby persistence -----
 
        std::array<std::optional<PlayerSlot>, net::kMaxPlayers> playerSlots{};
        std::array<std::optional<DisconnectedPlayerReclaim>, net::kMaxPlayers> disconnectedPlayerReclaims{};
 
        // ----- Active round authoritative world state -----
 
        std::array<std::optional<MatchPlayerState>, net::kMaxPlayers> matchPlayers{};
        std::array<std::optional<BombState>, kServerBombCapacity> bombs{};
        std::array<std::optional<PowerupState>, kServerPowerupCapacity> powerups{};
 
        sim::TileMap tiles{};
 
        // ----- Player-id allocation -----
 
        std::array<uint8_t, net::kMaxPlayers> playerIdPool{}; 
        uint8_t playerIdPoolSize = 0;
 
        // ----- Round map selection -----
 
        std::optional<uint32_t> fixedMapSeedOverride{}; 
        uint32_t mapSeed = 0;
 
        // ----- Lobby and round flow state -----
 
        uint32_t currentMatchId = 0; 
        uint32_t nextMatchId = 1;
 
        uint32_t currentLobbyCountdownPlayerMask = 0; 
        uint32_t currentLobbyCountdownDeadlineTick = 0;
        uint8_t currentLobbyCountdownLastBroadcastSecond = 0;
 
        uint32_t currentMatchPlayerMask = 0; 
        uint32_t currentMatchLoadedMask = 0;
        uint32_t currentMatchStartDeadlineTick = 0;
        uint32_t currentMatchGoShowTick = 0;
        uint32_t currentMatchUnlockTick = 0;
        uint32_t currentEndOfMatchReturnTick = 0;
        std::optional<uint8_t> roundWinnerPlayerId{}; 
        bool roundEndedInDraw = false;
 
        // ----- Diagnostics -----
 
        net::NetDiagnostics diag; 
    };
 
    // ----- Dispatcher context -----
 
    struct PacketDispatchContext
    {
        ServerState& state;
        ENetPeer* peer = nullptr;
        net::NetDiagnostics* diag = nullptr;
        net::NetPacketResult receiveResult = net::NetPacketResult::Rejected;
        std::optional<uint8_t> recordedPlayerId{}; 
    };
 
    // ----- Session lifecycle -----
 
    void initServerState(ServerState& state,
                         ENetHost* host,
                         bool diagEnabled = false,
                         bool overrideMapSeed = false,
                         uint32_t mapSeed = 0,
                         uint32_t inputLeadTicks = sim::kDefaultServerInputLeadTicks,
                         uint32_t snapshotIntervalTicks = sim::kDefaultServerSnapshotIntervalTicks,
                         bool powersEnabled = true);
 
    void rollNextRoundMapSeed(ServerState& state);
 
    // ----- Player-id allocation -----
 
    [[nodiscard]]
    std::optional<uint8_t> acquirePlayerId(ServerState& state);
 
    [[nodiscard]]
    bool acquireSpecificPlayerId(ServerState& state, uint8_t playerId);
 
    void releasePlayerId(ServerState& state, uint8_t playerId);
 
    // ----- Peer-session binding and lookup -----
    [[nodiscard]]
    PeerSession* bindPeerSession(ServerState& state, ENetPeer& peer);
 
    [[nodiscard]]
    PeerSession* getPeerSession(ENetPeer* peer);
    [[nodiscard]]
    const PeerSession* getPeerSession(const ENetPeer* peer);
 
    [[nodiscard]]
    PeerSession* findPeerSessionByPlayerId(ServerState& state, uint8_t playerId);
    [[nodiscard]]
    const PeerSession* findPeerSessionByPlayerId(const ServerState& state, uint8_t playerId);
 
    void acceptPeerSession(ServerState& state,
                           PeerSession& session,
                           uint8_t playerId,
                           std::string_view playerName,
                           uint8_t carriedWins = 0);
 
    [[nodiscard]]
    std::optional<uint8_t> releasePeerSession(ServerState& state, ENetPeer& peer);
 
    // ----- Match player state lifecycle -----
    void createMatchPlayerState(ServerState& state, uint8_t playerId);
 
    void destroyMatchPlayerState(ServerState& state, uint8_t playerId);
 
    // ----- Fixed-tick simulation -----
 
    void simulateServerTick(ServerState& state);
} // namespace bomberman::server
 
#endif // BOMBERMAN_SERVERSTATE_H