protocol rework + map packet ids removal

include/protocol/Protocol.h

@@ -68,10 +68,12 @@ public:
     Packet() {}
     virtual ~Packet() {}
 
-    virtual DataBuffer Serialize() const = 0;
+    virtual DataBuffer Serialize(bool packetID = true) const = 0;
     virtual void Deserialize(DataBuffer& data) = 0;
     virtual void Dispatch(PacketHandler* handler) const = 0;
 
+    void WritePacketID(DataBuffer& data, bool packetID) const;
+
     virtual PacketType getType() const = 0;
     std::uint8_t getID() const { return (std::uint8_t)getType(); }
 };
@@ -86,7 +88,7 @@ public:
     KeepAlivePacket(std::uint64_t aliveID) : m_AliveID(aliveID) {}
     virtual ~KeepAlivePacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -103,7 +105,7 @@ public:
     PlayerLoginPacket(std::string playerName) : m_PlayerName(playerName) {}
     virtual ~PlayerLoginPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -122,7 +124,7 @@ public:
     }
     virtual ~WorldBeginDataPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -143,7 +145,6 @@ public:
 
     const game::TilePalette getTilePalette() const { return m_Header.m_TilePalette; }
 
-    DataBuffer SerializeCustom() const; // allow serialisation with invalid World member
     void setWorldHeader(const WorldHeader& header) { m_Header = header; }
 };
 
@@ -157,7 +158,7 @@ public:
     WorldDataPacket(const game::World* world) : m_World(world) {}
     virtual ~WorldDataPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -179,7 +180,7 @@ public:
 
     std::uint32_t getGold() const { return m_NewAmount; }
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -194,7 +195,7 @@ public:
     UpdateExpPacket(std::uint32_t newAmount) : m_NewAmount(newAmount) {}
     virtual ~UpdateExpPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -209,7 +210,7 @@ public:
     UpdateLobbyTimePacket(std::uint32_t remainingTime) : m_RemainingTime(remainingTime) {}
     virtual ~UpdateLobbyTimePacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -226,7 +227,7 @@ public:
     UpdateGameStatePacket(game::GameState gameState) : m_GameState(gameState) {}
     virtual ~UpdateGameStatePacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -248,7 +249,7 @@ public:
     PlayerListPacket(std::map<std::uint8_t, PlayerInfo> players) : m_Players(players) {}
     virtual ~PlayerListPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -266,7 +267,7 @@ public:
     PlayerJoinPacket(std::uint8_t playerID, const std::string& playerName) : m_PlayerID(playerID), m_PlayerName(playerName) {}
     virtual ~PlayerJoinPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -284,7 +285,7 @@ public:
     PlayerLeavePacket(std::uint8_t playerID) : m_PlayerID(playerID) {}
     virtual ~PlayerLeavePacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -301,7 +302,7 @@ public:
     ConnexionInfoPacket(std::uint8_t connectionID) : m_ConnectionID(connectionID) {}
     virtual ~ConnexionInfoPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -318,7 +319,7 @@ public:
     SelectTeamPacket(game::TeamColor selectedTeam) : m_SelectedTeam(selectedTeam) {}
     virtual ~SelectTeamPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -336,7 +337,7 @@ public:
     UpdatePlayerTeamPacket(std::uint8_t playerID, game::TeamColor selectedTeam) : m_PlayerID(playerID), m_SelectedTeam(selectedTeam) {}
     virtual ~UpdatePlayerTeamPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -354,7 +355,7 @@ public:
     DisconnectPacket(std::string reason) : m_Reason(reason) {}
     virtual ~DisconnectPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -372,7 +373,7 @@ public:
     ServerTpsPacket(float tps, std::uint64_t sendTime) : m_TPS(tps), m_PacketSendTime(sendTime) {}
     virtual ~ServerTpsPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -396,7 +397,7 @@ public:
     SendMobsPacket(const std::vector<MobSend>& mobSends) : m_MobSends(mobSends) {}
     virtual ~SendMobsPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -420,7 +421,7 @@ public:
         m_MobDirection(dir), m_Sender(sender), m_MobX(x), m_MobY(y) {}
     virtual ~SpawnMobPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -445,7 +446,7 @@ public:
         m_TowerX(x), m_TowerY(y), m_TowerType(type) {}
     virtual ~PlaceTowerPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -468,7 +469,7 @@ public:
         m_TowerID(id), m_TowerX(x), m_TowerY(y), m_TowerType(type), m_Builder(player) {}
     virtual ~WorldAddTowerPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -489,7 +490,7 @@ public:
     RemoveTowerPacket(game::TowerID id) : m_TowerID(id) {}
     virtual ~RemoveTowerPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -507,7 +508,7 @@ public:
     UpgradeTowerPacket(game::TowerID tower, game::TowerLevel level) : m_TowerID(tower), m_TowerLevel(level) {}
     virtual ~UpgradeTowerPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -542,7 +543,7 @@ public:
     UpdateMobStatesPacket() {}
     virtual ~UpdateMobStatesPacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 
