refactor tile serialize

include/td/game/Mobs.h

@@ -18,9 +18,6 @@ using Vec2fp = Vec2<FpFloat>;
 
 namespace game {
 
-
-struct WalkableTile;
-
 enum class EffectType : std::uint8_t {
 	Slowness = 0,
 	Stun,
@@ -127,6 +124,8 @@ class MobListener {
 	virtual void OnMobCastleDamage(Mob* damager, TeamCastle* enemyCastle, float damage) {}
 };
 
+using MobList = std::vector<MobPtr>;
+
 // typedef utils::ObjectNotifier<MobListener> MobNotifier;
 
 }  // namespace game

include/td/game/WorldTypes.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include <td/Maths.h>
-#include <td/game/Mobs.h>
 #include <td/game/Team.h>
 #include <td/game/Towers.h>
 
+#include <sp/io/SerializableMessage.h>
+
 namespace td {
 namespace game {
 
@@ -31,37 +32,44 @@ static constexpr Color RED{255, 0, 0};
 static constexpr Color GREEN{0, 255, 0};
 static constexpr Color BLUE{0, 0, 255};
 
-struct Tile {
+class TileHandler;
-	virtual TileType GetType() const = 0;
+
-	virtual ~Tile() = default;
+using Tile = sp::MessageBase<TileType, TileHandler>;
+
+template <TileType ID, typename TileData>
+using ConcreteTile = sp::ConcreteMessage<TileData, Tile, ID>;
+
+namespace data {
+struct EmptyData {};
+
+struct TowerTileData {
+	std::uint8_t m_ColorPaletteRef;
+	TeamColor m_TeamOwner;
 };
 
-struct TowerTile : Tile {
+struct WalkableTileData {
-	std::uint8_t color_palette_ref;
+	Direction m_Direction;
-	TeamColor team_owner;
-
-	virtual TileType GetType() const {
-		return TileType::Tower;
-	}
 };
 
-struct WalkableTile : Tile {
+struct DecorationTileData {
-	Direction direction;
+	std::uint16_t m_ColorPaletteRef;
-
-	virtual TileType GetType() const {
-		return TileType::Walk;
-	}
 };
+}  // namespace data
 
-struct DecorationTile : Tile {
+using EmptyTile = ConcreteTile<TileType::None, data::EmptyData>;
-	std::uint16_t color_palette_ref;
+using TowerTile = ConcreteTile<TileType::Tower, data::TowerTileData>;
+using WalkableTile = ConcreteTile<TileType::Walk, data::WalkableTileData>;
+using DecorationTile = ConcreteTile<TileType::Decoration, data::DecorationTileData>;
 
-	virtual TileType GetType() const {
+using AllTiles = std::tuple<EmptyTile, TowerTile, WalkableTile, DecorationTile>;
-		return TileType::Decoration;
-	}
-};
 
-typedef std::shared_ptr<Tile> TilePtr;
+using TileFactory = sp::MessageFactory<Tile, AllTiles>;
+
+class TileHandler : public sp::GenericHandler<AllTiles>{};
+
+using TilePtr = std::shared_ptr<sp::SerializableMessage<TileFactory>>;
+
+// typedef std::shared_ptr<Tile> TilePtr;
 typedef std::vector<std::uint16_t> ChunkPalette;
 
 typedef std::shared_ptr<WalkableTile> WalkableTilePtr;
@@ -85,6 +93,21 @@ struct Chunk {
 	}
 
 	// TODO: keep data packed
+	/*
+	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>(a_Chunk->m_Tiles[tileNumber]);
+
+		value &= individualValueMask;
+
+		chunkData[startLong] |= (value << startOffset);
+
+		if (startLong != endLong) {
+			chunkData[endLong] = (value >> (BITS_IN_LONG - startOffset));
+		}
+	*/
 };
 
 typedef std::shared_ptr<Chunk> ChunkPtr;
@@ -93,17 +116,12 @@ typedef std::array<Color, 2> TowerTileColorPalette;
 
 typedef std::vector<TilePtr> TilePalette;
 
-typedef std::vector<MobPtr> MobList;
-
 typedef std::array<Color, 2> SpawnColorPalette;
 
 typedef std::vector<TowerPtr> TowerList;
 
 using ChunkList = std::unordered_map<ChunkCoord, ChunkPtr>;
 
-sp::DataBuffer& operator>>(sp::DataBuffer& buffer, TilePtr& tile);
-
-
 }  // namespace game
 
 }  // namespace td

include/td/protocol/command/Commands.h

@@ -13,6 +13,7 @@
 #include <td/Types.h>
 #include <td/common/NonCopyable.h>
 #include <td/protocol/command/CommandData.h>
+#include <sp/io/SerializableMessage.h>
 
 namespace td {
 namespace protocol {
@@ -32,8 +33,6 @@ class CommandHandler;
 
 using CommandBase = sp::MessageBase<CommandID, CommandHandler>;
 
-using CommandPtr = std::unique_ptr<CommandBase>;
-
 template <typename TData, CommandID ID>
 using CommandMessage = sp::ConcreteMessage<TData, CommandBase, ID>;
 
@@ -61,5 +60,7 @@ using CommandFactory = sp::MessageFactory<CommandBase, AllCommands>;
 
 using LockStep = std::vector<std::shared_ptr<CommandBase>>;
 
+using CommandPtr = std::unique_ptr<sp::SerializableMessage<CommandFactory>>;
+
 }  // namespace protocol
 }  // namespace td

include/td/protocol/packet/PacketSerialize.h

@@ -43,8 +43,5 @@ sp::DataBuffer& operator>>(sp::DataBuffer& a_Buffer, TeamCastle& a_Castle);
 sp::DataBuffer& operator<<(sp::DataBuffer& a_Buffer, const ChunkPtr& a_Chunk);
 sp::DataBuffer& operator>>(sp::DataBuffer& a_Buffer, ChunkPtr& a_Chunk);
 
-sp::DataBuffer& operator<<(sp::DataBuffer& buffer, const TilePtr& tile);
-sp::DataBuffer& operator>>(sp::DataBuffer& buffer, TilePtr& tile);
-
 }  // namespace game
 }  // namespace td

include/td/simulation/WorldSnapshot.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <td/game/WorldTypes.h>
+#include <td/game/Mobs.h>
 
 namespace td {
 namespace sim {

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()) {
+	ColorTileVisitor visitor(*this);
-		case TileType::Tower: {
+	tile->Dispatch(visitor);
-			TowerTile* towerTile = dynamic_cast<TowerTile*>(tile.get());
+	return visitor.GetResult();
-			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;
 }
 
 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

xmake.lua

@@ -3,7 +3,7 @@ add_rules("mode.debug", "mode.release")
 add_repositories("persson-repo https://git.ale-pri.com/Persson-dev/xmake-repo.git")
 
 add_requires("imgui 1.92.0", {configs = {sdl3 = true, opengl3 = true}})
-add_requires("splib 2.0.2", "zlib")
+add_requires("splib 2.1.0", "zlib")
 add_requires("libsdl3 3.2.16", "glew", "fpm", "enet6")
 
 set_languages("c++17")