rework FluxProcessResults: this fix a packets process lag

JonathSpirit · JonathSpirit · commit 15a53ed382c4 · 2025-04-24T19:27:30.000+02:00
diff --git a/examples/clientServerLifeSimulator_004/client/main.cpp b/examples/clientServerLifeSimulator_004/client/main.cpp
@@ -289,8 +289,14 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
 
         //Handling server packets
         fge::net::ReceivedPacketPtr packet;
-        while (server.process(packet) == fge::net::FluxProcessResults::RETRIEVABLE)
-        {
+        fge::net::FluxProcessResults processResult;
+        do {
+            processResult = server.process(packet);
+            if (processResult != fge::net::FluxProcessResults::USER_RETRIEVABLE)
+            {
+                continue;
+            }
+
             //Prepare a sending packet
             auto transmissionPacket = fge::net::CreatePacket();
 
@@ -403,7 +409,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
             default:
                 break;
             }
-        }
+        } while (processResult != fge::net::FluxProcessResults::NONE_AVAILABLE);
 
         //Update scene
         mainScene->update(renderWindow, event,
diff --git a/examples/clientServerLifeSimulator_004/server/main.cpp b/examples/clientServerLifeSimulator_004/server/main.cpp
@@ -210,8 +210,14 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
         //Handling clients packets
         fge::net::ClientSharedPtr client;
         fge::net::ReceivedPacketPtr packet;
-        while (serverFlux->process(client, packet, true) == fge::net::FluxProcessResults::RETRIEVABLE)
-        {
+        fge::net::FluxProcessResults processResult;
+        do {
+            processResult = serverFlux->process(client, packet, true);
+            if (processResult != fge::net::FluxProcessResults::USER_RETRIEVABLE)
+            {
+                continue;
+            }
+
             //Prepare a sending packet
             auto transmissionPacket = fge::net::CreatePacket();
 
@@ -316,7 +322,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
             default:
                 break;
             }
-        }
+        } while (processResult != fge::net::FluxProcessResults::NONE_AVAILABLE);
 
         //Scene update
         mainScene.update(event, std::chrono::duration_cast<std::chrono::milliseconds>(deltaTime.restart()));
diff --git a/includes/FastEngine/network/C_netCommand.hpp b/includes/FastEngine/network/C_netCommand.hpp
@@ -34,7 +34,7 @@
 #define FGE_NET_MTU_TIMEOUT_MS                                                                                         \
     std::chrono::milliseconds                                                                                          \
     {                                                                                                                  \
-        500                                                                                                            \
+        400                                                                                                            \
     }
 #define FGE_NET_MTU_TRY_COUNT 12
 #define FGE_NET_MTU_MIN_INTERVAL 16
diff --git a/includes/FastEngine/network/C_server.hpp b/includes/FastEngine/network/C_server.hpp
@@ -59,11 +59,12 @@ class ClientSideNetUdp;
 
 enum class FluxProcessResults
 {
-    RETRIEVABLE,
-    BAD_REALM,
-    BAD_REORDER,
-    NOT_RETRIEVABLE,
-    INTERNALLY_HANDLED
+    USER_RETRIEVABLE,
+
+    INTERNALLY_HANDLED,
+    INTERNALLY_DISCARDED,
+
+    NONE_AVAILABLE
 };
 
 enum class ReturnEvents
diff --git a/sources/network/C_server.cpp b/sources/network/C_server.cpp
@@ -73,11 +73,11 @@ FluxProcessResults NetFluxUdp::processReorder(Client& client,
 
         if (stat == PacketReorderer::Stats::RETRIEVABLE)
         {
-            return FluxProcessResults::RETRIEVABLE;
+            return FluxProcessResults::USER_RETRIEVABLE;
         }
 
         client.getPacketReorderer().push(std::move(packet));
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::INTERNALLY_HANDLED;
     }
 
     //We push the packet in the reorderer
