Join queue despaghettification

NitroxClient/Communication/MultiplayerSession/MultiplayerSessionManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using NitroxClient.Communication.Abstract;
 using NitroxClient.Communication.MultiplayerSession.ConnectionState;
@@ -82,28 +82,13 @@ public void ProcessSessionPolicy(MultiplayerSessionPolicy policy)
 
         public void RequestSessionReservation(PlayerSettings playerSettings, AuthenticationContext authenticationContext)
         {
-            // If a reservation has already been sent (in which case the client is enqueued in the join queue)
-            if (CurrentState.CurrentStage == MultiplayerSessionConnectionStage.AWAITING_SESSION_RESERVATION)
-            {
-                Log.Info("Waiting in join queue…");
-                Log.InGame(Language.main.Get("Nitrox_Waiting"));
-                return;
-            }
-
             PlayerSettings = playerSettings;
             AuthenticationContext = authenticationContext;
             CurrentState.NegotiateReservationAsync(this);
         }
 
         public void ProcessReservationResponsePacket(MultiplayerSessionReservation reservation)
         {
-            if (reservation.ReservationState == MultiplayerSessionReservationState.ENQUEUED_IN_JOIN_QUEUE)
-            {
-                Log.Info("Waiting in join queue…");
-                Log.InGame(Language.main.Get("Nitrox_Waiting"));
-                return;
-            }
-
             Reservation = reservation;
             CurrentState.NegotiateReservationAsync(this);
         }

NitroxClient/Communication/Packets/Processors/InitialPlayerSyncProcessor.cs