@@ -562,7 +563,7 @@ public:
     UpdateCastleLifePacket(std::uint16_t life, game::TeamColor team) : m_CastleLife(life), m_Team(team) {}
     virtual ~UpdateCastleLifePacket() {}
 
-    virtual DataBuffer Serialize() const;
+    virtual DataBuffer Serialize(bool packetID = true) const;
     virtual void Deserialize(DataBuffer& data);
     virtual void Dispatch(PacketHandler* handler) const;
 

src/game/World.cpp

@@ -72,15 +72,9 @@ bool World::loadMapFromFile(const std::string& fileName) {
     DataBuffer mapHeaderPacketBuffer = utils::Decompress(buffer);
     DataBuffer mapDataPacketBuffer = utils::Decompress(buffer);
 
-    protocol::PacketType packetType;
-
-    mapHeaderPacketBuffer >> packetType;
-
     protocol::WorldBeginDataPacket headerPacket;
     headerPacket.Deserialize(mapHeaderPacketBuffer);
 
-    mapDataPacketBuffer >> packetType;
-
     protocol::WorldDataPacket dataPacket;
     dataPacket.Deserialize(mapDataPacketBuffer);
 
@@ -94,8 +88,8 @@ bool World::saveMap(const std::string& fileName) const {
     protocol::WorldBeginDataPacket headerPacket(this);
     protocol::WorldDataPacket dataPacket(this);
 
-    DataBuffer mapHeaderCompressed = utils::Compress(headerPacket.Serialize());
+    DataBuffer mapHeaderCompressed = utils::Compress(headerPacket.Serialize(false));
-    DataBuffer mapDataCompressed = utils::Compress(dataPacket.Serialize());
+    DataBuffer mapDataCompressed = utils::Compress(dataPacket.Serialize(false));
 
     std::cout << "Header Packet Size : " << mapHeaderCompressed.GetSize() << std::endl;
     std::cout << "World Data Packet Size : " << mapDataCompressed.GetSize() << std::endl;

src/protocol/Protocol.cpp

@@ -1,7 +1,10 @@
 #include "protocol/PacketHandler.h"
+
 #include <cmath>
 
-#define REGISTER_DISPATCH_CLASS(className) void className::Dispatch(PacketHandler* handler) const {handler->HandlePacket(this);}
+#define REGISTER_DISPATCH_CLASS(className)  void className::Dispatch(PacketHandler* handler) const { \
+                                                handler->HandlePacket(this);\
+                                            }
 
 namespace td {
 namespace protocol {
@@ -12,30 +15,42 @@ const int BITS_IN_LONG = BITS_IN_BYTE * sizeof(std::uint64_t);
 unsigned int countBits(unsigned int number) {
     // log function in base 2
     // take only integer part
-    return (int)std::log2(number) + 1;
+    return static_cast<unsigned int>(std::log2(number) + 1);
+}
+
+void Packet::WritePacketID(DataBuffer& data, bool packetID) const {
+    if (packetID) {
+        data << getID();
+    }
 }
 
 DataBuffer& operator<<(DataBuffer& buffer, game::TilePtr tile) {
     buffer << tile->getType();
+
     switch (tile->getType()) {
+
     case game::TileType::Tower: {
-        const game::TowerTile* towerTile = (const game::TowerTile*)tile.get();
+        const game::TowerTile* towerTile = dynamic_cast<const game::TowerTile*>(tile.get());
         buffer << towerTile->color_palette_ref << towerTile->team_owner;
         break;
     }
+
     case game::TileType::Walk: {
-        const game::WalkableTile* walkTile = (const game::WalkableTile*)tile.get();
+        const game::WalkableTile* walkTile = dynamic_cast<const game::WalkableTile*>(tile.get());
         buffer << walkTile->direction;
         break;
     }
+
     case game::TileType::Decoration: {
-        const game::DecorationTile* decoTile = (const game::DecorationTile*)tile.get();
+        const game::DecorationTile* decoTile = dynamic_cast<const game::DecorationTile*>(tile.get());
         buffer << decoTile->color_palette_ref;
         break;
     }
+
     default:
         break;
     }
+
     return buffer;
 }
 
@@ -44,19 +59,19 @@ DataBuffer& operator>>(DataBuffer& buffer, game::TilePtr& tile) {
     buffer >> tileType;
     switch (tileType) {
     case game::TileType::Tower: {
-        std::shared_ptr<game::TowerTile> tilePtr = std::make_shared<game::TowerTile>();
+        auto tilePtr = std::make_shared<game::TowerTile>();
         buffer >> tilePtr->color_palette_ref >> tilePtr->team_owner;
         tile = tilePtr;
         break;
     }
     case game::TileType::Walk: {
-        std::shared_ptr<game::WalkableTile> tilePtr = std::make_shared<game::WalkableTile>();
+        auto tilePtr = std::make_shared<game::WalkableTile>();
         buffer >> tilePtr->direction;
         tile = tilePtr;
         break;
     }
     case game::TileType::Decoration: {
-        std::shared_ptr<game::DecorationTile> tilePtr = std::make_shared<game::DecorationTile>();
+        auto tilePtr = std::make_shared<game::DecorationTile>();
         buffer >> tilePtr->color_palette_ref;
         tile = tilePtr;
         break;
@@ -67,9 +82,11 @@ DataBuffer& operator>>(DataBuffer& buffer, game::TilePtr& tile) {
     return buffer;
 }
 
-DataBuffer PlayerLoginPacket::Serialize() const {
+DataBuffer PlayerLoginPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_PlayerName;
+
+    WritePacketID(data, packetID);
+    data << m_PlayerName;
     return data;
 }
 
@@ -77,53 +94,21 @@ void PlayerLoginPacket::Deserialize(DataBuffer& data) {
     data >> m_PlayerName;
 }
 
-DataBuffer WorldBeginDataPacket::SerializeCustom() const {
+DataBuffer WorldBeginDataPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    const game::TowerTileColorPalette towerTilePalette = m_Header.m_TowerPlacePalette;
+    const game::TowerTileColorPalette& towerTilePalette = m_Header.m_World->getTowerTileColorPalette();
-    const std::vector<game::Color>& decoTilePalette = m_Header.m_DecorationPalette;
-
-    data << getID() << towerTilePalette << m_Header.m_WalkablePalette
-        << (std::uint16_t)decoTilePalette.size();
-
-    // deco color palette
-    std::size_t bufferSize = data.GetSize();
-    data.Resize(bufferSize + decoTilePalette.size() * sizeof(game::Color));
-
-    memcpy((std::uint8_t*)data.data() + bufferSize, decoTilePalette.data(), decoTilePalette.size() * sizeof(game::Color));
-
-    data << m_Header.m_Background;
-
-    const game::Spawn& redSpawn = m_Header.m_RedSpawn, blueSpawn = m_Header.m_BlueSpawn;
-    const game::TeamCastle& redCastle = m_Header.m_RedCastle, blueCastle = m_Header.m_BlueCastle;
-
-    data << redSpawn << static_cast<utils::shape::Rectangle>(redCastle);
-    data << blueSpawn << static_cast<utils::shape::Rectangle>(blueCastle);
-
-    // tile palette
-    data << static_cast<std::uint64_t>(m_Header.m_TilePalette.size());
-
-    for (game::TilePtr tile : m_Header.m_TilePalette) {
-        data << tile;
-    }
-
-    data << m_Header.m_SpawnColorPalette;
-
-    return data;
-}
-
-DataBuffer WorldBeginDataPacket::Serialize() const {
-    DataBuffer data;
-    const game::TowerTileColorPalette towerTilePalette = m_Header.m_World->getTowerTileColorPalette();
     const std::vector<game::Color>& decoTilePalette = m_Header.m_World->getDecorationPalette();
 
-    data << getID() << towerTilePalette << m_Header.m_World->getWalkableTileColor()
+    WritePacketID(data, packetID);
+
+    data << towerTilePalette << m_Header.m_World->getWalkableTileColor()
         << (std::uint16_t)decoTilePalette.size();
 
     // deco color palette
     std::size_t bufferSize = data.GetSize();
     data.Resize(bufferSize + decoTilePalette.size() * sizeof(game::Color));
 
-    memcpy((std::uint8_t*)data.data() + bufferSize, decoTilePalette.data(), decoTilePalette.size() * sizeof(game::Color));
+    memcpy(reinterpret_cast<std::uint8_t*>(data.data()) + bufferSize, decoTilePalette.data(), decoTilePalette.size() * sizeof(game::Color));
 
     data << m_Header.m_World->getBackgroundColor();
 
@@ -155,7 +140,7 @@ void WorldBeginDataPacket::Deserialize(DataBuffer& data) {
 
     m_Header.m_DecorationPalette.resize(decoPaletteSize);
 
-    memcpy((std::uint8_t*)m_Header.m_DecorationPalette.data(), data.data() + data.GetReadOffset(), decoPalletteSizeByte);
+    memcpy(reinterpret_cast<std::uint8_t*>(m_Header.m_DecorationPalette.data()), data.data() + data.GetReadOffset(), decoPalletteSizeByte);
 
     data.SetReadOffset(data.GetReadOffset() + decoPalletteSizeByte);
 
@@ -185,61 +170,21 @@ void WorldBeginDataPacket::Deserialize(DataBuffer& data) {
 
 typedef std::vector<uint64_t> ChunkPackedData;
 
-DataBuffer WorldDataPacket::SerializeCustom() const {
+DataBuffer WorldDataPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_WorldData.m_Chunks.size();
-    for (const auto& pair : m_WorldData.m_Chunks) {
-        game::ChunkCoord coords = pair.first;
-        game::ChunkPtr chunk = pair.second;
 
-        data << coords.x << coords.y << (std::uint64_t)chunk->palette.size();
+    WritePacketID(data, packetID);
 
-        std::size_t bufferSize = data.GetSize();
+    data << m_World->getChunks().size();
-        data.Resize(data.GetSize() + chunk->palette.size() * sizeof(game::ChunkPalette::value_type));
-        memcpy((std::uint8_t*)data.data() + bufferSize, chunk->palette.data(), chunk->palette.size() * sizeof(game::ChunkPalette::value_type));
-
-        std::uint8_t bitsPerTile = countBits(chunk->palette.size());
-
-        game::Chunk::ChunkData::value_type individualValueMask = ((1 << bitsPerTile) - 1);
-
-        ChunkPackedData chunkData(game::Chunk::ChunkSize / (BITS_IN_BYTE * sizeof(ChunkPackedData::value_type) / bitsPerTile), 0);
-
-        for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++) {
-            int startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG;
-            int startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG;
-            int endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG;
-
-            std::uint64_t value = chunk->tiles[tileNumber];
-
-            value &= individualValueMask;
-
-
-            chunkData[startLong] |= (value << startOffset);
-
-            if (startLong != endLong) {
-                chunkData[endLong] = (value >> (BITS_IN_LONG - startOffset));
-            }
-        }
-
-        bufferSize = data.GetSize();
-        data.Resize(data.GetSize() + chunkData.size() * sizeof(ChunkPackedData::value_type));
-        memcpy((std::uint8_t*)data.data() + bufferSize, chunkData.data(), chunkData.size() * sizeof(ChunkPackedData::value_type));
-    }
-    return data;
-}
-
-DataBuffer WorldDataPacket::Serialize() const {
-    DataBuffer data;
-    data << getID() << m_World->getChunks().size();
     for (const auto& pair : m_World->getChunks()) {
         game::ChunkCoord coords = pair.first;
         game::ChunkPtr chunk = pair.second;
 
-        data << coords.x << coords.y << (std::uint64_t)chunk->palette.size();
+        data << coords.x << coords.y << static_cast<std::uint64_t>(chunk->palette.size());
 
         std::size_t bufferSize = data.GetSize();
         data.Resize(data.GetSize() + chunk->palette.size() * sizeof(game::ChunkPalette::value_type));
-        memcpy((std::uint8_t*)data.data() + bufferSize, chunk->palette.data(), chunk->palette.size() * sizeof(game::ChunkPalette::value_type));
+        memcpy(reinterpret_cast<std::uint8_t*>(data.data()) + bufferSize, chunk->palette.data(), chunk->palette.size() * sizeof(game::ChunkPalette::value_type));
 
         std::uint8_t bitsPerTile = countBits(chunk->palette.size());
 
@@ -256,7 +201,6 @@ DataBuffer WorldDataPacket::Serialize() const {
 
             value &= individualValueMask;
 
-
             chunkData[startLong] |= (value << startOffset);
 
             if (startLong != endLong) {
@@ -266,7 +210,7 @@ DataBuffer WorldDataPacket::Serialize() const {
 
         bufferSize = data.GetSize();
         data.Resize(data.GetSize() + chunkData.size() * sizeof(ChunkPackedData::value_type));
-        memcpy((std::uint8_t*)data.data() + bufferSize, chunkData.data(), chunkData.size() * sizeof(ChunkPackedData::value_type));
+        memcpy(reinterpret_cast<std::uint8_t*>(data.data()) + bufferSize, chunkData.data(), chunkData.size() * sizeof(ChunkPackedData::value_type));
     }
     return data;
 }
@@ -286,7 +230,7 @@ void WorldDataPacket::Deserialize(DataBuffer& data) {
 
         game::ChunkPalette chunkPalette(chunkPaletteSize);
 
-        memcpy((void*)chunkPalette.data(), data.data() + data.GetReadOffset(), chunkPaletteSize * sizeof(game::ChunkPalette::value_type));
+        memcpy(reinterpret_cast<void*>(chunkPalette.data()), data.data() + data.GetReadOffset(), chunkPaletteSize * sizeof(game::ChunkPalette::value_type));
         data.SetReadOffset(data.GetReadOffset() + chunkPaletteSize * sizeof(game::ChunkPalette::value_type));
 
         chunk->palette = chunkPalette;
@@ -298,7 +242,7 @@ void WorldDataPacket::Deserialize(DataBuffer& data) {
 
         ChunkPackedData chunkData(game::Chunk::ChunkSize / (BITS_IN_BYTE * sizeof(ChunkPackedData::value_type) / bitsPerTile), 0);
 
-        memcpy((void*)chunkData.data(), data.data() + data.GetReadOffset(), chunkData.size() * sizeof(ChunkPackedData::value_type));
+        memcpy(reinterpret_cast<void*>(chunkData.data()), data.data() + data.GetReadOffset(), chunkData.size() * sizeof(ChunkPackedData::value_type));
         data.SetReadOffset(data.GetReadOffset() + chunkData.size() * sizeof(ChunkPackedData::value_type));
 
         for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++) {
@@ -323,9 +267,11 @@ void WorldDataPacket::Deserialize(DataBuffer& data) {
     }
 }
 
-DataBuffer KeepAlivePacket::Serialize() const {
+DataBuffer KeepAlivePacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_AliveID;
+
+    WritePacketID(data, packetID);
+    data << m_AliveID;
     return data;
 }
 
@@ -333,9 +279,11 @@ void KeepAlivePacket::Deserialize(DataBuffer& data) {
     data >> m_AliveID;
 }
 
-DataBuffer UpdateMoneyPacket::Serialize() const {
+DataBuffer UpdateMoneyPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_NewAmount;
+
+    WritePacketID(data, packetID);
+    data << m_NewAmount;
     return data;
 }
 
@@ -343,9 +291,11 @@ void UpdateMoneyPacket::Deserialize(DataBuffer& data) {
     data >> m_NewAmount;
 }
 
-DataBuffer UpdateExpPacket::Serialize() const {
+DataBuffer UpdateExpPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_NewAmount;
+
+    WritePacketID(data, packetID);
+    data << m_NewAmount;
     return data;
 }
 
@@ -353,9 +303,11 @@ void UpdateExpPacket::Deserialize(DataBuffer& data) {
     data >> m_NewAmount;
 }
 
-DataBuffer UpdateLobbyTimePacket::Serialize() const {
+DataBuffer UpdateLobbyTimePacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_RemainingTime;
+
+    WritePacketID(data, packetID);
+    data << m_RemainingTime;
     return data;
 }
 
@@ -363,9 +315,11 @@ void UpdateLobbyTimePacket::Deserialize(DataBuffer& data) {
     data >> m_RemainingTime;
 }
 
-DataBuffer UpdateGameStatePacket::Serialize() const {
+DataBuffer UpdateGameStatePacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_GameState;
+
+    WritePacketID(data, packetID);
+    data << m_GameState;
     return data;
 }
 
@@ -373,9 +327,11 @@ void UpdateGameStatePacket::Deserialize(DataBuffer& data) {
     data >> m_GameState;
 }
 
-DataBuffer PlayerListPacket::Serialize() const {
+DataBuffer PlayerListPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << (std::uint8_t)m_Players.size();
+
+    WritePacketID(data, packetID);
+    data << static_cast<std::uint8_t>(m_Players.size());
     for (auto pair : m_Players) {
         data << pair.first << pair.second.name << pair.second.team;
     }
@@ -394,9 +350,11 @@ void PlayerListPacket::Deserialize(DataBuffer& data) {
     }
 }
 
-DataBuffer PlayerJoinPacket::Serialize() const {
+DataBuffer PlayerJoinPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_PlayerID << m_PlayerName;
+
+    WritePacketID(data, packetID);
+    data << m_PlayerID << m_PlayerName;
     return data;
 }
 
@@ -404,9 +362,11 @@ void PlayerJoinPacket::Deserialize(DataBuffer& data) {
     data >> m_PlayerID >> m_PlayerName;
 }
 
-DataBuffer PlayerLeavePacket::Serialize() const {
+DataBuffer PlayerLeavePacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_PlayerID;
+
+    WritePacketID(data, packetID);
+    data << m_PlayerID;
     return data;
 }
 
@@ -414,9 +374,11 @@ void PlayerLeavePacket::Deserialize(DataBuffer& data) {
     data >> m_PlayerID;
 }
 
-DataBuffer ConnexionInfoPacket::Serialize() const {
+DataBuffer ConnexionInfoPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_ConnectionID;
+
+    WritePacketID(data, packetID);
+    data << m_ConnectionID;
     return data;
 }
 
@@ -424,9 +386,11 @@ void ConnexionInfoPacket::Deserialize(DataBuffer& data) {
     data >> m_ConnectionID;
 }
 
-DataBuffer SelectTeamPacket::Serialize() const {
+DataBuffer SelectTeamPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_SelectedTeam;
+
+    WritePacketID(data, packetID);
+    data << m_SelectedTeam;
     return data;
 }
 
@@ -434,9 +398,11 @@ void SelectTeamPacket::Deserialize(DataBuffer& data) {
     data >> m_SelectedTeam;
 }
 
-DataBuffer UpdatePlayerTeamPacket::Serialize() const {
+DataBuffer UpdatePlayerTeamPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_PlayerID << m_SelectedTeam;
+
+    WritePacketID(data, packetID);
+    data << m_PlayerID << m_SelectedTeam;
     return data;
 }
 
@@ -444,9 +410,11 @@ void UpdatePlayerTeamPacket::Deserialize(DataBuffer& data) {
     data >> m_PlayerID >> m_SelectedTeam;
 }
 
-DataBuffer DisconnectPacket::Serialize() const {
+DataBuffer DisconnectPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_Reason;
+
+    WritePacketID(data, packetID);
+    data << m_Reason;
     return data;
 }
 
@@ -454,9 +422,11 @@ void DisconnectPacket::Deserialize(DataBuffer& data) {
     data >> m_Reason;
 }
 
-DataBuffer ServerTpsPacket::Serialize() const {
+DataBuffer ServerTpsPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_TPS << m_PacketSendTime;
+
+    WritePacketID(data, packetID);
+    data << m_TPS << m_PacketSendTime;
     return data;
 }
 
@@ -464,9 +434,11 @@ void ServerTpsPacket::Deserialize(DataBuffer& data) {
     data >> m_TPS >> m_PacketSendTime;
 }
 
-DataBuffer SpawnMobPacket::Serialize() const {
+DataBuffer SpawnMobPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_MobID << m_MobType << m_MobLevel << m_MobDirection
+
+    WritePacketID(data, packetID);
+    data << m_MobID << m_MobType << m_MobLevel << m_MobDirection
         << m_Sender << m_MobX << m_MobY;
     return data;
 }
@@ -476,9 +448,11 @@ void SpawnMobPacket::Deserialize(DataBuffer& data) {
         >> m_Sender >> m_MobX >> m_MobY;
 }
 
-DataBuffer PlaceTowerPacket::Serialize() const {
+DataBuffer PlaceTowerPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_TowerX << m_TowerY << m_TowerType;
+
+    WritePacketID(data, packetID);
+    data << m_TowerX << m_TowerY << m_TowerType;
     return data;
 }
 
@@ -486,9 +460,11 @@ void PlaceTowerPacket::Deserialize(DataBuffer& data) {
     data >> m_TowerX >> m_TowerY >> m_TowerType;
 }
 
-DataBuffer WorldAddTowerPacket::Serialize() const {
+DataBuffer WorldAddTowerPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_TowerID << m_TowerX << m_TowerY << m_TowerType << m_Builder;
+
+    WritePacketID(data, packetID);
+    data << m_TowerID << m_TowerX << m_TowerY << m_TowerType << m_Builder;
     return data;
 }
 
@@ -496,9 +472,11 @@ void WorldAddTowerPacket::Deserialize(DataBuffer& data) {
     data >> m_TowerID >> m_TowerX >> m_TowerY >> m_TowerType >> m_Builder;
 }
 
-DataBuffer RemoveTowerPacket::Serialize() const {
+DataBuffer RemoveTowerPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_TowerID;
+
+    WritePacketID(data, packetID);
+    data << m_TowerID;
     return data;
 }
 
@@ -506,9 +484,11 @@ void RemoveTowerPacket::Deserialize(DataBuffer& data) {
     data >> m_TowerID;
 }
 
-DataBuffer SendMobsPacket::Serialize() const {
+DataBuffer SendMobsPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << static_cast<std::uint8_t>(m_MobSends.size());
+
+    WritePacketID(data, packetID);
+    data << static_cast<std::uint8_t>(m_MobSends.size());
     for (const MobSend& mobSend : m_MobSends) {
         data << mobSend;
     }
@@ -525,9 +505,11 @@ void SendMobsPacket::Deserialize(DataBuffer& data) {
     }
 }
 
-DataBuffer UpgradeTowerPacket::Serialize() const {
+DataBuffer UpgradeTowerPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_TowerID << m_TowerLevel;
+
+    WritePacketID(data, packetID);
+    data << m_TowerID << m_TowerLevel;
     return data;
 }
 
@@ -535,9 +517,11 @@ void UpgradeTowerPacket::Deserialize(DataBuffer& data) {
     data >> m_TowerID >> m_TowerLevel;
 }
 
-DataBuffer UpdateCastleLifePacket::Serialize() const {
+DataBuffer UpdateCastleLifePacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << m_CastleLife << m_Team;
+
+    WritePacketID(data, packetID);
+    data << m_CastleLife << m_Team;
     return data;
 }
 
@@ -545,9 +529,11 @@ void UpdateCastleLifePacket::Deserialize(DataBuffer& data) {
     data >> m_CastleLife >> m_Team;
 }
 
-DataBuffer UpdateMobStatesPacket::Serialize() const {
+DataBuffer UpdateMobStatesPacket::Serialize(bool packetID) const {
     DataBuffer data;
-    data << getID() << static_cast<std::uint64_t>(m_MobStates.size());
+
+    WritePacketID(data, packetID);
+    data << static_cast<std::uint64_t>(m_MobStates.size());
     for (auto mobState : m_MobStates) {
         data << mobState;
     }