@@ -89,7 +89,7 @@ FluxProcessResults NetFluxUdp::processReorder(Client& client,
     auto const stat = client.getPacketReorderer().checkStat(currentCounter, currentRealm).value();
     if (!forced && stat != PacketReorderer::Stats::RETRIEVABLE)
     {
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::INTERNALLY_HANDLED;
     }
 
     packet = client.getPacketReorderer().pop();
@@ -129,7 +129,7 @@ FluxProcessResults NetFluxUdp::processReorder(Client& client,
 
     FGE_PLACE_DESTRUCT(ReceivedPacketPtr, FGE_NET_PACKET_REORDERER_CACHE_MAX, containerInversed);
 
-    return FluxProcessResults::RETRIEVABLE;
+    return FluxProcessResults::USER_RETRIEVABLE;
 }
 
 ReceivedPacketPtr NetFluxUdp::popNextPacket()
@@ -265,15 +265,15 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
     if (this->_g_remainingPackets == 0)
     {
         this->_g_remainingPackets = this->getPacketsSize();
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::NONE_AVAILABLE;
     }
 
     //Popping the next packet
     packet = this->popNextPacket();
     if (!packet)
     {
         this->_g_remainingPackets = this->getPacketsSize();
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::NONE_AVAILABLE;
     }
     --this->_g_remainingPackets;
 
@@ -288,15 +288,15 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
         }
 
         this->g_server->repushPacket(std::move(packet));
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::INTERNALLY_HANDLED;
     }
     refClient = refClientData->_client;
     auto const& status = refClient->getStatus();
 
     //Ignore packets if the client is disconnected
     if (status.isDisconnected())
     {
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::INTERNALLY_DISCARDED;
     }
 
     //Check if the client is in an acknowledged state
@@ -316,12 +316,12 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
         }
         else
         {
-            return FluxProcessResults::NOT_RETRIEVABLE;
+            return FluxProcessResults::INTERNALLY_HANDLED;
         }
 
         if (!packet->haveCorrectHeader())
         {
-            return FluxProcessResults::NOT_RETRIEVABLE;
+            return FluxProcessResults::INTERNALLY_DISCARDED;
         }
     }
 
@@ -334,7 +334,7 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
     if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG) && !packet->isMarkedAsLocallyReordered())
     {
         auto reorderResult = this->processReorder(*refClient, packet, refClient->getClientPacketCounter(), true);
-        if (reorderResult != FluxProcessResults::RETRIEVABLE)
+        if (reorderResult != FluxProcessResults::USER_RETRIEVABLE)
         {
             return reorderResult;
         }
@@ -343,7 +343,7 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
     //Verify the realm
     if (!this->verifyRealm(refClient, packet))
     {
-        return FluxProcessResults::BAD_REALM;
+        return FluxProcessResults::INTERNALLY_DISCARDED;
     }
 
     auto const stat =
@@ -354,8 +354,7 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
         if (stat == PacketReorderer::Stats::OLD_COUNTER)
         {
             refClient->advanceLostPacketCount();
-            --this->_g_remainingPackets;
-            return FluxProcessResults::NOT_RETRIEVABLE;
+            return FluxProcessResults::INTERNALLY_DISCARDED;
         }
     }
 
@@ -476,7 +475,7 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,
         return FluxProcessResults::INTERNALLY_HANDLED;
     }
 
-    return FluxProcessResults::RETRIEVABLE;
+    return FluxProcessResults::USER_RETRIEVABLE;
 }
 
 FluxProcessResults ServerNetFluxUdp::processUnknownClient(ClientSharedPtr& refClient, ReceivedPacketPtr& packet)
