packet.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <string>
#include <vector>
#include <utility>
#include <ostream>
#include <sstream>
#include <iostream>
 
#include <boost/asio.hpp>
 
#include "shared/game/event.hpp"
#include "shared/network/constants.hpp"
#include "shared/utilities/typedefs.hpp"
#include "shared/utilities/serialize_macro.hpp"
#include "shared/utilities/serialize.hpp"
 
 
// Might want to move this later on to somewhere in the game code
 
enum class PacketType: uint16_t {
    // Setup
    ServerLobbyBroadcast = 0, 
    ClientDeclareInfo,   
    ServerAssignEID,     
 
    // Gameplay
    Event = 2000, 
};
 
struct PacketHeader {
    PacketHeader(uint16_t size, PacketType type): size{size}, type{type} {}
 
    void to_network() {
        this->size = htons(this->size);
        this->type = static_cast<PacketType>(htons(static_cast<uint16_t>(this->type))); 
    }
 
    explicit PacketHeader(void* buffer) {
        PacketHeader* buf_hdr = static_cast<PacketHeader*>(buffer);
        this->size = ntohs(buf_hdr->size);
        this->type = static_cast<PacketType>(ntohs(static_cast<uint16_t>(buf_hdr->type)));
    }
 
    uint16_t size;
    PacketType type;
};
 
struct ServerLobbyBroadcastPacket {
    std::string lobby_name;
    int slots_taken;
    int slots_avail;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & this->lobby_name;
        ar & this->slots_taken;
        ar & this->slots_avail;
    }
};
 
struct ClientDeclareInfoPacket {
    std::string player_name;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & this->player_name;
    }
};
 
struct ServerAssignEIDPacket {
    EntityID eid;
    bool is_dungeon_master;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & eid & is_dungeon_master;
    }
};
 
struct EventPacket {
    Event event;
    
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & event;
    }
};
 
class PackagedPacket { 
public:
    ~PackagedPacket() = default;
 
    template <class Packet>
    static std::shared_ptr<PackagedPacket> make_shared(PacketType type, Packet packet) {
        std::string data = serialize<Packet>(packet);
 
        PacketHeader hdr(data.size(), type);
 
        return std::shared_ptr<PackagedPacket>(new PackagedPacket(hdr, data));
    }
 
    std::array<boost::asio::const_buffer, 2> toBuffer() {
        return {
            boost::asio::buffer(&this->hdr, sizeof(PacketHeader)),
            boost::asio::buffer(this->data)
        };
    }
 
private:
    PackagedPacket(PacketHeader hdr, const std::string& data)
        :hdr(hdr), data(data)
    {
        this->hdr.size = data.size();
        this->hdr.to_network();
    }
 
    PackagedPacket(const PackagedPacket& a) = delete;
    PackagedPacket& operator=(const PackagedPacket& a) = delete;
 
    PacketHeader hdr;
    std::string data;
};