sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Network/ENetPacket: Turn ENetPacketFlag into enum class

This commit is contained in:
SirLynix 2024-02-22 19:12:20 +01:00
parent e25fbe30e6
commit b08897628c
3 changed files with 14 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/Nazara/Network/ENetPacket.hpp
View File

@ -14,17 +14,17 @@
namespace Nz namespace Nz
{ {
enum ENetPacketFlag enum class ENetPacketFlag
{ {
ENetPacketFlag_Reliable, Reliable,
ENetPacketFlag_Unsequenced, Unsequenced,
ENetPacketFlag_UnreliableFragment UnreliableFragment
}; };
template<> template<>
struct EnumAsFlags<ENetPacketFlag> struct EnumAsFlags<ENetPacketFlag>
{ {
static constexpr ENetPacketFlag max = ENetPacketFlag_UnreliableFragment; static constexpr ENetPacketFlag max = ENetPacketFlag::UnreliableFragment;
}; };
using ENetPacketFlags = Flags<ENetPacketFlag>; using ENetPacketFlags = Flags<ENetPacketFlag>;

2
include/Nazara/Network/ENetPeer.hpp
View File

@ -120,7 +120,7 @@ namespace Nz
void ResetQueues(); void ResetQueues();
bool QueueAcknowledgement(ENetProtocol* command, UInt16 sentTime); 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); inline void QueueOutgoingCommand(ENetProtocol& command);
void QueueOutgoingCommand(ENetProtocol& command, ENetPacketRef packet, UInt32 offset, UInt16 length); void QueueOutgoingCommand(ENetProtocol& command, ENetPacketRef packet, UInt32 offset, UInt16 length);

16
src/Nazara/Network/ENetPeer.cpp
View File

@ -212,7 +212,7 @@ namespace Nz
UInt8 commandNumber; UInt8 commandNumber;
UInt16 startSequenceNumber; UInt16 startSequenceNumber;
if ((packetRef->flags & (ENetPacketFlag_Reliable | ENetPacketFlag_UnreliableFragment)) == ENetPacketFlag_UnreliableFragment && if ((packetRef->flags & (ENetPacketFlag::Reliable | ENetPacketFlag::UnreliableFragment)) == ENetPacketFlag::UnreliableFragment &&
channel.outgoingUnreliableSequenceNumber < 0xFFFF) channel.outgoingUnreliableSequenceNumber < 0xFFFF)
{ {
commandNumber = ENetProtocolCommand_SendUnreliableFragment; commandNumber = ENetProtocolCommand_SendUnreliableFragment;
@ -251,12 +251,12 @@ namespace Nz
ENetProtocol command; ENetProtocol command;
command.header.channelID = channelId; 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.header.command = ENetProtocolCommand_SendUnsequenced | ENetProtocolFlag_Unsequenced;
command.sendUnsequenced.dataLength = HostToNet(UInt16(packetRef->data.GetDataSize())); 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.header.command = ENetProtocolCommand_SendReliable | ENetProtocolFlag_Acknowledge;
command.sendReliable.dataLength = HostToNet(UInt16(packetRef->data.GetDataSize())); command.sendReliable.dataLength = HostToNet(UInt16(packetRef->data.GetDataSize()));
@ -658,7 +658,7 @@ namespace Nz
ENetProtocol hostCommand = *command; ENetProtocol hostCommand = *command;
hostCommand.header.reliableSequenceNumber = static_cast<UInt16>(startSequenceNumber); 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) if (!startCommand)
return false; 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]) if (dataLength >= m_host->m_maximumPacketSize || *data < m_host->m_receivedData || *data > &m_host->m_receivedData[m_host->m_receivedDataLength])
return false; 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 false;
return true; return true;
@ -783,7 +783,7 @@ namespace Nz
if (!startCommand) if (!startCommand)
{ {
startCommand = QueueIncomingCommand(*command, nullptr, totalLength, ENetPacketFlag_UnreliableFragment, fragmentCount); startCommand = QueueIncomingCommand(*command, nullptr, totalLength, ENetPacketFlag::UnreliableFragment, fragmentCount);
if (!startCommand) if (!startCommand)
return false; return false;
} }
@ -836,7 +836,7 @@ namespace Nz
else if (m_unsequencedWindow[index / 32] & (1 << (index % 32))) else if (m_unsequencedWindow[index / 32] & (1 << (index % 32)))
return true; 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; return false;
m_unsequencedWindow[index / 32] |= 1 << (index % 32); m_unsequencedWindow[index / 32] |= 1 << (index % 32);
@ -1095,7 +1095,7 @@ namespace Nz
return true; 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; static IncomingCommmand dummyCommand;