Skip to content

Commit c63aeff

Browse files
JonathSpiritJonathSpirit
committed
fixing server, make sure PacketCache work
1 parent 39d9e8a commit c63aeff

File tree

2 files changed

+80
-37
lines changed

2 files changed

+80
-37
lines changed

‎examples/clientServerLifeSimulator_004/client/main.cpp

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -297,8 +297,6 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
297297
continue;
298298
}
299299

300-
server._client.acknowledgeReception(packet);
301-
302300
//Prepare a sending packet
303301
auto transmissionPacket = fge::net::CreatePacket();
304302

‎sources/network/C_server.cpp

Lines changed: 80 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,7 @@ FluxProcessResults NetFluxUdp::processReorder(Client& client,
7373

7474
if (stat == PacketReorderer::Stats::RETRIEVABLE)
7575
{
76+
packet->markAsLocallyReordered();
7677
return FluxProcessResults::USER_RETRIEVABLE;
7778
}
7879

@@ -331,7 +332,25 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
331332
return this->processMTUDiscoveredClient(*refClientData, packet);
332333
}
333334

334-
if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG) && !packet->isMarkedAsLocallyReordered())
335+
auto const stat =
336+
PacketReorderer::checkStat(packet, refClient->getClientPacketCounter(), refClient->getCurrentRealm());
337+
338+
if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_DISCARD_FLAG))
339+
{
340+
if (stat == PacketReorderer::Stats::OLD_COUNTER)
341+
{
342+
auto const packetCounter = packet->retrieveCounter().value();
343+
auto const packetRealm = packet->retrieveRealm().value();
344+
auto const currentCounter = refClient->getClientPacketCounter();
345+
FGE_DEBUG_PRINT("Packet is old, discarding it packetCounter: {}, packetRealm: {}, currentCounter: {}",
346+
packetCounter, packetRealm, currentCounter);
347+
refClient->advanceLostPacketCount();
348+
return FluxProcessResults::INTERNALLY_DISCARDED;
349+
}
350+
}
351+
352+
bool const doNotReorder = packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG);
353+
if (!doNotReorder && !packet->isMarkedAsLocallyReordered())
335354
{
336355
auto reorderResult = this->processReorder(*refClient, packet, refClient->getClientPacketCounter(), true);
337356
if (reorderResult != FluxProcessResults::USER_RETRIEVABLE)
@@ -343,28 +362,25 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
343362
//Verify the realm
344363
if (!this->verifyRealm(refClient, packet))
345364
{
365+
FGE_DEBUG_PRINT("Packet bad realm, discarding it");
346366
return FluxProcessResults::INTERNALLY_DISCARDED;
347367
}
348368

349-
auto const stat =
350-
PacketReorderer::checkStat(packet, refClient->getClientPacketCounter(), refClient->getCurrentRealm());
351-
352-
if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_DISCARD_FLAG))
353-
{
354-
if (stat == PacketReorderer::Stats::OLD_COUNTER)
355-
{
356-
refClient->advanceLostPacketCount();
357-
return FluxProcessResults::INTERNALLY_DISCARDED;
358-
}
359-
}
360-
361369
if (stat == PacketReorderer::Stats::WAITING_NEXT_REALM || stat == PacketReorderer::Stats::WAITING_NEXT_COUNTER)
362370
{
371+
auto const packetCounter = packet->retrieveCounter().value();
372+
auto const packetRealm = packet->retrieveRealm().value();
373+
auto const currentCounter = refClient->getClientPacketCounter();
374+
FGE_DEBUG_PRINT("We lose a packet packetCounter: {}, packetRealm: {}, currentCounter: {}", packetCounter,
375+
packetRealm, currentCounter);
363376
refClient->advanceLostPacketCount(); //We are missing a packet
364377
}
365378

366-
auto const countId = packet->retrieveCounter().value();
367-
refClient->setClientPacketCounter(countId);
379+
if (!doNotReorder)
380+
{
381+
auto const countId = packet->retrieveCounter().value();
382+
refClient->setClientPacketCounter(countId);
383+
}
368384

369385
//Check if the packet is a return packet, and if so, handle it
370386
if (packet->retrieveHeaderId().value() == NET_INTERNAL_ID_RETURN_PACKET)
@@ -468,12 +484,16 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
468484
packet->packet() >> label._counter >> label._realm;
469485
if (!packet->isValid())
470486
{
487+
FGE_DEBUG_PRINT("received bad label");
471488
return FluxProcessResults::INTERNALLY_DISCARDED;
472489
}
473490
acknowledgedPackets[i] = label;
474491
}
475-
refClient->getPacketCache().acknowledgeReception(acknowledgedPackets);
476-
FGE_DEBUG_PRINT("Acknowledged packets: {}", acknowledgedPacketsSize);
492+
493+
{
494+
auto const packetCache = refClient->getPacketCache();
495+
packetCache.first->acknowledgeReception(acknowledgedPackets);
496+
}
477497

478498
this->_onClientReturnPacket.call(refClient, packet->getIdentity(), packet);
479499

@@ -709,6 +729,7 @@ FluxProcessResults ServerNetFluxUdp::processMTUDiscoveredClient(ClientList::Data
709729
refClient->getStatus().setNetworkStatus(ClientStatus::NetworkStatus::CONNECTED);
710730
refClient->getStatus().setTimeout(FGE_NET_STATUS_DEFAULT_CONNECTED_TIMEOUT);
711731
refClient->setClientPacketCounter(0);
732+
refClient->setCurrentPacketCounter(0);
712733
this->_onClientConnected.call(refClient, packet->getIdentity());
713734
return FluxProcessResults::INTERNALLY_HANDLED;
714735
}
@@ -1079,14 +1100,19 @@ void ServerSideNetUdp::threadTransmission()
10791100
auto& client = itClient->second._client;
10801101

