NetCommon.h

Go to the documentation of this file.

#ifndef BOMBERMAN_NET_NETCOMMON_H
#define BOMBERMAN_NET_NETCOMMON_H
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <string_view>
 
#include "Const.h"
#include "Sim/PowerupConfig.h"
 
namespace bomberman::net
{
    // =================================================================================================================
    // ===== Protocol Definition =======================================================================================
    // =================================================================================================================
 
    // ----- Protocol Constants -----
 
    constexpr uint16_t      kProtocolVersion = 9;
 
    constexpr uint16_t      kDefaultServerPort = 12345;  
    constexpr std::size_t   kMaxPacketSize = 1400;       
    constexpr uint32_t      kInputLogEveryN = 30;        
    constexpr uint32_t      kSnapshotLogEveryN = 30;     
    constexpr uint32_t      kPeerPingIntervalMs = 500;   
    constexpr uint32_t      kPeerTimeoutLimit = 8;       
    constexpr uint32_t      kPeerTimeoutMinimumMs = 5000;  
    constexpr uint32_t      kPeerTimeoutMaximumMs = 10000; 
 
    constexpr std::size_t   kPlayerNameMax = 16;
    constexpr uint8_t       kMaxPlayers = 4;             
    constexpr uint8_t       kMaxSnapshotBombs = kMaxPlayers * 4; 
    constexpr uint8_t       kMaxSnapshotPowerups = sim::kPowerupsPerRound; 
    constexpr std::size_t   kMaxExplosionBlastCells =
        1u + 4u * (static_cast<std::size_t>((tileArrayWidth > tileArrayHeight) ?
            tileArrayWidth :
            tileArrayHeight) - 1u); 
    constexpr std::size_t   kMaxExplosionDestroyedBricks = kMaxExplosionBlastCells - 1u; 
 
    constexpr uint32_t      kFirstInputSeq = 1;
 
    constexpr uint8_t       kMaxInputBatchSize = 16;
 
    // ----- Input Bitmask Constants -----
 
    constexpr uint8_t kInputUp    = 0x01;
    constexpr uint8_t kInputDown  = 0x02;
    constexpr uint8_t kInputLeft  = 0x04;
    constexpr uint8_t kInputRight = 0x08;
    constexpr uint8_t kInputBomb  = 0x10;
 
    constexpr uint8_t kInputKnownBits = kInputUp | kInputDown | kInputLeft | kInputRight | kInputBomb;
 
    constexpr int8_t buttonsToMoveX(uint8_t buttons)
    {
        int8_t dx = 0;
        if (buttons & kInputRight) dx += 1;
        if (buttons & kInputLeft)  dx -= 1;
        return dx;
    }
 
    constexpr int8_t buttonsToMoveY(uint8_t buttons)
    {
        int8_t dy = 0;
        if (buttons & kInputDown) dy += 1;
        if (buttons & kInputUp)   dy -= 1;
        return dy;
    }
 
    // ----- ENet Channels -----
 
    enum class EChannel : uint8_t
    {
        ControlReliable      = 0,
        GameplayReliable     = 1,
        InputUnreliable      = 2,
        SnapshotUnreliable   = 3,
        CorrectionUnreliable = 4
    };
    constexpr std::size_t kChannelCount = 5;  
 
    constexpr std::string_view channelName(uint8_t id)
    {
        switch (id)
        {
            case static_cast<uint8_t>(EChannel::ControlReliable):      return "ControlReliable";
            case static_cast<uint8_t>(EChannel::GameplayReliable):     return "GameplayReliable";
            case static_cast<uint8_t>(EChannel::InputUnreliable):      return "InputUnreliable";
            case static_cast<uint8_t>(EChannel::SnapshotUnreliable):   return "SnapshotUnreliable";
            case static_cast<uint8_t>(EChannel::CorrectionUnreliable): return "CorrectionUnreliable";
            default:                                                   return "Unknown";
        }
    }
 
    // ----- Wire Size Constants -----
    //
    // All current protocol payloads are fixed-size on the wire. That keeps
    // packet validation cheap and lets both sides reject malformed packets
    // immediately using only the message type and payload size.
 
    constexpr std::size_t kPacketHeaderSize =
        sizeof(uint8_t) +  // type
        sizeof(uint16_t);  // payloadSize
 
    constexpr std::size_t kMsgHelloSize =
        sizeof(uint16_t) + // protocolVersion
        kPlayerNameMax;    // name (fixed-size field)
 
    constexpr std::size_t kMsgWelcomeSize =
        sizeof(uint16_t) + // protocolVersion
        sizeof(uint8_t) +  // playerId
        sizeof(uint16_t);  // serverTickRate
 
    constexpr std::size_t kMsgRejectSize =
        sizeof(uint8_t) +  // reason
        sizeof(uint16_t);  // expectedProtocolVersion
 
    constexpr std::size_t kMsgLevelInfoSize =
        sizeof(uint32_t) +  // matchId
        sizeof(uint32_t);   // mapSeed
 
    constexpr std::size_t kMsgLobbyReadySize =
        sizeof(uint8_t);   // ready
 
    constexpr std::size_t kMsgMatchLoadedSize =
        sizeof(uint32_t);  // matchId
 
    constexpr std::size_t kMsgMatchStartSize =
        sizeof(uint32_t) +  // matchId
        sizeof(uint32_t) +  // goShowServerTick
        sizeof(uint32_t);   // unlockServerTick
 
    constexpr std::size_t kMsgMatchCancelledSize =
        sizeof(uint32_t);  // matchId
 
    constexpr std::size_t kMsgMatchResultSize =
        sizeof(uint32_t) +  // matchId
        sizeof(uint8_t) +   // result
        sizeof(uint8_t) +   // winnerPlayerId
        kPlayerNameMax;     // winnerName
 
    constexpr std::size_t kMsgLobbyStateSeatSize =
        sizeof(uint8_t) +  // flags
        sizeof(uint8_t) +  // wins
        kPlayerNameMax;    // name (fixed-size field)
 
    constexpr std::size_t kMsgLobbyStateSize =
        sizeof(uint8_t) +   // phase
        sizeof(uint8_t) +   // countdownSecondsRemaining
        sizeof(uint16_t) +  // reserved
        kMaxPlayers * kMsgLobbyStateSeatSize;
 
    constexpr std::size_t kMsgInputSize =
        sizeof(uint32_t) + // baseInputSeq
        sizeof(uint8_t) +  // count
        kMaxInputBatchSize; // inputs[kMaxInputBatchSize]
 
    constexpr std::size_t kMsgSnapshotSize =
        sizeof(uint32_t) + // matchId
        sizeof(uint32_t) + // serverTick
        sizeof(uint8_t) +  // playerCount
        sizeof(uint8_t) +  // bombCount
        sizeof(uint8_t) +  // powerupCount
        kMaxPlayers *
            (sizeof(uint8_t) +   // playerId
             sizeof(int16_t) +   // xQ
             sizeof(int16_t) +   // yQ
             sizeof(uint8_t)) +  // flags
        kMaxSnapshotBombs *
            (sizeof(uint8_t) +   // ownerId
             sizeof(uint8_t) +   // col
             sizeof(uint8_t) +   // row
             sizeof(uint8_t)) +  // radius
        kMaxSnapshotPowerups *
            (sizeof(uint8_t) +   // type
             sizeof(uint8_t) +   // col
             sizeof(uint8_t));   // row
 
    constexpr std::size_t kMsgCorrectionSize =
        sizeof(uint32_t) + // matchId
        sizeof(uint32_t) + // serverTick
        sizeof(uint32_t) + // lastProcessedInputSeq
        sizeof(int16_t) +  // xQ
        sizeof(int16_t) +  // yQ
        sizeof(uint8_t) +  // playerFlags
        3u;                // reserved
 
    constexpr std::size_t kMsgBombPlacedSize =
        sizeof(uint32_t) + // matchId
        sizeof(uint32_t) + // serverTick
        sizeof(uint32_t) + // explodeTick
        sizeof(uint8_t) +  // ownerId
        sizeof(uint8_t) +  // col
        sizeof(uint8_t) +  // row
        sizeof(uint8_t);   // radius
 
