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 NitroxClient.Communication.Packets.Processors.Abstract;
+using NitroxModel.Packets;
+using System;
+
+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

@@ -32,6 +32,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.
@@ -85,6 +86,7 @@ public static void SubnauticaLoadingCompleted()
             if (Active)
             {
                 Main.InitialSyncCompleted = false;
+                Main.TimedOut = false;
                 Main.StartCoroutine(LoadAsync());
             }
             else
@@ -104,11 +106,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();
         }

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,3 @@
+namespace NitroxModel.Packets;
+
+public class PlayerSyncTimeout : Packet { }

NitroxServer/Communication/Packets/PacketHandler.cs

@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Linq;
 using System.Collections.Generic;
 using NitroxModel.Core;
 using NitroxModel.Packets;
@@ -25,13 +26,13 @@ public PacketHandler(PlayerManager playerManager, DefaultServerPacketProcessor p
         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 (!playerManager.GetQueuedPlayers().Contains(connection))
             {
-                ProcessAuthenticated(packet, player);
+                ProcessUnauthenticated(packet, connection);
             }
         }
 

NitroxServer/Communication/Packets/Processors/PlayerJoiningMultiplayerSessionProcessor.cs

@@ -1,117 +1,21 @@
-using System.Collections.Generic;
-using System.Linq;
-using NitroxModel.DataStructures;
-using NitroxModel.DataStructures.GameLogic;
-using NitroxModel.DataStructures.GameLogic.Entities;
-using NitroxModel.DataStructures.Unity;
-using NitroxModel.DataStructures.Util;
-using NitroxModel.Helper;
-using NitroxModel.MultiplayerSession;
 using NitroxModel.Packets;
 using NitroxServer.Communication.Packets.Processors.Abstract;
 using NitroxServer.GameLogic;
-using NitroxServer.GameLogic.Bases;
-using NitroxServer.GameLogic.Entities;
-using NitroxServer.Serialization.World;
 
 namespace NitroxServer.Communication.Packets.Processors
 {
     public class PlayerJoiningMultiplayerSessionProcessor : UnauthenticatedPacketProcessor<PlayerJoiningMultiplayerSession>
     {
         private readonly PlayerManager playerManager;
-        private readonly ScheduleKeeper scheduleKeeper;
-        private readonly StoryManager storyManager;
-        private readonly World world;
-        private readonly EntityRegistry entityRegistry;
-        private readonly BuildingManager buildingManager;
 
-        public PlayerJoiningMultiplayerSessionProcessor(ScheduleKeeper scheduleKeeper, StoryManager storyManager, PlayerManager playerManager, World world, EntityRegistry entityRegistry, BuildingManager buildingManager)
+        public PlayerJoiningMultiplayerSessionProcessor(PlayerManager playerManager)
         {
-            this.scheduleKeeper = scheduleKeeper;
-            this.storyManager = storyManager;
             this.playerManager = playerManager;
-            this.world = world;
-            this.entityRegistry = entityRegistry;
-            this.buildingManager = buildingManager;
         }
 
         public override void Process(PlayerJoiningMultiplayerSession packet, INitroxConnection connection)
         {
-            Player player = playerManager.PlayerConnected(connection, packet.ReservationKey, out bool wasBrandNewPlayer);
-            NitroxId assignedEscapePodId = world.EscapePodManager.AssignPlayerToEscapePod(player.Id, out Optional<EscapePodWorldEntity> newlyCreatedEscapePod);
-
-            if (newlyCreatedEscapePod.HasValue)
-            {
-                SpawnEntities spawnNewEscapePod = new(newlyCreatedEscapePod.Value);
-                playerManager.SendPacketToOtherPlayers(spawnNewEscapePod, player);
-            }
-
-            List<EquippedItemData> equippedItems = player.GetEquipment();
-
-            // Make players on localhost admin by default.
-            if (connection.Endpoint.Address.IsLocalhost())
-            {
-                Log.Info($"Granted admin to '{player.Name}' because they're playing on the host machine");
-                player.Permissions = Perms.ADMIN;
-            }
-
-            List<SimulatedEntity> simulations = world.EntitySimulation.AssignGlobalRootEntitiesAndGetData(player);
-
-            player.Entity = wasBrandNewPlayer ? SetupPlayerEntity(player) : RespawnExistingEntity(player); ;
-
-            List<GlobalRootEntity> globalRootEntities = world.WorldEntityManager.GetGlobalRootEntities(true);
-            bool isFirstPlayer = playerManager.GetConnectedPlayers().Count == 1;
-
-            InitialPlayerSync initialPlayerSync = new(player.GameObjectId,
-                wasBrandNewPlayer,
-                assignedEscapePodId,
-                equippedItems,
-                player.UsedItems,
-                player.QuickSlotsBindingIds,
-                world.GameData.PDAState.GetInitialPDAData(),
-                world.GameData.StoryGoals.GetInitialStoryGoalData(scheduleKeeper, player),
-                player.Position,
-                player.Rotation,
-                player.SubRootId,
-                player.Stats,
-                GetOtherPlayers(player),
-                globalRootEntities,
-                simulations,
-                player.GameMode,
-                player.Permissions,
-                new(new(player.PingInstancePreferences), player.PinnedRecipePreferences.ToList()),
-                storyManager.GetTimeData(),
-                isFirstPlayer,
-                BuildingManager.GetEntitiesOperations(globalRootEntities)
-            );
-
-            player.SendPacket(initialPlayerSync);
-        }
-
-        private IEnumerable<PlayerContext> GetOtherPlayers(Player player)
-        {
-            return playerManager.GetConnectedPlayers().Where(p => p != player)
-                                                      .Select(p => p.PlayerContext);
-        }
-
-        private PlayerWorldEntity SetupPlayerEntity(Player player)
-        {
-            NitroxTransform transform = new(player.Position, player.Rotation, NitroxVector3.One);
-
-            PlayerWorldEntity playerEntity = new PlayerWorldEntity(transform, 0, null, false, player.GameObjectId, NitroxTechType.None, null, null, new List<Entity>());
-            entityRegistry.AddOrUpdate(playerEntity);
-            world.WorldEntityManager.TrackEntityInTheWorld(playerEntity);
-            return playerEntity;
-        }
-
-        private PlayerWorldEntity RespawnExistingEntity(Player player)
-        {
-            if (entityRegistry.TryGetEntityById(player.PlayerContext.PlayerNitroxId, out PlayerWorldEntity playerWorldEntity))
-            {
-                return playerWorldEntity;
-            }
-            Log.Error($"Unable to find player entity for {player.Name}. Re-creating one");
-            return SetupPlayerEntity(player);
+            playerManager.AddToJoinQueue(connection, packet.ReservationKey);
         }
     }
 }

NitroxServer/Communication/Packets/Processors/PlayerSyncFinishedProcessor.cs

@@ -21,7 +21,7 @@ public override void Process(PlayerSyncFinished packet, Player player)
                 Server.Instance.ResumeServer();
             }
 
-            playerManager.FinishProcessingReservation(player);
+            playerManager.SyncFinishedCallback?.Invoke();
         }
     }
 }