restructure project

src/td/protocol/packets/ConnectionInfoPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/ConnectionInfoPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer ConnexionInfoPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_ConnectionID;
+	return data;
+}
+
+void ConnexionInfoPacket::Deserialize(DataBuffer& data) {
+	data >> m_ConnectionID;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/DisconnectPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/DisconnectPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer DisconnectPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_Reason;
+	return data;
+}
+
+void DisconnectPacket::Deserialize(DataBuffer& data) {
+	data >> m_Reason;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/KeepAlivePacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/KeepAlivePacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer KeepAlivePacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_AliveID;
+	return data;
+}
+
+void KeepAlivePacket::Deserialize(DataBuffer& data) {
+	data >> m_AliveID;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/PlaceTowerPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/PlaceTowerPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer PlaceTowerPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_TowerX << m_TowerY << m_TowerType;
+	return data;
+}
+
+void PlaceTowerPacket::Deserialize(DataBuffer& data) {
+	data >> m_TowerX >> m_TowerY >> m_TowerType;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/PlayerBuyItemPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/PlayerBuyItemPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer PlayerBuyItemPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_ItemType << m_Count;
+	return data;
+}
+
+void PlayerBuyItemPacket::Deserialize(DataBuffer& data) {
+	data >> m_ItemType >> m_Count;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/PlayerBuyMobUpgradePacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/PlayerBuyMobUpgradePacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer PlayerBuyMobUpgradePacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_MobType << m_MobLevel;
+	return data;
+}
+
+void PlayerBuyMobUpgradePacket::Deserialize(DataBuffer& data) {
+	data >> m_MobType >> m_MobLevel;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/PlayerJoinPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/PlayerJoinPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer PlayerJoinPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_PlayerID << m_PlayerName;
+	return data;
+}
+
+void PlayerJoinPacket::Deserialize(DataBuffer& data) {
+	data >> m_PlayerID >> m_PlayerName;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/PlayerLeavePacket.cpp

@@ -0,0 +1,20 @@
+#include "td/protocol/packets/PlayerLeavePacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer PlayerLeavePacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_PlayerID;
+	return data;
+}
+
+void PlayerLeavePacket::Deserialize(DataBuffer& data) {
+	data >> m_PlayerID;
+}
+
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/PlayerListPacket.cpp

