Packet.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** R-Type
** File description:
** Packet.hpp, Packet
 * declaration
*/
 
#ifndef RTYPE_NETWORK_PACKET_HPP_
    #define RTYPE_NETWORK_PACKET_HPP_
 
    #include "RType/ECS/ComponentConcept.hpp"
    #include "RType/Math/Vec2.hpp"
 
    #include <bit>
    #include <cstdint>
    #include <cstring>
    #include <span>
    #include <stdexcept>
    #include <string>
    #include <string_view>
    #include <utility>
    #include <vector>
    #include <asio/buffer.hpp>
    #include <array>
    #include <type_traits>
 
namespace rtp::net
{
 
    // Constants and Enums
 
    constexpr std::endian NATIVE_ENDIAN = std::endian::native;
    
    constexpr uint16_t MAGIC_NUMBER = 0xA1B2;
    
    constexpr size_t MTU_SIZE = 1400;
 
    constexpr uint32_t MAX_STRING_SIZE = 2048;
 
    constexpr uint32_t MAX_VECTOR_SIZE = 8192;
 
    constexpr uint32_t MAX_BODY_SIZE   = 64 * 1024;
 
    enum class OpCode : uint8_t {
        None = 0x00,                    
        // Connection Management
        Hello = 0x01,                   
        Welcome = 0x02,                 
        Disconnect = 0x03,              
        // Authentication
        LoginRequest = 0x1A,            
        RegisterRequest = 0x1B,         
        LoginResponse = 0x9A,           
        RegisterResponse = 0x9B,        
        // Lobby Management
        ListRooms = 0x04,               
        RoomList = 0x05,                
        CreateRoom = 0x06,              
        JoinRoom = 0x07,                
        LeaveRoom = 0x08,               
        RoomUpdate = 0x09,              
        SetReady = 0x0A,                
        RoomChatSended = 0x0B,          
        RoomChatReceived = 0x0C,        
        StartGame = 0x0D,               
        // Gameplay (C -> S)
        InputTick = 0x10,               
        UpdateSelectedWeapon = 0x11,    
        // Game State (S -> C)
        // RoomUpdate = 0x20,             /**< Entity state snapshot */
        EntitySpawn = 0x21,             
        EntityDeath = 0x22,             
        AmmoUpdate = 0x23,              
        Ping = 0x24,                    
        Pong = 0x25,                    
        DebugModeUpdate = 0x26,         
        Kicked = 0x27                   
        ,
        BeamState = 0x28,              
        ScoreUpdate = 0x29,            
        GameOver = 0x2A,               
        HealthUpdate = 0x2B            
    };
 
    #pragma pack(push, 1)
 
    struct Header {
        uint16_t magic = MAGIC_NUMBER;  
        uint16_t sequenceId = 0;        
        uint32_t bodySize = 0;          
        uint16_t ackId = 0;             
        OpCode opCode = OpCode::None;   
        uint8_t reserved = 0;           
        uint32_t sessionId = 0;         
    };
 
    enum class EntityType : uint8_t {
        Player = 1,
        Scout  = 2,
        Tank   = 3,
        Boss   = 4,
        Bullet = 5,
        PowerupHeal = 6,        // Red - Health regen
        PowerupSpeed = 7,       // (unused for now)
        Obstacle = 8,
        EnemyBullet = 9,
        ObstacleSolid = 10,
        ChargedBullet = 11,
        PowerupDoubleFire = 12, // Yellow/White - Double fire for 20s
        PowerupShield = 13,      // Green - Shield (absorb 1 hit)
        BossShield = 14,
        Boss2 = 15,              // Kraken Alien Boss (r-typesheet35.gif)
        Boss2Bullet = 16         // Kraken's boomerang projectile
    };
 
    // Payload Structures
 
    /***** Connection Management *****/
    struct ConnectPayload {
        uint32_t sessionId;             
    };
 
    struct BooleanPayload {
        uint8_t status;                 
    };
 
    /***** Authentication *****/
    struct LoginPayload {
        char username[32];              
        char password[32];              
        uint8_t weaponKind;             
    };
 
    struct RegisterPayload {
        char username[32];              
        char password[32];              
    };
 
    struct LoginResponsePayload {
        uint8_t success;                
        char username[32];              
    };
 
    struct RegisterResponsePayload {
        uint8_t success;                
        char username[32];              
    };
 
    /***** Lobby Management *****/
    enum class roomType : uint8_t {
        Lobby = 0,                      
        Public = 1,                     
        Private = 2                     
    };
    struct RoomInfo {
        uint32_t roomId;                
        char roomName[64];              
        uint32_t currentPlayers;        
        uint32_t maxPlayers;            
        uint8_t inGame;                 
        float difficulty;               
        float speed;                    
        uint32_t duration;              
        uint32_t seed;                  
        uint32_t levelId;               
        uint8_t roomType;               
    };
 
    struct CreateRoomPayload {
        char roomName[64];              
        uint32_t maxPlayers;            
        float difficulty;               
        float speed;                    
        uint32_t levelId;                // not used
        uint32_t seed;                   // not used
        uint32_t duration;               // not used
        uint8_t roomType;               
    };
 
    struct JoinRoomPayload {
        uint32_t roomId;                
        uint8_t isSpectator;            
    };
 
    struct RoomSnapshotPayload {
        uint32_t roomId;                
        uint32_t currentPlayers;        
        uint32_t serverTick;            
        uint16_t entityCount;           
        uint8_t inGame;                 
    };
 
    struct SetReadyPayload {
        uint8_t isReady;                
    };
 
    struct RoomChatPayload {
        char message[256];              
    };
 
    struct RoomChatReceivedPayload {
        uint32_t sessionId;             
        char username[32];              
        char message[256];              
    };
 
    /***** Gameplay *****/
    struct EntitySnapshotPayload {
        uint32_t netId;                 
        Vec2f position;                 
        Vec2f velocity;                 
        float rotation;                 
    };
 
    struct EntitySpawnPayload {
        uint32_t netId;                 
        uint8_t type;                   
        float posX;                     
        float posY;                     
        float sizeX{0.0f};              
        float sizeY{0.0f};              
        uint8_t weaponKind{0};          
    };
 
    struct EntityDeathPayload {
        uint32_t netId;                 
        uint8_t type;                   
        Vec2f position;                 
    };
 
    struct AmmoUpdatePayload {
        uint16_t current;               
        uint16_t max;                   
        uint8_t isReloading;            
        float cooldownRemaining;        
    };
 
    struct BeamStatePayload {
        uint32_t ownerNetId;            
        uint8_t active;                 
        float timeRemaining;            
        float length;                   
        float offsetY;                  
    };
 
    struct ScoreUpdatePayload {
        int32_t score;                  
    };
 
    struct GameOverPayload {
        char bestPlayer[32];            
        int32_t bestScore;              
        int32_t playerScore;            
    };
 
    struct HealthUpdatePayload {
        int32_t current;                
        int32_t max;                    
    };
 
    struct PingPayload {
        uint64_t clientTimeMs;          
    };
 
    struct DebugModePayload {
        uint8_t enabled;                
    };
 
    #pragma pack(pop)
 
    // Packet Class
 
    using BufferSequence = std::array<asio::const_buffer, 2>;
 
    struct InputPayload {
        uint8_t inputMask;              
    };
 
    class Packet {
        public:
            Header header;              
            std::vector<uint8_t> body;  
            Packet() = default;
            
            explicit Packet(OpCode op);
 
            void resetRead(void);
            
            BufferSequence getBufferSequence(void) const;
 
            template <typename T>
            static inline T to_network(T v)
            {
                if constexpr (std::is_enum_v<T>) {
                    using U = std::underlying_type_t<T>;
                    return static_cast<T>(to_network(static_cast<U>(v)));
                } else if constexpr (std::is_integral_v<T>) {
                    if constexpr (sizeof(T) > 1 && NATIVE_ENDIAN == std::endian::little)
                        return std::byteswap(v);
                    return v;
                } else if constexpr (std::is_same_v<T, float>) {
                    if constexpr (NATIVE_ENDIAN == std::endian::little) {
                        uint32_t u = std::bit_cast<uint32_t>(v);
                        u = std::byteswap(u);
                        return std::bit_cast<float>(u);
                    }
                    return v;
                }
                return v;
            }
 
            template <typename T>
            static inline T from_network(T value) {
                return to_network(value);
            };
 
            template <typename T>
            auto operator<<(T data) -> Packet &;
 
            template <typename T>
            auto operator<<(const std::vector<T> &vec) -> Packet &;
            
            auto operator<<(std::string_view str) -> Packet &;
 
            template <typename T>
            auto operator>>(T &data) -> Packet &;
 
            template <typename T>
            auto operator>>(std::vector<T> &vec) -> Packet &;
 
            auto operator>>(std::string &str) -> Packet &;
 
        private:
            void _bumpBodySizeOrThrow(); 
            size_t _readPos = 0;         
            mutable Header _cacheHeader; 
    };
}   
 
#include "Packet.tpp"
 
#endif /* !RTYPE_NETWORK_PACKET_HPP_ */