    constexpr std::size_t kMsgExplosionResolvedSize =
        sizeof(uint32_t) + // matchId
        sizeof(uint32_t) + // serverTick
        sizeof(uint8_t) +  // ownerId
        sizeof(uint8_t) +  // originCol
        sizeof(uint8_t) +  // originRow
        sizeof(uint8_t) +  // radius
        sizeof(uint8_t) +  // killedPlayerMask
        sizeof(uint8_t) +  // blastCellCount
        sizeof(uint8_t) +  // destroyedBrickCount
        kMaxExplosionBlastCells *
            (sizeof(uint8_t) + // col
             sizeof(uint8_t)) + // row
        kMaxExplosionDestroyedBricks *
            (sizeof(uint8_t) + // col
             sizeof(uint8_t)); // row
 
    static_assert(sizeof(char) == 1, "Unexpected char size");
 
    static_assert(kPacketHeaderSize         == 3,  "PacketHeader size mismatch");
    static_assert(kMsgHelloSize             == 18, "MsgHello size mismatch");
    static_assert(kMsgWelcomeSize           == 5,  "MsgWelcome size mismatch");
    static_assert(kMsgRejectSize            == 3,  "MsgReject size mismatch");
    static_assert(kMsgLevelInfoSize         == 8,  "MsgLevelInfo size mismatch");
    static_assert(kMsgLobbyReadySize        == 1,  "MsgLobbyReady size mismatch");
    static_assert(kMsgMatchLoadedSize       == 4,  "MsgMatchLoaded size mismatch");
    static_assert(kMsgMatchStartSize        == 12, "MsgMatchStart size mismatch");
    static_assert(kMsgMatchCancelledSize    == 4,  "MsgMatchCancelled size mismatch");
    static_assert(kMsgMatchResultSize       == 22, "MsgMatchResult size mismatch");
    static_assert(kMsgLobbyStateSeatSize    == 18, "MsgLobbyState seat size mismatch");
    static_assert(kMsgLobbyStateSize        == 76, "MsgLobbyState size mismatch");
    static_assert(kMsgInputSize             == 21, "MsgInput size mismatch");
    static_assert(kMsgSnapshotSize          == 111, "MsgSnapshot size mismatch");
    static_assert(kMsgCorrectionSize        == 20, "MsgCorrection size mismatch");
    static_assert(kMsgBombPlacedSize        == 16, "MsgBombPlaced size mismatch");
    static_assert(kMsgExplosionResolvedSize == 497,"MsgExplosionResolved size mismatch");
 
    constexpr std::size_t kSnapshotPlayersOffset =
        sizeof(uint32_t) + // matchId
        sizeof(uint32_t) + // serverTick
        sizeof(uint8_t) +  // playerCount
        sizeof(uint8_t) +  // bombCount
        sizeof(uint8_t);   // powerupCount
    constexpr std::size_t kSnapshotPlayerEntrySize =
        sizeof(uint8_t) +  // playerId
        sizeof(int16_t) +  // xQ
        sizeof(int16_t) +  // yQ
        sizeof(uint8_t);   // flags
    constexpr std::size_t kSnapshotBombsOffset =
        kSnapshotPlayersOffset + kMaxPlayers * kSnapshotPlayerEntrySize;
    constexpr std::size_t kSnapshotBombEntrySize =
        sizeof(uint8_t) +  // ownerId
        sizeof(uint8_t) +  // col
        sizeof(uint8_t) +  // row
        sizeof(uint8_t);   // radius
    constexpr std::size_t kSnapshotPowerupsOffset =
        kSnapshotBombsOffset + kMaxSnapshotBombs * kSnapshotBombEntrySize;
    constexpr std::size_t kSnapshotPowerupEntrySize =
        sizeof(uint8_t) +  // type
        sizeof(uint8_t) +  // col
        sizeof(uint8_t);   // row
 
    constexpr std::size_t kExplosionBlastCellsOffset =
        sizeof(uint32_t) + // matchId
        sizeof(uint32_t) + // serverTick
        sizeof(uint8_t) +  // ownerId
        sizeof(uint8_t) +  // originCol
        sizeof(uint8_t) +  // originRow
        sizeof(uint8_t) +  // radius
        sizeof(uint8_t) +  // killedPlayerMask
        sizeof(uint8_t) +  // blastCellCount
        sizeof(uint8_t);   // destroyedBrickCount
    constexpr std::size_t kExplosionCellEntrySize =
        sizeof(uint8_t) +  // col
        sizeof(uint8_t);   // row
    constexpr std::size_t kExplosionDestroyedBricksOffset =
        kExplosionBlastCellsOffset + kMaxExplosionBlastCells * kExplosionCellEntrySize;
 
    // ----- Message Types -----
 
    enum class EMsgType : uint8_t
    {
        Invalid    = 0x00,      
        Hello      = 0x01,      
        Welcome    = 0x02,      
        Reject     = 0x03,      
        LevelInfo  = 0x04,      
        LobbyState = 0x05,      
        LobbyReady = 0x06,      
        MatchLoaded = 0x07,     
        MatchStart = 0x08,      
        MatchCancelled = 0x09,  
        MatchResult = 0x0A,     
 
        Input      = 0x10,      
        Snapshot   = 0x11,      
        Correction = 0x12,      
        BombPlaced = 0x13,      
        ExplosionResolved = 0x14 
    };
 
    inline bool isValidMsgType(uint8_t raw)
    {
        return raw == static_cast<uint8_t>(EMsgType::Hello)      ||
               raw == static_cast<uint8_t>(EMsgType::Welcome)    ||
               raw == static_cast<uint8_t>(EMsgType::Reject)     ||
               raw == static_cast<uint8_t>(EMsgType::LevelInfo)  ||
               raw == static_cast<uint8_t>(EMsgType::LobbyState) ||
               raw == static_cast<uint8_t>(EMsgType::LobbyReady) ||
               raw == static_cast<uint8_t>(EMsgType::MatchLoaded) ||
               raw == static_cast<uint8_t>(EMsgType::MatchStart) ||
               raw == static_cast<uint8_t>(EMsgType::MatchCancelled) ||
               raw == static_cast<uint8_t>(EMsgType::MatchResult) ||
               raw == static_cast<uint8_t>(EMsgType::Input)      ||
               raw == static_cast<uint8_t>(EMsgType::Snapshot)   ||
               raw == static_cast<uint8_t>(EMsgType::Correction) ||
               raw == static_cast<uint8_t>(EMsgType::BombPlaced) ||
               raw == static_cast<uint8_t>(EMsgType::ExplosionResolved);
    }
 
    constexpr std::string_view msgTypeName(EMsgType type)
    {
        switch (type)
        {
            case EMsgType::Invalid:    return "Invalid";
            case EMsgType::Hello:      return "Hello";
            case EMsgType::Welcome:    return "Welcome";
            case EMsgType::Reject:     return "Reject";
            case EMsgType::LevelInfo:  return "LevelInfo";
            case EMsgType::LobbyState: return "LobbyState";
            case EMsgType::LobbyReady: return "LobbyReady";
            case EMsgType::MatchLoaded: return "MatchLoaded";
            case EMsgType::MatchStart: return "MatchStart";
            case EMsgType::MatchCancelled: return "MatchCancelled";
            case EMsgType::MatchResult: return "MatchResult";
            case EMsgType::Input:      return "Input";
            case EMsgType::Snapshot:   return "Snapshot";
            case EMsgType::Correction: return "Correction";
            case EMsgType::BombPlaced: return "BombPlaced";
            case EMsgType::ExplosionResolved: return "ExplosionResolved";
            default:                   return "Unknown";
        }
    }
 
    constexpr EChannel expectedChannelFor(EMsgType type)
    {
        switch (type)
        {
            case EMsgType::Hello:
            case EMsgType::Welcome:
            case EMsgType::Reject:
            case EMsgType::LevelInfo:
            case EMsgType::LobbyState:
            case EMsgType::LobbyReady:
            case EMsgType::MatchLoaded:
            case EMsgType::MatchStart:
            case EMsgType::MatchCancelled:
            case EMsgType::MatchResult:
                return EChannel::ControlReliable;
            case EMsgType::Input:
                return EChannel::InputUnreliable;
            case EMsgType::Snapshot:
                return EChannel::SnapshotUnreliable;
            case EMsgType::Correction:
                return EChannel::CorrectionUnreliable;
            case EMsgType::BombPlaced:
            case EMsgType::ExplosionResolved:
                return EChannel::GameplayReliable;
            default:
                return EChannel::ControlReliable;
        }
    }
 
    constexpr bool isValidPlayerMask(const uint32_t mask)
    {
        return (mask & ~((1u << kMaxPlayers) - 1u)) == 0;
    }
 
    constexpr std::size_t explosionBlastCellOffset(std::size_t index)
    {
        return kExplosionBlastCellsOffset + index * kExplosionCellEntrySize;
    }
 
    constexpr std::size_t explosionDestroyedBrickOffset(std::size_t index)
    {
        return kExplosionDestroyedBricksOffset + index * kExplosionCellEntrySize;
    }
 
    constexpr bool isValidTileCell(const uint8_t col, const uint8_t row)
    {
        return col < ::bomberman::tileArrayWidth && row < ::bomberman::tileArrayHeight;
    }
 
    constexpr uint16_t tileCellKey(const uint8_t col, const uint8_t row)
    {
        return static_cast<uint16_t>(row) * static_cast<uint16_t>(::bomberman::tileArrayWidth) +
               static_cast<uint16_t>(col);
    }
 
    constexpr bool isExpectedChannelFor(EMsgType type, uint8_t channelId)
    {
        return channelId == static_cast<uint8_t>(expectedChannelFor(type));
    }
 
    constexpr std::size_t expectedPayloadSize(EMsgType type)
    {
        switch (type)
        {
            case EMsgType::Hello:      return kMsgHelloSize;
            case EMsgType::Welcome:    return kMsgWelcomeSize;
            case EMsgType::Reject:     return kMsgRejectSize;
            case EMsgType::LevelInfo:  return kMsgLevelInfoSize;
            case EMsgType::LobbyState: return kMsgLobbyStateSize;
            case EMsgType::LobbyReady: return kMsgLobbyReadySize;
            case EMsgType::MatchLoaded: return kMsgMatchLoadedSize;
            case EMsgType::MatchStart: return kMsgMatchStartSize;
            case EMsgType::MatchCancelled: return kMsgMatchCancelledSize;
            case EMsgType::MatchResult: return kMsgMatchResultSize;
            case EMsgType::Input:      return kMsgInputSize;
            case EMsgType::Snapshot:   return kMsgSnapshotSize;
            case EMsgType::Correction: return kMsgCorrectionSize;
            case EMsgType::BombPlaced: return kMsgBombPlacedSize;
            case EMsgType::ExplosionResolved: return kMsgExplosionResolvedSize;
            default:                   return 0;
        }
    }
 
    // =================================================================================================================
    // ===== Wire Payload Types ========================================================================================
    // =================================================================================================================
    //
    // These are protocol payload models, not gameplay-domain classes. Their
    // field layout intentionally mirrors the fixed wire format defined above.
 
    struct PacketHeader
    {
        EMsgType type = EMsgType::Invalid; 
        uint16_t payloadSize = 0; 
    };
 
    // ----- Control Message Payloads -----
 
    struct MsgHello
    {
        uint16_t protocolVersion; 
 
        char name[kPlayerNameMax];
    };
 
    struct MsgWelcome
    {
        uint16_t protocolVersion; 
        uint8_t playerId;         
        uint16_t serverTickRate;  
    };
 
    struct MsgReject
    {
        enum class EReason : uint8_t
        {
            VersionMismatch = 0x01,
            ServerFull = 0x02,
            Banned = 0x03,
            GameInProgress = 0x04, 
            Other = 0xFF
        };
 
        EReason reason = EReason::Other; 
 
        uint16_t expectedProtocolVersion = 0; 
    };
 
    struct MsgLevelInfo
    {
        uint32_t matchId = 0; 
        uint32_t mapSeed = 0; 
    };
 
    struct MsgLobbyReady
    {
        uint8_t ready = 0; 
    };
 
    struct MsgMatchLoaded
    {
        uint32_t matchId = 0; 
    };
 
    struct MsgMatchStart
    {
        uint32_t matchId = 0;          
        uint32_t goShowServerTick = 0; 
        uint32_t unlockServerTick = 0; 
    };
 
    struct MsgMatchCancelled
    {
        uint32_t matchId = 0; 
    };
 
    struct MsgMatchResult
    {
        enum class EResult : uint8_t
        {
            Draw = 0x00,
            Win = 0x01
        };
 
        uint32_t matchId = 0;              
        EResult result = EResult::Draw;    
        uint8_t winnerPlayerId = 0xFF;     
        char winnerName[kPlayerNameMax]{}; 
    };
 
    struct MsgLobbyState
    {
        enum class EPhase : uint8_t
        {
            Idle = 0x00,
            Countdown = 0x01
        };
 
        struct SeatEntry
        {
            enum class ESeatFlags : uint8_t
            {
                None = 0x00,
                Occupied = 0x01,
                Ready = 0x02
            };
 
            static constexpr uint8_t kKnownFlags =
                static_cast<uint8_t>(ESeatFlags::Occupied) |
                static_cast<uint8_t>(ESeatFlags::Ready);
 
            ESeatFlags flags = ESeatFlags::None; 
            uint8_t wins = 0;                    
            char name[kPlayerNameMax]{};         
        };
 
        EPhase phase = EPhase::Idle;           
        uint8_t countdownSecondsRemaining = 0; 
        uint16_t reserved = 0;                 
        SeatEntry seats[kMaxPlayers]{}; 
    };
 
    static_assert(sizeof(MsgLobbyState::SeatEntry) == kMsgLobbyStateSeatSize, "MsgLobbyState::SeatEntry size mismatch");
    static_assert(sizeof(MsgLobbyState) == kMsgLobbyStateSize, "MsgLobbyState size mismatch");
 
    // ----- Gameplay Message Payloads -----
 
    struct MsgInput
    {
        uint32_t baseInputSeq = 0;              
        uint8_t count = 0;                      
        uint8_t inputs[kMaxInputBatchSize]{};   
    };
 
    struct MsgCell
    {
        uint8_t col = 0;                        
        uint8_t row = 0;                        
    };
 
    struct MsgSnapshot
    {
        uint32_t matchId = 0;           
        uint32_t serverTick = 0;        
        uint8_t playerCount = 0;        
        uint8_t bombCount = 0;          
        uint8_t powerupCount = 0;       
 
        struct PlayerEntry
        {
            uint8_t playerId = 0;       
            int16_t xQ = 0;             
            int16_t yQ = 0;             
 
            enum class EPlayerFlags : uint8_t
            {
                None = 0x00,            
                Alive = 0x01,           
                Invulnerable = 0x02,    
                InputLocked = 0x04,     
                BombRangeBoost = 0x08,  
                MaxBombsBoost = 0x10,   
                SpeedBoost = 0x20       
            };
 
            static constexpr uint8_t kKnownFlags =
                static_cast<uint8_t>(EPlayerFlags::Alive) |
                static_cast<uint8_t>(EPlayerFlags::Invulnerable) |
                static_cast<uint8_t>(EPlayerFlags::InputLocked) |
                static_cast<uint8_t>(EPlayerFlags::BombRangeBoost) |
                static_cast<uint8_t>(EPlayerFlags::MaxBombsBoost) |
                static_cast<uint8_t>(EPlayerFlags::SpeedBoost);
 
            EPlayerFlags flags = EPlayerFlags::None; 
        };
 
        PlayerEntry players[kMaxPlayers]; 
 
        struct BombEntry
        {
            uint8_t ownerId = 0;        
            uint8_t col = 0;            
            uint8_t row = 0;            
            uint8_t radius = 0;         
        };
 
        BombEntry bombs[kMaxSnapshotBombs]; 
 
        struct PowerupEntry
        {
            sim::PowerupType type = sim::PowerupType::SpeedBoost; 
            uint8_t col = 0;                                      
            uint8_t row = 0;                                      
        };
 
        PowerupEntry powerups[kMaxSnapshotPowerups]; 
    };
 