@@ -0,0 +1,30 @@
+#include "td/protocol/packets/PlayerListPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer PlayerListPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << static_cast<std::uint8_t>(m_Players.size());
+	for (auto [playerID, playerInfo] : m_Players) {
+		data << playerID << playerInfo.name << playerInfo.team;
+	}
+	return data;
+}
+
+void PlayerListPacket::Deserialize(DataBuffer& data) {
+	std::uint8_t playerCount;
+	data >> playerCount;
+
+	for (int i = 0; i < playerCount; i++) {
+		std::uint8_t playerID;
+		PlayerInfo playerInfo;
+		data >> playerID >> playerInfo.name >> playerInfo.team;
+		m_Players.insert({ playerID, playerInfo });
+	}
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/PlayerLoginPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/PlayerLoginPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer PlayerLoginPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_PlayerName;
+	return data;
+}
+
+void PlayerLoginPacket::Deserialize(DataBuffer& data) {
+	data >> m_PlayerName;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/RemoveTowerPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/RemoveTowerPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer RemoveTowerPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_TowerID;
+	return data;
+}
+
+void RemoveTowerPacket::Deserialize(DataBuffer& data) {
+	data >> m_TowerID;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/SelectTeamPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/SelectTeamPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer SelectTeamPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_SelectedTeam;
+	return data;
+}
+
+void SelectTeamPacket::Deserialize(DataBuffer& data) {
+	data >> m_SelectedTeam;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/SendMobsPacket.cpp

@@ -0,0 +1,26 @@
+#include "td/protocol/packets/SendMobsPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer SendMobsPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << static_cast<std::uint8_t>(m_MobSends.size());
+
+	data.WriteSome(reinterpret_cast<const std::uint8_t*>(m_MobSends.data()), m_MobSends.size() * sizeof(m_MobSends));
+
+	return data;
+}
+
+void SendMobsPacket::Deserialize(DataBuffer& data) {
+	std::uint8_t mobSendCount;
+	data >> mobSendCount;
+
+	m_MobSends.resize(mobSendCount);
+	data.ReadSome(reinterpret_cast<std::uint8_t*>(m_MobSends.data()), mobSendCount * sizeof(MobSend));
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/ServerTpsPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/ServerTpsPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer ServerTpsPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_TPS << m_MSPT << m_PacketSendTime;
+	return data;
+}
+
+void ServerTpsPacket::Deserialize(DataBuffer& data) {
+	data >> m_TPS >> m_MSPT >> m_PacketSendTime;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/SpawnMobPacket.cpp

@@ -0,0 +1,21 @@
+#include "td/protocol/packets/SpawnMobPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer SpawnMobPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_MobID << m_MobType << m_MobLevel << m_MobDirection
+		<< m_Sender << m_MobX << m_MobY;
+	return data;
+}
+
+void SpawnMobPacket::Deserialize(DataBuffer& data) {
+	data >> m_MobID >> m_MobType >> m_MobLevel >> m_MobDirection
+		>> m_Sender >> m_MobX >> m_MobY;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/UpdateCastleLifePacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/UpdateCastleLifePacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer UpdateCastleLifePacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_CastleLife << m_Team;
+	return data;
+}
+
+void UpdateCastleLifePacket::Deserialize(DataBuffer& data) {
+	data >> m_CastleLife >> m_Team;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/UpdateExpPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/UpdateExpPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer UpdateExpPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_NewAmount;
+	return data;
+}
+
+void UpdateExpPacket::Deserialize(DataBuffer& data) {
+	data >> m_NewAmount;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/UpdateGameStatePacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/UpdateGameStatePacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer UpdateGameStatePacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_GameState;
+	return data;
+}
+
+void UpdateGameStatePacket::Deserialize(DataBuffer& data) {
+	data >> m_GameState;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/UpdateLobbyTimePacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/UpdateLobbyTimePacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer UpdateLobbyTimePacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_RemainingTime;
+	return data;
+}
+
+void UpdateLobbyTimePacket::Deserialize(DataBuffer& data) {
+	data >> m_RemainingTime;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/UpdateMobStatesPacket.cpp

@@ -0,0 +1,25 @@
+#include "td/protocol/packets/UpdateMobStatesPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer UpdateMobStatesPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << static_cast<std::uint64_t>(m_MobStates.size());
+
+	data.WriteSome(reinterpret_cast<const std::uint8_t*>(m_MobStates.data()), m_MobStates.size() * sizeof(MobState));
+	return data;
+}
+
+void UpdateMobStatesPacket::Deserialize(DataBuffer& data) {
+	std::uint64_t mobCount;
+	data >> mobCount;
+	m_MobStates.resize(mobCount);
+
+	data.ReadSome(reinterpret_cast<std::uint8_t*>(m_MobStates.data()), mobCount * sizeof(MobState));
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/UpdateMoneyPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/UpdateMoneyPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer UpdateMoneyPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_NewAmount;
+	return data;
+}
+
+void UpdateMoneyPacket::Deserialize(DataBuffer& data) {
+	data >> m_NewAmount;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/UpdatePlayerTeamPacket.cpp

@@ -0,0 +1,20 @@
+#include "td/protocol/packets/UpdatePlayerTeamPacket.h"
+
+namespace td {
+namespace protocol {
+
+
+DataBuffer UpdatePlayerTeamPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_PlayerID << m_SelectedTeam;
+	return data;
+}
+
+void UpdatePlayerTeamPacket::Deserialize(DataBuffer& data) {
+	data >> m_PlayerID >> m_SelectedTeam;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/UpgradeTowerPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/UpgradeTowerPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer UpgradeTowerPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_TowerID << m_TowerLevel;
+	return data;
+}
+
+void UpgradeTowerPacket::Deserialize(DataBuffer& data) {
+	data >> m_TowerID >> m_TowerLevel;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/WorldAddTowerPacket.cpp

@@ -0,0 +1,19 @@
+#include "td/protocol/packets/WorldAddTowerPacket.h"
+
+namespace td {
+namespace protocol {
+
+DataBuffer WorldAddTowerPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+	data << m_TowerID << m_TowerX << m_TowerY << m_TowerType << m_Builder;
+	return data;
+}
+
+void WorldAddTowerPacket::Deserialize(DataBuffer& data) {
+	data >> m_TowerID >> m_TowerX >> m_TowerY >> m_TowerType >> m_Builder;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/WorldBeginDataPacket.cpp

@@ -0,0 +1,139 @@
+#include "td/protocol/packets/WorldBeginDataPacket.h"
+
+namespace td {
+namespace protocol {
+
+static DataBuffer& operator<<(DataBuffer& buffer, game::TilePtr tile) {
+	buffer << tile->GetType();
+
+	switch (tile->GetType()) {
+
+	case game::TileType::Tower: {
+		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 = dynamic_cast<const game::WalkableTile*>(tile.get());
+		buffer << walkTile->direction;
+		break;
+	}
+
+	case game::TileType::Decoration: {
+		const game::DecorationTile* decoTile = dynamic_cast<const game::DecorationTile*>(tile.get());
+		buffer << decoTile->color_palette_ref;
+		break;
+	}
+
+	default:
+		break;
+	}
+
+	return buffer;
+}
+
+static DataBuffer& operator>>(DataBuffer& buffer, game::TilePtr& tile) {
+	game::TileType tileType;
+	buffer >> tileType;
+	switch (tileType) {
+	case game::TileType::Tower: {
+		auto tilePtr = std::make_shared<game::TowerTile>();
+		buffer >> tilePtr->color_palette_ref >> tilePtr->team_owner;
+		tile = tilePtr;
+		break;
+	}
+	case game::TileType::Walk: {
+		auto tilePtr = std::make_shared<game::WalkableTile>();
+		buffer >> tilePtr->direction;
+		tile = tilePtr;
+		break;
+	}
+	case game::TileType::Decoration: {
+		auto tilePtr = std::make_shared<game::DecorationTile>();
+		buffer >> tilePtr->color_palette_ref;
+		tile = tilePtr;
+		break;
+	}
+	default:
+		break;
+	}
+	return buffer;
+}
+
+DataBuffer WorldBeginDataPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+	const game::TowerTileColorPalette& towerTilePalette = m_Header.m_World->GetTowerTileColorPalette();
+	const std::vector<Color>& decoTilePalette = m_Header.m_World->GetDecorationPalette();
+
+	WritePacketID(data, packetID);
+
+	data << towerTilePalette << m_Header.m_World->GetWalkableTileColor()
+		<< static_cast<std::uint16_t>(decoTilePalette.size());
+
+	// deco color palette
+	std::size_t bufferSize = data.GetSize();
+	data.Resize(bufferSize + decoTilePalette.size() * sizeof(Color));
+
+	memcpy(reinterpret_cast<std::uint8_t*>(data.data()) + bufferSize, decoTilePalette.data(), decoTilePalette.size() * sizeof(Color));
+
+	data << m_Header.m_World->GetBackgroundColor();
+
+	const game::Spawn& redSpawn = m_Header.m_World->GetRedTeam().GetSpawn(), blueSpawn = m_Header.m_World->GetBlueTeam().GetSpawn();
+	const game::TeamCastle& redCastle = m_Header.m_World->GetRedTeam().GetCastle(), blueCastle = m_Header.m_World->GetBlueTeam().GetCastle();
+
+	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_World->GetTilePalette().size());
+
+	for (game::TilePtr tile : m_Header.m_World->GetTilePalette()) {
+		data << tile;
+	}
+
+	data << m_Header.m_World->GetSpawnColors();
+
+	return data;
+}
+
+void WorldBeginDataPacket::Deserialize(DataBuffer& data) {
+	data >> m_Header.m_TowerPlacePalette >> m_Header.m_WalkablePalette;
+
+	std::uint16_t decoPaletteSize;
+	data >> decoPaletteSize;
+
+	std::size_t decoPalletteSizeByte = decoPaletteSize * sizeof(Color);
+
+	m_Header.m_DecorationPalette.resize(decoPaletteSize);
+
+	memcpy(reinterpret_cast<std::uint8_t*>(m_Header.m_DecorationPalette.data()), data.data() + data.GetReadOffset(), decoPalletteSizeByte);
+
+	data.SetReadOffset(data.GetReadOffset() + decoPalletteSizeByte);
+
+	data >> m_Header.m_Background;
+
+	utils::shape::Rectangle redCastle, blueCastle;
+
+	data >> m_Header.m_RedSpawn >> redCastle;
+	data >> m_Header.m_BlueSpawn >> blueCastle;
+
+	m_Header.m_RedCastle.SetShape(redCastle);
+	m_Header.m_BlueCastle.SetShape(blueCastle);
+
+	std::uint64_t tilePaletteSize;
+	data >> tilePaletteSize;
+
+	m_Header.m_TilePalette.reserve(tilePaletteSize);
+
+	for (std::uint64_t tileNumber = 0; tileNumber < tilePaletteSize; tileNumber++) {
+		game::TilePtr tile;
+		data >> tile;
+		m_Header.m_TilePalette.push_back(tile);
+	}
+
+	data >> m_Header.m_SpawnColorPalette;
+}
+
+} // namespace protocol
+} // namespace td

src/td/protocol/packets/WorldDataPacket.cpp

@@ -0,0 +1,115 @@
+#include "td/protocol/packets/WorldDataPacket.h"
+
+namespace td {
+namespace protocol {
+
+const int BITS_IN_BYTE = 8;
+const int BITS_IN_LONG = BITS_IN_BYTE * sizeof(std::uint64_t);
+
+static unsigned int countBits(unsigned int number) {
+	// log function in base 2
+	// take only integer part
+	return static_cast<unsigned int>(std::log2(number) + 1);
+}
+
+typedef std::vector<uint64_t> ChunkPackedData;
+
+DataBuffer WorldDataPacket::Serialize(bool packetID) const {
+	DataBuffer data;
+
+	WritePacketID(data, packetID);
+
+	data << 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 << 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(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());
+
+		game::Chunk::ChunkData::value_type individualValueMask = ((1 << bitsPerTile) - 1);
+
+		ChunkPackedData chunkData(game::Chunk::ChunkSize / (BITS_IN_BYTE * sizeof(ChunkPackedData::value_type) / bitsPerTile), 0);
+
+		for (unsigned int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++) {
+			std::size_t startLong = static_cast<std::size_t>((tileNumber * bitsPerTile) / BITS_IN_LONG);
+			std::size_t startOffset = static_cast<std::size_t>((tileNumber * bitsPerTile) % BITS_IN_LONG);
+			std::size_t endLong = static_cast<std::size_t>(((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG);
+
+			std::uint64_t value = static_cast<std::uint64_t>(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(reinterpret_cast<std::uint8_t*>(data.data()) + bufferSize, chunkData.data(), chunkData.size() * sizeof(ChunkPackedData::value_type));
+	}
+	return data;
+}
+
+void WorldDataPacket::Deserialize(DataBuffer& data) {
+	std::uint64_t chunkCount;
+	data >> chunkCount;
+
+	for (std::uint64_t chunkNumber = 0; chunkNumber < chunkCount; chunkNumber++) {
+		game::ChunkPtr chunk = std::make_shared<game::Chunk>();
+
+		decltype(game::ChunkCoord::x) chunkX, chunkY;
+		data >> chunkX >> chunkY;
+
+		std::uint64_t chunkPaletteSize;
+		data >> chunkPaletteSize;
+
+		game::ChunkPalette chunkPalette(chunkPaletteSize);
+
+		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;
+
+		std::uint8_t bitsPerTile = countBits(chunkPaletteSize);
+
+		// A bitmask that contains bitsPerTile set bits
+		game::Chunk::ChunkData::value_type individualValueMask = ((1 << bitsPerTile) - 1);
+
+		ChunkPackedData chunkData(game::Chunk::ChunkSize / (BITS_IN_BYTE * sizeof(ChunkPackedData::value_type) / bitsPerTile), 0);
+
+		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 (unsigned int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++) {
+			std::size_t startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG;
+			std::size_t startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG;
+			std::size_t endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG;
+
+			game::Chunk::ChunkData::value_type value;
+			if (startLong == endLong) {
+				value = (chunkData[startLong] >> startOffset);
+			} else {
+				int endOffset = BITS_IN_LONG - startOffset;
+				value = (chunkData[startLong] >> startOffset | chunkData[endLong] << endOffset);
+			}
+			value &= individualValueMask;
+
+			chunk->tiles[tileNumber] = value;
+		}
+
+
+		m_WorldData.m_Chunks.insert({ {chunkX, chunkY}, chunk });
+	}
+}
+
+} // namespace protocol
+} // namespace td