4 #include "NetworkConfig.hh"

     5 #include "Network.hh"

     6 

     7 #include <stdexcept>

     8 

     9 enum packet_type {

    10     PKT_INVALID,

    11     PKT_HELLO

    12 };

    13 

    14 class NetworkPacket {

    15     private:

    16         char buf[NETWORK_PACKET_MAX];

    17         size_t size;

    18         size_t offset;

    19     public:

    20         CL_IPAddress src;

    21 

    22     public:

    23         NetworkPacket () : size(0), offset(0) { }

    24 

    25         void recvFromSocket (CL_Socket &sock) {

    26             size = sock.recv((void *) buf, NETWORK_PACKET_MAX, src);

    27 

    28             offset = 0;

    29         }

    30     

    31         template <typename T> void read_into (T* val_ptr) {

    32             if (offset + sizeof(T) > size)

    33                 throw std::logic_error("short packet");

    34 

    35             *val_ptr = *((T*) (buf + offset));

    36 

    37             offset += sizeof(T);

    38         }

    39 

    40         template <typename T> T read_type (void) {

    41             T val;

    42 

    43             read_into(&val);

    44 

    45             return val;

    46         }

    47         

    48         uint8_t read_uint8 (void) {

    49             return read_type<uint8_t>();

    50         }

    51 

    52         uint16_t read_uint16 (void) {

    53             return htons(read_type<uint16_t>());

    54         }

    55 

    56         enum packet_type read_pkt_type (void) {

    57             return (enum packet_type) read_uint8();

    58         }

    59 };

    60 

    61 struct pkt_base {

    62     NetworkPacket &packet;

    63     

    64     pkt_base (NetworkPacket &packet) : packet(packet) { }

    65 };

    66 

    67 struct pkt_Hello : public pkt_base {

    68     uint16_t player_id;

    69 

    70     pkt_Hello (NetworkPacket &packet) : pkt_base(packet), 

    71         player_id(packet.read_uint16()) { }

    72 };

    73