diff --git a/include/Nazara/Network/ENetPacket.hpp b/include/Nazara/Network/ENetPacket.hpp
index 51ee89840..6353309f3 100644
--- a/include/Nazara/Network/ENetPacket.hpp
+++ b/include/Nazara/Network/ENetPacket.hpp
@@ -14,17 +14,17 @@
 
 namespace Nz
 {
-	enum ENetPacketFlag
+	enum class ENetPacketFlag
 	{
-		ENetPacketFlag_Reliable,
-		ENetPacketFlag_Unsequenced,
-		ENetPacketFlag_UnreliableFragment
+		Reliable,
+		Unsequenced,
+		UnreliableFragment
 	};
 
 	template<>
 	struct EnumAsFlags<ENetPacketFlag>
 	{
-		static constexpr ENetPacketFlag max = ENetPacketFlag_UnreliableFragment;
+		static constexpr ENetPacketFlag max = ENetPacketFlag::UnreliableFragment;
 	};
 
 	using ENetPacketFlags = Flags<ENetPacketFlag>;
diff --git a/include/Nazara/Network/ENetPeer.hpp b/include/Nazara/Network/ENetPeer.hpp
index f76ddd10d..c69bab883 100644
--- a/include/Nazara/Network/ENetPeer.hpp
+++ b/include/Nazara/Network/ENetPeer.hpp
@@ -120,7 +120,7 @@ namespace Nz
 			void ResetQueues();
 
 			bool QueueAcknowledgement(ENetProtocol* command, UInt16 sentTime);
-			IncomingCommmand* QueueIncomingCommand(const ENetProtocol& command, const void* data, std::size_t dataLength, UInt32 flags, UInt32 fragmentCount);
+			IncomingCommmand* QueueIncomingCommand(const ENetProtocol& command, const void* data, std::size_t dataLength, ENetPacketFlags flags, UInt32 fragmentCount);
 			inline void QueueOutgoingCommand(ENetProtocol& command);
 			void QueueOutgoingCommand(ENetProtocol& command, ENetPacketRef packet, UInt32 offset, UInt16 length);
 
diff --git a/src/Nazara/Network/ENetPeer.cpp b/src/Nazara/Network/ENetPeer.cpp
index fa4de992c..7789c1a6d 100644
--- a/src/Nazara/Network/ENetPeer.cpp
+++ b/src/Nazara/Network/ENetPeer.cpp
@@ -212,7 +212,7 @@ namespace Nz
 
 			UInt8 commandNumber;
 			UInt16 startSequenceNumber;
-			if ((packetRef->flags & (ENetPacketFlag_Reliable | ENetPacketFlag_UnreliableFragment)) == ENetPacketFlag_UnreliableFragment &&
+			if ((packetRef->flags & (ENetPacketFlag::Reliable | ENetPacketFlag::UnreliableFragment)) == ENetPacketFlag::UnreliableFragment &&
 				channel.outgoingUnreliableSequenceNumber < 0xFFFF)
 			{
 				commandNumber = ENetProtocolCommand_SendUnreliableFragment;
@@ -251,12 +251,12 @@ namespace Nz
 		ENetProtocol command;
 		command.header.channelID = channelId;
 
-		if ((packetRef->flags & (ENetPacketFlag_Reliable | ENetPacketFlag_Unsequenced)) == ENetPacketFlag_Unsequenced)
+		if ((packetRef->flags & (ENetPacketFlag::Reliable | ENetPacketFlag::Unsequenced)) == ENetPacketFlag::Unsequenced)
 		{
 			command.header.command = ENetProtocolCommand_SendUnsequenced | ENetProtocolFlag_Unsequenced;
 			command.sendUnsequenced.dataLength = HostToNet(UInt16(packetRef->data.GetDataSize()));
 		}
-		else if (packetRef->flags & ENetPacketFlag_Reliable || channel.outgoingUnreliableSequenceNumber >= 0xFFFF)
+		else if (packetRef->flags & ENetPacketFlag::Reliable || channel.outgoingUnreliableSequenceNumber >= 0xFFFF)
 		{
 			command.header.command = ENetProtocolCommand_SendReliable | ENetProtocolFlag_Acknowledge;
 			command.sendReliable.dataLength = HostToNet(UInt16(packetRef->data.GetDataSize()));
@@ -658,7 +658,7 @@ namespace Nz
 			ENetProtocol hostCommand = *command;
 			hostCommand.header.reliableSequenceNumber = static_cast<UInt16>(startSequenceNumber);
 
-			startCommand = QueueIncomingCommand(hostCommand, nullptr, totalLength, ENetPacketFlag_Reliable, fragmentCount);
+			startCommand = QueueIncomingCommand(hostCommand, nullptr, totalLength, ENetPacketFlag::Reliable, fragmentCount);
 			if (!startCommand)
 				return false;
 		}
@@ -691,7 +691,7 @@ namespace Nz
 		if (dataLength >= m_host->m_maximumPacketSize || *data < m_host->m_receivedData || *data > &m_host->m_receivedData[m_host->m_receivedDataLength])
 			return false;
 
-		if (!QueueIncomingCommand(*command, reinterpret_cast<const UInt8*>(command) + sizeof(ENetProtocolSendReliable), dataLength, ENetPacketFlag_Reliable, 0))
+		if (!QueueIncomingCommand(*command, reinterpret_cast<const UInt8*>(command) + sizeof(ENetProtocolSendReliable), dataLength, ENetPacketFlag::Reliable, 0))
 			return false;
 
 		return true;
@@ -783,7 +783,7 @@ namespace Nz
 
 		if (!startCommand)
 		{
-			startCommand = QueueIncomingCommand(*command, nullptr, totalLength, ENetPacketFlag_UnreliableFragment, fragmentCount);
+			startCommand = QueueIncomingCommand(*command, nullptr, totalLength, ENetPacketFlag::UnreliableFragment, fragmentCount);
 			if (!startCommand)
 				return false;
 		}
@@ -836,7 +836,7 @@ namespace Nz
 		else if (m_unsequencedWindow[index / 32] & (1 << (index % 32)))
 			return true;
 
-		if (!QueueIncomingCommand(*command, reinterpret_cast<const UInt8*>(command) + sizeof(ENetProtocolSendUnsequenced), dataLength, ENetPacketFlag_Unsequenced, 0))
+		if (!QueueIncomingCommand(*command, reinterpret_cast<const UInt8*>(command) + sizeof(ENetProtocolSendUnsequenced), dataLength, ENetPacketFlag::Unsequenced, 0))
 			return false;
 
 		m_unsequencedWindow[index / 32] |= 1 << (index % 32);
@@ -1095,7 +1095,7 @@ namespace Nz
 		return true;
 	}
 
-	ENetPeer::IncomingCommmand* ENetPeer::QueueIncomingCommand(const ENetProtocol& command, const void* data, std::size_t dataLength, UInt32 flags, UInt32 fragmentCount)
+	ENetPeer::IncomingCommmand* ENetPeer::QueueIncomingCommand(const ENetProtocol& command, const void* data, std::size_t dataLength, ENetPacketFlags flags, UInt32 fragmentCount)
 	{
 		static IncomingCommmand dummyCommand;