@@ -13,7 +13,7 @@ public class InitialPlayerSyncProcessor : ClientPacketProcessor<InitialPlayerSyn
     {
         private readonly IPacketSender packetSender;
         private readonly HashSet<IInitialSyncProcessor> processors;
-        private readonly HashSet<Type> alreadyRan = new();
+        private readonly HashSet<Type> alreadyRan = [];
         private InitialPlayerSync packet;
 
         private WaitScreen.ManualWaitItem loadingMultiplayerWaitItem;
@@ -31,7 +31,10 @@ public InitialPlayerSyncProcessor(IPacketSender packetSender, IEnumerable<IIniti
         public override void Process(InitialPlayerSync packet)
         {
             this.packet = packet;
+
             loadingMultiplayerWaitItem = WaitScreen.Add(Language.main.Get("Nitrox_SyncingWorld"));
+            Log.InGame(Language.main.Get("Nitrox_SyncingWorld"));
+
             cumulativeProcessorsRan = 0;
             Multiplayer.Main.StartCoroutine(ProcessInitialSyncPacket(this, null));
         }

NitroxClient/Communication/Packets/Processors/JoinQueueInfoProcessor.cs

@@ -0,0 +1,24 @@
+using System;
+using NitroxClient.Communication.Packets.Processors.Abstract;
+using NitroxModel.Packets;
+
+namespace NitroxClient.Communication.Packets.Processors;
+
+public class JoinQueueInfoProcessor : ClientPacketProcessor<JoinQueueInfo>
+{
+    public override void Process(JoinQueueInfo packet)
+    {
+        Log.InGame($"You are at position #{packet.Position} in the queue.");
+
+        if (packet.ShowMaximumWait)
+        {
+            Log.InGame($"The maximum wait time per person is {MillisToMinutes(packet.Timeout)} minutes.");
+        }
+    }
+
+    private static string MillisToMinutes(int milliseconds)
+    {
+        double minutes = milliseconds / 60000.0;
+        return Math.Round(minutes, 1).ToString();
+    }
+}

NitroxClient/Communication/Packets/Processors/PlayerSyncTimeoutProcessor.cs

@@ -0,0 +1,25 @@
+using NitroxClient.Communication.Abstract;
+using NitroxClient.Communication.Packets.Processors.Abstract;
+using NitroxClient.MonoBehaviours;
+using NitroxModel.Packets;
+
+namespace NitroxClient.Communication.Packets.Processors;
+
+public class PlayerSyncTimeoutProcessor : ClientPacketProcessor<PlayerSyncTimeout>
+{
+    private readonly IMultiplayerSession session;
+
+    public PlayerSyncTimeoutProcessor(IMultiplayerSession session)
+    {
+        this.session = session;
+    }
+
+    public override void Process(PlayerSyncTimeout packet)
+    {
+        // This will advance the coroutine in Multiplayer::LoadAsync() which quits to menu
+        Multiplayer.Main.InitialSyncCompleted = true;
+        Multiplayer.Main.TimedOut = true;
+
+        session.Disconnect();
+    }
+}

NitroxClient/MonoBehaviours/Multiplayer.cs

@@ -34,6 +34,7 @@ public class Multiplayer : MonoBehaviour
         private GameLogic.Terrain terrain;
 
         public bool InitialSyncCompleted { get; set; }
+        public bool TimedOut { get; set; }
 
         /// <summary>
         ///     True if multiplayer is loaded and client is connected to a server.
@@ -93,6 +94,7 @@ public static void SubnauticaLoadingCompleted()
             if (Active)
             {
                 Main.InitialSyncCompleted = false;
+                Main.TimedOut = false;
                 Main.StartCoroutine(LoadAsync());
             }
             else
@@ -113,11 +115,29 @@ public static IEnumerator LoadAsync()
 
             WaitScreen.Remove(worldSettleItem);
 
-            WaitScreen.ManualWaitItem item = WaitScreen.Add(Language.main.Get("Nitrox_JoiningSession"));
+            WaitScreen.ManualWaitItem joiningItem = WaitScreen.Add(Language.main.Get("Nitrox_JoiningSession"));
             yield return Main.StartCoroutine(Main.StartSession());
-            WaitScreen.Remove(item);
+            WaitScreen.Remove(joiningItem);
 
+            WaitScreen.ManualWaitItem waitingItem = WaitScreen.Add(Language.main.Get("Nitrox_Waiting"));
+            Log.InGame(Language.main.Get("Nitrox_Waiting"));
             yield return new WaitUntil(() => Main.InitialSyncCompleted);
+            WaitScreen.Remove(waitingItem);
+
+            if (Main.TimedOut)
+            {
+                int timer = 5;
+
+                while (timer > 0)
+                {
+                    Log.InGame($"Initial sync timed out. Quitting game in {timer} second{(timer > 1 ? "s" : "")}…");
+                    yield return new WaitForSecondsRealtime(1);
+                    timer--;
+                }
+
+                IngameMenu.main.QuitGame(false);
+                yield break;
+            }
 
             SetLoadingComplete();
             OnLoadingComplete?.Invoke();

NitroxModel/MultiplayerSession/MultiplayerSessionReservationState.cs

@@ -23,11 +23,8 @@ public enum MultiplayerSessionReservationState
         [Description("The server is using hardcore gamemode, player is dead.")]
         HARDCORE_PLAYER_DEAD = 1 << 4,
 
-        [Description("Another user is currently joining the server.")]
-        ENQUEUED_IN_JOIN_QUEUE = 1 << 5,
-
         [Description("The player name is invalid, It must not contain any space or doubtful characters\n Allowed characters : A-Z a-z 0-9 _ . -\nLength : [3, 25]")]
-        INCORRECT_USERNAME = 1 << 6
+        INCORRECT_USERNAME = 1 << 5
     }
 
     public static class MultiplayerSessionReservationStateExtensions

NitroxModel/Packets/JoinQueueInfo.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace NitroxModel.Packets;
+
+[Serializable]
+public class JoinQueueInfo : Packet
+{
+    public int Position { get; }
+    public int Timeout { get; }
+    public bool ShowMaximumWait { get; }
+
+    public JoinQueueInfo(int position, int timeout, bool showMaximumWait)
+    {
+        Position = position;
+        Timeout = timeout;
+        ShowMaximumWait = showMaximumWait;
+    }
+}

NitroxModel/Packets/PlayerSyncTimeout.cs

@@ -0,0 +1,6 @@
+using System;
+
+namespace NitroxModel.Packets;
+
+[Serializable]
+public class PlayerSyncTimeout : Packet { }

NitroxServer/Communication/LiteNetLib/LiteNetLibServer.cs

@@ -18,7 +18,7 @@ public class LiteNetLibServer : NitroxServer
     private readonly EventBasedNetListener listener;
     private readonly NetManager server;
 
-    public LiteNetLibServer(PacketHandler packetHandler, PlayerManager playerManager, EntitySimulation entitySimulation, ServerConfig serverConfig) : base(packetHandler, playerManager, entitySimulation, serverConfig)
+    public LiteNetLibServer(PacketHandler packetHandler, PlayerManager playerManager, JoiningManager joiningManager, EntitySimulation entitySimulation, ServerConfig serverConfig) : base(packetHandler, playerManager, joiningManager, entitySimulation, serverConfig)
     {
         listener = new EventBasedNetListener();
         server = new NetManager(listener);

NitroxServer/Communication/NitroxServer.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using NitroxModel.DataStructures;
 using NitroxModel.Packets;
@@ -25,11 +25,13 @@ static NitroxServer()
         protected readonly EntitySimulation entitySimulation;
         protected readonly Dictionary<int, INitroxConnection> connectionsByRemoteIdentifier = new();
         protected readonly PlayerManager playerManager;
+        protected readonly JoiningManager joiningManager;
 
-        public NitroxServer(PacketHandler packetHandler, PlayerManager playerManager, EntitySimulation entitySimulation, ServerConfig serverConfig)
+        public NitroxServer(PacketHandler packetHandler, PlayerManager playerManager, JoiningManager joiningManager, EntitySimulation entitySimulation, ServerConfig serverConfig)
         {
             this.packetHandler = packetHandler;
             this.playerManager = playerManager;
+            this.joiningManager = joiningManager;
             this.entitySimulation = entitySimulation;
 
             portNumber = serverConfig.ServerPort;
@@ -46,24 +48,23 @@ protected void ClientDisconnected(INitroxConnection connection)
         {
             Player player = playerManager.GetPlayer(connection);
 
-            if (player != null)
+            if (player == null)
             {
-                playerManager.PlayerDisconnected(connection);
+                joiningManager.JoiningPlayerDisconnected(connection);
+                return;
+            }
 
-                Disconnect disconnect = new(player.Id);
-                playerManager.SendPacketToAllPlayers(disconnect);
+            playerManager.PlayerDisconnected(connection);
 
-                List<SimulatedEntity> ownershipChanges = entitySimulation.CalculateSimulationChangesFromPlayerDisconnect(player);
+            Disconnect disconnect = new(player.Id);
+            playerManager.SendPacketToAllPlayers(disconnect);
 
-                if (ownershipChanges.Count > 0)
-                {
-                    SimulationOwnershipChange ownershipChange = new(ownershipChanges);
-                    playerManager.SendPacketToAllPlayers(ownershipChange);
-                }
-            }
-            else
+            List<SimulatedEntity> ownershipChanges = entitySimulation.CalculateSimulationChangesFromPlayerDisconnect(player);
+
+            if (ownershipChanges.Count > 0)
             {
-                playerManager.NonPlayerDisconnected(connection);
+                SimulationOwnershipChange ownershipChange = new(ownershipChanges);
+                playerManager.SendPacketToAllPlayers(ownershipChange);
             }
         }
 

NitroxServer/Communication/Packets/PacketHandler.cs

@@ -1,5 +1,6 @@
-using System;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using NitroxModel.Core;
 using NitroxModel.Packets;
 using NitroxModel.Packets.Processors.Abstract;
@@ -12,26 +13,28 @@ namespace NitroxServer.Communication.Packets
     public class PacketHandler
     {
         private readonly PlayerManager playerManager;
+        private readonly JoiningManager joiningManager;
         private readonly DefaultServerPacketProcessor defaultServerPacketProcessor;
         private readonly Dictionary<Type, PacketProcessor> packetProcessorAuthCache = new();
         private readonly Dictionary<Type, PacketProcessor> packetProcessorUnauthCache = new();
 
-        public PacketHandler(PlayerManager playerManager, DefaultServerPacketProcessor packetProcessor)
+        public PacketHandler(PlayerManager playerManager, JoiningManager joiningManager, DefaultServerPacketProcessor packetProcessor)
         {
             this.playerManager = playerManager;
+            this.joiningManager = joiningManager;
             defaultServerPacketProcessor = packetProcessor;
         }
 
         public void Process(Packet packet, INitroxConnection connection)
         {
             Player player = playerManager.GetPlayer(connection);
-            if (player == null)
+            if (player != null)
             {
-                ProcessUnauthenticated(packet, connection);
+                ProcessAuthenticated(packet, player);
             }
-            else
+            else if (!joiningManager.GetQueuedPlayers().Contains(connection))
             {
-                ProcessAuthenticated(packet, player);
+                ProcessUnauthenticated(packet, connection);
             }
         }