    struct MsgCorrection
    {
        uint32_t matchId = 0;               
        uint32_t serverTick = 0;            
        uint32_t lastProcessedInputSeq = 0; 
        int16_t xQ = 0;                     
        int16_t yQ = 0;                     
        uint8_t playerFlags = 0;            
        uint8_t reserved[3]{};              
    };
 
    struct MsgBombPlaced
    {
        uint32_t matchId = 0;               
        uint32_t serverTick = 0;            
        uint32_t explodeTick = 0;           
        uint8_t ownerId = 0;                
        uint8_t col = 0;                    
        uint8_t row = 0;                    
        uint8_t radius = 0;                 
    };
 
    struct MsgExplosionResolved
    {
        uint32_t matchId = 0;                   
        uint32_t serverTick = 0;                
        uint8_t ownerId = 0;                    
        uint8_t originCol = 0;                  
        uint8_t originRow = 0;                  
        uint8_t radius = 0;                     
        uint8_t killedPlayerMask = 0;           
        uint8_t blastCellCount = 0;             
        uint8_t destroyedBrickCount = 0;        
        MsgCell blastCells[kMaxExplosionBlastCells]{};              
        MsgCell destroyedBricks[kMaxExplosionDestroyedBricks]{};    
    };
 
    // =================================================================================================================
    // ===== Wire Helpers ==============================================================================================
    // =================================================================================================================
 
    // ----- Endian Helpers -----
 
    constexpr void writeU16LE(uint8_t* out, uint16_t value)
    {
        out[0] = static_cast<uint8_t>(value & 0xFFu);
        out[1] = static_cast<uint8_t>((value >> 8u) & 0xFFu);
    }
 
    constexpr void writeU32LE(uint8_t* out, uint32_t value)
    {
        out[0] = static_cast<uint8_t>(value & 0xFFu);
        out[1] = static_cast<uint8_t>((value >> 8u) & 0xFFu);
        out[2] = static_cast<uint8_t>((value >> 16u) & 0xFFu);
        out[3] = static_cast<uint8_t>((value >> 24u) & 0xFFu);
    }
 
    constexpr uint16_t readU16LE(const uint8_t* in)
    {
        return static_cast<uint16_t>(in[0]) |
               (static_cast<uint16_t>(in[1]) << 8u);
    }
 
    constexpr uint32_t readU32LE(const uint8_t* in)
    {
        return static_cast<uint32_t>(in[0]) |
               (static_cast<uint32_t>(in[1]) << 8u) |
               (static_cast<uint32_t>(in[2]) << 16u) |
               (static_cast<uint32_t>(in[3]) << 24u);
    }
 
    // ----- String Field Helpers -----
 
    constexpr std::size_t boundedStrLen(const char* s, const std::size_t maxBytes)
    {
        if (!s) return 0;
 
        std::size_t length = 0;
        while(length < maxBytes && s[length] != '\0')
        {
            ++length;
        }
        return length;
    }
 
    constexpr std::size_t snapshotPlayerOffset(std::size_t index)
    {
        return kSnapshotPlayersOffset + index * kSnapshotPlayerEntrySize;
    }
 
    constexpr std::size_t snapshotBombOffset(std::size_t index)
    {
        return kSnapshotBombsOffset + index * kSnapshotBombEntrySize;
    }
 
    constexpr std::size_t snapshotPowerupOffset(std::size_t index)
    {
        return kSnapshotPowerupsOffset + index * kSnapshotPowerupEntrySize;
    }
 
    inline void setHelloName(MsgHello& hello, std::string_view name)
    {
        std::memset(hello.name, 0, kPlayerNameMax);
 
        const std::size_t copyLen = (name.size() < (kPlayerNameMax - 1)) ? name.size() : (kPlayerNameMax - 1);
        std::memcpy(hello.name, name.data(), copyLen);
    }
    inline void setHelloName(MsgHello& hello, const char* name)
    {
        if (!name) {
            std::memset(hello.name, 0, kPlayerNameMax);
            return;
        }
 
        const std::size_t copyLen = boundedStrLen(name, kPlayerNameMax - 1);
        setHelloName(hello, std::string_view{name, copyLen});
    }
 
    constexpr bool isValidLobbySeatFlags(const uint8_t flags)
    {
        return (flags & static_cast<uint8_t>(~MsgLobbyState::SeatEntry::kKnownFlags)) == 0;
    }
 
    constexpr bool isValidLobbyPhase(const uint8_t rawPhase)
    {
        return rawPhase == static_cast<uint8_t>(MsgLobbyState::EPhase::Idle) ||
               rawPhase == static_cast<uint8_t>(MsgLobbyState::EPhase::Countdown);
    }
 
    inline void setLobbySeatName(MsgLobbyState::SeatEntry& seat, std::string_view name)
    {
        std::memset(seat.name, 0, kPlayerNameMax);
 
        const std::size_t copyLen = (name.size() < (kPlayerNameMax - 1)) ? name.size() : (kPlayerNameMax - 1);
        std::memcpy(seat.name, name.data(), copyLen);
    }
 
    inline void setMatchResultWinnerName(MsgMatchResult& matchResult, std::string_view name)
    {
        std::memset(matchResult.winnerName, 0, kPlayerNameMax);
 
        const std::size_t copyLen = (name.size() < (kPlayerNameMax - 1)) ? name.size() : (kPlayerNameMax - 1);
        std::memcpy(matchResult.winnerName, name.data(), copyLen);
    }
 
    [[nodiscard]]
    inline std::string_view lobbySeatName(const MsgLobbyState::SeatEntry& seat)
    {
        return std::string_view(seat.name, boundedStrLen(seat.name, kPlayerNameMax - 1));
    }
 
    [[nodiscard]]
    inline std::string_view matchResultWinnerName(const MsgMatchResult& matchResult)
    {
        return std::string_view(matchResult.winnerName, boundedStrLen(matchResult.winnerName, kPlayerNameMax - 1));
    }
 
    constexpr bool lobbySeatIsOccupied(const MsgLobbyState::SeatEntry& seat)
    {
        return (static_cast<uint8_t>(seat.flags) &
                static_cast<uint8_t>(MsgLobbyState::SeatEntry::ESeatFlags::Occupied)) != 0;
    }
 
    constexpr bool lobbySeatIsReady(const MsgLobbyState::SeatEntry& seat)
    {
        return (static_cast<uint8_t>(seat.flags) &
                static_cast<uint8_t>(MsgLobbyState::SeatEntry::ESeatFlags::Ready)) != 0;
    }
 
    constexpr bool lobbyCountdownActive(const MsgLobbyState& lobbyState)
    {
        return lobbyState.phase == MsgLobbyState::EPhase::Countdown &&
               lobbyState.countdownSecondsRemaining > 0;
    }
 
    // =================================================================================================================
    // ===== Serialization =============================================================================================
    // =================================================================================================================
 
    // ----- Header Serialization -----
 
    inline void serializeHeader(const PacketHeader& header, uint8_t* out) noexcept
    {
        out[0] = static_cast<uint8_t>(header.type);
        writeU16LE(out + 1, header.payloadSize);
    }
 
    [[nodiscard]]
    inline bool deserializeHeader(const uint8_t* in, std::size_t inSize, PacketHeader& outHeader)
    {
        if (inSize < kPacketHeaderSize)
        {
            return false;
        }
 
        const uint8_t rawType = in[0];
        if (!isValidMsgType(rawType))
        {
            return false;
        }
 
        const uint16_t payloadSize = readU16LE(in + 1);
        if (inSize != kPacketHeaderSize + payloadSize)
        {
            return false;
        }
 
        // Current protocol uses fixed-size payloads for all message types.
        const auto msgType = static_cast<EMsgType>(rawType);
        const std::size_t expected = expectedPayloadSize(msgType);
        if (expected > 0 && payloadSize != expected)
        {
            return false;
        }
 
        outHeader.type = msgType;
        outHeader.payloadSize = payloadSize;
        return true;
    }
 
    // ----- Control Payload Serialization -----
 
    inline void serializeMsgHello(const MsgHello& hello, uint8_t* out) noexcept
    {
        writeU16LE(out, hello.protocolVersion);
        std::memset(out + 2, 0, kPlayerNameMax);
        const std::size_t nameLen = boundedStrLen(hello.name, kPlayerNameMax - 1);
        std::memcpy(out + 2, hello.name, nameLen);
    }
 
