|
|
|
|
@ -9,7 +9,7 @@
|
|
|
|
|
#include "enet/time.h"
|
|
|
|
|
#include "enet/enet.h"
|
|
|
|
|
|
|
|
|
|
static size_t commandSizes [ENET_PROTOCOL_COMMAND_COUNT] =
|
|
|
|
|
static const size_t commandSizes [ENET_PROTOCOL_COMMAND_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
0,
|
|
|
|
|
sizeof (ENetProtocolAcknowledge),
|
|
|
|
|
@ -159,16 +159,16 @@ enet_protocol_notify_disconnect (ENetHost * host, ENetPeer * peer, ENetEvent * e
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer)
|
|
|
|
|
enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer, ENetList * sentUnreliableCommands)
|
|
|
|
|
{
|
|
|
|
|
ENetOutgoingCommand * outgoingCommand;
|
|
|
|
|
|
|
|
|
|
if (enet_list_empty (& peer -> sentUnreliableCommands))
|
|
|
|
|
if (enet_list_empty (sentUnreliableCommands))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
outgoingCommand = (ENetOutgoingCommand *) enet_list_front (& peer -> sentUnreliableCommands);
|
|
|
|
|
outgoingCommand = (ENetOutgoingCommand *) enet_list_front (sentUnreliableCommands);
|
|
|
|
|
|
|
|
|
|
enet_list_remove (& outgoingCommand -> outgoingCommandList);
|
|
|
|
|
|
|
|
|
|
@ -185,14 +185,38 @@ enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
enet_free (outgoingCommand);
|
|
|
|
|
} while (! enet_list_empty (& peer -> sentUnreliableCommands));
|
|
|
|
|
} while (! enet_list_empty (sentUnreliableCommands));
|
|
|
|
|
|
|
|
|
|
if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER &&
|
|
|
|
|
enet_list_empty (& peer -> outgoingCommands) &&
|
|
|
|
|
enet_list_empty (& peer -> sentReliableCommands))
|
|
|
|
|
! enet_peer_has_outgoing_commands (peer))
|
|
|
|
|
enet_peer_disconnect (peer, peer -> eventData);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static ENetOutgoingCommand *
|
|
|
|
|
enet_protocol_find_sent_reliable_command (ENetList * list, enet_uint16 reliableSequenceNumber, enet_uint8 channelID)
|
|
|
|
|
{
|
|
|
|
|
ENetListIterator currentCommand;
|
|
|
|
|
|
|
|
|
|
for (currentCommand = enet_list_begin (list);
|
|
|
|
|
currentCommand != enet_list_end (list);
|
|
|
|
|
currentCommand = enet_list_next (currentCommand))
|
|
|
|
|
{
|
|
|
|
|
ENetOutgoingCommand * outgoingCommand = (ENetOutgoingCommand *) currentCommand;
|
|
|
|
|
|
|
|
|
|
if (! (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> sendAttempts < 1)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> reliableSequenceNumber == reliableSequenceNumber &&
|
|
|
|
|
outgoingCommand -> command.header.channelID == channelID)
|
|
|
|
|
return outgoingCommand;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static ENetProtocolCommand
|
|
|
|
|
enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint16 reliableSequenceNumber, enet_uint8 channelID)
|
|
|
|
|
{
|
|
|
|
|
@ -214,24 +238,9 @@ enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint16 reliabl
|
|
|
|
|
|
|
|
|
|
if (currentCommand == enet_list_end (& peer -> sentReliableCommands))
|
|
|
|
|
{
|
|
|
|
|
for (currentCommand = enet_list_begin (& peer -> outgoingCommands);
|
|
|
|
|
currentCommand != enet_list_end (& peer -> outgoingCommands);
|
|
|
|
|
currentCommand = enet_list_next (currentCommand))
|
|
|
|
|
{
|
|
|
|
|
outgoingCommand = (ENetOutgoingCommand *) currentCommand;
|
|
|
|
|
|
|
|
|
|
if (! (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> sendAttempts < 1) return ENET_PROTOCOL_COMMAND_NONE;
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> reliableSequenceNumber == reliableSequenceNumber &&
|
|
|
|
|
outgoingCommand -> command.header.channelID == channelID)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (currentCommand == enet_list_end (& peer -> outgoingCommands))
|
|
|
|
|
return ENET_PROTOCOL_COMMAND_NONE;
|
|
|
|
|
outgoingCommand = enet_protocol_find_sent_reliable_command (& peer -> outgoingCommands, reliableSequenceNumber, channelID);
|
|
|
|
|
if (outgoingCommand == NULL)
|
|
|
|
|
outgoingCommand = enet_protocol_find_sent_reliable_command (& peer -> outgoingSendReliableCommands, reliableSequenceNumber, channelID);
|
|
|
|
|
|
|
|
|
|
wasSent = 0;
|
|
|
|
|
}
|
|
|
|
|
@ -331,6 +340,7 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
|
|
|
|
|
peer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
|
|
|
|
|
peer -> connectID = command -> connect.connectID;
|
|
|
|
|
peer -> address = host -> receivedAddress;
|
|
|
|
|
peer -> mtu = host -> mtu;
|
|
|
|
|
peer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> connect.outgoingPeerID);
|
|
|
|
|
peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.incomingBandwidth);
|
|
|
|
|
peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.outgoingBandwidth);
|
|
|
|
|
@ -375,6 +385,7 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
|
|
|
|
|
if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)
|
|
|
|
|
mtu = ENET_PROTOCOL_MAXIMUM_MTU;
|
|
|
|
|
|
|
|
|
|
if (mtu < peer -> mtu)
|
|
|
|
|
peer -> mtu = mtu;
|
|
|
|
|
|
|
|
|
|
if (host -> outgoingBandwidth == 0 &&
|
|
|
|
|
@ -542,7 +553,8 @@ enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENet
|
|
|
|
|
|
|
|
|
|
fragmentLength = ENET_NET_TO_HOST_16 (command -> sendFragment.dataLength);
|
|
|
|
|
* currentData += fragmentLength;
|
|
|
|
|
if (fragmentLength > host -> maximumPacketSize ||
|
|
|
|
|
if (fragmentLength <= 0 ||
|
|
|
|
|
fragmentLength > host -> maximumPacketSize ||
|
|
|
|
|
* currentData < host -> receivedData ||
|
|
|
|
|
* currentData > & host -> receivedData [host -> receivedDataLength])
|
|
|
|
|
return -1;
|
|
|
|
|
@ -566,6 +578,7 @@ enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENet
|
|
|
|
|
if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
|
|
|
|
|
fragmentNumber >= fragmentCount ||
|
|
|
|
|
totalLength > host -> maximumPacketSize ||
|
|
|
|
|
totalLength < fragmentCount ||
|
|
|
|
|
fragmentOffset >= totalLength ||
|
|
|
|
|
fragmentLength > totalLength - fragmentOffset)
|
|
|
|
|
return -1;
|
|
|
|
|
@ -921,8 +934,7 @@ enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer *
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ENET_PEER_STATE_DISCONNECT_LATER:
|
|
|
|
|
if (enet_list_empty (& peer -> outgoingCommands) &&
|
|
|
|
|
enet_list_empty (& peer -> sentReliableCommands))
|
|
|
|
|
if (! enet_peer_has_outgoing_commands (peer))
|
|
|
|
|
enet_peer_disconnect (peer, peer -> eventData);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
@ -1230,6 +1242,9 @@ enet_protocol_receive_incoming_commands (ENetHost * host, ENetEvent * event)
|
|
|
|
|
& buffer,
|
|
|
|
|
1);
|
|
|
|
|
|
|
|
|
|
if (receivedLength == -2)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (receivedLength < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
@ -1293,7 +1308,7 @@ enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer)
|
|
|
|
|
buffer >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
|
|
|
|
|
peer -> mtu - host -> packetSize < sizeof (ENetProtocolAcknowledge))
|
|
|
|
|
{
|
|
|
|
|
host -> continueSending = 1;
|
|
|
|
|
peer -> flags |= ENET_PEER_FLAG_CONTINUE_SENDING;
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
@ -1333,10 +1348,11 @@ static int
|
|
|
|
|
enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * event)
|
|
|
|
|
{
|
|
|
|
|
ENetOutgoingCommand * outgoingCommand;
|
|
|
|
|
ENetListIterator currentCommand, insertPosition;
|
|
|
|
|
ENetListIterator currentCommand, insertPosition, insertSendReliablePosition;
|
|
|
|
|
|
|
|
|
|
currentCommand = enet_list_begin (& peer -> sentReliableCommands);
|
|
|
|
|
insertPosition = enet_list_begin (& peer -> outgoingCommands);
|
|
|
|
|
insertSendReliablePosition = enet_list_begin (& peer -> outgoingSendReliableCommands);
|
|
|
|
|
|
|
|
|
|
while (currentCommand != enet_list_end (& peer -> sentReliableCommands))
|
|
|
|
|
{
|
|
|
|
|
@ -1353,7 +1369,7 @@ enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * even
|
|
|
|
|
|
|
|
|
|
if (peer -> earliestTimeout != 0 &&
|
|
|
|
|
(ENET_TIME_DIFFERENCE (host -> serviceTime, peer -> earliestTimeout) >= peer -> timeoutMaximum ||
|
|
|
|
|
(outgoingCommand -> roundTripTimeout >= outgoingCommand -> roundTripTimeoutLimit &&
|
|
|
|
|
((1 << (outgoingCommand -> sendAttempts - 1)) >= peer -> timeoutLimit &&
|
|
|
|
|
ENET_TIME_DIFFERENCE (host -> serviceTime, peer -> earliestTimeout) >= peer -> timeoutMinimum)))
|
|
|
|
|
{
|
|
|
|
|
enet_protocol_notify_disconnect (host, peer, event);
|
|
|
|
|
@ -1361,13 +1377,17 @@ enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * even
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> packet != NULL)
|
|
|
|
|
peer -> reliableDataInTransit -= outgoingCommand -> fragmentLength;
|
|
|
|
|
|
|
|
|
|
++ peer -> packetsLost;
|
|
|
|
|
|
|
|
|
|
outgoingCommand -> roundTripTimeout *= 2;
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> packet != NULL)
|
|
|
|
|
{
|
|
|
|
|
peer -> reliableDataInTransit -= outgoingCommand -> fragmentLength;
|
|
|
|
|
|
|
|
|
|
enet_list_insert (insertSendReliablePosition, enet_list_remove (& outgoingCommand -> outgoingCommandList));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
enet_list_insert (insertPosition, enet_list_remove (& outgoingCommand -> outgoingCommandList));
|
|
|
|
|
|
|
|
|
|
if (currentCommand == enet_list_begin (& peer -> sentReliableCommands) &&
|
|
|
|
|
@ -1383,56 +1403,71 @@ enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * even
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)
|
|
|
|
|
enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer, ENetList * sentUnreliableCommands)
|
|
|
|
|
{
|
|
|
|
|
ENetProtocol * command = & host -> commands [host -> commandCount];
|
|
|
|
|
ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
|
|
|
|
|
ENetOutgoingCommand * outgoingCommand;
|
|
|
|
|
ENetListIterator currentCommand;
|
|
|
|
|
ENetChannel *channel;
|
|
|
|
|
enet_uint16 reliableWindow;
|
|
|
|
|
ENetListIterator currentCommand, currentSendReliableCommand;
|
|
|
|
|
ENetChannel *channel = NULL;
|
|
|
|
|
enet_uint16 reliableWindow = 0;
|
|
|
|
|
size_t commandSize;
|
|
|
|
|
int windowExceeded = 0, windowWrap = 0, canPing = 1;
|
|
|
|
|
int windowWrap = 0, canPing = 1;
|
|
|
|
|
|
|
|
|
|
currentCommand = enet_list_begin (& peer -> outgoingCommands);
|
|
|
|
|
currentSendReliableCommand = enet_list_begin (& peer -> outgoingSendReliableCommands);
|
|
|
|
|
|
|
|
|
|
while (currentCommand != enet_list_end (& peer -> outgoingCommands))
|
|
|
|
|
for (;;)
|
|
|
|
|
{
|
|
|
|
|
if (currentCommand != enet_list_end (& peer -> outgoingCommands))
|
|
|
|
|
{
|
|
|
|
|
outgoingCommand = (ENetOutgoingCommand *) currentCommand;
|
|
|
|
|
|
|
|
|
|
if (currentSendReliableCommand != enet_list_end (& peer -> outgoingSendReliableCommands) &&
|
|
|
|
|
ENET_TIME_LESS (((ENetOutgoingCommand *) currentSendReliableCommand) -> queueTime, outgoingCommand -> queueTime))
|
|
|
|
|
goto useSendReliableCommand;
|
|
|
|
|
|
|
|
|
|
currentCommand = enet_list_next (currentCommand);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
if (currentSendReliableCommand != enet_list_end (& peer -> outgoingSendReliableCommands))
|
|
|
|
|
{
|
|
|
|
|
useSendReliableCommand:
|
|
|
|
|
outgoingCommand = (ENetOutgoingCommand *) currentSendReliableCommand;
|
|
|
|
|
currentSendReliableCommand = enet_list_next (currentSendReliableCommand);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
|
|
|
|
|
{
|
|
|
|
|
channel = outgoingCommand -> command.header.channelID < peer -> channelCount ? & peer -> channels [outgoingCommand -> command.header.channelID] : NULL;
|
|
|
|
|
reliableWindow = outgoingCommand -> reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
|
|
|
|
|
if (channel != NULL)
|
|
|
|
|
{
|
|
|
|
|
if (! windowWrap &&
|
|
|
|
|
outgoingCommand -> sendAttempts < 1 &&
|
|
|
|
|
if (windowWrap)
|
|
|
|
|
continue;
|
|
|
|
|
else
|
|
|
|
|
if (outgoingCommand -> sendAttempts < 1 &&
|
|
|
|
|
! (outgoingCommand -> reliableSequenceNumber % ENET_PEER_RELIABLE_WINDOW_SIZE) &&
|
|
|
|
|
(channel -> reliableWindows [(reliableWindow + ENET_PEER_RELIABLE_WINDOWS - 1) % ENET_PEER_RELIABLE_WINDOWS] >= ENET_PEER_RELIABLE_WINDOW_SIZE ||
|
|
|
|
|
channel -> usedReliableWindows & ((((1 << (ENET_PEER_FREE_RELIABLE_WINDOWS + 2)) - 1) << reliableWindow) |
|
|
|
|
|
(((1 << (ENET_PEER_FREE_RELIABLE_WINDOWS + 2)) - 1) >> (ENET_PEER_RELIABLE_WINDOWS - reliableWindow)))))
|
|
|
|
|
windowWrap = 1;
|
|
|
|
|
if (windowWrap)
|
|
|
|
|
{
|
|
|
|
|
currentCommand = enet_list_next (currentCommand);
|
|
|
|
|
windowWrap = 1;
|
|
|
|
|
currentSendReliableCommand = enet_list_end (& peer -> outgoingSendReliableCommands);
|
|
|
|
|
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> packet != NULL)
|
|
|
|
|
{
|
|
|
|
|
if (! windowExceeded)
|
|
|
|
|
{
|
|
|
|
|
enet_uint32 windowSize = (peer -> packetThrottle * peer -> windowSize) / ENET_PEER_PACKET_THROTTLE_SCALE;
|
|
|
|
|
|
|
|
|
|
if (peer -> reliableDataInTransit + outgoingCommand -> fragmentLength > ENET_MAX (windowSize, peer -> mtu))
|
|
|
|
|
windowExceeded = 1;
|
|
|
|
|
}
|
|
|
|
|
if (windowExceeded)
|
|
|
|
|
{
|
|
|
|
|
currentCommand = enet_list_next (currentCommand);
|
|
|
|
|
currentSendReliableCommand = enet_list_end (& peer -> outgoingSendReliableCommands);
|
|
|
|
|
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
@ -1448,13 +1483,11 @@ enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)
|
|
|
|
|
(outgoingCommand -> packet != NULL &&
|
|
|
|
|
(enet_uint16) (peer -> mtu - host -> packetSize) < (enet_uint16) (commandSize + outgoingCommand -> fragmentLength)))
|
|
|
|
|
{
|
|
|
|
|
host -> continueSending = 1;
|
|
|
|
|
peer -> flags |= ENET_PEER_FLAG_CONTINUE_SENDING;
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
currentCommand = enet_list_next (currentCommand);
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
|
|
|
|
|
{
|
|
|
|
|
if (channel != NULL && outgoingCommand -> sendAttempts < 1)
|
|
|
|
|
@ -1466,10 +1499,7 @@ enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)
|
|
|
|
|
++ outgoingCommand -> sendAttempts;
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> roundTripTimeout == 0)
|
|
|
|
|
{
|
|
|
|
|
outgoingCommand -> roundTripTimeout = peer -> roundTripTime + 4 * peer -> roundTripTimeVariance;
|
|
|
|
|
outgoingCommand -> roundTripTimeoutLimit = peer -> timeoutLimit * outgoingCommand -> roundTripTimeout;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (enet_list_empty (& peer -> sentReliableCommands))
|
|
|
|
|
peer -> nextTimeout = host -> serviceTime + outgoingCommand -> roundTripTimeout;
|
|
|
|
|
@ -1522,7 +1552,7 @@ enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)
|
|
|
|
|
enet_list_remove (& outgoingCommand -> outgoingCommandList);
|
|
|
|
|
|
|
|
|
|
if (outgoingCommand -> packet != NULL)
|
|
|
|
|
enet_list_insert (enet_list_end (& peer -> sentUnreliableCommands), outgoingCommand);
|
|
|
|
|
enet_list_insert (enet_list_end (sentUnreliableCommands), outgoingCommand);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
buffer -> data = command;
|
|
|
|
|
@ -1555,9 +1585,8 @@ enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)
|
|
|
|
|
host -> bufferCount = buffer - host -> buffers;
|
|
|
|
|
|
|
|
|
|
if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER &&
|
|
|
|
|
enet_list_empty (& peer -> outgoingCommands) &&
|
|
|
|
|
enet_list_empty (& peer -> sentReliableCommands) &&
|
|
|
|
|
enet_list_empty (& peer -> sentUnreliableCommands))
|
|
|
|
|
! enet_peer_has_outgoing_commands (peer) &&
|
|
|
|
|
enet_list_empty (sentUnreliableCommands))
|
|
|
|
|
enet_peer_disconnect (peer, peer -> eventData);
|
|
|
|
|
|
|
|
|
|
return canPing;
|
|
|
|
|
@ -1568,22 +1597,24 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
|
|
|
|
|
{
|
|
|
|
|
enet_uint8 headerData [sizeof (ENetProtocolHeader) + sizeof (enet_uint32)];
|
|
|
|
|
ENetProtocolHeader * header = (ENetProtocolHeader *) headerData;
|
|
|
|
|
ENetPeer * currentPeer;
|
|
|
|
|
int sentLength;
|
|
|
|
|
int sentLength = 0;
|
|
|
|
|
size_t shouldCompress = 0;
|
|
|
|
|
ENetList sentUnreliableCommands;
|
|
|
|
|
|
|
|
|
|
host -> continueSending = 1;
|
|
|
|
|
enet_list_clear (& sentUnreliableCommands);
|
|
|
|
|
|
|
|
|
|
while (host -> continueSending)
|
|
|
|
|
for (host -> continueSending = 0,
|
|
|
|
|
currentPeer = host -> peers;
|
|
|
|
|
for (int sendPass = 0, continueSending = 0; sendPass <= continueSending; ++ sendPass)
|
|
|
|
|
for (ENetPeer * currentPeer = host -> peers;
|
|
|
|
|
currentPeer < & host -> peers [host -> peerCount];
|
|
|
|
|
++ currentPeer)
|
|
|
|
|
{
|
|
|
|
|
if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED ||
|
|
|
|
|
currentPeer -> state == ENET_PEER_STATE_ZOMBIE)
|
|
|
|
|
currentPeer -> state == ENET_PEER_STATE_ZOMBIE ||
|
|
|
|
|
(sendPass > 0 && ! (currentPeer -> flags & ENET_PEER_FLAG_CONTINUE_SENDING)))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
currentPeer -> flags &= ~ ENET_PEER_FLAG_CONTINUE_SENDING;
|
|
|
|
|
|
|
|
|
|
host -> headerFlags = 0;
|
|
|
|
|
host -> commandCount = 0;
|
|
|
|
|
host -> bufferCount = 1;
|
|
|
|
|
@ -1600,21 +1631,22 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
|
|
|
|
|
if (event != NULL && event -> type != ENET_EVENT_TYPE_NONE)
|
|
|
|
|
return 1;
|
|
|
|
|
else
|
|
|
|
|
continue;
|
|
|
|
|
goto nextPeer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((enet_list_empty (& currentPeer -> outgoingCommands) ||
|
|
|
|
|
enet_protocol_check_outgoing_commands (host, currentPeer)) &&
|
|
|
|
|
if (((enet_list_empty (& currentPeer -> outgoingCommands) &&
|
|
|
|
|
enet_list_empty (& currentPeer -> outgoingSendReliableCommands)) ||
|
|
|
|
|
enet_protocol_check_outgoing_commands (host, currentPeer, & sentUnreliableCommands)) &&
|
|
|
|
|
enet_list_empty (& currentPeer -> sentReliableCommands) &&
|
|
|
|
|
ENET_TIME_DIFFERENCE (host -> serviceTime, currentPeer -> lastReceiveTime) >= currentPeer -> pingInterval &&
|
|
|
|
|
currentPeer -> mtu - host -> packetSize >= sizeof (ENetProtocolPing))
|
|
|
|
|
{
|
|
|
|
|
enet_peer_ping (currentPeer);
|
|
|
|
|
enet_protocol_check_outgoing_commands (host, currentPeer);
|
|
|
|
|
enet_protocol_check_outgoing_commands (host, currentPeer, & sentUnreliableCommands);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (host -> commandCount == 0)
|
|
|
|
|
continue;
|
|
|
|
|
goto nextPeer;
|
|
|
|
|
|
|
|
|
|
if (currentPeer -> packetLossEpoch == 0)
|
|
|
|
|
currentPeer -> packetLossEpoch = host -> serviceTime;
|
|
|
|
|
@ -1625,7 +1657,7 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
|
|
|
|
|
enet_uint32 packetLoss = currentPeer -> packetsLost * ENET_PEER_PACKET_LOSS_SCALE / currentPeer -> packetsSent;
|
|
|
|
|
|
|
|
|
|
#ifdef ENET_DEBUG
|
|
|
|
|
printf ("peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u outgoing, %u/%u incoming\n", currentPeer -> incomingPeerID, currentPeer -> packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> roundTripTime, currentPeer -> roundTripTimeVariance, currentPeer -> packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE, enet_list_size (& currentPeer -> outgoingCommands), currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingReliableCommands) : 0, currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands) : 0);
|
|
|
|
|
printf ("peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u outgoing, %u/%u incoming\n", currentPeer -> incomingPeerID, currentPeer -> packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> roundTripTime, currentPeer -> roundTripTimeVariance, currentPeer -> packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE, enet_list_size (& currentPeer -> outgoingCommands) + enet_list_size (& currentPeer -> outgoingSendReliableCommands), currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingReliableCommands) : 0, currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands) : 0);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
currentPeer -> packetLossVariance = (currentPeer -> packetLossVariance * 3 + ENET_DIFFERENCE (packetLoss, currentPeer -> packetLoss)) / 4;
|
|
|
|
|
@ -1687,13 +1719,17 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
|
|
|
|
|
|
|
|
|
|
sentLength = enet_socket_send (host -> socket, & currentPeer -> address, host -> buffers, host -> bufferCount);
|
|
|
|
|
|
|
|
|
|
enet_protocol_remove_sent_unreliable_commands (currentPeer);
|
|
|
|
|
enet_protocol_remove_sent_unreliable_commands (currentPeer, & sentUnreliableCommands);
|
|
|
|
|
|
|
|
|
|
if (sentLength < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
host -> totalSentData += sentLength;
|
|
|
|
|
host -> totalSentPackets ++;
|
|
|
|
|
|
|
|
|
|
nextPeer:
|
|
|
|
|
if (currentPeer -> flags & ENET_PEER_FLAG_CONTINUE_SENDING)
|
|
|
|
|
continueSending = sendPass + 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
Fabio Alessandrelli
Yuri Sizov