@@ -485,7 +484,7 @@ FluxProcessResults ServerNetFluxUdp::processUnknownClient(ClientSharedPtr& refCl
     if (packet->isFragmented())
     {
         //We can't (disallow) process fragmented packets from unknown clients
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::INTERNALLY_DISCARDED;
     }
 
     //Check if the packet is a handshake
@@ -506,7 +505,7 @@ FluxProcessResults ServerNetFluxUdp::processUnknownClient(ClientSharedPtr& refCl
             versioningString != this->g_server->getVersioningString())
         { //TODO: endReached() check should be done in .end() method
             std::cout << "Handshake failed" << std::endl;
-            return FluxProcessResults::NOT_RETRIEVABLE;
+            return FluxProcessResults::INTERNALLY_DISCARDED;
         }
 
         std::cout << "Handshake accepted" << std::endl;
@@ -537,7 +536,7 @@ FluxProcessResults ServerNetFluxUdp::processUnknownClient(ClientSharedPtr& refCl
     }
 
     //We can't process packets further for unknown clients
-    return FluxProcessResults::NOT_RETRIEVABLE;
+    return FluxProcessResults::INTERNALLY_DISCARDED;
 }
 FluxProcessResults ServerNetFluxUdp::processAcknowledgedClient(ClientList::Data& refClientData,
                                                                ReceivedPacketPtr& packet)
@@ -577,7 +576,7 @@ FluxProcessResults ServerNetFluxUdp::processAcknowledgedClient(ClientList::Data&
                 //Discard the packet and the client
                 this->_clients.remove(packet->getIdentity());
                 this->_onClientDropped.call(refClientData._client, packet->getIdentity());
-                return FluxProcessResults::NOT_RETRIEVABLE;
+                return FluxProcessResults::INTERNALLY_DISCARDED;
             }
             std::cout << "CryptServerCreate success, starting crypt exchange" << std::endl;
             refClientData._client->getStatus().setNetworkStatus(ClientStatus::NetworkStatus::MTU_DISCOVERED);
@@ -594,7 +593,7 @@ FluxProcessResults ServerNetFluxUdp::processAcknowledgedClient(ClientList::Data&
             //Discard the packet and the client
             this->_clients.remove(packet->getIdentity());
             this->_onClientDropped.call(refClientData._client, packet->getIdentity());
-            return FluxProcessResults::NOT_RETRIEVABLE;
+            return FluxProcessResults::INTERNALLY_DISCARDED;
         }
 
         if (result == NetCommandResults::SUCCESS)
@@ -617,7 +616,7 @@ FluxProcessResults ServerNetFluxUdp::processAcknowledgedClient(ClientList::Data&
                     //Discard the packet and the client
                     this->_clients.remove(packet->getIdentity());
                     this->_onClientDropped.call(refClientData._client, packet->getIdentity());
-                    return FluxProcessResults::NOT_RETRIEVABLE;
+                    return FluxProcessResults::INTERNALLY_DISCARDED;
                 }
 
                 std::cout << "CryptServerCreate success, starting crypt exchange" << std::endl;
@@ -638,7 +637,7 @@ FluxProcessResults ServerNetFluxUdp::processMTUDiscoveredClient(ClientList::Data
     //Check if the packet is a crypt handshake
     if (packet->retrieveHeaderId().value() != NET_INTERNAL_ID_CRYPT_HANDSHAKE)
     {
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::INTERNALLY_DISCARDED;
     }
 
     auto& refClient = refClientData._client;
@@ -662,7 +661,7 @@ FluxProcessResults ServerNetFluxUdp::processMTUDiscoveredClient(ClientList::Data
             refClient->getStatus().setNetworkStatus(ClientStatus::NetworkStatus::DISCONNECTED);
             this->_clients.remove(packet->getIdentity());
             this->_onClientDropped.call(refClient, packet->getIdentity());
-            return FluxProcessResults::NOT_RETRIEVABLE;
+            return FluxProcessResults::INTERNALLY_DISCARDED;
         }
     }
 
