diff --git a/include/blitz/network/EnetConnexion.h b/include/blitz/network/EnetConnexion.h
index 6b0e309..9ad802d 100644
--- a/include/blitz/network/EnetConnexion.h
+++ b/include/blitz/network/EnetConnexion.h
@@ -1,9 +1,15 @@
 #pragma once
 
-#include <Nazara/Network/ENetPeer.hpp>
+#include <NazaraUtils/Signal.hpp>
 #include <blitz/protocol/PacketSerializer.h>
 #include <blitz/protocol/Packets.h>
 
+namespace Nz {
+
+class ENetPeer;
+
+}  // namespace Nz
+
 namespace blitz {
 namespace network {
 
@@ -12,11 +18,10 @@ 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&)
+#define DeclarePacket(PacketName, ...)                                                                                                \
+	void Send##PacketName(const blitz::protocol::data::PacketName& a_##PacketName) const;                                             \
+                                                                                                                                      \
+	NazaraSignal(On##PacketName, const blitz::protocol::data::PacketName&);
 
 
 
@@ -26,22 +31,18 @@ class EnetConnexion {
   public:
 	EnetConnexion(Nz::ENetPeer* a_Peer = nullptr);
 
-	bool IsConnected() const {
-        if (!m_Peer)
-            return false;
-		return m_Peer->IsConnected();
-	}
+	bool IsConnected() const;
 
-    DeclareAllPacket()
+	DeclareAllPacket()
 
-  private:
-	Nz::ENetPeer* m_Peer;
+  private : 
+  	Nz::ENetPeer* m_Peer;
 
 	void Recieve(Nz::ByteArray&);
-    void SetPeer(Nz::ENetPeer* a_Peer);
+	void SetPeer(Nz::ENetPeer* a_Peer);
 
-    friend class EnetClient;
-    friend class EnetServer;
+	friend class EnetClient;
+	friend class EnetServer;
 };
 
 #undef DeclarePacket
diff --git a/include/blitz/protocol/PacketDeclare.h b/include/blitz/protocol/PacketDeclare.h
index d3eac6a..c48ee8d 100644
--- a/include/blitz/protocol/PacketDeclare.h
+++ b/include/blitz/protocol/PacketDeclare.h
@@ -1,19 +1,40 @@
 #pragma once
 
+namespace blitz {
+namespace protocol {
+
+enum class PacketSender {
+	/** Sent by clients and server */
+	Both,
+	/** Sent by clients to the server */
+	Client,
+	/** Sent by server to the clients */
+	Server,
+};
+
+
+/**
+ * \def DeclareAllPacket
+ * \brief Avoids repetitive operations on packets
+ */
 #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);
+	DeclarePacket(ChatMessage, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both) \
+	DeclarePacket(Disconnect, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both) \
+    DeclarePacket(KeepAlive, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both)  \
+    DeclarePacket(LoggingSuccess, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
+    DeclarePacket(PlayerDeath, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
+    DeclarePacket(PlayerJoin, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
+    DeclarePacket(PlayerLeave, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
+    DeclarePacket(PlayerList, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
+    DeclarePacket(PlayerLogin, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Client) \
+    DeclarePacket(PlayerPositionAndRotation, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both) \
+    DeclarePacket(PlayerShoot, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both) \
+    DeclarePacket(PlayerStats, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
+    DeclarePacket(ServerConfig, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
+    DeclarePacket(ServerTps, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
+    DeclarePacket(UpdateGameState, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
+    DeclarePacket(UpdateHealth, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Client)
+
+
+}  // namespace protocol
+}  // namespace blitz
\ No newline at end of file
diff --git a/include/blitz/protocol/Packets.h b/include/blitz/protocol/Packets.h
index 897fd14..a9c8d99 100644
--- a/include/blitz/protocol/Packets.h
+++ b/include/blitz/protocol/Packets.h
@@ -11,37 +11,17 @@ class PacketVisitor;
 
 using PacketID = std::uint8_t;
 
+#define DeclarePacket(PacketName, ...) PacketName,
+
 enum class PacketType : PacketID {
-	// client --> server
 
-	PlayerLogin = 0,
-	UpdateHealth,
-
-	// client <-- server
-
-	LoggingSuccess,
-	PlayerDeath,
-	PlayerJoin,
-	PlayerLeave,
-	PlayerList,
-	PlayerStats,
-	ServerConfig,
-	ServerTps,
-	UpdateGameState,
-
-	// client <--> server
-
-	KeepAlive,
-	Disconnect,
-	ChatMessage,
-	PlayerPositionAndRotation,
-	PlayerShoot,
+	DeclareAllPacket()
 
 	PACKET_COUNT
 };
 
 
-
+#undef DeclarePacket
 
 
 class Packet {
@@ -59,7 +39,7 @@ namespace packets {
 
 /**
  * \tparam PT The packet type
- * \tparam Data The structure holding the data of the packet
+ * \tparam Data The structure holding the data of the packet (in blitz::protocol::data namespace)
  */
 template <PacketType PT, typename Data>
 class ConcretePacket : public Packet {
@@ -90,9 +70,9 @@ class ConcretePacket : public Packet {
 #ifdef BLITZ_INSTANCIATE_PACKETS
 #define DeclarePacket(PacketName, ...)                                                                                                \
 	using PacketName = ConcretePacket<PacketType::PacketName, data::PacketName>;                                                      \
-	template class ConcretePacket<PacketType::PacketName, data::PacketName>
+	template class ConcretePacket<PacketType::PacketName, data::PacketName>;
 #else
-#define DeclarePacket(PacketName, ...) using PacketName = ConcretePacket<PacketType::PacketName, data::PacketName>
+#define DeclarePacket(PacketName, ...) using PacketName = ConcretePacket<PacketType::PacketName, data::PacketName>;
 #endif
 
 DeclareAllPacket()
diff --git a/src/blitz/network/EnetConnexion.cpp b/src/blitz/network/EnetConnexion.cpp
index ed3a177..496d6fa 100644
--- a/src/blitz/network/EnetConnexion.cpp
+++ b/src/blitz/network/EnetConnexion.cpp
@@ -1,5 +1,6 @@
 #include <blitz/network/EnetConnexion.h>
 
+#include <Nazara/Network/ENetPeer.hpp>
 #include <blitz/protocol/PacketSerializer.h>
 #include <blitz/protocol/PacketVisitor.h>
 
@@ -20,12 +21,14 @@ class PacketDispatcher : public protocol::PacketVisitor {
   public:
 	PacketDispatcher(EnetConnexion& a_Connexion) : m_Connexion(a_Connexion) {}
 
-	DeclareAllPacket();
+	DeclareAllPacket()
 
   private:
 	EnetConnexion& m_Connexion;
 };
 
+#undef DeclarePacket
+
 
 
 
@@ -36,6 +39,12 @@ void EnetConnexion::SetPeer(Nz::ENetPeer* a_Peer) {
 	m_Peer = a_Peer;
 }
 
+bool EnetConnexion::IsConnected() const {
+	if (!m_Peer)
+		return false;
+	return m_Peer->IsConnected();
+}
+
 void EnetConnexion::Recieve(Nz::ByteArray& a_Data) {
 	auto packet = protocol::PacketSerializer::Deserialize(a_Data);
 	if (!packet)
@@ -44,5 +53,12 @@ void EnetConnexion::Recieve(Nz::ByteArray& a_Data) {
 	dispatcher.Check(*packet.get());
 }
 
+#define DeclarePacket(Name, NFlag, ...)                                                                                               \
+	void EnetConnexion::Send##Name(const blitz::protocol::data::Name& a_##Name) const {                                               \
+		m_Peer->Send(0, NFlag, protocol::PacketSerializer::Serialize(protocol::packets::Name(a_##Name)));                             \
+	}
+
+DeclareAllPacket()
+
 }  // namespace network
 }  // namespace blitz
diff --git a/src/blitz/protocol/PacketFactory.cpp b/src/blitz/protocol/PacketFactory.cpp
index 4ad0764..4511316 100644
--- a/src/blitz/protocol/PacketFactory.cpp
+++ b/src/blitz/protocol/PacketFactory.cpp
@@ -9,29 +9,18 @@ namespace PacketFactory {
 
 using PacketCreator = std::function<std::unique_ptr<Packet>()>;
 
+#define DeclarePacket(PacketName, ...) std::make_unique<packets::PacketName>(),
+
 static const std::array<std::unique_ptr<Packet>, static_cast<std::size_t>(PacketType::PACKET_COUNT)> Packets = {
-    std::make_unique<packets::PlayerLogin>(),
-    std::make_unique<packets::UpdateHealth>(),
-    std::make_unique<packets::LoggingSuccess>(),
-    std::make_unique<packets::PlayerDeath>(),
-    std::make_unique<packets::PlayerJoin>(),
-    std::make_unique<packets::PlayerLeave>(),
-    std::make_unique<packets::PlayerList>(),
-    std::make_unique<packets::PlayerStats>(),
-    std::make_unique<packets::ServerConfig>(),
-    std::make_unique<packets::ServerTps>(),
-    std::make_unique<packets::UpdateGameState>(),
-    std::make_unique<packets::KeepAlive>(),
-    std::make_unique<packets::Disconnect>(),
-    std::make_unique<packets::ChatMessage>(),
-    std::make_unique<packets::PlayerPositionAndRotation>(),
-    std::make_unique<packets::PlayerShoot>(),
+
+	DeclareAllPacket()
+
 };
 
 const std::unique_ptr<Packet>& CreateReadOnlyPacket(PacketType a_Type) {
-    return Packets[static_cast<std::size_t>(a_Type)];
+	return Packets[static_cast<std::size_t>(a_Type)];
 }
 
-}	// namespace PacketFactory
+}  // namespace PacketFactory
 }  // namespace protocol
 }  // namespace blitz
diff --git a/src/blitz/protocol/PacketSerializer.cpp b/src/blitz/protocol/PacketSerializer.cpp
index 014aabe..4b2dea5 100644
--- a/src/blitz/protocol/PacketSerializer.cpp
+++ b/src/blitz/protocol/PacketSerializer.cpp
@@ -11,29 +11,16 @@ namespace protocol {
 
 namespace PacketSerializer {
 
-#define VisitSerialize(ClassName)                                                                                                     \
-	void Visit(const ClassName& a_Packet) override {                                                                                  \
+#define DeclarePacket(PacketName, ...)                                                                                                     \
+	void Visit(const packets::PacketName& a_Packet) override {                                                                                  \
 		const auto& packetData = a_Packet.m_Data;                                                                                     \
 		SerializePacketData(packetData);                                                                                              \
 	}                                                                                                                                 \
                                                                                                                                       \
-	void SerializePacketData(const ClassName::PacketDataType& a_Packet)
-
-#define VisitDeserialize(ClassName)                                                                                                   \
-	void Visit(const ClassName& a_Packet) override {                                                                                  \
-		auto packetPtr = PacketFactory::CreatePacket<ClassName>();                                                                    \
-		auto& packetData = packetPtr->m_Data;                                                                                         \
-                                                                                                                                      \
-		DeserializePacketData(packetData);                                                                                            \
-                                                                                                                                      \
-		m_Packet = std::move(packetPtr);                                                                                              \
-	}                                                                                                                                 \
-                                                                                                                                      \
-	void DeserializePacketData(ClassName::PacketDataType& a_Packet)
+	void SerializePacketData(const packets::PacketName::PacketDataType& a_Packet);
+
 
 
-#define DeclarePacket(PacketName, ...) \
-	VisitSerialize(packets::PacketName)
 
 class Serializer : public PacketVisitor {
   private:
@@ -51,8 +38,24 @@ class Serializer : public PacketVisitor {
 };
 
 #undef DeclarePacket
-#define DeclarePacket(PacketName, ...) \
-	VisitDeserialize(packets::PacketName)
+
+
+
+
+
+#define DeclarePacket(PacketName, ...)                                                                                                   \
+	void Visit(const packets::PacketName& a_Packet) override {                                                                                  \
+		auto packetPtr = PacketFactory::CreatePacket<packets::PacketName>();                                                                    \
+		auto& packetData = packetPtr->m_Data;                                                                                         \
+                                                                                                                                      \
+		DeserializePacketData(packetData);                                                                                            \
+                                                                                                                                      \
+		m_Packet = std::move(packetPtr);                                                                                              \
+	}                                                                                                                                 \
+                                                                                                                                      \
+	void DeserializePacketData(packets::PacketName::PacketDataType& a_Packet);
+
+
 
 class Deserializer : public PacketVisitor {
   private: