refactor tile serialize

src/main.cpp

@@ -13,7 +13,6 @@
 #include <sp/common/DataBuffer.h>
 #include <sp/extensions/Compress.h>
 #include <sp/io/MessageStream.h>
-#include <sp/io/MessageSerialize.h>
 #include <sp/io/StdIo.h>
 
 class WorldApply : public td::protocol::PacketHandler {

src/td/game/World.cpp

@@ -5,27 +5,39 @@
 namespace td {
 namespace game {
 
+class ColorTileVisitor : public TileHandler {
+  private:
+	const World& m_World;
+	const Color* m_Result;
+
+  public:
+	ColorTileVisitor(const World& a_World) : m_World(a_World), m_Result(nullptr) {}
+
+	virtual void Handle(const EmptyTile& a_Tile) override {}
+	
+	virtual void Handle(const TowerTile& a_Tile) override {
+		m_Result = &m_World.GetTowerTileColorPalette()[a_Tile->m_ColorPaletteRef];
+	}
+
+	virtual void Handle(const WalkableTile& a_Tile) override {
+		m_Result = &m_World.GetWalkableTileColor();
+	}
+
+	virtual void Handle(const DecorationTile& a_Tile) override {
+		m_Result = &m_World.GetDecorationPalette()[a_Tile->m_ColorPaletteRef];
+	}
+
+	const Color* GetResult() {
+		return m_Result;
+	}
+};
+
 World::World() : m_CurrentState(std::make_shared<sim::WorldSnapshot>()), m_NextState(m_CurrentState) {}
 
 const Color* World::GetTileColor(const TilePtr& tile) const {
-	switch (tile->GetType()) {
-		case TileType::Tower: {
-			TowerTile* towerTile = dynamic_cast<TowerTile*>(tile.get());
-			return &m_TowerPlacePalette[towerTile->color_palette_ref];
-		}
-		case TileType::Walk: {
-			return &m_WalkablePalette;
-		}
-		case TileType::Decoration: {
-			DecorationTile* towerTile = dynamic_cast<DecorationTile*>(tile.get());
-			return &m_DecorationPalette[towerTile->color_palette_ref];
-			break;
-		}
-		default: {
-			return nullptr;
-		}
-	}
-	return nullptr;
+	ColorTileVisitor visitor(*this);
+	tile->Dispatch(visitor);
+	return visitor.GetResult();
 }
 
 bool World::LoadMap(const protocol::pdata::WorldHeader& a_WorldHeader) {

src/td/game/WorldTypes.cpp

@@ -1,7 +1,5 @@
 #include <td/game/WorldTypes.h>
 
-#include <sp/common/DataBuffer.h>
-
 namespace td {
 namespace game {
 

src/td/protocol/packet/PacketSerialize.cpp

@@ -15,63 +15,5 @@ sp::DataBuffer& operator>>(sp::DataBuffer& a_Buffer, TeamCastle& a_Castle) {
 	return a_Buffer;
 }
 
-sp::DataBuffer& operator<<(sp::DataBuffer& buffer, const 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;
-}
-
-sp::DataBuffer& operator>>(sp::DataBuffer& buffer, 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;
-}
-
 }  // namespace game
 }  // namespace td