@@ -672,7 +671,7 @@ FluxProcessResults ServerNetFluxUdp::processMTUDiscoveredClient(ClientList::Data
     if (pendingSize == 0)
     {
         std::cout << "NONE" << std::endl;
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::INTERNALLY_DISCARDED;
     }
     std::cout << "transmitting crypt" << std::endl;
     auto response = CreatePacket(NET_INTERNAL_ID_CRYPT_HANDSHAKE);
@@ -686,7 +685,7 @@ FluxProcessResults ServerNetFluxUdp::processMTUDiscoveredClient(ClientList::Data
         refClient->getStatus().setNetworkStatus(ClientStatus::NetworkStatus::DISCONNECTED);
         this->_clients.remove(packet->getIdentity());
         this->_onClientDropped.call(refClient, packet->getIdentity());
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::INTERNALLY_DISCARDED;
     }
     refClient->pushPacket(std::move(response));
     this->g_server->notifyTransmission();
@@ -1330,11 +1329,10 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
     ///TODO: no lock ?
     packet.reset();
 
-    auto const networkStatus = this->_client.getStatus().getNetworkStatus();
-    if (networkStatus == ClientStatus::NetworkStatus::TIMEOUT ||
-        networkStatus == ClientStatus::NetworkStatus::DISCONNECTED)
+    if (this->_client.getStatus().isDisconnected())
     {
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        this->_g_remainingPackets = 0;
+        return FluxProcessResults::NONE_AVAILABLE;
     }
 
     //Checking timeout
@@ -1344,7 +1342,7 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
         this->_g_remainingPackets = 0;
         this->clearPackets();
         this->_onClientTimeout.call(*this);
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::NONE_AVAILABLE;
     }
 
     //Checking return packet
@@ -1363,23 +1361,23 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
     if (this->_g_remainingPackets == 0)
     {
         this->_g_remainingPackets = this->getPacketsSize();
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::NONE_AVAILABLE;
     }
 
     //Popping the next packet
     packet = this->popNextPacket();
     if (!packet)
     {
         this->_g_remainingPackets = this->getPacketsSize();
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::NONE_AVAILABLE;
     }
     --this->_g_remainingPackets;
 
     if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG) && !packet->isMarkedAsLocallyReordered())
     {
         auto reorderResult =
                 this->processReorder(this->_client, packet, this->_client.getCurrentPacketCounter(), false);
-        if (reorderResult != FluxProcessResults::RETRIEVABLE)
+        if (reorderResult != FluxProcessResults::USER_RETRIEVABLE)
         {
             return reorderResult;
         }
@@ -1393,8 +1391,7 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
         if (stat == PacketReorderer::Stats::OLD_REALM || stat == PacketReorderer::Stats::OLD_COUNTER)
         {
             this->_client.advanceLostPacketCount();
-            --this->_g_remainingPackets;
-            return FluxProcessResults::NOT_RETRIEVABLE;
+            return FluxProcessResults::INTERNALLY_DISCARDED;
         }
     }
 
@@ -1404,7 +1401,7 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
         this->_g_remainingPackets = 0;
         this->clearPackets();
         this->_onClientDisconnected.call(*this);
-        return FluxProcessResults::NOT_RETRIEVABLE;
+        return FluxProcessResults::NONE_AVAILABLE;
     }
 
     if (stat == PacketReorderer::Stats::WAITING_NEXT_REALM || stat == PacketReorderer::Stats::WAITING_NEXT_COUNTER)
@@ -1418,7 +1415,7 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
     this->_client.setCurrentPacketCounter(serverCountId);
     this->_client.setCurrentRealm(serverRealm);
 