    [[nodiscard]]
    inline bool deserializeMsgHello(const uint8_t* in, std::size_t inSize, MsgHello& outHello)
    {
        if (inSize < kMsgHelloSize)
        {
            return false;
        }
 
        outHello.protocolVersion = readU16LE(in);
        std::memcpy(outHello.name, in + 2, kPlayerNameMax);
 
        outHello.name[kPlayerNameMax - 1] = '\0';
 
        const std::size_t n = boundedStrLen(outHello.name, kPlayerNameMax - 1);
        std::memset(outHello.name + n, 0, kPlayerNameMax - n);
 
        return true;
    }
 
    inline void serializeMsgWelcome(const MsgWelcome& welcome, uint8_t* out) noexcept
    {
        writeU16LE(out, welcome.protocolVersion);
        out[2] = welcome.playerId;
        writeU16LE(out + 3, welcome.serverTickRate);
    }
 
    [[nodiscard]]
    inline bool deserializeMsgWelcome(const uint8_t* in, std::size_t inSize, MsgWelcome& outWelcome)
    {
        if (inSize < kMsgWelcomeSize)
        {
            return false;
        }
        outWelcome.protocolVersion = readU16LE(in);
        outWelcome.playerId = in[2];
        if (outWelcome.playerId >= kMaxPlayers)
        {
            return false;
        }
        outWelcome.serverTickRate = readU16LE(in + 3);
        return outWelcome.serverTickRate != 0;
    }
 
    inline void serializeMsgReject(const MsgReject& reject, uint8_t* out) noexcept
    {
        out[0] = static_cast<uint8_t>(reject.reason);
        writeU16LE(out + 1, reject.expectedProtocolVersion);
    }
 
    [[nodiscard]]
    inline bool deserializeMsgReject(const uint8_t* in, std::size_t inSize, MsgReject& outReject)
    {
        if (inSize < kMsgRejectSize)
        {
            return false;
        }
 
        outReject.reason = static_cast<MsgReject::EReason>(in[0]);
 
        switch (outReject.reason)
        {
            case MsgReject::EReason::VersionMismatch:
                outReject.expectedProtocolVersion = readU16LE(in + 1);
                break;
            case MsgReject::EReason::ServerFull:
            case MsgReject::EReason::Banned:
            case MsgReject::EReason::GameInProgress:
            case MsgReject::EReason::Other:
                outReject.expectedProtocolVersion = 0;
                break;
            default:
                return false;
        }
 
        return true;
    }
 
    inline void serializeMsgLevelInfo(const MsgLevelInfo& info, uint8_t* out) noexcept
    {
        writeU32LE(out, info.matchId);
        writeU32LE(out + 4, info.mapSeed);
    }
 
    [[nodiscard]]
    inline bool deserializeMsgLevelInfo(const uint8_t* in, std::size_t inSize, MsgLevelInfo& outInfo)
    {
        if (inSize < kMsgLevelInfoSize)
        {
            return false;
        }
        outInfo.matchId = readU32LE(in);
        outInfo.mapSeed = readU32LE(in + 4);
        if (outInfo.matchId == 0)
        {
            return false;
        }
        return true;
    }
 
    constexpr bool isValidLobbyReadyValue(const uint8_t ready)
    {
        return ready <= 1u;
    }
 
    inline void serializeMsgLobbyReady(const MsgLobbyReady& ready, uint8_t* out) noexcept
    {
        out[0] = ready.ready != 0 ? 1u : 0u;
    }
 
    [[nodiscard]]
    inline bool deserializeMsgLobbyReady(const uint8_t* in, std::size_t inSize, MsgLobbyReady& outReady)
    {
        if (inSize < kMsgLobbyReadySize)
        {
            return false;
        }
 
        if (!isValidLobbyReadyValue(in[0]))
        {
            return false;
        }
 
        outReady.ready = in[0];
        return true;
    }
 
    inline void serializeMsgMatchLoaded(const MsgMatchLoaded& loaded, uint8_t* out) noexcept
    {
        writeU32LE(out, loaded.matchId);
    }
 
    [[nodiscard]]
    inline bool deserializeMsgMatchLoaded(const uint8_t* in, std::size_t inSize, MsgMatchLoaded& outLoaded)
    {
        if (inSize < kMsgMatchLoadedSize)
        {
            return false;
        }
 
        outLoaded.matchId = readU32LE(in);
        return outLoaded.matchId != 0;
    }
 
    inline void serializeMsgMatchStart(const MsgMatchStart& matchStart, uint8_t* out) noexcept
    {
        writeU32LE(out, matchStart.matchId);
        writeU32LE(out + 4, matchStart.goShowServerTick);
        writeU32LE(out + 8, matchStart.unlockServerTick);
    }
 
    [[nodiscard]]
    inline bool deserializeMsgMatchStart(const uint8_t* in, std::size_t inSize, MsgMatchStart& outMatchStart)
    {
        if (inSize < kMsgMatchStartSize)
        {
            return false;
        }
 
        outMatchStart.matchId = readU32LE(in);
        outMatchStart.goShowServerTick = readU32LE(in + 4);
        outMatchStart.unlockServerTick = readU32LE(in + 8);
        return outMatchStart.matchId != 0 &&
               outMatchStart.goShowServerTick != 0 &&
               outMatchStart.unlockServerTick != 0 &&
               outMatchStart.goShowServerTick <= outMatchStart.unlockServerTick;
    }
 
    inline void serializeMsgMatchCancelled(const MsgMatchCancelled& cancelled, uint8_t* out) noexcept
    {
        writeU32LE(out, cancelled.matchId);
    }
 
    [[nodiscard]]
    inline bool deserializeMsgMatchCancelled(const uint8_t* in,
                                             std::size_t inSize,
                                             MsgMatchCancelled& outCancelled)
    {
        if (inSize < kMsgMatchCancelledSize)
        {
            return false;
        }
 
        outCancelled.matchId = readU32LE(in);
        return outCancelled.matchId != 0;
    }
 
    inline void serializeMsgMatchResult(const MsgMatchResult& matchResult, uint8_t* out) noexcept
    {
        writeU32LE(out, matchResult.matchId);
        out[4] = static_cast<uint8_t>(matchResult.result);
        out[5] = matchResult.winnerPlayerId;
        std::memset(out + 6, 0, kPlayerNameMax);
        const std::size_t nameLen = boundedStrLen(matchResult.winnerName, kPlayerNameMax - 1);
        std::memcpy(out + 6, matchResult.winnerName, nameLen);
    }
 
    [[nodiscard]]
    inline bool deserializeMsgMatchResult(const uint8_t* in, std::size_t inSize, MsgMatchResult& outMatchResult)
    {
        if (inSize < kMsgMatchResultSize)
        {
            return false;
        }
 
        outMatchResult.matchId = readU32LE(in);
        outMatchResult.result = static_cast<MsgMatchResult::EResult>(in[4]);
        outMatchResult.winnerPlayerId = in[5];
        std::memcpy(outMatchResult.winnerName, in + 6, kPlayerNameMax);
        outMatchResult.winnerName[kPlayerNameMax - 1] = '\0';
 
        switch (outMatchResult.result)
        {
            case MsgMatchResult::EResult::Draw:
                outMatchResult.winnerPlayerId = 0xFF;
                std::memset(outMatchResult.winnerName, 0, kPlayerNameMax);
                return outMatchResult.matchId != 0;
            case MsgMatchResult::EResult::Win:
                if (outMatchResult.matchId == 0 || outMatchResult.winnerPlayerId >= kMaxPlayers)
                {
                    return false;
                }
                return !matchResultWinnerName(outMatchResult).empty();
            default:
                return false;
        }
    }
 