10811102
//check cache
1082-
auto const clientLatency =
1083-
client->getPacketReturnRate() * 1.5f +
1084-
std::chrono::milliseconds(client->_latencyPlanner.getRoundTripTime().value_or(1));
1085-
while (client->getPacketCache().check(
1086-
timePoint, std::chrono::duration_cast<std::chrono::milliseconds>(clientLatency)))
10871103
{
1088-
FGE_DEBUG_PRINT("re-transmit packet as client didn't acknowledge it");
1089-
client->pushForcedFrontPacket(client->getPacketCache().pop());
1104+
auto const packetCache = client->getPacketCache();
1105+
1106+
auto const clientLatency =
1107+
client->getPacketReturnRate() * 1.5f +
1108+
std::chrono::milliseconds(client->_latencyPlanner.getRoundTripTime().value_or(1));
1109+
1110+
while (packetCache.first->check(
1111+
timePoint, std::chrono::duration_cast<std::chrono::milliseconds>(clientLatency)))
1112+
{
1113+
FGE_DEBUG_PRINT("re-transmit packet as client didn't acknowledge it");
1114+
client->pushForcedFrontPacket(packetCache.first->pop());
1115+
}
10901116
}
10911117

10921118
if (client->isPendingPacketsEmpty())
@@ -1111,7 +1137,8 @@ void ServerSideNetUdp::threadTransmission()
11111137
{
11121138
continue;
11131139
}
1114-
client->getPacketCache().push(transmissionPacket);
1140+
auto const packetCache = client->getPacketCache();
1141+
packetCache.first->push(transmissionPacket);
11151142
}
11161143
else
11171144
{
@@ -1403,14 +1430,9 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
14031430
}
14041431
--this->_g_remainingPackets;
14051432

1406-
if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG) && !packet->isMarkedAsLocallyReordered())
1433+
if (!packet->isMarkedAsLocallyReordered())
14071434
{
1408-
auto reorderResult =
1409-
this->processReorder(this->_client, packet, this->_client.getCurrentPacketCounter(), false);
1410-
if (reorderResult != FluxProcessResults::USER_RETRIEVABLE)
1411-
{
1412-
return reorderResult;
1413-
}
1435+
this->_client.acknowledgeReception(packet);
14141436
}
14151437

14161438
auto const stat = PacketReorderer::checkStat(packet, this->_client.getCurrentPacketCounter(),
@@ -1420,11 +1442,27 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
14201442
{
14211443
if (stat == PacketReorderer::Stats::OLD_REALM || stat == PacketReorderer::Stats::OLD_COUNTER)
14221444
{
1445+
auto const packetCounter = packet->retrieveCounter().value();
1446+
auto const packetRealm = packet->retrieveRealm().value();
1447+
auto const currentCounter = this->_client.getCurrentPacketCounter();
1448+
FGE_DEBUG_PRINT("Packet is old, discarding it packetCounter: {}, packetRealm: {}, currentCounter: {}",
1449+
packetCounter, packetRealm, currentCounter);
14231450
this->_client.advanceLostPacketCount();
14241451
return FluxProcessResults::INTERNALLY_DISCARDED;
14251452
}
14261453
}
14271454

1455+
bool const doNotReorder = packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG);
1456+
if (!doNotReorder && !packet->isMarkedAsLocallyReordered())
1457+
{
1458+
auto reorderResult =
1459+
this->processReorder(this->_client, packet, this->_client.getCurrentPacketCounter(), false);
1460+
if (reorderResult != FluxProcessResults::USER_RETRIEVABLE)
1461+
{
1462+
return reorderResult;
1463+
}
1464+
}
1465+
14281466
if (packet->retrieveHeaderId().value() == NET_INTERNAL_ID_DISCONNECT)
14291467
{
14301468
this->_client.getStatus().setNetworkStatus(ClientStatus::NetworkStatus::DISCONNECTED);
@@ -1436,13 +1474,20 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
14361474

14371475
if (stat == PacketReorderer::Stats::WAITING_NEXT_REALM || stat == PacketReorderer::Stats::WAITING_NEXT_COUNTER)
14381476
{
1477+
auto const packetCounter = packet->retrieveCounter().value();
1478+
auto const packetRealm = packet->retrieveRealm().value();
1479+
auto const currentCounter = this->_client.getCurrentPacketCounter();
1480+
FGE_DEBUG_PRINT("We lose a packet packetCounter: {}, packetRealm: {}, currentCounter: {}", packetCounter,
1481+
packetRealm, currentCounter);
14391482
this->_client.advanceLostPacketCount(); //We are missing a packet
14401483
}
14411484

1485+
if (!doNotReorder)
1486+
{
1487+
auto const serverCountId = packet->retrieveCounter().value();
1488+
this->_client.setCurrentPacketCounter(serverCountId);
1489+
}
14421490
auto const serverRealm = packet->retrieveRealm().value();
1443-
auto const serverCountId = packet->retrieveCounter().value();
1444-
1445-
this->_client.setCurrentPacketCounter(serverCountId);
14461491
this->_client.setCurrentRealm(serverRealm);
14471492

14481493
return FluxProcessResults::USER_RETRIEVABLE;

0 commit comments

Comments
 (0)