-    return FluxProcessResults::RETRIEVABLE;
+    return FluxProcessResults::USER_RETRIEVABLE;
 }
 
 void ClientSideNetUdp::resetReturnPacket()

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@`
`34`	`34`	`#define FGE_NET_MTU_TIMEOUT_MS \`
`35`	`35`	`std::chrono::milliseconds \`
`36`	`36`	`{ \`
`37`		`- 500 \`
	`37`	`+ 400 \`
`38`	`38`	`}`
`39`	`39`	`#define FGE_NET_MTU_TRY_COUNT 12`
`40`	`40`	`#define FGE_NET_MTU_MIN_INTERVAL 16`
Original file line number	Diff line number	Diff line change
`@@ -73,11 +73,11 @@ FluxProcessResults NetFluxUdp::processReorder(Client& client,`
`73`	`73`
`74`	`74`	`if (stat == PacketReorderer::Stats::RETRIEVABLE)`
`75`	`75`	`{`
`76`		`- return FluxProcessResults::RETRIEVABLE;`
	`76`	`+ return FluxProcessResults::USER_RETRIEVABLE;`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`client.getPacketReorderer().push(std::move(packet));`
`80`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`80`	`+ return FluxProcessResults::INTERNALLY_HANDLED;`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`//We push the packet in the reorderer`
`@@ -89,7 +89,7 @@ FluxProcessResults NetFluxUdp::processReorder(Client& client,`
`89`	`89`	`auto const stat = client.getPacketReorderer().checkStat(currentCounter, currentRealm).value();`
`90`	`90`	`if (!forced && stat != PacketReorderer::Stats::RETRIEVABLE)`
`91`	`91`	`{`
`92`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`92`	`+ return FluxProcessResults::INTERNALLY_HANDLED;`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`packet = client.getPacketReorderer().pop();`
`@@ -129,7 +129,7 @@ FluxProcessResults NetFluxUdp::processReorder(Client& client,`
`129`	`129`
`130`	`130`	`FGE_PLACE_DESTRUCT(ReceivedPacketPtr, FGE_NET_PACKET_REORDERER_CACHE_MAX, containerInversed);`
`131`	`131`
`132`		`- return FluxProcessResults::RETRIEVABLE;`
	`132`	`+ return FluxProcessResults::USER_RETRIEVABLE;`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`ReceivedPacketPtr NetFluxUdp::popNextPacket()`
`@@ -265,15 +265,15 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,`
`265`	`265`	`if (this->_g_remainingPackets == 0)`
`266`	`266`	`{`
`267`	`267`	`this->_g_remainingPackets = this->getPacketsSize();`
`268`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`268`	`+ return FluxProcessResults::NONE_AVAILABLE;`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`//Popping the next packet`
`272`	`272`	`packet = this->popNextPacket();`
`273`	`273`	`if (!packet)`
`274`	`274`	`{`
`275`	`275`	`this->_g_remainingPackets = this->getPacketsSize();`
`276`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`276`	`+ return FluxProcessResults::NONE_AVAILABLE;`
`277`	`277`	`}`
`278`	`278`	`--this->_g_remainingPackets;`
`279`	`279`
`@@ -288,15 +288,15 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,`
`288`	`288`	`}`
`289`	`289`
`290`	`290`	`this->g_server->repushPacket(std::move(packet));`
`291`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`291`	`+ return FluxProcessResults::INTERNALLY_HANDLED;`
`292`	`292`	`}`
`293`	`293`	`refClient = refClientData->_client;`
`294`	`294`	`auto const& status = refClient->getStatus();`
`295`	`295`
`296`	`296`	`//Ignore packets if the client is disconnected`
`297`	`297`	`if (status.isDisconnected())`
`298`	`298`	`{`
`299`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`299`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`300`	`300`	`}`
`301`	`301`
`302`	`302`	`//Check if the client is in an acknowledged state`
`@@ -316,12 +316,12 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,`
`316`	`316`	`}`
`317`	`317`	`else`
`318`	`318`	`{`
`319`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`319`	`+ return FluxProcessResults::INTERNALLY_HANDLED;`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`if (!packet->haveCorrectHeader())`
`323`	`323`	`{`
`324`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`324`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`325`	`325`	`}`
`326`	`326`	`}`
`327`	`327`
`@@ -334,7 +334,7 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,`
`334`	`334`	`if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG) && !packet->isMarkedAsLocallyReordered())`
`335`	`335`	`{`
`336`	`336`	`auto reorderResult = this->processReorder(*refClient, packet, refClient->getClientPacketCounter(), true);`
`337`		`- if (reorderResult != FluxProcessResults::RETRIEVABLE)`
	`337`	`+ if (reorderResult != FluxProcessResults::USER_RETRIEVABLE)`