    inline void serializeMsgLobbyState(const MsgLobbyState& lobbyState, uint8_t* out) noexcept
    {
        out[0] = static_cast<uint8_t>(lobbyState.phase);
        out[1] = lobbyState.countdownSecondsRemaining;
        writeU16LE(out + 2, 0);
 
        for (std::size_t i = 0; i < kMaxPlayers; ++i)
        {
            const auto offset = 4 + i * kMsgLobbyStateSeatSize;
            const auto& seat = lobbyState.seats[i];
 
            out[offset] = static_cast<uint8_t>(seat.flags);
            out[offset + 1] = seat.wins;
            std::memset(out + offset + 2, 0, kPlayerNameMax);
            const std::size_t nameLen = boundedStrLen(seat.name, kPlayerNameMax - 1);
            std::memcpy(out + offset + 2, seat.name, nameLen);
        }
    }
 
    [[nodiscard]]
    inline bool deserializeMsgLobbyState(const uint8_t* in, std::size_t inSize, MsgLobbyState& outLobbyState)
    {
        if (inSize < kMsgLobbyStateSize)
        {
            return false;
        }
 
        if (!isValidLobbyPhase(in[0]))
        {
            return false;
        }
 
        outLobbyState.phase = static_cast<MsgLobbyState::EPhase>(in[0]);
        outLobbyState.countdownSecondsRemaining = in[1];
        outLobbyState.reserved = readU16LE(in + 2);
        if (outLobbyState.reserved != 0)
        {
            return false;
        }
        if (outLobbyState.phase == MsgLobbyState::EPhase::Countdown)
        {
            if (outLobbyState.countdownSecondsRemaining == 0)
            {
                return false;
            }
        }
        else
        {
            outLobbyState.countdownSecondsRemaining = 0;
        }
 
        for (std::size_t i = 0; i < kMaxPlayers; ++i)
        {
            const auto offset = 4 + i * kMsgLobbyStateSeatSize;
            auto& seat = outLobbyState.seats[i];
 
            const uint8_t rawFlags = in[offset];
            if (!isValidLobbySeatFlags(rawFlags))
            {
                return false;
            }
            if ((rawFlags & static_cast<uint8_t>(MsgLobbyState::SeatEntry::ESeatFlags::Ready)) != 0 &&
                (rawFlags & static_cast<uint8_t>(MsgLobbyState::SeatEntry::ESeatFlags::Occupied)) == 0)
            {
                return false;
            }
 
            seat.flags = static_cast<MsgLobbyState::SeatEntry::ESeatFlags>(rawFlags);
            seat.wins = in[offset + 1];
            std::memcpy(seat.name, in + offset + 2, kPlayerNameMax);
            seat.name[kPlayerNameMax - 1] = '\0';
 
            const std::size_t nameLen = boundedStrLen(seat.name, kPlayerNameMax - 1);
            std::memset(seat.name + nameLen, 0, kPlayerNameMax - nameLen);
 
            if (!lobbySeatIsOccupied(seat))
            {
                seat.wins = 0;
                std::memset(seat.name, 0, kPlayerNameMax);
                continue;
            }
 
        }
 
        return true;
    }
 
    // ----- Gameplay Payload Serialization -----
 
    inline void serializeMsgInput(const MsgInput& input, uint8_t* out) noexcept
    {
        writeU32LE(out, input.baseInputSeq);
        out[4] = input.count;
        std::memcpy(out + 5, input.inputs, kMaxInputBatchSize);
    }
 
    [[nodiscard]]
    inline bool deserializeMsgInput(const uint8_t* in, std::size_t inSize, MsgInput& outInput)
    {
        if (inSize < kMsgInputSize)
        {
            return false;
        }
 
        outInput.baseInputSeq = readU32LE(in);
        outInput.count = in[4];
 
        if (outInput.count == 0 || outInput.count > kMaxInputBatchSize)
        {
            return false;
        }
 
        // Reject if the batch starts before the first valid sequence.
        if (outInput.baseInputSeq < kFirstInputSeq)
        {
            return false;
        }
 
        std::memcpy(outInput.inputs, in + 5, kMaxInputBatchSize);
 
        // Reject if any input entry contains unknown bits outside the defined input mask.
        for (uint8_t i = 0; i < outInput.count; ++i)
        {
            if ((outInput.inputs[i] & ~kInputKnownBits) != 0)
            {
                return false;
            }
        }
 
        return true;
    }
 
    inline void serializeMsgSnapshot(const MsgSnapshot& snap, uint8_t* out) noexcept
    {
        writeU32LE(out, snap.matchId);
        writeU32LE(out + 4, snap.serverTick);
        const uint8_t playerCount = (snap.playerCount <= kMaxPlayers) ? snap.playerCount : kMaxPlayers;
        const uint8_t bombCount = (snap.bombCount <= kMaxSnapshotBombs) ? snap.bombCount : kMaxSnapshotBombs;
        const uint8_t powerupCount = (snap.powerupCount <= kMaxSnapshotPowerups) ? snap.powerupCount : kMaxSnapshotPowerups;
        out[8] = playerCount;
        out[9] = bombCount;
        out[10] = powerupCount;
 
        for (std::size_t i = 0; i < kMaxPlayers; ++i)
        {
            const auto& player = snap.players[i];
            const std::size_t offset = snapshotPlayerOffset(i);
            out[offset] = player.playerId;
            writeU16LE(out + offset + 1, static_cast<uint16_t>(player.xQ));
            writeU16LE(out + offset + 3, static_cast<uint16_t>(player.yQ));
            out[offset + 5] = static_cast<uint8_t>(player.flags);
        }
 
        for (std::size_t i = 0; i < kMaxSnapshotBombs; ++i)
        {
            const auto& bomb = snap.bombs[i];
            const std::size_t offset = snapshotBombOffset(i);
            out[offset] = bomb.ownerId;
            out[offset + 1] = bomb.col;
            out[offset + 2] = bomb.row;
            out[offset + 3] = bomb.radius;
        }
 
        for (std::size_t i = 0; i < kMaxSnapshotPowerups; ++i)
        {
            const auto& powerup = snap.powerups[i];
            const std::size_t offset = snapshotPowerupOffset(i);
            out[offset] = static_cast<uint8_t>(powerup.type);
            out[offset + 1] = powerup.col;
            out[offset + 2] = powerup.row;
        }
    }
 
