basic packet structure

src/main.cpp

@@ -1,21 +1,125 @@
 #include <iostream>
-// #include <sp/protocol/packet/PacketVisitor.h>
-#include <sp/game/GameHistory.h>
-#include <sp/protocol/command/CommandDispatcher.h>
-#include <sp/protocol/command/CommandFactory.h>
-#include <sp/protocol/command/CommandSerializer.h>
-#include <sp/protocol/command/CommandVisitor.h>
 
-class Test : public sp::protocol::CommandVisitor {};
+#include <sp/GenericHandler.h>
+#include <sp/MessageBase.h>
+#include <sp/Templates.h>
 
-int main(int argc, char** argv) {
-	// Test visitor;
-	// sp::protocol::packets::ChatMessage chat{{"coucou"}};
-	// visitor.Check(chat);
+#define PacketClass(className) class className : public sp::MessageBase<className>
+
+template <typename T>
+class Packet : public sp::MessageBase<T> {
+  public:
+	virtual std::string_view GetName() const = 0;
+	void WriteImpl(sp::DataBuffer& buffer) const = 0;
+	void ReadImpl(const sp::DataBuffer& buffer) = 0;
+	int GetId() const = 0;
+};
+
+template <typename T>
+class Command : public sp::MessageBase<T> {
+  public:
+	virtual std::string_view GetName() const = 0;
+	void WriteImpl(sp::DataBuffer& buffer) const = 0;
+	void ReadImpl(const sp::DataBuffer& buffer) = 0;
+	int GetId() const = 0;
+};
 
 
-	td::protocol::commands::UpgradeTower com{{1, 2}};
-	std::cout << (unsigned)com.GetType() << std::endl;
-	td::protocol::CommandDispatcher disptacher;
+#define TestPacket(packetName)                                                                                                        \
+	class packetName : public Packet<packetName> {                                                                                    \
+	  public:                                                                                                                         \
+		std::string_view GetName() const {                                                                                            \
+			return #packetName;                                                                                                       \
+		}                                                                                                                             \
+		void WriteImpl(sp::DataBuffer& buffer) const {}                                                                               \
+		void ReadImpl(const sp::DataBuffer& buffer) {}                                                                                \
+		int GetId() const {                                                                                                           \
+			return 0;                                                                                                                 \
+		}                                                                                                                             \
+	}
+
+#define TestCommand(commandName)                                                                                                      \
+	class commandName : public Command<commandName> {                                                                                 \
+	  public:                                                                                                                         \
+		std::string_view GetName() const {                                                                                            \
+			return #commandName;                                                                                                      \
+		}                                                                                                                             \
+		void WriteImpl(sp::DataBuffer& buffer) const {}                                                                               \
+		void ReadImpl(const sp::DataBuffer& buffer) {}                                                                                \
+		int GetId() const {                                                                                                           \
+			return 0;                                                                                                                 \
+		}                                                                                                                             \
+	}
+
+TestPacket(ChatPacket);
+TestPacket(PlayerJoinPacket);
+TestPacket(PlayerLeavePacket);
+
+TestCommand(SpawnTroopCommand);
+TestCommand(PlaceTowerCommand);
+
+class ActualMessage2 : public sp::MessageBase<ActualMessage2> {
+	std::string_view GetName() const {
+		return "mesmes";
+	}
+	void WriteImpl(sp::DataBuffer& buffer) const {}
+	void ReadImpl(const sp::DataBuffer& buffer) {}
+	int GetId() const {
+		return 0;
+	}
+};
+
+using AllPackets = std::tuple<ChatPacket, PlayerJoinPacket, PlayerLeavePacket>;
+using AllCommands = std::tuple<SpawnTroopCommand, PlaceTowerCommand>;
+using AllTests = std::tuple<ActualMessage2>;
+
+using AllMessages = sp::tuple_cat_t<AllPackets, AllCommands, AllTests>;
+
+namespace sp {
+class Handler : public sp::GenericHandler<sp::Message, AllMessages> {};
+}  // namespace sp
+
+using PacketHandler = sp::Handler;
+using CommandHandler = sp::Handler;
+
+class PacketPrinter : public PacketHandler {
+  public:
+	void Handle(ChatPacket& packet) override {
+		std::cout << packet.GetName() << std::endl;
+	}
+
+	// void Handle(SpawnTroopCommand& cmd) {
+	// 	std::cout << "NOOOOOO\n";
+	// }
+};
+
+
+
+class ActualHandler1 : public sp::Handler {
+  public:
+	virtual void Handle(ActualMessage2& msg) override {
+		std::cout << "Handling ActualMessage2" << std::endl;
+	}
+
+	virtual void Handle(sp::Message& msg) override {
+		std::cout << "Common handling function is invoked" << std::endl;
+	}
+
+	virtual void Handle(ChatPacket& msg) override {
+		std::cout << "Chat invoked" << std::endl;
+	}
+};
+
+
+int main() {
+	std::unique_ptr<sp::Message> msg = std::make_unique<ActualMessage2>();
+	std::unique_ptr<sp::Message> chat = std::make_unique<ChatPacket>();
+	SpawnTroopCommand cmd;
+	PacketPrinter packetHandler;
+	PacketHandler pp;
+	chat->Dispatch(packetHandler);
+	ActualHandler1 handler;
+	msg->Dispatch(handler);
+	chat->Dispatch(handler);
 	return 0;
-}
+}