`338`	`338`	`{`
`339`	`339`	`return reorderResult;`
`340`	`340`	`}`
`@@ -343,7 +343,7 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,`
`343`	`343`	`//Verify the realm`
`344`	`344`	`if (!this->verifyRealm(refClient, packet))`
`345`	`345`	`{`
`346`		`- return FluxProcessResults::BAD_REALM;`
	`346`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`347`	`347`	`}`
`348`	`348`
`349`	`349`	`auto const stat =`
`@@ -354,8 +354,7 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,`
`354`	`354`	`if (stat == PacketReorderer::Stats::OLD_COUNTER)`
`355`	`355`	`{`
`356`	`356`	`refClient->advanceLostPacketCount();`
`357`		`- --this->_g_remainingPackets;`
`358`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`357`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`359`	`358`	`}`
`360`	`359`	`}`
`361`	`360`
`@@ -476,7 +475,7 @@ ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet,`
`476`	`475`	`return FluxProcessResults::INTERNALLY_HANDLED;`
`477`	`476`	`}`
`478`	`477`
`479`		`- return FluxProcessResults::RETRIEVABLE;`
	`478`	`+ return FluxProcessResults::USER_RETRIEVABLE;`
`480`	`479`	`}`
`481`	`480`
`482`	`481`	`FluxProcessResults ServerNetFluxUdp::processUnknownClient(ClientSharedPtr& refClient, ReceivedPacketPtr& packet)`
`@@ -485,7 +484,7 @@ FluxProcessResults ServerNetFluxUdp::processUnknownClient(ClientSharedPtr& refCl`
`485`	`484`	`if (packet->isFragmented())`
`486`	`485`	`{`
`487`	`486`	`//We can't (disallow) process fragmented packets from unknown clients`
`488`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`487`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`489`	`488`	`}`
`490`	`489`
`491`	`490`	`//Check if the packet is a handshake`
`@@ -506,7 +505,7 @@ FluxProcessResults ServerNetFluxUdp::processUnknownClient(ClientSharedPtr& refCl`
`506`	`505`	`versioningString != this->g_server->getVersioningString())`
`507`	`506`	`{ //TODO: endReached() check should be done in .end() method`
`508`	`507`	`std::cout << "Handshake failed" << std::endl;`
`509`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`508`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`510`	`509`	`}`
`511`	`510`
`512`	`511`	`std::cout << "Handshake accepted" << std::endl;`
`@@ -537,7 +536,7 @@ FluxProcessResults ServerNetFluxUdp::processUnknownClient(ClientSharedPtr& refCl`
`537`	`536`	`}`
`538`	`537`
`539`	`538`	`//We can't process packets further for unknown clients`
`540`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`539`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`541`	`540`	`}`
`542`	`541`	`FluxProcessResults ServerNetFluxUdp::processAcknowledgedClient(ClientList::Data& refClientData,`
`543`	`542`	`ReceivedPacketPtr& packet)`
`@@ -577,7 +576,7 @@ FluxProcessResults ServerNetFluxUdp::processAcknowledgedClient(ClientList::Data&`
`577`	`576`	`//Discard the packet and the client`
`578`	`577`	`this->_clients.remove(packet->getIdentity());`
`579`	`578`	`this->_onClientDropped.call(refClientData._client, packet->getIdentity());`
`580`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`579`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`581`	`580`	`}`
`582`	`581`	`std::cout << "CryptServerCreate success, starting crypt exchange" << std::endl;`
`583`	`582`	`refClientData._client->getStatus().setNetworkStatus(ClientStatus::NetworkStatus::MTU_DISCOVERED);`
`@@ -594,7 +593,7 @@ FluxProcessResults ServerNetFluxUdp::processAcknowledgedClient(ClientList::Data&`
`594`	`593`	`//Discard the packet and the client`
`595`	`594`	`this->_clients.remove(packet->getIdentity());`
`596`	`595`	`this->_onClientDropped.call(refClientData._client, packet->getIdentity());`
`597`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`596`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`598`	`597`	`}`
`599`	`598`
`600`	`599`	`if (result == NetCommandResults::SUCCESS)`
`@@ -617,7 +616,7 @@ FluxProcessResults ServerNetFluxUdp::processAcknowledgedClient(ClientList::Data&`
`617`	`616`	`//Discard the packet and the client`
`618`	`617`	`this->_clients.remove(packet->getIdentity());`
`619`	`618`	`this->_onClientDropped.call(refClientData._client, packet->getIdentity());`
`620`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`619`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`621`	`620`	`}`
`622`	`621`
`623`	`622`	`std::cout << "CryptServerCreate success, starting crypt exchange" << std::endl;`
`@@ -638,7 +637,7 @@ FluxProcessResults ServerNetFluxUdp::processMTUDiscoveredClient(ClientList::Data`
`638`	`637`	`//Check if the packet is a crypt handshake`
`639`	`638`	`if (packet->retrieveHeaderId().value() != NET_INTERNAL_ID_CRYPT_HANDSHAKE)`
`640`	`639`	`{`
`641`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`640`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`642`	`641`	`}`
`643`	`642`
`644`	`643`	`auto& refClient = refClientData._client;`
`@@ -662,7 +661,7 @@ FluxProcessResults ServerNetFluxUdp::processMTUDiscoveredClient(ClientList::Data`
`662`	`661`	`refClient->getStatus().setNetworkStatus(ClientStatus::NetworkStatus::DISCONNECTED);`
`663`	`662`	`this->_clients.remove(packet->getIdentity());`
`664`	`663`	`this->_onClientDropped.call(refClient, packet->getIdentity());`
`665`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`664`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`666`	`665`	`}`
`667`	`666`	`}`
`668`	`667`
`@@ -672,7 +671,7 @@ FluxProcessResults ServerNetFluxUdp::processMTUDiscoveredClient(ClientList::Data`
`672`	`671`	`if (pendingSize == 0)`
`673`	`672`	`{`
`674`	`673`	`std::cout << "NONE" << std::endl;`
`675`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`674`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`676`	`675`	`}`
`677`	`676`	`std::cout << "transmitting crypt" << std::endl;`
`678`	`677`	`auto response = CreatePacket(NET_INTERNAL_ID_CRYPT_HANDSHAKE);`
`@@ -686,7 +685,7 @@ FluxProcessResults ServerNetFluxUdp::processMTUDiscoveredClient(ClientList::Data`
`686`	`685`	`refClient->getStatus().setNetworkStatus(ClientStatus::NetworkStatus::DISCONNECTED);`
`687`	`686`	`this->_clients.remove(packet->getIdentity());`
`688`	`687`	`this->_onClientDropped.call(refClient, packet->getIdentity());`
`689`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`688`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`690`	`689`	`}`
`691`	`690`	`refClient->pushPacket(std::move(response));`
`692`	`691`	`this->g_server->notifyTransmission();`
`@@ -1330,11 +1329,10 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)`
`1330`	`1329`	`///TODO: no lock ?`
`1331`	`1330`	`packet.reset();`
`1332`	`1331`
`1333`		`- auto const networkStatus = this->_client.getStatus().getNetworkStatus();`
`1334`		`- if (networkStatus == ClientStatus::NetworkStatus::TIMEOUT \|\|`
`1335`		`- networkStatus == ClientStatus::NetworkStatus::DISCONNECTED)`
	`1332`	`+ if (this->_client.getStatus().isDisconnected())`