    [[nodiscard]]
    inline bool deserializeMsgSnapshot(const uint8_t* in, std::size_t inSize, MsgSnapshot& outSnap)
    {
        if (inSize < kMsgSnapshotSize)
        {
            return false;
        }
 
        outSnap.matchId = readU32LE(in);
        outSnap.serverTick = readU32LE(in + 4);
        outSnap.playerCount = in[8];
        outSnap.bombCount = in[9];
        outSnap.powerupCount = in[10];
        if (outSnap.playerCount > kMaxPlayers)
        {
            return false;
        }
        if (outSnap.bombCount > kMaxSnapshotBombs)
        {
            return false;
        }
        if (outSnap.powerupCount > kMaxSnapshotPowerups)
        {
            return false;
        }
 
        uint8_t seenPlayerMask = 0;
        uint8_t previousPlayerId = 0;
        bool hasPreviousPlayer = false;
 
        for (std::size_t i = 0; i < kMaxPlayers; ++i)
        {
            const std::size_t offset = snapshotPlayerOffset(i);
            auto& player = outSnap.players[i];
            player.playerId = in[offset];
            player.xQ = static_cast<int16_t>(readU16LE(in + offset + 1));
            player.yQ = static_cast<int16_t>(readU16LE(in + offset + 3));
            const uint8_t rawFlags = in[offset + 5];
 
            // Only validate active player entries.
            if (i < outSnap.playerCount)
            {
                if (player.playerId >= kMaxPlayers)
                {
                    return false;
                }
                if (hasPreviousPlayer && player.playerId <= previousPlayerId)
                {
                    return false;
                }
 
                const uint8_t playerBit = static_cast<uint8_t>(1u << player.playerId);
                if ((seenPlayerMask & playerBit) != 0)
                {
                    return false;
                }
                seenPlayerMask |= playerBit;
                previousPlayerId = player.playerId;
                hasPreviousPlayer = true;
 
                if ((rawFlags & ~MsgSnapshot::PlayerEntry::kKnownFlags) != 0)
                {
                    return false;
                }
            }
 
            player.flags = static_cast<MsgSnapshot::PlayerEntry::EPlayerFlags>(rawFlags);
        }
 
        uint16_t previousBombCellKey = 0;
        bool hasPreviousBomb = false;
        for (std::size_t i = 0; i < kMaxSnapshotBombs; ++i)
        {
            const std::size_t offset = snapshotBombOffset(i);
            auto& bomb = outSnap.bombs[i];
            bomb.ownerId = in[offset];
            bomb.col = in[offset + 1];
            bomb.row = in[offset + 2];
            bomb.radius = in[offset + 3];
 
            if (i < outSnap.bombCount)
            {
                if (bomb.ownerId >= kMaxPlayers)
                {
                    return false;
                }
                if (bomb.col >= ::bomberman::tileArrayWidth || bomb.row >= ::bomberman::tileArrayHeight)
                {
                    return false;
                }
                if (bomb.radius == 0)
                {
                    return false;
                }
 
                const uint16_t bombCellKey =
                    static_cast<uint16_t>(bomb.row) * static_cast<uint16_t>(::bomberman::tileArrayWidth) +
                    static_cast<uint16_t>(bomb.col);
                if (hasPreviousBomb && bombCellKey <= previousBombCellKey)
                {
                    return false;
                }
 
                previousBombCellKey = bombCellKey;
                hasPreviousBomb = true;
            }
        }
 
        uint16_t previousPowerupCellKey = 0;
        bool hasPreviousPowerup = false;
        for (std::size_t i = 0; i < kMaxSnapshotPowerups; ++i)
        {
            const std::size_t offset = snapshotPowerupOffset(i);
            auto& powerup = outSnap.powerups[i];
            const uint8_t rawType = in[offset];
            powerup.type = static_cast<sim::PowerupType>(rawType);
            powerup.col = in[offset + 1];
            powerup.row = in[offset + 2];
 
            if (i < outSnap.powerupCount)
            {
                if (!sim::isValidPowerupType(rawType) ||
                    powerup.col >= ::bomberman::tileArrayWidth ||
                    powerup.row >= ::bomberman::tileArrayHeight)
                {
                    return false;
                }
 
                const uint16_t powerupCellKey =
                    static_cast<uint16_t>(powerup.row) * static_cast<uint16_t>(::bomberman::tileArrayWidth) +
                    static_cast<uint16_t>(powerup.col);
                if (hasPreviousPowerup && powerupCellKey <= previousPowerupCellKey)
                {
                    return false;
                }
 
                previousPowerupCellKey = powerupCellKey;
                hasPreviousPowerup = true;
            }
        }
 
        return true;
    }
 
    inline void serializeMsgCorrection(const MsgCorrection& corr, uint8_t* out) noexcept
    {
        writeU32LE(out, corr.matchId);
        writeU32LE(out + 4, corr.serverTick);
        writeU32LE(out + 8, corr.lastProcessedInputSeq);
        writeU16LE(out + 12, static_cast<uint16_t>(corr.xQ));
        writeU16LE(out + 14, static_cast<uint16_t>(corr.yQ));
        out[16] = corr.playerFlags;
        out[17] = 0;
        out[18] = 0;
        out[19] = 0;
    }
 
    [[nodiscard]]
    inline bool deserializeMsgCorrection(const uint8_t* in, std::size_t inSize, MsgCorrection& outCorr)
    {
        if (inSize < kMsgCorrectionSize)
        {
            return false;
        }
        outCorr.matchId = readU32LE(in);
        outCorr.serverTick = readU32LE(in + 4);
        outCorr.lastProcessedInputSeq = readU32LE(in + 8);
        outCorr.xQ = static_cast<int16_t>(readU16LE(in + 12));
        outCorr.yQ = static_cast<int16_t>(readU16LE(in + 14));
        outCorr.playerFlags = in[16];
        return true;
    }
 
    inline void serializeMsgBombPlaced(const MsgBombPlaced& bombPlaced, uint8_t* out) noexcept
    {
        writeU32LE(out, bombPlaced.matchId);
        writeU32LE(out + 4, bombPlaced.serverTick);
        writeU32LE(out + 8, bombPlaced.explodeTick);
        out[12] = bombPlaced.ownerId;
        out[13] = bombPlaced.col;
        out[14] = bombPlaced.row;
        out[15] = bombPlaced.radius;
    }
 
    [[nodiscard]]
    inline bool deserializeMsgBombPlaced(const uint8_t* in, std::size_t inSize, MsgBombPlaced& outBombPlaced)
    {
        if (inSize < kMsgBombPlacedSize)
        {
            return false;
        }
 
        outBombPlaced.matchId = readU32LE(in);
        outBombPlaced.serverTick = readU32LE(in + 4);
        outBombPlaced.explodeTick = readU32LE(in + 8);
        outBombPlaced.ownerId = in[12];
        outBombPlaced.col = in[13];
        outBombPlaced.row = in[14];
        outBombPlaced.radius = in[15];
 
        if (outBombPlaced.ownerId >= kMaxPlayers)
        {
            return false;
        }
        if (!isValidTileCell(outBombPlaced.col, outBombPlaced.row))
        {
            return false;
        }
        if (outBombPlaced.radius == 0 || outBombPlaced.explodeTick < outBombPlaced.serverTick)
        {
            return false;
        }
 
        return true;
    }
 
    inline void serializeMsgExplosionResolved(const MsgExplosionResolved& explosion, uint8_t* out) noexcept
    {
        writeU32LE(out, explosion.matchId);
        writeU32LE(out + 4, explosion.serverTick);
        out[8] = explosion.ownerId;
        out[9] = explosion.originCol;
        out[10] = explosion.originRow;
        out[11] = explosion.radius;
        out[12] = explosion.killedPlayerMask;
        out[13] = static_cast<uint8_t>((explosion.blastCellCount <= kMaxExplosionBlastCells) ?
            explosion.blastCellCount :
            kMaxExplosionBlastCells);
        out[14] = static_cast<uint8_t>((explosion.destroyedBrickCount <= kMaxExplosionDestroyedBricks) ?
            explosion.destroyedBrickCount :
            kMaxExplosionDestroyedBricks);
 
        for (std::size_t i = 0; i < kMaxExplosionBlastCells; ++i)
        {
            const std::size_t offset = explosionBlastCellOffset(i);
            out[offset] = explosion.blastCells[i].col;
            out[offset + 1] = explosion.blastCells[i].row;
        }
 
        for (std::size_t i = 0; i < kMaxExplosionDestroyedBricks; ++i)
        {
            const std::size_t offset = explosionDestroyedBrickOffset(i);
            out[offset] = explosion.destroyedBricks[i].col;
            out[offset + 1] = explosion.destroyedBricks[i].row;
        }
    }
 
    [[nodiscard]]
    inline bool deserializeMsgExplosionResolved(const uint8_t* in,
                                                std::size_t inSize,
                                                MsgExplosionResolved& outExplosion)
    {
        if (inSize < kMsgExplosionResolvedSize)
        {
            return false;
        }
 
        outExplosion.matchId = readU32LE(in);
        outExplosion.serverTick = readU32LE(in + 4);
        outExplosion.ownerId = in[8];
        outExplosion.originCol = in[9];
        outExplosion.originRow = in[10];
        outExplosion.radius = in[11];
        outExplosion.killedPlayerMask = in[12];
        outExplosion.blastCellCount = in[13];
        outExplosion.destroyedBrickCount = in[14];
 
        if (outExplosion.ownerId >= kMaxPlayers)
        {
            return false;
        }
        if (!isValidTileCell(outExplosion.originCol, outExplosion.originRow))
        {
            return false;
        }
        if (outExplosion.radius == 0)
        {
            return false;
        }
        if (!isValidPlayerMask(outExplosion.killedPlayerMask))
        {
            return false;
        }
        if (outExplosion.blastCellCount == 0 || outExplosion.blastCellCount > kMaxExplosionBlastCells)
        {
            return false;
        }
        if (outExplosion.destroyedBrickCount > kMaxExplosionDestroyedBricks ||
            outExplosion.destroyedBrickCount > outExplosion.blastCellCount)
        {
            return false;
        }
 
        std::array<bool, static_cast<std::size_t>(::bomberman::tileArrayWidth) *
                              static_cast<std::size_t>(::bomberman::tileArrayHeight)> seenBlastCells{};
        std::array<bool, static_cast<std::size_t>(::bomberman::tileArrayWidth) *
                              static_cast<std::size_t>(::bomberman::tileArrayHeight)> seenDestroyedBricks{};
 
        for (std::size_t i = 0; i < kMaxExplosionBlastCells; ++i)
        {
            const std::size_t offset = explosionBlastCellOffset(i);
            auto& cell = outExplosion.blastCells[i];
            cell.col = in[offset];
            cell.row = in[offset + 1];
 
            if (i < outExplosion.blastCellCount)
            {
                if (!isValidTileCell(cell.col, cell.row))
                {
                    return false;
                }
 
                const std::size_t cellIndex = tileCellKey(cell.col, cell.row);
                if (seenBlastCells[cellIndex])
                {
                    return false;
                }
 
                seenBlastCells[cellIndex] = true;
            }
        }
 
        if (outExplosion.blastCells[0].col != outExplosion.originCol ||
            outExplosion.blastCells[0].row != outExplosion.originRow)
        {
            return false;
        }
 
        for (std::size_t i = 0; i < kMaxExplosionDestroyedBricks; ++i)
        {
            const std::size_t offset = explosionDestroyedBrickOffset(i);
            auto& cell = outExplosion.destroyedBricks[i];
            cell.col = in[offset];
            cell.row = in[offset + 1];
 
            if (i < outExplosion.destroyedBrickCount)
            {
                if (!isValidTileCell(cell.col, cell.row))
                {
                    return false;
                }
 
                const std::size_t cellIndex = tileCellKey(cell.col, cell.row);
                if (!seenBlastCells[cellIndex] || seenDestroyedBricks[cellIndex])
                {
                    return false;
                }
 
                seenDestroyedBricks[cellIndex] = true;
            }
        }
 
        return true;
    }
 
