improve packet interface

include/blitz/network/EnetClient.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <Nazara/Network/ENetHost.hpp>
+#include <blitz/common/NonCopyable.h>
+#include <blitz/network/EnetConnexion.h>
+#include <thread>
+
+namespace blitz {
+namespace network {
+
+class EnetClient : private NonCopyable {
+  public:
+	EnetClient(const Nz::IpAddress& address);
+	~EnetClient();
+
+	void Disconnect();
+
+	NazaraSignal(OnConnect);
+	NazaraSignal(OnDisconnect);
+	NazaraSignal(OnDisconnectTimeout);
+
+	const EnetConnexion& GetConnexion() const {
+		return m_Connexion;
+	}
+
+  private:
+	EnetConnexion m_Connexion;
+	Nz::ENetHost m_Host;
+	Nz::ENetPeer* m_Peer;
+	std::thread m_Thread;
+	bool m_Running;
+
+	void Update();
+	void WorkerThread();
+};
+
+}  // namespace network
+}  // namespace blitz

include/blitz/network/EnetConnexion.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <Nazara/Network/ENetPeer.hpp>
+#include <blitz/protocol/PacketSerializer.h>
+#include <blitz/protocol/Packets.h>
+
+namespace blitz {
+namespace network {
+
+class EnetClient;
+class EnetServer;
+
+
+
+#define DeclarePacket(Name, NFlag)                                                                                                    \
+	void Send##Name(const blitz::protocol::data::Name& a_##Name) const {                                                                                      \
+		m_Peer->Send(0, NFlag, protocol::PacketSerializer::Serialize(protocol::packets::Name(a_##Name)));                             \
+	}                                                                                                                                 \
+	NazaraSignal(On##Name, const blitz::protocol::data::Name&)
+
+
+
+
+
+class EnetConnexion {
+  public:
+	EnetConnexion(Nz::ENetPeer* a_Peer = nullptr);
+
+	bool IsConnected() const {
+        if (!m_Peer)
+            return false;
+		return m_Peer->IsConnected();
+	}
+
+    DeclareAllPacket()
+
+  private:
+	Nz::ENetPeer* m_Peer;
+
+	void Recieve(Nz::ByteArray&);
+    void SetPeer(Nz::ENetPeer* a_Peer);
+
+    friend class EnetClient;
+    friend class EnetServer;
+};
+
+#undef DeclarePacket
+
+}  // namespace network
+}  // namespace blitz

include/blitz/network/EnetServer.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <Nazara/Core/ThreadExt.hpp>
+#include <Nazara/Network/ENetHost.hpp>
+#include <blitz/common/NonCopyable.h>
+#include <blitz/network/EnetConnexion.h>
+#include <blitz/protocol/Packets.h>
+#include <cstdint>
+#include <map>
+#include <thread>
+
+namespace blitz {
+namespace network {
+
+class EnetServer : private NonCopyable {
+  public:
+	EnetServer(std::uint16_t port);
+	~EnetServer();
+
+	void Destroy();
+
+	void BroadcastPacket(const protocol::Packet& a_Packet, Nz::ENetPacketFlags a_Flags);
+
+	EnetConnexion* GetConnexion(std::uint16_t a_PeerId);
+
+	NazaraSignal(OnClientConnect, EnetConnexion& /*a_Peer*/);
+	NazaraSignal(OnClientDisconnect, EnetConnexion& /*a_Peer*/);
+	NazaraSignal(OnClientDisconnectTimeout, EnetConnexion& /*a_Peer*/);
+
+  private:
+	void Update();
+	void WorkerThread();
+
+	void RemoveConnexion(std::uint16_t a_PeerId);
+
+	Nz::ENetHost m_Host;
+	bool m_Running;
+	std::thread m_Thread;
+	std::map<std::uint16_t, EnetConnexion> m_Connexion;
+};
+
+}  // namespace network
+}  // namespace blitz

include/blitz/protocol/PacketDeclare.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#define DeclareAllPacket() \
+DeclarePacket(PlayerLogin, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(UpdateHealth, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(LoggingSuccess, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(PlayerDeath, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(PlayerJoin, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(PlayerLeave, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(PlayerStats, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(PlayerList, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(ServerConfig, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(ServerTps, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(UpdateGameState, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(KeepAlive, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(Disconnect, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(ChatMessage, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(PlayerPositionAndRotation, Nz::ENetPacketFlag::Reliable); \
+DeclarePacket(PlayerShoot, Nz::ENetPacketFlag::Reliable);

include/blitz/protocol/PacketVisitor.h

@@ -1,10 +1,14 @@
 #pragma once
 
 #include <blitz/protocol/Packets.h>
+#include <blitz/protocol/PacketDeclare.h>
 
 namespace blitz {
 namespace protocol {
 
+#define DeclarePacket(PacketName, ...) \
+	virtual void Visit(const packets::PacketName&) {}
+
 class PacketVisitor {
   protected:
 	PacketVisitor() {}
@@ -13,23 +17,10 @@ class PacketVisitor {
   public:
 	void Check(const Packet& packet);
 
-	virtual void Visit(const packets::PlayerLogin&) {}
-	virtual void Visit(const packets::UpdateHealth&) {}
-	virtual void Visit(const packets::LoggingSuccess&) {}
-	virtual void Visit(const packets::PlayerDeath&) {}
-	virtual void Visit(const packets::PlayerJoin&) {}
-	virtual void Visit(const packets::PlayerLeave&) {}
-	virtual void Visit(const packets::PlayerList&) {}
-	virtual void Visit(const packets::PlayerStats&) {}
-	virtual void Visit(const packets::ServerConfig&) {}
-	virtual void Visit(const packets::ServerTps&) {}
-	virtual void Visit(const packets::UpdateGameState&) {}
-	virtual void Visit(const packets::KeepAlive&) {}
-	virtual void Visit(const packets::Disconnect&) {}
-	virtual void Visit(const packets::ChatMessage&) {}
-	virtual void Visit(const packets::PlayerPositionAndRotation&) {}
-	virtual void Visit(const packets::PlayerShoot&) {}
+	DeclareAllPacket()
 };
 
+#undef DeclarePacket
+
 }  // namespace protocol
 }  // namespace blitz

include/blitz/protocol/Packets.h

@@ -1,7 +1,8 @@
 #pragma once
 
-#include <string>
 #include <blitz/protocol/PacketData.h>
+#include <blitz/protocol/PacketDeclare.h>
+#include <string>
 
 namespace blitz {
 namespace protocol {
@@ -64,7 +65,7 @@ template <PacketType PT, typename Data>
 class ConcretePacket : public Packet {
   public:
 	using PacketDataType = Data;
-	
+
 	PacketDataType m_Data;
 
 	ConcretePacket(const PacketDataType& a_Data = {});
@@ -87,33 +88,16 @@ class ConcretePacket : public Packet {
 // before including this file
 // if you want to instantiate templates
 #ifdef BLITZ_INSTANCIATE_PACKETS
-#define DeclarePacket(Type)                                                                                                 \
-	using Type = ConcretePacket<PacketType::Type, data::Type>;                                                                          \
-	template class ConcretePacket<PacketType::Type, data::Type>
+#define DeclarePacket(PacketName, ...)                                                                                                \
+	using PacketName = ConcretePacket<PacketType::PacketName, data::PacketName>;                                                      \
+	template class ConcretePacket<PacketType::PacketName, data::PacketName>
 #else
-#define DeclarePacket(Type) using Type = ConcretePacket<PacketType::Type, data::Type>
+#define DeclarePacket(PacketName, ...) using PacketName = ConcretePacket<PacketType::PacketName, data::PacketName>
 #endif
 
+DeclareAllPacket()
 
-
-
-
-DeclarePacket(PlayerLogin);
-DeclarePacket(UpdateHealth);
-DeclarePacket(LoggingSuccess);
-DeclarePacket(PlayerDeath);
-DeclarePacket(PlayerJoin);
-DeclarePacket(PlayerLeave);
-DeclarePacket(PlayerStats);
-DeclarePacket(PlayerList);
-DeclarePacket(ServerConfig);
-DeclarePacket(ServerTps);
-DeclarePacket(UpdateGameState);
-DeclarePacket(KeepAlive);
-DeclarePacket(Disconnect);
-DeclarePacket(ChatMessage);
-DeclarePacket(PlayerPositionAndRotation);
-DeclarePacket(PlayerShoot);
+#undef DeclarePacket
 
 }  // namespace packets