`1336`	`1333`	`{`
`1337`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`1334`	`+ this->_g_remainingPackets = 0;`
	`1335`	`+ return FluxProcessResults::NONE_AVAILABLE;`
`1338`	`1336`	`}`
`1339`	`1337`
`1340`	`1338`	`//Checking timeout`
`@@ -1344,7 +1342,7 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)`
`1344`	`1342`	`this->_g_remainingPackets = 0;`
`1345`	`1343`	`this->clearPackets();`
`1346`	`1344`	`this->_onClientTimeout.call(*this);`
`1347`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`1345`	`+ return FluxProcessResults::NONE_AVAILABLE;`
`1348`	`1346`	`}`
`1349`	`1347`
`1350`	`1348`	`//Checking return packet`
`@@ -1363,23 +1361,23 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)`
`1363`	`1361`	`if (this->_g_remainingPackets == 0)`
`1364`	`1362`	`{`
`1365`	`1363`	`this->_g_remainingPackets = this->getPacketsSize();`
`1366`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`1364`	`+ return FluxProcessResults::NONE_AVAILABLE;`
`1367`	`1365`	`}`
`1368`	`1366`
`1369`	`1367`	`//Popping the next packet`
`1370`	`1368`	`packet = this->popNextPacket();`
`1371`	`1369`	`if (!packet)`
`1372`	`1370`	`{`
`1373`	`1371`	`this->_g_remainingPackets = this->getPacketsSize();`
`1374`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`1372`	`+ return FluxProcessResults::NONE_AVAILABLE;`
`1375`	`1373`	`}`
`1376`	`1374`	`--this->_g_remainingPackets;`
`1377`	`1375`
`1378`	`1376`	`if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG) && !packet->isMarkedAsLocallyReordered())`
`1379`	`1377`	`{`
`1380`	`1378`	`auto reorderResult =`
`1381`	`1379`	`this->processReorder(this->_client, packet, this->_client.getCurrentPacketCounter(), false);`
`1382`		`- if (reorderResult != FluxProcessResults::RETRIEVABLE)`
	`1380`	`+ if (reorderResult != FluxProcessResults::USER_RETRIEVABLE)`