    // =================================================================================================================
    // ===== Packet Builders ===========================================================================================
    // =================================================================================================================
 
    // ----- Control Packet Builders -----
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgHelloSize> makeHelloPacket(const MsgHello& hello)
    {
        PacketHeader header{};
        header.type = EMsgType::Hello;
        header.payloadSize = static_cast<uint16_t>(kMsgHelloSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgHelloSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgHello(hello, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
    inline std::array<uint8_t, kPacketHeaderSize + kMsgHelloSize> makeHelloPacket(std::string_view name, uint16_t protocolVersion)
    {
        MsgHello hello{};
        hello.protocolVersion = protocolVersion;
        setHelloName(hello, name);
        return makeHelloPacket(hello);
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgWelcomeSize> makeWelcomePacket(const MsgWelcome& welcome)
    {
        PacketHeader header{};
        header.type = EMsgType::Welcome;
        header.payloadSize = static_cast<uint16_t>(kMsgWelcomeSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgWelcomeSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgWelcome(welcome, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgRejectSize> makeRejectPacket(const MsgReject& reject)
    {
        PacketHeader header{};
        header.type = EMsgType::Reject;
        header.payloadSize = static_cast<uint16_t>(kMsgRejectSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgRejectSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgReject(reject, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgLevelInfoSize> makeLevelInfoPacket(const MsgLevelInfo& info)
    {
        PacketHeader header{};
        header.type = EMsgType::LevelInfo;
        header.payloadSize = static_cast<uint16_t>(kMsgLevelInfoSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgLevelInfoSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgLevelInfo(info, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgLobbyReadySize> makeLobbyReadyPacket(const MsgLobbyReady& ready)
    {
        PacketHeader header{};
        header.type = EMsgType::LobbyReady;
        header.payloadSize = static_cast<uint16_t>(kMsgLobbyReadySize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgLobbyReadySize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgLobbyReady(ready, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgLobbyReadySize> makeLobbyReadyPacket(const bool ready)
    {
        MsgLobbyReady msg{};
        msg.ready = ready ? 1u : 0u;
        return makeLobbyReadyPacket(msg);
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgMatchLoadedSize> makeMatchLoadedPacket(const MsgMatchLoaded& loaded)
    {
        PacketHeader header{};
        header.type = EMsgType::MatchLoaded;
        header.payloadSize = static_cast<uint16_t>(kMsgMatchLoadedSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgMatchLoadedSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgMatchLoaded(loaded, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgMatchLoadedSize> makeMatchLoadedPacket(const uint32_t matchId)
    {
        MsgMatchLoaded loaded{};
        loaded.matchId = matchId;
        return makeMatchLoadedPacket(loaded);
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgMatchStartSize> makeMatchStartPacket(const MsgMatchStart& matchStart)
    {
        PacketHeader header{};
        header.type = EMsgType::MatchStart;
        header.payloadSize = static_cast<uint16_t>(kMsgMatchStartSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgMatchStartSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgMatchStart(matchStart, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgMatchStartSize> makeMatchStartPacket(const uint32_t matchId,
                                                                                             const uint32_t goShowServerTick,
                                                                                             const uint32_t unlockServerTick)
    {
        MsgMatchStart matchStart{};
        matchStart.matchId = matchId;
        matchStart.goShowServerTick = goShowServerTick;
        matchStart.unlockServerTick = unlockServerTick;
        return makeMatchStartPacket(matchStart);
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgMatchCancelledSize> makeMatchCancelledPacket(
        const MsgMatchCancelled& cancelled)
    {
        PacketHeader header{};
        header.type = EMsgType::MatchCancelled;
        header.payloadSize = static_cast<uint16_t>(kMsgMatchCancelledSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgMatchCancelledSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgMatchCancelled(cancelled, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgMatchCancelledSize> makeMatchCancelledPacket(
        const uint32_t matchId)
    {
        MsgMatchCancelled cancelled{};
        cancelled.matchId = matchId;
        return makeMatchCancelledPacket(cancelled);
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgMatchResultSize> makeMatchResultPacket(
        const MsgMatchResult& matchResult)
    {
        PacketHeader header{};
        header.type = EMsgType::MatchResult;
        header.payloadSize = static_cast<uint16_t>(kMsgMatchResultSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgMatchResultSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgMatchResult(matchResult, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgLobbyStateSize> makeLobbyStatePacket(const MsgLobbyState& lobbyState)
    {
        PacketHeader header{};
        header.type = EMsgType::LobbyState;
        header.payloadSize = static_cast<uint16_t>(kMsgLobbyStateSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgLobbyStateSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgLobbyState(lobbyState, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    // ----- Gameplay Packet Builders -----
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgInputSize> makeInputPacket(const MsgInput& input)
    {
        PacketHeader header{};
        header.type = EMsgType::Input;
        header.payloadSize = static_cast<uint16_t>(kMsgInputSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgInputSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgInput(input, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgSnapshotSize> makeSnapshotPacket(const MsgSnapshot& snap)
    {
        PacketHeader header{};
        header.type = EMsgType::Snapshot;
        header.payloadSize = static_cast<uint16_t>(kMsgSnapshotSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgSnapshotSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgSnapshot(snap, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgCorrectionSize> makeCorrectionPacket(const MsgCorrection& corr)
    {
        PacketHeader header{};
        header.type = EMsgType::Correction;
        header.payloadSize = static_cast<uint16_t>(kMsgCorrectionSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgCorrectionSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgCorrection(corr, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgBombPlacedSize> makeBombPlacedPacket(const MsgBombPlaced& bombPlaced)
    {
        PacketHeader header{};
        header.type = EMsgType::BombPlaced;
        header.payloadSize = static_cast<uint16_t>(kMsgBombPlacedSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgBombPlacedSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgBombPlaced(bombPlaced, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
    inline std::array<uint8_t, kPacketHeaderSize + kMsgExplosionResolvedSize> makeExplosionResolvedPacket(
        const MsgExplosionResolved& explosion)
    {
        PacketHeader header{};
        header.type = EMsgType::ExplosionResolved;
        header.payloadSize = static_cast<uint16_t>(kMsgExplosionResolvedSize);
 
        std::array<uint8_t, kPacketHeaderSize + kMsgExplosionResolvedSize> bytes{};
        serializeHeader(header, bytes.data());
        serializeMsgExplosionResolved(explosion, bytes.data() + kPacketHeaderSize);
 
        return bytes;
    }
 
} // namespace bomberman::net
 
#endif // BOMBERMAN_NET_NETCOMMON_H