`1383`	`1381`	`{`
`1384`	`1382`	`return reorderResult;`
`1385`	`1383`	`}`
`@@ -1393,8 +1391,7 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)`
`1393`	`1391`	`if (stat == PacketReorderer::Stats::OLD_REALM \|\| stat == PacketReorderer::Stats::OLD_COUNTER)`
`1394`	`1392`	`{`
`1395`	`1393`	`this->_client.advanceLostPacketCount();`
`1396`		`- --this->_g_remainingPackets;`
`1397`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`1394`	`+ return FluxProcessResults::INTERNALLY_DISCARDED;`
`1398`	`1395`	`}`
`1399`	`1396`	`}`
`1400`	`1397`
`@@ -1404,7 +1401,7 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)`
`1404`	`1401`	`this->_g_remainingPackets = 0;`
`1405`	`1402`	`this->clearPackets();`
`1406`	`1403`	`this->_onClientDisconnected.call(*this);`
`1407`		`- return FluxProcessResults::NOT_RETRIEVABLE;`
	`1404`	`+ return FluxProcessResults::NONE_AVAILABLE;`
`1408`	`1405`	`}`
`1409`	`1406`
`1410`	`1407`	`if (stat == PacketReorderer::Stats::WAITING_NEXT_REALM \|\| stat == PacketReorderer::Stats::WAITING_NEXT_COUNTER)`
`@@ -1418,7 +1415,7 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)`
`1418`	`1415`	`this->_client.setCurrentPacketCounter(serverCountId);`
`1419`	`1416`	`this->_client.setCurrentRealm(serverRealm);`
`1420`	`1417`
`1421`		`- return FluxProcessResults::RETRIEVABLE;`
	`1418`	`+ return FluxProcessResults::USER_RETRIEVABLE;`
`1422`	`1419`	`}`
`1423`	`1420`
`1424`	`1421`	`void ClientSideNetUdp::resetReturnPacket()`