From 95ed3da300ad458b1fac47c7958e453dc4ba355e Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Thu, 28 Sep 2023 15:57:22 +0200
Subject: [PATCH 01/14] Handle uncatched MainMenu errors from Sn Update

---
 ...LoadButton_RestoreParentsSettings_Patch.cs | 19 ++++++++++++++++
 .../SystemsSpawner_SetupSingleton_Patch.cs    | 22 +++++++++++++++++++
 2 files changed, 41 insertions(+)
 create mode 100644 NitroxPatcher/Patches/Persistent/MainMenuLoadButton_RestoreParentsSettings_Patch.cs
 create mode 100644 NitroxPatcher/Patches/Persistent/SystemsSpawner_SetupSingleton_Patch.cs

diff --git a/NitroxPatcher/Patches/Persistent/MainMenuLoadButton_RestoreParentsSettings_Patch.cs b/NitroxPatcher/Patches/Persistent/MainMenuLoadButton_RestoreParentsSettings_Patch.cs
new file mode 100644
index 0000000000..97afc16037
--- /dev/null
+++ b/NitroxPatcher/Patches/Persistent/MainMenuLoadButton_RestoreParentsSettings_Patch.cs
@@ -0,0 +1,19 @@
+using System.Reflection;
+using NitroxModel.Helper;
+using UnityEngine.UI;
+
+namespace NitroxPatcher.Patches.Persistent;
+
+/// <summary>
+/// MainMenuLoadButton.RestoreParentsSettings() is throwing null refs because we copy it for our MainMenu and then destroy it.
+/// Unfortunately OnDestroy can't be prevented when destroying MBs so we fix the NRE here.
+/// </summary>
+public sealed partial class MainMenuLoadButton_RestoreParentsSettings_Patch : NitroxPatch, IPersistentPatch
+{
+    private static readonly MethodInfo TARGET_METHOD = Reflect.Method((MainMenuLoadButton lb) => lb.RestoreParentsSettings());
+
+    public static bool Prefix(GridLayoutGroup ___gridLayoutGroup, ScrollRect ___scrollRect)
+    {
+        return ___gridLayoutGroup && ___scrollRect;
+    }
+}
diff --git a/NitroxPatcher/Patches/Persistent/SystemsSpawner_SetupSingleton_Patch.cs b/NitroxPatcher/Patches/Persistent/SystemsSpawner_SetupSingleton_Patch.cs
new file mode 100644
index 0000000000..dc48a687b0
--- /dev/null
+++ b/NitroxPatcher/Patches/Persistent/SystemsSpawner_SetupSingleton_Patch.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Reflection;
+using HarmonyLib;
+using NitroxModel.Helper;
+
+namespace NitroxPatcher.Patches.Persistent;
+
+/// <summary>
+///     Patch to suppress SentrySdk NRE as it's destroyed by us
+/// </summary>
+public sealed partial class SystemsSpawner_SetupSingleton_Patch : NitroxPatch, IPersistentPatch
+{
+    private static readonly MethodInfo TARGET_METHOD = AccessTools.EnumeratorMoveNext(Reflect.Method((SystemsSpawner s) => s.SetupSingleton(default)));
+
+    public static void Finalizer(ref Exception __exception)
+    {
+        if (__exception is NullReferenceException)
+        {
+            __exception = null;
+        }
+    }
+}

From 5c30d7145fb727d0e2915c567c93935d94281f7a Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Sat, 24 Jun 2023 17:42:00 +0200
Subject: [PATCH 02/14] Add controller support for server list

---
 .../MonoBehaviours/Discord/DiscordClient.cs   |   3 +-
 .../Gui/MainMenu/MainMenuAddServerWindow.cs   | 158 ++++++
 .../Gui/MainMenu/MainMenuMods.cs              |   1 +
 .../Gui/MainMenu/MainMenuMultiplayerPanel.cs  | 494 ++++++++----------
 .../Gui/MainMenu/MainMenuServerButton.cs      | 136 +++++
 5 files changed, 505 insertions(+), 287 deletions(-)
 create mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuAddServerWindow.cs
 create mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs

diff --git a/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs b/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs
index 8fb6a0dd1b..ea935fff2b 100644
--- a/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs
+++ b/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs
@@ -109,7 +109,8 @@ private void ActivityJoin(string secret)
         string[] splitSecret = secret.Split(':');
         string ip = string.Join(":", splitSecret.Take(splitSecret.Length - 1));
         string port = splitSecret.Last();
-        _ = MainMenuMultiplayerPanel.OpenJoinServerMenuAsync(ip, port);
+        int portInt = int.Parse(port);
+        _ = MainMenuServerButton.OpenJoinServerMenuAsync(ip, portInt);
     }
 
     private void ActivityJoinRequest(ref User user)
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuAddServerWindow.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuAddServerWindow.cs
new file mode 100644
index 0000000000..f156428aa3
--- /dev/null
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuAddServerWindow.cs
@@ -0,0 +1,158 @@
+using System.Collections;
+using NitroxClient.Unity.Helper;
+using NitroxModel.Serialization;
+using UnityEngine;
+using UWE;
+
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
+
+public static class MainMenuAddServerWindow
+{
+    private static Rect addServerWindowRect = new(Screen.width / 2 - 250, 200, 500, 200);
+
+    private static string serverHostInput;
+    private static string serverNameInput;
+    private static string serverPortInput;
+
+    private static bool shouldFocus;
+    private static bool showingAddServer;
+
+    public static void OnExternalGUI()
+    {
+        if (showingAddServer)
+        {
+            addServerWindowRect = GUILayout.Window(GUIUtility.GetControlID(FocusType.Keyboard), addServerWindowRect, DoAddServerWindow, Language.main.Get("Nitrox_AddServer"));
+        }
+    }
+
+    public static void ShowAddServerWindow()
+    {
+        serverNameInput = "local";
+        serverHostInput = "127.0.0.1";
+        serverPortInput = ServerList.DEFAULT_PORT.ToString();
+        showingAddServer = true;
+        shouldFocus = true;
+        uGUI_MainMenu.main.canvasGroup.interactable = false;
+    }
+
+    public static void HideAddServerWindow()
+    {
+        IEnumerator SetWindowComponents()
+        {
+            showingAddServer = false;
+            shouldFocus = true;
+            yield return null;
+            uGUI_MainMenu.main.canvasGroup.interactable = true;
+        }
+
+        CoroutineHost.StartCoroutine(SetWindowComponents());
+    }
+
+    private static void OnAddServerButtonClicked()
+    {
+        serverNameInput = serverNameInput.Trim();
+        serverHostInput = serverHostInput.Trim();
+        if (int.TryParse(serverPortInput.Trim(), out int serverPort))
+        {
+            MainMenuMultiplayerPanel.Main.CreateServerButton(serverNameInput, serverHostInput, serverPort);
+            ServerList.Instance.Add(new ServerList.Entry(serverNameInput, serverHostInput, serverPort));
+            ServerList.Instance.Save();
+
+            HideAddServerWindow();
+        }
+        else
+        {
+            Log.InGame("Server port was not a valid number!");
+        }
+    }
+
+    private static void OnCancelButtonClicked()
+    {
+        HideAddServerWindow();
+    }
+
+    private static void DoAddServerWindow(int windowId)
+    {
+        Event e = Event.current;
+        if (e.isKey)
+        {
+            switch (e.keyCode)
+            {
+                case KeyCode.Return:
+                    OnAddServerButtonClicked();
+                    break;
+                case KeyCode.Escape:
+                    OnCancelButtonClicked();
+                    break;
+            }
+        }
+
+        GUISkinUtils.RenderWithSkin(GetGUISkin(),
+                                    () =>
+                                    {
+                                        using (new GUILayout.VerticalScope("Box"))
+                                        {
+                                            using (new GUILayout.HorizontalScope())
+                                            {
+                                                GUILayout.Label(Language.main.Get("Nitrox_AddServerName"));
+                                                GUI.SetNextControlName("serverNameField");
+                                                // 120 so users can't go too crazy.
+                                                serverNameInput = GUILayout.TextField(serverNameInput, 120);
+                                            }
+
+                                            using (new GUILayout.HorizontalScope())
+                                            {
+                                                GUILayout.Label(Language.main.Get("Nitrox_AddServerHost"));
+                                                GUI.SetNextControlName("serverHostField");
+                                                // 120 so users can't go too crazy.
+                                                serverHostInput = GUILayout.TextField(serverHostInput, 120);
+                                            }
+
+                                            using (new GUILayout.HorizontalScope())
+                                            {
+                                                GUILayout.Label(Language.main.Get("Nitrox_AddServerPort"));
+                                                GUI.SetNextControlName("serverPortField");
+                                                serverPortInput = GUILayout.TextField(serverPortInput);
+                                            }
+
+                                            if (GUILayout.Button(Language.main.Get("Nitrox_AddServerAdd")))
+                                            {
+                                                OnAddServerButtonClicked();
+                                            }
+
+                                            if (GUILayout.Button(Language.main.Get("Nitrox_Cancel")))
+                                            {
+                                                OnCancelButtonClicked();
+                                            }
+                                        }
+                                    });
+
+        if (shouldFocus)
+        {
+            GUI.FocusControl("serverNameField");
+            shouldFocus = false;
+        }
+    }
+
+    private static GUISkin GetGUISkin()
+    {
+        return GUISkinUtils.RegisterDerivedOnce("menus.server",
+                                                s =>
+                                                {
+                                                    s.textField.fontSize = 14;
+                                                    s.textField.richText = false;
+                                                    s.textField.alignment = TextAnchor.MiddleLeft;
+                                                    s.textField.wordWrap = true;
+                                                    s.textField.stretchHeight = true;
+                                                    s.textField.padding = new RectOffset(10, 10, 5, 5);
+
+                                                    s.label.fontSize = 14;
+                                                    s.label.alignment = TextAnchor.MiddleRight;
+                                                    s.label.stretchHeight = true;
+                                                    s.label.fixedWidth = 80; //change this when adding new labels that need more space.
+
+                                                    s.button.fontSize = 14;
+                                                    s.button.stretchHeight = true;
+                                                });
+    }
+}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs
index 9743a976b2..c3532d3925 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs
@@ -55,6 +55,7 @@ private void MultiplayerMenuMods()
             header.GetComponent<TranslationLiveUpdate>().translationKey = "Nitrox_Multiplayer";
             Destroy(loadedMultiplayer.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame"));
             Destroy(loadedMultiplayer.GetComponent<MainMenuLoadPanel>());
+            Destroy(loadedMultiplayer.GetComponentInChildren<MainMenuLoadMenu>());
 
             loadedMultiplayer.AddComponent<MainMenuMultiplayerPanel>().Setup(loadedMultiplayer, savedGamesRef);
 
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs
index 596457fa77..eaccaf0ff4 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs
@@ -1,350 +1,272 @@
-using System;
-using System.Collections;
 using System.Net;
-using System.Net.Sockets;
+using FMODUnity;
 using NitroxClient.Communication;
 using NitroxClient.GameLogic.Settings;
 using NitroxClient.Unity.Helper;
 using NitroxModel.Serialization;
 using TMPro;
 using UnityEngine;
-using UnityEngine.Events;
 using UnityEngine.UI;
-using UWE;
 
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
+
+public class MainMenuMultiplayerPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver
 {
-    public class MainMenuMultiplayerPanel : MonoBehaviour
+    public static MainMenuMultiplayerPanel Main;
+
+    private GameObject multiplayerButtonRef;
+
+    private Sprite normalSprite;
+    private Sprite selectedSprite;
+    private FMODAsset hoverSound;
+
+    private Transform serverAreaContent;
+    private GameObject selectedServerItem;
+
+    public JoinServer JoinServer { get; private set; }
+    public bool IsJoining{ get; set; }
+
+
+    public void Setup(GameObject loadedMultiplayer, GameObject savedGamesRef)
     {
-        public static MainMenuMultiplayerPanel Main;
-        private Rect addServerWindowRect = new(Screen.width / 2 - 250, 200, 500, 200);
-        private GameObject loadedMultiplayerRef;
-        private GameObject savedGamesRef;
-        private GameObject deleteButtonRef;
-        private GameObject multiplayerButton;
-        private Transform savedGameAreaContent;
-        public JoinServer JoinServer { get; private set; }
-
-        private string serverHostInput;
-        private string serverNameInput;
-        private string serverPortInput;
-
-        private bool shouldFocus;
-        private bool showingAddServer;
-        private bool isJoining;
-
-        public void Setup(GameObject loadedMultiplayer, GameObject savedGames)
-        {
-            Main = this;
-            loadedMultiplayerRef = loadedMultiplayer;
-            savedGamesRef = savedGames;
-
-            //This sucks, but the only way around it is to establish a Subnautica resources cache and reference it everywhere we need it.
-            //Given recent push-back on elaborate designs, I've just crammed it here until we can all get on the same page as far as code-quality standards are concerned.
-            JoinServer = new GameObject("NitroxJoinServer").AddComponent<JoinServer>();
-            JoinServer.Setup(savedGamesRef);
-
-            multiplayerButton = savedGamesRef.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame");
-            savedGameAreaContent = loadedMultiplayerRef.RequireTransform("Scroll View/Viewport/SavedGameAreaContent");
-            deleteButtonRef = savedGamesRef.GetComponent<MainMenuLoadPanel>().saveInstance.GetComponent<MainMenuLoadButton>().deleteButton;
-
-            CreateButton(translationKey: "Nitrox_AddServer", clickEvent: ShowAddServerWindow, disableTranslation: false);
-            LoadSavedServers();
-            _ = FindLANServersAsync();
-        }
+        Main = this;
 
-        private void CreateButton(string translationKey, UnityAction clickEvent, bool disableTranslation)
-        {
-            GameObject multiplayerButtonInst = Instantiate(multiplayerButton, savedGameAreaContent, false);
-            Transform txt = multiplayerButtonInst.RequireTransform("NewGameButton/Text");
-            txt.GetComponent<TextMeshProUGUI>().text = translationKey;
+        //This sucks, but the only way around it is to establish a Subnautica resources cache and reference it everywhere we need it.
+        //Given recent push-back on elaborate designs, I've just crammed it here until we can all get on the same page as far as code-quality standards are concerned.
+        JoinServer = new GameObject("NitroxJoinServer").AddComponent<JoinServer>();
+        JoinServer.Setup(savedGamesRef);
 
-            if (disableTranslation)
-            {
-                Destroy(txt.GetComponent<TranslationLiveUpdate>());
-            }
+        MainMenuLoadMenu loadMenu = loadedMultiplayer.GetComponentInChildren<MainMenuLoadMenu>();
+        normalSprite = loadMenu.normalSprite;
+        selectedSprite = loadMenu.selectedSprite;
+        hoverSound = loadMenu.hoverSound;
 
-            Button multiplayerButtonButton = multiplayerButtonInst.RequireTransform("NewGameButton").GetComponent<Button>();
-            multiplayerButtonButton.onClick = new Button.ButtonClickedEvent();
-            multiplayerButtonButton.onClick.AddListener(clickEvent);
-        }
+        serverAreaContent = loadedMultiplayer.RequireTransform("Scroll View/Viewport/SavedGameAreaContent");
+        multiplayerButtonRef = savedGamesRef.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame");
+
+        MainMenuLoadButton loadButtonRef = savedGamesRef.GetComponent<MainMenuLoadPanel>().saveInstance.GetComponent<MainMenuLoadButton>();
+        MainMenuServerButton.Setup(loadButtonRef);
 
-        private void CreateServerButton(string text, string joinIp, string joinPort, bool isReadOnly = false)
+        CreateAddServerButton();
+        LoadSavedServers();
+        _ = FindLANServersAsync();
+    }
+
+    public bool OnButtonDown(GameInput.Button button)
+    {
+        switch (button)
         {
-            GameObject multiplayerButtonInst = Instantiate(multiplayerButton, savedGameAreaContent, false);
-            multiplayerButtonInst.name = (savedGameAreaContent.childCount - 1).ToString();
-            Transform txt = multiplayerButtonInst.RequireTransform("NewGameButton/Text");
-            txt.GetComponent<TextMeshProUGUI>().text = text;
-            Color prevTextColor = txt.GetComponent<TextMeshProUGUI>().color;
-            Destroy(txt.GetComponent<TranslationLiveUpdate>());
-            Button multiplayerButtonButton = multiplayerButtonInst.RequireTransform("NewGameButton").GetComponent<Button>();
-            multiplayerButtonButton.onClick = new Button.ButtonClickedEvent();
-            multiplayerButtonButton.onClick.AddListener(async () =>
-            {
-                if (isJoining)
-                {
-                    // Do not attempt to join multiple servers.
-                    return;
-                }
-                isJoining = true;
-
-                txt.GetComponent<TextMeshProUGUI>().color = prevTextColor; // Visual fix for black text after click (hover state still active)
-                await OpenJoinServerMenuAsync(joinIp, joinPort)
-                    .ContinueWith(t =>
-                    {
-                        isJoining = false;
-                    });
-            });
-
-            // We don't want servers that are discovered automatically to be deleted
-            if (!isReadOnly)
-            {
-                GameObject delete = Instantiate(deleteButtonRef, multiplayerButtonInst.transform, false);
-                Button deleteButtonButton = delete.GetComponent<Button>();
-                deleteButtonButton.onClick = new Button.ButtonClickedEvent();
-                deleteButtonButton.onClick.AddListener(() =>
-                {
-                    ServerList.Instance.RemoveAt(multiplayerButtonInst.transform.GetSiblingIndex() - 1);
-                    ServerList.Instance.Save();
-                    Destroy(multiplayerButtonInst);
-                });
-            }
+            case GameInput.Button.UISubmit:
+                OnConfirm();
+                return true;
+            case GameInput.Button.UICancel:
+                OnBack();
+                return true;
+            case GameInput.Button.UIClear:
+                OnClear();
+                return true;
+            default:
+                return false;
         }
+    }
 
-        public static async System.Threading.Tasks.Task OpenJoinServerMenuAsync(string serverIp, string serverPort)
-        {
-            if (Main == null)
-            {
-                Log.Error("MainMenuMultiplayerPanel is not instantiated although OpenJoinServerMenu is called.");
-                return;
-            }
-            IPEndPoint endpoint = ResolveIPEndPoint(serverIp, serverPort);
-            if (endpoint == null)
-            {
-                Log.ErrorSensitive("Unable to contact the remote server at: {ip}:{port}", serverIp, serverPort);
-                Log.InGame($"{Language.main.Get("Nitrox_UnableToConnect")} {serverIp}:{serverPort}");
-                return;
-            }
+    public void OnBack()
+    {
+        MainMenuAddServerWindow.HideAddServerWindow();
+        MainMenuRightSide.main.OpenGroup("Home");
+    }
 
-            await Main.JoinServer.ShowAsync(endpoint.Address.ToString(), endpoint.Port);
+    public void OnClear()
+    {
+        if (selectedServerItem && selectedServerItem.TryGetComponent(out MainMenuServerButton serverButton))
+        {
+            serverButton.RequestDelete();
         }
+    }
 
-        private void ShowAddServerWindow()
+    public void OnConfirm()
+    {
+        if (!selectedServerItem)
         {
-            serverNameInput = "local";
-            serverHostInput = "127.0.0.1";
-            serverPortInput = ServerList.DEFAULT_PORT.ToString();
-            showingAddServer = true;
-            shouldFocus = true;
-            uGUI_MainMenu.main.canvasGroup.interactable = false;
+            return;
         }
 
-        private void HideAddServerWindow()
+        if (selectedServerItem.gameObject.name == "NewServer")
         {
-            IEnumerator SetWindowComponents()
-            {
-                showingAddServer = false;
-                shouldFocus = true;
-                yield return null;
-                uGUI_MainMenu.main.canvasGroup.interactable = true;
-            }
-            CoroutineHost.StartCoroutine(SetWindowComponents());
+            selectedServerItem.GetComponentInChildren<Button>().onClick.Invoke();
         }
-
-        private void OnGUI()
+        else if(selectedServerItem.TryGetComponent(out MainMenuServerButton serverButton))
         {
-            if (showingAddServer)
-            {
-                addServerWindowRect = GUILayout.Window(GUIUtility.GetControlID(FocusType.Keyboard), addServerWindowRect, DoAddServerWindow, Language.main.Get("Nitrox_AddServer"));
-            }
+            serverButton.OnJoinButtonClicked();
         }
+    }
+
+    object uGUI_INavigableIconGrid.GetSelectedItem() => selectedServerItem;
+
+    bool uGUI_INavigableIconGrid.ShowSelector => false;
+
+    bool uGUI_INavigableIconGrid.EmulateRaycast => false;
+    bool uGUI_INavigableIconGrid.SelectItemClosestToPosition(Vector3 worldPos) => false;
+    uGUI_INavigableIconGrid uGUI_INavigableIconGrid.GetNavigableGridInDirection(int dirX, int dirY) => null;
+
+    Graphic uGUI_INavigableIconGrid.GetSelectedIcon() => null;
 
-        private void LoadSavedServers()
+    public void SelectItem(object item)
+    {
+        DeselectItem();
+        selectedServerItem = item as GameObject;
+
+        if (selectedServerItem.TryGetComponentInChildren(out mGUI_Change_Legend_On_Select componentInChildren))
         {
-            ServerList.Refresh();
-            foreach (ServerList.Entry entry in ServerList.Instance.Entries)
-            {
-                CreateServerButton(MakeButtonText(entry.Name, entry.Address, entry.Port), $"{entry.Address}", $"{entry.Port}");
-            }
+            componentInChildren.SyncLegendBarToGUISelection();
         }
 
-        private async System.Threading.Tasks.Task FindLANServersAsync()
-        {
-            void AddButton(IPEndPoint serverEndPoint)
-            {
-                // Add ServerList entry to keep indices in sync with servers UI, to enable removal by index
-                ServerList.Instance.Add(new("LAN Server", $"{serverEndPoint.Address}", $"{serverEndPoint.Port}", false));
-                CreateServerButton(MakeButtonText("LAN Server", serverEndPoint.Address, serverEndPoint.Port), $"{serverEndPoint.Address}", $"{serverEndPoint.Port}", true);
-            }
+        UIUtils.ScrollToShowItemInCenter(selectedServerItem.transform);
 
-            LANBroadcastClient.ServerFound += AddButton;
-            await LANBroadcastClient.SearchAsync();
-            LANBroadcastClient.ServerFound -= AddButton;
-        }
+        selectedServerItem.transform.GetChild(0).GetComponent<Image>().sprite = selectedSprite;
+        selectedServerItem.GetComponentInChildren<TextMeshProUGUI>().color = Color.black;
+        RuntimeManager.PlayOneShot(this.hoverSound.path);
+    }
 
-        private string MakeButtonText(string serverName, object address, object port)
+    public void DeselectItem()
+    {
+        if (!selectedServerItem)
         {
-            return $"{Language.main.Get("Nitrox_ConnectTo")} <b>{serverName}</b>\n{HideIfNecessary(address)}:{HideIfNecessary(port)}";
+            return;
         }
-        private static string HideIfNecessary(object text)
+
+        selectedServerItem.transform.GetChild(0).GetComponent<Image>().sprite = normalSprite;
+        selectedServerItem.GetComponentInChildren<TextMeshProUGUI>().color = Color.white;
+        selectedServerItem = null;
+    }
+
+
+    public bool SelectFirstItem()
+    {
+        MainMenuServerButton firstServerObject = serverAreaContent.GetComponentInChildren<MainMenuServerButton>();
+        if (firstServerObject)
         {
-            return NitroxPrefs.HideIp.Value ? "****" : $"{text}";
+            SelectItem(firstServerObject.gameObject);
+            return true;
         }
 
-        private static IPEndPoint ResolveIPEndPoint(string serverIp, string serverPort)
+        Transform serverCreationButton = serverAreaContent.GetChild(0);
+        if (serverCreationButton && serverCreationButton.name == "NewServer")
         {
-            UriHostNameType hostType = Uri.CheckHostName(serverIp);
-            IPAddress address;
-            switch (hostType)
-            {
-                case UriHostNameType.IPv4:
-                case UriHostNameType.IPv6:
-                    IPAddress.TryParse(serverIp, out address);
-                    break;
-                case UriHostNameType.Dns:
-                    address = ResolveHostName(serverIp, serverPort);
-                    break;
-                default:
-                    return null;
-            }
+            SelectItem(serverCreationButton.gameObject);
+            return true;
+        }
 
-            if (address == null)
-            {
-                return null;
-            }
-            return new IPEndPoint(address, int.Parse(serverPort));
+        return false;
+    }
+
+
+    public bool SelectItemInDirection(int dirX, int dirY)
+    {
+        if (selectedServerItem)
+        {
+            return dirY != 0 && SelectItemInYDirection(GetSelectedIndex(), dirY);
         }
 
-        private static IPAddress ResolveHostName(string hostname, string serverPort)
+        return SelectFirstItem();
+    }
+
+    public int GetSelectedIndex() => selectedServerItem ? selectedServerItem.transform.GetSiblingIndex() : -1;
+
+    public bool SelectItemInYDirection(int selectedIndex, int dirY)
+    {
+        int dir = dirY > 0 ? 1 : -1;
+        for (int newIndex =  selectedIndex + dir; newIndex >= 0 && newIndex < serverAreaContent.childCount; newIndex += dir)
         {
-            try
-            {
-                IPHostEntry hostEntry = Dns.GetHostEntry(hostname);
-                return hostEntry.AddressList[0];
-            }
-            catch (SocketException ex)
+            if (SelectItemByIndex(newIndex))
             {
-                Log.ErrorSensitive(ex, "Unable to resolve the address {hostname}:{serverPort}", hostname, serverPort);
-                return null;
+                return true;
             }
         }
+        return false;
+    }
 
-        private void OnAddServerButtonClicked()
+    private bool SelectItemByIndex(int selectedIndex)
+    {
+        if (selectedIndex < serverAreaContent.childCount && selectedIndex >= 0)
         {
-            serverNameInput = serverNameInput.Trim();
-            serverHostInput = serverHostInput.Trim();
-            serverPortInput = serverPortInput.Trim();
-            ServerList.Instance.Add(new ServerList.Entry(serverNameInput, serverHostInput, serverPortInput));
-            ServerList.Instance.Save();
-            CreateServerButton(MakeButtonText(serverNameInput, serverHostInput, serverPortInput), serverHostInput, serverPortInput);
-            HideAddServerWindow();
+            SelectItem(serverAreaContent.GetChild(selectedIndex).gameObject);
+            return true;
         }
 
-        private void OnCancelButtonClicked()
+        return false;
+    }
+
+
+
+
+
+    private void OnGUI()
+    {
+        MainMenuAddServerWindow.OnExternalGUI();
+    }
+
+    private void LoadSavedServers()
+    {
+        ServerList.Refresh();
+        foreach (ServerList.Entry entry in ServerList.Instance.Entries)
         {
-            HideAddServerWindow();
+            CreateServerButton(entry.Name, entry.Address, entry.Port);
         }
+    }
 
-        private GUISkin GetGUISkin()
+    private async System.Threading.Tasks.Task FindLANServersAsync()
+    {
+        void AddButton(IPEndPoint serverEndPoint)
         {
-            return GUISkinUtils.RegisterDerivedOnce("menus.server",
-                s =>
-                {
-                    s.textField.fontSize = 14;
-                    s.textField.richText = false;
-                    s.textField.alignment = TextAnchor.MiddleLeft;
-                    s.textField.wordWrap = true;
-                    s.textField.stretchHeight = true;
-                    s.textField.padding = new RectOffset(10, 10, 5, 5);
-
-                    s.label.fontSize = 14;
-                    s.label.alignment = TextAnchor.MiddleRight;
-                    s.label.stretchHeight = true;
-                    s.label.fixedWidth = 80; //change this when adding new labels that need more space.
-
-                    s.button.fontSize = 14;
-                    s.button.stretchHeight = true;
-                });
+            // Add ServerList entry to keep indices in sync with servers UI, to enable removal by index
+            ServerList.Instance.Add(new("LAN Server", $"{serverEndPoint.Address}", $"{serverEndPoint.Port}", false));
+            CreateServerButton("LAN Server", serverEndPoint.Address.ToString(), serverEndPoint.Port, true);
         }
 
-        private void DoAddServerWindow(int windowId)
-        {
-            Event e = Event.current;
-            if (e.isKey)
-            {
-                switch (e.keyCode)
-                {
-                    case KeyCode.Return:
-                        OnAddServerButtonClicked();
-                        break;
-                    case KeyCode.Escape:
-                        OnCancelButtonClicked();
-                        break;
-                }
-            }
+        LANBroadcastClient.ServerFound += AddButton;
+        await LANBroadcastClient.SearchAsync();
+        LANBroadcastClient.ServerFound -= AddButton;
+    }
 
-            GUISkinUtils.RenderWithSkin(GetGUISkin(),
-                () =>
-                {
-                    using (new GUILayout.VerticalScope("Box"))
-                    {
-                        using (new GUILayout.HorizontalScope())
-                        {
-                            GUILayout.Label(Language.main.Get("Nitrox_AddServerName"));
-                            GUI.SetNextControlName("serverNameField");
-                            // 120 so users can't go too crazy.
-                            serverNameInput = GUILayout.TextField(serverNameInput, 120);
-                        }
-
-                        using (new GUILayout.HorizontalScope())
-                        {
-                            GUILayout.Label(Language.main.Get("Nitrox_AddServerHost"));
-                            GUI.SetNextControlName("serverHostField");
-                            // 120 so users can't go too crazy.
-                            serverHostInput = GUILayout.TextField(serverHostInput, 120);
-                        }
-
-                        using (new GUILayout.HorizontalScope())
-                        {
-                            GUILayout.Label(Language.main.Get("Nitrox_AddServerPort"));
-                            GUI.SetNextControlName("serverPortField");
-                            serverPortInput = GUILayout.TextField(serverPortInput);
-                        }
-
-                        if (GUILayout.Button(Language.main.Get("Nitrox_AddServerAdd")))
-                        {
-                            OnAddServerButtonClicked();
-                        }
-
-                        if (GUILayout.Button(Language.main.Get("Nitrox_Cancel")))
-                        {
-                            OnCancelButtonClicked();
-                        }
-                    }
-                });
-
-            if (shouldFocus)
-            {
-                GUI.FocusControl("serverNameField");
-                shouldFocus = false;
-            }
-        }
+    public void CreateServerButton(string serverName, string address, int port, bool isReadOnly = false)
+    {
+        string HideIfNecessary(object text) => NitroxPrefs.HideIp.Value ? "****" : $"{text}";
 
-        public void RefreshServerEntries()
-        {
-            if (!savedGameAreaContent)
-            {
-                return;
-            }
+        GameObject multiplayerButtonInst = Instantiate(multiplayerButtonRef, serverAreaContent, false);
+        multiplayerButtonInst.name = $"NitroxServer_{serverAreaContent.childCount - 1}";
 
-            foreach (Transform child in savedGameAreaContent)
-            {
-                Destroy(child.gameObject);
-            }
+        string text = $"{Language.main.Get("Nitrox_ConnectTo")} <b>{serverName}</b>\n{HideIfNecessary(address)}:{HideIfNecessary(port)}";
+        MainMenuServerButton serverButton = multiplayerButtonInst.AddComponent<MainMenuServerButton>();
+        serverButton.Init(text, address, port, isReadOnly);
+    }
+
+    private void CreateAddServerButton()
+    {
+        GameObject multiplayerButtonInst = Instantiate(multiplayerButtonRef, serverAreaContent, false);
+        multiplayerButtonInst.name = "NewServer"; // "NewServer" is important, see OnConfirm()
+        Transform txt = multiplayerButtonInst.RequireTransform("NewGameButton/Text");
+        txt.GetComponent<TextMeshProUGUI>().text = "Nitrox_AddServer";
+
+        Button multiplayerButtonButton = multiplayerButtonInst.RequireTransform("NewGameButton").GetComponent<Button>();
+        multiplayerButtonButton.onClick = new Button.ButtonClickedEvent();
+        multiplayerButtonButton.onClick.AddListener(MainMenuAddServerWindow.ShowAddServerWindow);
+    }
 
-            CreateButton(translationKey: "Nitrox_AddServer", clickEvent: ShowAddServerWindow, disableTranslation: false);
-            LoadSavedServers();
-            _ = FindLANServersAsync();
+    public void RefreshServerEntries()
+    {
+        if (!serverAreaContent)
+        {
+            return;
+        }
+
+        foreach (Transform child in serverAreaContent)
+        {
+            Destroy(child.gameObject);
         }
+
+        CreateAddServerButton();
+        LoadSavedServers();
+        _ = FindLANServersAsync();
     }
 }
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs
new file mode 100644
index 0000000000..1cc4dae13c
--- /dev/null
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs
@@ -0,0 +1,136 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using NitroxClient.Unity.Helper;
+using NitroxModel.Serialization;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
+
+public class MainMenuServerButton : MonoBehaviour
+{
+    private static LegendButtonData[] confirmButtonLegendData;
+    private static GameObject deleteButtonRef;
+
+    private string joinIp;
+    private int joinPort;
+
+    public static void Setup(MainMenuLoadButton loadButtonRef)
+    {
+        confirmButtonLegendData = loadButtonRef.GetComponent<mGUI_Change_Legend_On_Select>().legendButtonConfiguration;
+        deleteButtonRef = loadButtonRef.deleteButton;
+    }
+
+    public void Init(string text, string ip, int port, bool isReadOnly)
+    {
+        joinIp = ip;
+        joinPort = port;
+
+        Transform newGameButtonTransform = this.RequireTransform("NewGameButton");
+
+        TextMeshProUGUI tmp = newGameButtonTransform.RequireTransform("Text").GetComponent<TextMeshProUGUI>();
+        tmp.text = text;
+        Destroy(tmp.GetComponent<TranslationLiveUpdate>());
+
+        Button multiplayerJoinButton = newGameButtonTransform.GetComponent<Button>();
+        multiplayerJoinButton.onClick = new Button.ButtonClickedEvent();
+        multiplayerJoinButton.onClick.AddListener(OnJoinButtonClicked);
+
+        gameObject.AddComponent<mGUI_Change_Legend_On_Select>().legendButtonConfiguration = confirmButtonLegendData;
+
+        // We don't want servers that are discovered automatically to be deleted
+        if (!isReadOnly)
+        {
+            GameObject delete = Instantiate(deleteButtonRef, transform, false);
+            Button deleteButtonButton = delete.GetComponent<Button>();
+            deleteButtonButton.onClick = new Button.ButtonClickedEvent();
+            deleteButtonButton.onClick.AddListener(RequestDelete);
+        }
+    }
+
+    public void RequestDelete()
+    {
+        ServerList.Instance.RemoveAt(transform.GetSiblingIndex() - 1);
+        ServerList.Instance.Save();
+
+        int scrollIndex = MainMenuMultiplayerPanel.Main.GetSelectedIndex();
+        if (GameInput.IsPrimaryDeviceGamepad() && !MainMenuMultiplayerPanel.Main.SelectItemInYDirection(scrollIndex, 1))
+        {
+            MainMenuMultiplayerPanel.Main.SelectItemInYDirection(scrollIndex, -1);
+        }
+
+        Destroy(gameObject);
+    }
+
+    public async void OnJoinButtonClicked()
+    {
+        if (MainMenuMultiplayerPanel.Main.IsJoining)
+        {
+            // Do not attempt to join multiple servers.
+            return;
+        }
+
+        MainMenuMultiplayerPanel.Main.IsJoining = true;
+
+        await OpenJoinServerMenuAsync(joinIp, joinPort).ContinueWith(_ => { MainMenuMultiplayerPanel.Main.IsJoining = false; });
+    }
+
+    public static async System.Threading.Tasks.Task OpenJoinServerMenuAsync(string serverIp, int serverPort)
+    {
+        if (!MainMenuMultiplayerPanel.Main)
+        {
+            Log.Error("MainMenuMultiplayerPanel is not instantiated although OpenJoinServerMenuAsync is called.");
+            return;
+        }
+
+        IPEndPoint endpoint = ResolveIPEndPoint(serverIp, serverPort);
+        if (endpoint == null)
+        {
+            Log.InGame($"{Language.main.Get("Nitrox_UnableToConnect")}: {serverIp}:{serverPort}");
+            return;
+        }
+
+        await MainMenuMultiplayerPanel.Main.JoinServer.ShowAsync(endpoint.Address.ToString(), endpoint.Port);
+    }
+
+    private static IPEndPoint ResolveIPEndPoint(string serverIp, int serverPort)
+    {
+        static IPAddress ResolveHostName(string hostname, int serverPort)
+        {
+            try
+            {
+                IPHostEntry hostEntry = Dns.GetHostEntry(hostname);
+                return hostEntry.AddressList[0];
+            }
+            catch (SocketException ex)
+            {
+                Log.ErrorSensitive(ex, "Unable to resolve the address {hostname}:{serverPort}", hostname, serverPort);
+                return null;
+            }
+        }
+
+        UriHostNameType hostType = Uri.CheckHostName(serverIp);
+        IPAddress address;
+        switch (hostType)
+        {
+            case UriHostNameType.IPv4:
+            case UriHostNameType.IPv6:
+                IPAddress.TryParse(serverIp, out address);
+                break;
+            case UriHostNameType.Dns:
+                address = ResolveHostName(serverIp, serverPort);
+                break;
+            default:
+                return null;
+        }
+
+        if (address == null)
+        {
+            return null;
+        }
+
+        return new IPEndPoint(address, serverPort);
+    }
+}

From 9b4baecfef87cafac090b44a6d941352da5819f1 Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Sat, 24 Jun 2023 20:41:49 +0200
Subject: [PATCH 03/14] Revamped AddServer window to SN style and UI based

Also it's now controller friendly
---
 .../LanguageFiles/en.json                     |  15 +-
 .../Gui/MainMenu/MainMenuAddServerWindow.cs   | 158 ------------
 .../Gui/MainMenu/MainMenuCreateServerPanel.cs | 244 ++++++++++++++++++
 .../Gui/MainMenu/MainMenuMods.cs              |  32 ++-
 .../Gui/MainMenu/MainMenuMultiplayerPanel.cs  |  66 ++---
 5 files changed, 309 insertions(+), 206 deletions(-)
 delete mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuAddServerWindow.cs
 create mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs

diff --git a/Nitrox.Assets.Subnautica/LanguageFiles/en.json b/Nitrox.Assets.Subnautica/LanguageFiles/en.json
index 6bc005c136..5016e3b5e1 100644
--- a/Nitrox.Assets.Subnautica/LanguageFiles/en.json
+++ b/Nitrox.Assets.Subnautica/LanguageFiles/en.json
@@ -1,11 +1,14 @@
 {
     "Nitrox_AddServer": "Add Server",
-    "Nitrox_AddServerAdd": "Add",
-    "Nitrox_AddServerHost": "Host:",
-    "Nitrox_AddServerName": "Name:",
-    "Nitrox_AddServerPort": "Port:",
-    "Nitrox_BuildingDesyncDetected": "Server detected a desync with the local client's buildings (go to Nitrox settings to request a resync)",
-    "Nitrox_BuildingSettings": "Base building",
+    "Nitrox_AddServer_NameDescription": "Name:",
+    "Nitrox_AddServer_AddressDescription": "Host:",
+    "Nitrox_AddServer_PortDescription": "Port:",
+    "Nitrox_AddServer_NamePlaceholder": "Enter a name for the server",
+    "Nitrox_AddServer_AddressPlaceholder": "Enter the IP or address of the server",
+    "Nitrox_AddServer_PortPlaceholder": "Enter the numeric port of the server",
+    "Nitrox_AddServer_Confirm": "Create server",
+    "Nitrox_AddServer_Back": "Back",
+    "Nitrox_AddServer_InvalidInput": "You input is invalid. Please check if all text boxes are filled out.",
     "Nitrox_Cancel": "Cancel",
     "Nitrox_CommandNotAvailable": "This command is not available in Nitrox",
     "Nitrox_ConnectTo": "Connect to",
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuAddServerWindow.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuAddServerWindow.cs
deleted file mode 100644
index f156428aa3..0000000000
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuAddServerWindow.cs
+++ /dev/null
@@ -1,158 +0,0 @@
-using System.Collections;
-using NitroxClient.Unity.Helper;
-using NitroxModel.Serialization;
-using UnityEngine;
-using UWE;
-
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
-
-public static class MainMenuAddServerWindow
-{
-    private static Rect addServerWindowRect = new(Screen.width / 2 - 250, 200, 500, 200);
-
-    private static string serverHostInput;
-    private static string serverNameInput;
-    private static string serverPortInput;
-
-    private static bool shouldFocus;
-    private static bool showingAddServer;
-
-    public static void OnExternalGUI()
-    {
-        if (showingAddServer)
-        {
-            addServerWindowRect = GUILayout.Window(GUIUtility.GetControlID(FocusType.Keyboard), addServerWindowRect, DoAddServerWindow, Language.main.Get("Nitrox_AddServer"));
-        }
-    }
-
-    public static void ShowAddServerWindow()
-    {
-        serverNameInput = "local";
-        serverHostInput = "127.0.0.1";
-        serverPortInput = ServerList.DEFAULT_PORT.ToString();
-        showingAddServer = true;
-        shouldFocus = true;
-        uGUI_MainMenu.main.canvasGroup.interactable = false;
-    }
-
-    public static void HideAddServerWindow()
-    {
-        IEnumerator SetWindowComponents()
-        {
-            showingAddServer = false;
-            shouldFocus = true;
-            yield return null;
-            uGUI_MainMenu.main.canvasGroup.interactable = true;
-        }
-
-        CoroutineHost.StartCoroutine(SetWindowComponents());
-    }
-
-    private static void OnAddServerButtonClicked()
-    {
-        serverNameInput = serverNameInput.Trim();
-        serverHostInput = serverHostInput.Trim();
-        if (int.TryParse(serverPortInput.Trim(), out int serverPort))
-        {
-            MainMenuMultiplayerPanel.Main.CreateServerButton(serverNameInput, serverHostInput, serverPort);
-            ServerList.Instance.Add(new ServerList.Entry(serverNameInput, serverHostInput, serverPort));
-            ServerList.Instance.Save();
-
-            HideAddServerWindow();
-        }
-        else
-        {
-            Log.InGame("Server port was not a valid number!");
-        }
-    }
-
-    private static void OnCancelButtonClicked()
-    {
-        HideAddServerWindow();
-    }
-
-    private static void DoAddServerWindow(int windowId)
-    {
-        Event e = Event.current;
-        if (e.isKey)
-        {
-            switch (e.keyCode)
-            {
-                case KeyCode.Return:
-                    OnAddServerButtonClicked();
-                    break;
-                case KeyCode.Escape:
-                    OnCancelButtonClicked();
-                    break;
-            }
-        }
-
-        GUISkinUtils.RenderWithSkin(GetGUISkin(),
-                                    () =>
-                                    {
-                                        using (new GUILayout.VerticalScope("Box"))
-                                        {
-                                            using (new GUILayout.HorizontalScope())
-                                            {
-                                                GUILayout.Label(Language.main.Get("Nitrox_AddServerName"));
-                                                GUI.SetNextControlName("serverNameField");
-                                                // 120 so users can't go too crazy.
-                                                serverNameInput = GUILayout.TextField(serverNameInput, 120);
-                                            }
-
-                                            using (new GUILayout.HorizontalScope())
-                                            {
-                                                GUILayout.Label(Language.main.Get("Nitrox_AddServerHost"));
-                                                GUI.SetNextControlName("serverHostField");
-                                                // 120 so users can't go too crazy.
-                                                serverHostInput = GUILayout.TextField(serverHostInput, 120);
-                                            }
-
-                                            using (new GUILayout.HorizontalScope())
-                                            {
-                                                GUILayout.Label(Language.main.Get("Nitrox_AddServerPort"));
-                                                GUI.SetNextControlName("serverPortField");
-                                                serverPortInput = GUILayout.TextField(serverPortInput);
-                                            }
-
-                                            if (GUILayout.Button(Language.main.Get("Nitrox_AddServerAdd")))
-                                            {
-                                                OnAddServerButtonClicked();
-                                            }
-
-                                            if (GUILayout.Button(Language.main.Get("Nitrox_Cancel")))
-                                            {
-                                                OnCancelButtonClicked();
-                                            }
-                                        }
-                                    });
-
-        if (shouldFocus)
-        {
-            GUI.FocusControl("serverNameField");
-            shouldFocus = false;
-        }
-    }
-
-    private static GUISkin GetGUISkin()
-    {
-        return GUISkinUtils.RegisterDerivedOnce("menus.server",
-                                                s =>
-                                                {
-                                                    s.textField.fontSize = 14;
-                                                    s.textField.richText = false;
-                                                    s.textField.alignment = TextAnchor.MiddleLeft;
-                                                    s.textField.wordWrap = true;
-                                                    s.textField.stretchHeight = true;
-                                                    s.textField.padding = new RectOffset(10, 10, 5, 5);
-
-                                                    s.label.fontSize = 14;
-                                                    s.label.alignment = TextAnchor.MiddleRight;
-                                                    s.label.stretchHeight = true;
-                                                    s.label.fixedWidth = 80; //change this when adding new labels that need more space.
-
-                                                    s.button.fontSize = 14;
-                                                    s.button.stretchHeight = true;
-                                                });
-    }
-}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs
new file mode 100644
index 0000000000..aac77486c8
--- /dev/null
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs
@@ -0,0 +1,244 @@
+using System;
+using System.Linq;
+using FMODUnity;
+using NitroxClient.Unity.Helper;
+using NitroxModel.Serialization;
+using TMPro;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
+
+public class MainMenuCreateServerPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver
+{
+    private TMP_InputField serverNameInput, serverAddressInput, serverPortInput;
+    private mGUI_Change_Legend_On_Select legendChange;
+
+    private GameObject selectedItem;
+    private GameObject[] selectableItems;
+
+    public void Setup(GameObject savedGamesRef)
+    {
+        GameObject multiplayerButtonRef = savedGamesRef.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame");
+        GameObject generalTextRef = multiplayerButtonRef.GetComponentInChildren<TextMeshProUGUI>().gameObject;
+
+        GameObject inputFieldRef = GameObject.Find("/Menu canvas/Panel/MainMenu/RightSide/Home/EmailBox/InputField");
+        GameObject inputFieldBlueprint = Instantiate(inputFieldRef, transform, false);
+        inputFieldBlueprint.GetComponent<RectTransform>().sizeDelta = new Vector2(300, 40);
+        TMP_InputField inputFieldBlueprintInput = inputFieldBlueprint.GetComponent<TMP_InputField>();
+        inputFieldBlueprintInput.characterValidation = TMP_InputField.CharacterValidation.None;
+        inputFieldBlueprintInput.onEndEdit = new TMP_InputField.SubmitEvent();
+        inputFieldBlueprintInput.onSubmit = new TMP_InputField.SubmitEvent();
+        inputFieldBlueprintInput.onSubmit.AddListener(_ => { SelectItemInDirection(0, 1); });
+        inputFieldBlueprintInput.onValueChanged = new TMP_InputField.OnChangeEvent();
+
+        GameObject serverName = Instantiate(inputFieldBlueprint, transform, false);
+        serverName.transform.localPosition = new Vector3(-160, 300, 0);
+        serverNameInput = serverName.GetComponent<TMP_InputField>();
+        serverNameInput.placeholder.GetComponent<TranslationLiveUpdate>().translationKey = Language.main.Get("Nitrox_AddServer_NamePlaceholder");
+        GameObject serverNameDesc = Instantiate(generalTextRef, serverName.transform, false);
+        serverNameDesc.transform.localPosition = new Vector3(-200, 0, 0);
+        serverNameDesc.GetComponent<TextMeshProUGUI>().text = Language.main.Get("Nitrox_AddServer_NameDescription");
+
+        GameObject serverAddress = Instantiate(inputFieldBlueprint, transform, false);
+        serverAddress.transform.localPosition = new Vector3(-160, 225, 0);
+        serverAddressInput = serverAddress.GetComponent<TMP_InputField>();
+        serverAddressInput.placeholder.GetComponent<TranslationLiveUpdate>().translationKey = Language.main.Get("Nitrox_AddServer_AddressPlaceholder");
+        GameObject serverAddressDesc = Instantiate(generalTextRef, serverAddress.transform, false);
+        serverAddressDesc.transform.localPosition = new Vector3(-200, 0, 0);
+        serverAddressDesc.GetComponent<TextMeshProUGUI>().text = Language.main.Get("Nitrox_AddServer_AddressDescription");
+
+        GameObject serverPort = Instantiate(inputFieldBlueprint, transform, false);
+        serverPort.transform.localPosition = new Vector3(-160, 150, 0);
+        serverPortInput = serverPort.GetComponent<TMP_InputField>();
+        serverPortInput.characterValidation = TMP_InputField.CharacterValidation.Integer;
+        serverPortInput.placeholder.GetComponent<TranslationLiveUpdate>().translationKey = Language.main.Get("Nitrox_AddServer_PortPlaceholder");
+        GameObject serverPortDesc = Instantiate(generalTextRef, serverPort.transform, false);
+        serverPortDesc.transform.localPosition = new Vector3(-200, 0, 0);
+        serverPortDesc.GetComponent<TextMeshProUGUI>().text = Language.main.Get("Nitrox_AddServer_PortDescription");
+
+        GameObject confirmButton = Instantiate(multiplayerButtonRef, transform, false);
+        confirmButton.transform.localPosition = new Vector3(-200, 90, 0);
+        confirmButton.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
+        confirmButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_AddServer_Confirm");
+        Button confirmButtonButton = confirmButton.RequireTransform("NewGameButton").GetComponent<Button>();
+        confirmButtonButton.onClick = new Button.ButtonClickedEvent();
+        confirmButtonButton.onClick.AddListener(SaveServer);
+
+        GameObject backButton = Instantiate(multiplayerButtonRef, transform, false);
+        backButton.transform.localPosition = new Vector3(-200, 40, 0);
+        backButton.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
+        backButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_AddServer_Back");
+        Button backButtonButton = backButton.RequireTransform("NewGameButton").GetComponent<Button>();
+        backButtonButton.onClick = new Button.ButtonClickedEvent();
+        backButtonButton.onClick.AddListener(OnBack);
+
+        selectableItems = new[] { serverName, serverAddress, serverPort, confirmButton, backButton };
+        Destroy(inputFieldBlueprint);
+        Destroy(transform.Find("Scroll View").gameObject);
+
+        legendChange = gameObject.AddComponent<mGUI_Change_Legend_On_Select>();
+        legendChange.legendButtonConfiguration = confirmButtonButton.GetComponent<mGUI_Change_Legend_On_Select>().legendButtonConfiguration.Take(2).ToArray();
+    }
+
+    private void SaveServer()
+    {
+        string serverNameText = serverNameInput.text.Trim();
+        string serverHostText = serverAddressInput.text.Trim();
+        string serverPortText = serverPortInput.text.Trim();
+
+        if (string.IsNullOrWhiteSpace(serverNameText) ||
+            string.IsNullOrWhiteSpace(serverHostText) ||
+            string.IsNullOrWhiteSpace(serverPortText))
+        {
+            Log.InGame(Language.main.Get("Nitrox_AddServer_InvalidInput"));
+            return;
+        }
+
+        int serverPort = int.Parse(serverPortText);
+        MainMenuMultiplayerPanel.Main.CreateServerButton(serverNameText, serverHostText, serverPort);
+        ServerList.Instance.Add(new ServerList.Entry(serverNameText, serverHostText, serverPort));
+        ServerList.Instance.Save();
+        OnBack();
+    }
+
+    public bool OnButtonDown(GameInput.Button button)
+    {
+        switch (button)
+        {
+            case GameInput.Button.UISubmit:
+                OnConfirm();
+                return true;
+            case GameInput.Button.UICancel:
+                OnBack();
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public void OnBack()
+    {
+        serverNameInput.text = string.Empty;
+        serverAddressInput.text = string.Empty;
+        serverPortInput.text = string.Empty;
+        DeselectAllItems();
+        MainMenuRightSide.main.OpenGroup("MultiplayerServerList");
+    }
+
+    public void OnConfirm()
+    {
+        if (selectedItem.TryGetComponentInChildren(out InputField inputField))
+        {
+            inputField.Select();
+        }
+
+        if (selectedItem.TryGetComponentInChildren(out Button button))
+        {
+            button.onClick.Invoke();
+        }
+    }
+
+    object uGUI_INavigableIconGrid.GetSelectedItem() => selectedItem;
+
+    bool uGUI_INavigableIconGrid.ShowSelector => false;
+
+    bool uGUI_INavigableIconGrid.EmulateRaycast => false;
+    bool uGUI_INavigableIconGrid.SelectItemClosestToPosition(Vector3 worldPos) => false;
+    uGUI_INavigableIconGrid uGUI_INavigableIconGrid.GetNavigableGridInDirection(int dirX, int dirY) => null;
+
+    Graphic uGUI_INavigableIconGrid.GetSelectedIcon() => null;
+
+    public void SelectItem(object item)
+    {
+        DeselectItem();
+        selectedItem = item as GameObject;
+
+        legendChange.SyncLegendBarToGUISelection();
+
+        if (selectedItem.TryGetComponent(out TMP_InputField selectedInputField))
+        {
+            selectedInputField.Select();
+        }
+        else
+        {
+            selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuMultiplayerPanel.SelectedSprite;
+        }
+
+        selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.black);
+        RuntimeManager.PlayOneShot(MainMenuMultiplayerPanel.HoverSound.path);
+    }
+
+    public void DeselectItem()
+    {
+        if (!selectedItem)
+        {
+            return;
+        }
+
+        if (selectedItem.TryGetComponent(out TMP_InputField selectedInputField))
+        {
+            selectedInputField.ReleaseSelection();
+            EventSystem.current.SetSelectedGameObject(null);
+        }
+        else
+        {
+            selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuMultiplayerPanel.NormalSprite;
+        }
+
+        selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.white);
+        selectedItem = null;
+    }
+
+    public void DeselectAllItems()
+    {
+        foreach (GameObject child in selectableItems)
+        {
+            child.GetComponentInChildren<TextMeshProUGUI>().color = Color.white;
+        }
+    }
+
+    public bool SelectFirstItem()
+    {
+        SelectItem(selectableItems[0]);
+        return true;
+    }
+
+    public bool SelectItemInDirection(int dirX, int dirY)
+    {
+        if (!selectedItem)
+        {
+            return SelectFirstItem();
+        }
+
+        if (dirX == dirY)
+        {
+            return false;
+        }
+
+        int dir = (dirX + dirY) > 0 ? 1 : -1;
+        for (int newIndex = GetSelectedIndex() + dir; newIndex >= 0 && newIndex < selectableItems.Length; newIndex += dir)
+        {
+            if (SelectItemByIndex(newIndex))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private int GetSelectedIndex() => selectedItem ? Array.IndexOf(selectableItems, selectedItem) : -1;
+
+    private bool SelectItemByIndex(int selectedIndex)
+    {
+        if (selectedIndex >= 0 && selectedIndex < selectableItems.Length)
+        {
+            SelectItem(selectableItems[selectedIndex]);
+            return true;
+        }
+
+        return false;
+    }
+}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs
index c3532d3925..adc5e4ebdd 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs
@@ -48,18 +48,28 @@ private void MultiplayerMenuMods()
             showLoadedMultiplayerButton.onClick.AddListener(ShowMultiplayerMenu);
 
             GameObject savedGamesRef = rightSide.gameObject.RequireGameObject("SavedGames");
-            GameObject loadedMultiplayer = Instantiate(savedGamesRef, rightSide.transform);
-            loadedMultiplayer.name = "Multiplayer";
-            Transform header = loadedMultiplayer.RequireTransform("Header");
-            header.GetComponent<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Multiplayer");
-            header.GetComponent<TranslationLiveUpdate>().translationKey = "Nitrox_Multiplayer";
-            Destroy(loadedMultiplayer.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame"));
-            Destroy(loadedMultiplayer.GetComponent<MainMenuLoadPanel>());
-            Destroy(loadedMultiplayer.GetComponentInChildren<MainMenuLoadMenu>());
 
-            loadedMultiplayer.AddComponent<MainMenuMultiplayerPanel>().Setup(loadedMultiplayer, savedGamesRef);
+            GameObject CloneMainMenuLoadPanel(string panelName, string translationKey)
+            {
+                GameObject menuPanel = Instantiate(savedGamesRef, rightSide.transform);
+                menuPanel.name = panelName;
+                Transform header = menuPanel.RequireTransform("Header");
+                header.GetComponent<TextMeshProUGUI>().text = Language.main.Get(translationKey);
+                header.GetComponent<TranslationLiveUpdate>().translationKey = translationKey;
+                Destroy(menuPanel.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame"));
+                Destroy(menuPanel.GetComponent<MainMenuLoadPanel>());
+                Destroy(menuPanel.GetComponentInChildren<MainMenuLoadMenu>());
+
+                rightSide.groups.Add(menuPanel.GetComponent<MainMenuGroup>());
+                return menuPanel;
+            }
+
+            GameObject serverList = CloneMainMenuLoadPanel("MultiplayerServerList", "Nitrox_Multiplayer");
+            serverList.AddComponent<MainMenuMultiplayerPanel>().Setup(savedGamesRef);
+
+            GameObject serverCreate = CloneMainMenuLoadPanel("MultiplayerCreateServer", "Nitrox_AddServer");
+            serverCreate.AddComponent<MainMenuCreateServerPanel>().Setup(savedGamesRef);
 
-            rightSide.groups.Add(loadedMultiplayer.GetComponent<MainMenuGroup>());
 
 #if RELEASE
             // Remove singleplayer button because SP is broken when Nitrox is injected. TODO: Allow SP to work and co-exist with Nitrox MP in the future
@@ -69,7 +79,7 @@ private void MultiplayerMenuMods()
 
         private void ShowMultiplayerMenu()
         {
-            rightSide.OpenGroup("Multiplayer");
+            rightSide.OpenGroup("MultiplayerServerList");
         }
     }
 }
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs
index eaccaf0ff4..57b74a12b2 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs
@@ -13,21 +13,18 @@ namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
 public class MainMenuMultiplayerPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver
 {
     public static MainMenuMultiplayerPanel Main;
+    public static Sprite NormalSprite;
+    public static Sprite SelectedSprite;
+    public static FMODAsset HoverSound;
 
     private GameObject multiplayerButtonRef;
-
-    private Sprite normalSprite;
-    private Sprite selectedSprite;
-    private FMODAsset hoverSound;
-
     private Transform serverAreaContent;
     private GameObject selectedServerItem;
 
     public JoinServer JoinServer { get; private set; }
-    public bool IsJoining{ get; set; }
-
+    public bool IsJoining { get; set; }
 
-    public void Setup(GameObject loadedMultiplayer, GameObject savedGamesRef)
+    public void Setup(GameObject savedGamesRef)
     {
         Main = this;
 
@@ -36,13 +33,14 @@ public void Setup(GameObject loadedMultiplayer, GameObject savedGamesRef)
         JoinServer = new GameObject("NitroxJoinServer").AddComponent<JoinServer>();
         JoinServer.Setup(savedGamesRef);
 
-        MainMenuLoadMenu loadMenu = loadedMultiplayer.GetComponentInChildren<MainMenuLoadMenu>();
-        normalSprite = loadMenu.normalSprite;
-        selectedSprite = loadMenu.selectedSprite;
-        hoverSound = loadMenu.hoverSound;
+        MainMenuLoadMenu loadMenu = savedGamesRef.GetComponentInChildren<MainMenuLoadMenu>();
+        NormalSprite = loadMenu.normalSprite;
+        SelectedSprite = loadMenu.selectedSprite;
+        HoverSound = loadMenu.hoverSound;
 
-        serverAreaContent = loadedMultiplayer.RequireTransform("Scroll View/Viewport/SavedGameAreaContent");
         multiplayerButtonRef = savedGamesRef.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame");
+        serverAreaContent = transform.RequireTransform("Scroll View/Viewport/SavedGameAreaContent");
+        serverAreaContent.gameObject.name = "ServerAreaContent";
 
         MainMenuLoadButton loadButtonRef = savedGamesRef.GetComponent<MainMenuLoadPanel>().saveInstance.GetComponent<MainMenuLoadButton>();
         MainMenuServerButton.Setup(loadButtonRef);
@@ -72,7 +70,7 @@ public bool OnButtonDown(GameInput.Button button)
 
     public void OnBack()
     {
-        MainMenuAddServerWindow.HideAddServerWindow();
+        DeselectAllItems();
         MainMenuRightSide.main.OpenGroup("Home");
     }
 
@@ -93,9 +91,10 @@ public void OnConfirm()
 
         if (selectedServerItem.gameObject.name == "NewServer")
         {
-            selectedServerItem.GetComponentInChildren<Button>().onClick.Invoke();
+            DeselectAllItems();
+            MainMenuRightSide.main.OpenGroup("MultiplayerCreateServer");
         }
-        else if(selectedServerItem.TryGetComponent(out MainMenuServerButton serverButton))
+        else if (selectedServerItem.TryGetComponent(out MainMenuServerButton serverButton))
         {
             serverButton.OnJoinButtonClicked();
         }
@@ -123,9 +122,9 @@ public void SelectItem(object item)
 
         UIUtils.ScrollToShowItemInCenter(selectedServerItem.transform);
 
-        selectedServerItem.transform.GetChild(0).GetComponent<Image>().sprite = selectedSprite;
+        selectedServerItem.transform.GetChild(0).GetComponent<Image>().sprite = SelectedSprite;
         selectedServerItem.GetComponentInChildren<TextMeshProUGUI>().color = Color.black;
-        RuntimeManager.PlayOneShot(this.hoverSound.path);
+        RuntimeManager.PlayOneShot(HoverSound.path);
     }
 
     public void DeselectItem()
@@ -135,11 +134,19 @@ public void DeselectItem()
             return;
         }
 
-        selectedServerItem.transform.GetChild(0).GetComponent<Image>().sprite = normalSprite;
+        selectedServerItem.transform.GetChild(0).GetComponent<Image>().sprite = NormalSprite;
         selectedServerItem.GetComponentInChildren<TextMeshProUGUI>().color = Color.white;
         selectedServerItem = null;
     }
 
+    public void DeselectAllItems()
+    {
+        foreach (Transform child in serverAreaContent)
+        {
+            child.GetChild(0).GetComponent<Image>().sprite = NormalSprite;
+            child.GetComponentInChildren<TextMeshProUGUI>().color = Color.white;
+        }
+    }
 
     public bool SelectFirstItem()
     {
@@ -160,7 +167,6 @@ public bool SelectFirstItem()
         return false;
     }
 
-
     public bool SelectItemInDirection(int dirX, int dirY)
     {
         if (selectedServerItem)
@@ -176,13 +182,14 @@ public bool SelectItemInDirection(int dirX, int dirY)
     public bool SelectItemInYDirection(int selectedIndex, int dirY)
     {
         int dir = dirY > 0 ? 1 : -1;
-        for (int newIndex =  selectedIndex + dir; newIndex >= 0 && newIndex < serverAreaContent.childCount; newIndex += dir)
+        for (int newIndex = selectedIndex + dir; newIndex >= 0 && newIndex < serverAreaContent.childCount; newIndex += dir)
         {
             if (SelectItemByIndex(newIndex))
             {
                 return true;
             }
         }
+
         return false;
     }
 
@@ -197,15 +204,6 @@ private bool SelectItemByIndex(int selectedIndex)
         return false;
     }
 
-
-
-
-
-    private void OnGUI()
-    {
-        MainMenuAddServerWindow.OnExternalGUI();
-    }
-
     private void LoadSavedServers()
     {
         ServerList.Refresh();
@@ -250,7 +248,13 @@ private void CreateAddServerButton()
 
         Button multiplayerButtonButton = multiplayerButtonInst.RequireTransform("NewGameButton").GetComponent<Button>();
         multiplayerButtonButton.onClick = new Button.ButtonClickedEvent();
-        multiplayerButtonButton.onClick.AddListener(MainMenuAddServerWindow.ShowAddServerWindow);
+        multiplayerButtonButton.onClick.AddListener(OpenAddServerGroup);
+    }
+
+    public void OpenAddServerGroup()
+    {
+        DeselectAllItems();
+        MainMenuRightSide.main.OpenGroup("MultiplayerCreateServer");
     }
 
     public void RefreshServerEntries()

From 43493bebf9d8a1c2535bbf683adefc54b0cc1c1b Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Sat, 24 Jun 2023 20:58:06 +0200
Subject: [PATCH 04/14] Renaming few MainMenu files to reflect behavior/SN
 naming conventions

---
 .../Settings/NitroxSettingsManager.cs         |  7 +-
 .../MonoBehaviours/Discord/DiscordClient.cs   |  2 +-
 .../MonoBehaviours/Gui/MainMenu/JoinServer.cs |  8 +-
 ...ification.cs => JoinServerNotification.cs} |  2 +-
 .../Gui/MainMenu/MainMenuCreateServerPanel.cs |  8 +-
 .../Gui/MainMenu/MainMenuMods.cs              | 85 -------------------
 .../Gui/MainMenu/MainMenuServerButton.cs      | 18 ++--
 ...yerPanel.cs => MainMenuServerListPanel.cs} |  4 +-
 .../MainMenu/NitroxMainMenuModifications.cs   | 82 ++++++++++++++++++
 .../MonoBehaviours/NitroxBootstrapper.cs      |  2 +-
 .../MainMenuRightSide_OpenGroup_Patch.cs      |  4 +-
 11 files changed, 110 insertions(+), 112 deletions(-)
 rename NitroxClient/MonoBehaviours/Gui/MainMenu/{MainMenuNotification.cs => JoinServerNotification.cs} (98%)
 delete mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs
 rename NitroxClient/MonoBehaviours/Gui/MainMenu/{MainMenuMultiplayerPanel.cs => MainMenuServerListPanel.cs} (98%)
 create mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs

diff --git a/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs b/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs
index a90acee3e2..b9e7274be4 100644
--- a/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs
+++ b/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs
@@ -21,9 +21,9 @@ public NitroxSettingsManager()
 
     /// <summary>
     /// Allows to create new settings
-    /// 
+    ///
     /// Available types : TOGGLE, SLIDER, LIST, BUTTON
-    /// 
+    ///
     /// <example>
     /// <para>Examples :</para>
     /// <code>
@@ -38,7 +38,7 @@ private void MakeSettings()
         AddSetting("Nitrox_StreamerSettings", new Setting("Nitrox_HideIp", NitroxPrefs.HideIp, hide =>
         {
             NitroxPrefs.HideIp.Value = hide;
-            MainMenuMultiplayerPanel.Main.RefreshServerEntries();
+            MainMenuServerListPanel.Main.RefreshServerEntries();
         }));
 
         AddSetting("Nitrox_ResyncSettings", new Setting("Nitrox_ResyncBuildings", () =>
@@ -48,6 +48,7 @@ private void MakeSettings()
                 BuildingHandler.Main.AskForResync();
             }
         }));
+                MainMenuServerListPanel.Main.RefreshServerEntries();
 
         AddSetting("Nitrox_BuildingSettings", new Setting("Nitrox_SafeBuilding", NitroxPrefs.SafeBuilding, safe => NitroxPrefs.SafeBuilding.Value = safe));
         AddSetting("Nitrox_BuildingSettings", new Setting("Nitrox_SafeBuildingLog", NitroxPrefs.SafeBuildingLog, safeLog => NitroxPrefs.SafeBuildingLog.Value = safeLog));
diff --git a/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs b/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs
index ea935fff2b..0e48eca2a7 100644
--- a/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs
+++ b/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs
@@ -99,7 +99,7 @@ private void ActivityJoin(string secret)
     {
         Log.Info("[Discord] Joining Server");
 
-        if (SceneManager.GetActiveScene().name != "StartScreen" || !MainMenuMultiplayerPanel.Main)
+        if (SceneManager.GetActiveScene().name != "StartScreen" || !MainMenuServerListPanel.Main)
         {
             Log.InGame(Language.main.Get("Nitrox_DiscordMultiplayerMenu"));
             Log.Warn("[Discord] Can't join a server outside of the main-menu.");
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServer.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServer.cs
index d66b1bef1c..c4236f80ba 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServer.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServer.cs
@@ -84,7 +84,7 @@ private void Hide()
     private void Update()
     {
         if (multiplayerSession.CurrentState.CurrentStage != MultiplayerSessionConnectionStage.AWAITING_RESERVATION_CREDENTIALS ||
-            gameObject.GetComponent<MainMenuNotification>())
+            gameObject.GetComponent<JoinServerNotification>())
         {
             return;
         }
@@ -251,16 +251,16 @@ private void SessionConnectionStateChangedHandler(IMultiplayerSessionConnectionS
 
     private void NotifyUser(string notificationMessage, Action continuationAction = null)
     {
-        if (gameObject.GetComponent<MainMenuNotification>())
+        if (gameObject.GetComponent<JoinServerNotification>())
         {
             return;
         }
 
-        MainMenuNotification notificationDialog = gameObject.AddComponent<MainMenuNotification>();
+        JoinServerNotification notificationDialog = gameObject.AddComponent<JoinServerNotification>();
         notificationDialog.ShowNotification(notificationMessage, () =>
         {
             continuationAction?.Invoke();
-            Destroy(gameObject.GetComponent<MainMenuNotification>(), 0.0001f);
+            Destroy(gameObject.GetComponent<JoinServerNotification>(), 0.0001f);
         });
     }
 
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotification.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerNotification.cs
similarity index 98%
rename from NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotification.cs
rename to NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerNotification.cs
index 72ae15cd5b..7043064606 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotification.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerNotification.cs
@@ -5,7 +5,7 @@
 namespace NitroxClient.MonoBehaviours.Gui.MainMenu
 {
     //I'd like to see about skinning this behavior with the notification window that appears at the bottom of the screen during certain story events in the game.
-    public class MainMenuNotification : MonoBehaviour
+    public class JoinServerNotification : MonoBehaviour
     {
         private bool awaitingAcknowledgement;
         private Action continuationAction;
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs
index aac77486c8..6209dbaa59 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs
@@ -97,7 +97,7 @@ private void SaveServer()
         }
 
         int serverPort = int.Parse(serverPortText);
-        MainMenuMultiplayerPanel.Main.CreateServerButton(serverNameText, serverHostText, serverPort);
+        MainMenuServerListPanel.Main.CreateServerButton(serverNameText, serverHostText, serverPort);
         ServerList.Instance.Add(new ServerList.Entry(serverNameText, serverHostText, serverPort));
         ServerList.Instance.Save();
         OnBack();
@@ -163,11 +163,11 @@ public void SelectItem(object item)
         }
         else
         {
-            selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuMultiplayerPanel.SelectedSprite;
+            selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuServerListPanel.SelectedSprite;
         }
 
         selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.black);
-        RuntimeManager.PlayOneShot(MainMenuMultiplayerPanel.HoverSound.path);
+        RuntimeManager.PlayOneShot(MainMenuServerListPanel.HoverSound.path);
     }
 
     public void DeselectItem()
@@ -184,7 +184,7 @@ public void DeselectItem()
         }
         else
         {
-            selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuMultiplayerPanel.NormalSprite;
+            selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuServerListPanel.NormalSprite;
         }
 
         selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.white);
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs
deleted file mode 100644
index adc5e4ebdd..0000000000
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMods.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-using NitroxClient.MonoBehaviours.Discord;
-using NitroxClient.Unity.Helper;
-using TMPro;
-using UnityEngine;
-using UnityEngine.SceneManagement;
-using UnityEngine.UI;
-
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu
-{
-    public class MainMenuMods : MonoBehaviour
-    {
-        private MainMenuRightSide rightSide;
-
-        private void OnEnable()
-        {
-            SceneManager.sceneLoaded += SceneManager_sceneLoaded;
-        }
-
-        private void OnDisable()
-        {
-            SceneManager.sceneLoaded -= SceneManager_sceneLoaded;
-        }
-
-        private void SceneManager_sceneLoaded(Scene scene, LoadSceneMode loadMode)
-        {
-            if (scene.name == "XMenu")
-            {
-                rightSide = MainMenuRightSide.main;
-                MultiplayerMenuMods();
-                DiscordClient.InitializeRPMenu();
-            }
-        }
-
-        private void MultiplayerMenuMods()
-        {
-            GameObject startButton = GameObjectHelper.RequireGameObject("Menu canvas/Panel/MainMenu/PrimaryOptions/MenuButtons/ButtonPlay");
-            GameObject showLoadedMultiplayer = Instantiate(startButton, startButton.transform.parent);
-            showLoadedMultiplayer.name = "ButtonMultiplayer";
-            showLoadedMultiplayer.transform.SetSiblingIndex(3);
-
-            TextMeshProUGUI buttonText = showLoadedMultiplayer.RequireGameObject("Circle/Bar/Text").GetComponent<TextMeshProUGUI>();
-            buttonText.text = Language.main.Get("Nitrox_Multiplayer");
-            buttonText.GetComponent<TranslationLiveUpdate>().translationKey = "Nitrox_Multiplayer";
-
-
-            Button showLoadedMultiplayerButton = showLoadedMultiplayer.GetComponent<Button>();
-            showLoadedMultiplayerButton.onClick.RemoveAllListeners();
-            showLoadedMultiplayerButton.onClick.AddListener(ShowMultiplayerMenu);
-
-            GameObject savedGamesRef = rightSide.gameObject.RequireGameObject("SavedGames");
-
-            GameObject CloneMainMenuLoadPanel(string panelName, string translationKey)
-            {
-                GameObject menuPanel = Instantiate(savedGamesRef, rightSide.transform);
-                menuPanel.name = panelName;
-                Transform header = menuPanel.RequireTransform("Header");
-                header.GetComponent<TextMeshProUGUI>().text = Language.main.Get(translationKey);
-                header.GetComponent<TranslationLiveUpdate>().translationKey = translationKey;
-                Destroy(menuPanel.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame"));
-                Destroy(menuPanel.GetComponent<MainMenuLoadPanel>());
-                Destroy(menuPanel.GetComponentInChildren<MainMenuLoadMenu>());
-
-                rightSide.groups.Add(menuPanel.GetComponent<MainMenuGroup>());
-                return menuPanel;
-            }
-
-            GameObject serverList = CloneMainMenuLoadPanel("MultiplayerServerList", "Nitrox_Multiplayer");
-            serverList.AddComponent<MainMenuMultiplayerPanel>().Setup(savedGamesRef);
-
-            GameObject serverCreate = CloneMainMenuLoadPanel("MultiplayerCreateServer", "Nitrox_AddServer");
-            serverCreate.AddComponent<MainMenuCreateServerPanel>().Setup(savedGamesRef);
-
-
-#if RELEASE
-            // Remove singleplayer button because SP is broken when Nitrox is injected. TODO: Allow SP to work and co-exist with Nitrox MP in the future
-            startButton.SetActive(false);
-#endif
-        }
-
-        private void ShowMultiplayerMenu()
-        {
-            rightSide.OpenGroup("MultiplayerServerList");
-        }
-    }
-}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs
index 1cc4dae13c..cadd56411f 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs
@@ -55,10 +55,10 @@ public void RequestDelete()
         ServerList.Instance.RemoveAt(transform.GetSiblingIndex() - 1);
         ServerList.Instance.Save();
 
-        int scrollIndex = MainMenuMultiplayerPanel.Main.GetSelectedIndex();
-        if (GameInput.IsPrimaryDeviceGamepad() && !MainMenuMultiplayerPanel.Main.SelectItemInYDirection(scrollIndex, 1))
+        int scrollIndex = MainMenuServerListPanel.Main.GetSelectedIndex();
+        if (GameInput.IsPrimaryDeviceGamepad() && !MainMenuServerListPanel.Main.SelectItemInYDirection(scrollIndex, 1))
         {
-            MainMenuMultiplayerPanel.Main.SelectItemInYDirection(scrollIndex, -1);
+            MainMenuServerListPanel.Main.SelectItemInYDirection(scrollIndex, -1);
         }
 
         Destroy(gameObject);
@@ -66,22 +66,22 @@ public void RequestDelete()
 
     public async void OnJoinButtonClicked()
     {
-        if (MainMenuMultiplayerPanel.Main.IsJoining)
+        if (MainMenuServerListPanel.Main.IsJoining)
         {
             // Do not attempt to join multiple servers.
             return;
         }
 
-        MainMenuMultiplayerPanel.Main.IsJoining = true;
+        MainMenuServerListPanel.Main.IsJoining = true;
 
-        await OpenJoinServerMenuAsync(joinIp, joinPort).ContinueWith(_ => { MainMenuMultiplayerPanel.Main.IsJoining = false; });
+        await OpenJoinServerMenuAsync(joinIp, joinPort).ContinueWith(_ => { MainMenuServerListPanel.Main.IsJoining = false; });
     }
 
     public static async System.Threading.Tasks.Task OpenJoinServerMenuAsync(string serverIp, int serverPort)
     {
-        if (!MainMenuMultiplayerPanel.Main)
+        if (!MainMenuServerListPanel.Main)
         {
-            Log.Error("MainMenuMultiplayerPanel is not instantiated although OpenJoinServerMenuAsync is called.");
+            Log.Error("MainMenuServerListPanel is not instantiated although OpenJoinServerMenuAsync is called.");
             return;
         }
 
@@ -92,7 +92,7 @@ public static async System.Threading.Tasks.Task OpenJoinServerMenuAsync(string s
             return;
         }
 
-        await MainMenuMultiplayerPanel.Main.JoinServer.ShowAsync(endpoint.Address.ToString(), endpoint.Port);
+        await MainMenuServerListPanel.Main.JoinServer.ShowAsync(endpoint.Address.ToString(), endpoint.Port);
     }
 
     private static IPEndPoint ResolveIPEndPoint(string serverIp, int serverPort)
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerListPanel.cs
similarity index 98%
rename from NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs
rename to NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerListPanel.cs
index 57b74a12b2..ee285ccf41 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuMultiplayerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerListPanel.cs
@@ -10,9 +10,9 @@
 
 namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
 
-public class MainMenuMultiplayerPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver
+public class MainMenuServerListPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver
 {
-    public static MainMenuMultiplayerPanel Main;
+    public static MainMenuServerListPanel Main;
     public static Sprite NormalSprite;
     public static Sprite SelectedSprite;
     public static FMODAsset HoverSound;
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
new file mode 100644
index 0000000000..b6a8e9c7ca
--- /dev/null
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
@@ -0,0 +1,82 @@
+using NitroxClient.MonoBehaviours.Discord;
+using NitroxClient.Unity.Helper;
+using TMPro;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using UnityEngine.UI;
+
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
+
+public class NitroxMainMenuModifications : MonoBehaviour
+{
+    private MainMenuRightSide rightSide;
+
+    private void OnEnable()
+    {
+        SceneManager.sceneLoaded += SceneManager_sceneLoaded;
+    }
+
+    private void OnDisable()
+    {
+        SceneManager.sceneLoaded -= SceneManager_sceneLoaded;
+    }
+
+    private void SceneManager_sceneLoaded(Scene scene, LoadSceneMode loadMode)
+    {
+        if (scene.name == "XMenu")
+        {
+            rightSide = MainMenuRightSide.main;
+            MultiplayerMenuMods();
+            DiscordClient.InitializeRPMenu();
+        }
+    }
+
+    private void MultiplayerMenuMods()
+    {
+        GameObject startButton = GameObjectHelper.RequireGameObject("Menu canvas/Panel/MainMenu/PrimaryOptions/MenuButtons/ButtonPlay");
+        GameObject showLoadedMultiplayer = Instantiate(startButton, startButton.transform.parent);
+        showLoadedMultiplayer.name = "ButtonMultiplayer";
+        showLoadedMultiplayer.transform.SetSiblingIndex(3);
+
+        TextMeshProUGUI buttonText = showLoadedMultiplayer.RequireGameObject("Circle/Bar/Text").GetComponent<TextMeshProUGUI>();
+        buttonText.text = Language.main.Get("Nitrox_Multiplayer");
+        buttonText.GetComponent<TranslationLiveUpdate>().translationKey = "Nitrox_Multiplayer";
+
+        Button showLoadedMultiplayerButton = showLoadedMultiplayer.GetComponent<Button>();
+        showLoadedMultiplayerButton.onClick.RemoveAllListeners();
+        showLoadedMultiplayerButton.onClick.AddListener(ShowMultiplayerServerList);
+
+        GameObject savedGamesRef = rightSide.gameObject.RequireGameObject("SavedGames");
+
+        GameObject CloneMainMenuLoadPanel(string panelName, string translationKey)
+        {
+            GameObject menuPanel = Instantiate(savedGamesRef, rightSide.transform);
+            menuPanel.name = panelName;
+            Transform header = menuPanel.RequireTransform("Header");
+            header.GetComponent<TextMeshProUGUI>().text = Language.main.Get(translationKey);
+            header.GetComponent<TranslationLiveUpdate>().translationKey = translationKey;
+            Destroy(menuPanel.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame"));
+            Destroy(menuPanel.GetComponent<MainMenuLoadPanel>());
+            Destroy(menuPanel.GetComponentInChildren<MainMenuLoadMenu>());
+
+            rightSide.groups.Add(menuPanel.GetComponent<MainMenuGroup>());
+            return menuPanel;
+        }
+
+        GameObject serverList = CloneMainMenuLoadPanel("MultiplayerServerList", "Nitrox_Multiplayer");
+        serverList.AddComponent<MainMenuServerListPanel>().Setup(savedGamesRef);
+
+        GameObject serverCreate = CloneMainMenuLoadPanel("MultiplayerCreateServer", "Nitrox_AddServer");
+        serverCreate.AddComponent<MainMenuCreateServerPanel>().Setup(savedGamesRef);
+
+#if RELEASE
+            // Remove singleplayer button because SP is broken when Nitrox is injected. TODO: Allow SP to work and co-exist with Nitrox MP in the future
+            startButton.SetActive(false);
+#endif
+    }
+
+    private void ShowMultiplayerServerList()
+    {
+        rightSide.OpenGroup("MultiplayerServerList");
+    }
+}
diff --git a/NitroxClient/MonoBehaviours/NitroxBootstrapper.cs b/NitroxClient/MonoBehaviours/NitroxBootstrapper.cs
index a9026a5e67..ca2f76288d 100644
--- a/NitroxClient/MonoBehaviours/NitroxBootstrapper.cs
+++ b/NitroxClient/MonoBehaviours/NitroxBootstrapper.cs
@@ -12,7 +12,7 @@ private void Awake()
         DontDestroyOnLoad(gameObject);
         Instance = this;
         gameObject.AddComponent<SceneCleanerPreserve>();
-        gameObject.AddComponent<MainMenuMods>();
+        gameObject.AddComponent<NitroxMainMenuModifications>();
         gameObject.AddComponent<DiscordClient>();
 
 #if DEBUG
diff --git a/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs b/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs
index fa0cd84f5f..4c2e22c097 100644
--- a/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs
+++ b/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs
@@ -12,9 +12,9 @@ public static void Prefix(string target)
         {
             // Don't stop the client if the client is trying to connect (in the case: target = "Join Server")
             // We can detect that the Join Server tab is still available because the gameobject is activated only when the tab is opened
-            if (MainMenuMultiplayerPanel.Main.JoinServer.gameObject.activeSelf && !target.Equals(MainMenuMultiplayerPanel.Main.JoinServer.MenuName))
+            if (MainMenuServerListPanel.Main.JoinServer.gameObject.activeSelf && !target.Equals(MainMenuServerListPanel.Main.JoinServer.MenuName))
             {
-                MainMenuMultiplayerPanel.Main.JoinServer.StopMultiplayerClient();
+                MainMenuServerListPanel.Main.JoinServer.StopMultiplayerClient();
             }
         }
     }

From 43de13f2e22eff97f2c45f96537f5e563aeb5acf Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Sun, 11 Feb 2024 00:24:48 +0100
Subject: [PATCH 05/14] Start SN through steam instead of direct start

This re-enables controller support
---
 NitroxModel/Platforms/Store/Steam.cs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/NitroxModel/Platforms/Store/Steam.cs b/NitroxModel/Platforms/Store/Steam.cs
index c4fd50e5ab..99946c08db 100644
--- a/NitroxModel/Platforms/Store/Steam.cs
+++ b/NitroxModel/Platforms/Store/Steam.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.IO;
 using System.Threading.Tasks;
@@ -82,12 +82,20 @@ public async Task<ProcessEx> StartGameAsync(string pathToGameExe, int steamAppId
                 throw new PlatformException(Instance, "Timeout reached while waiting for platform to start. Try again once platform has finished loading.", ex);
             }
 
+#if DEBUG // Needed to start multiple SN instances, but Steam Overlay doesn't work this way so only active for devs
             return ProcessEx.Start(
-                    pathToGameExe,
-                    new[] { ("SteamGameId", steamAppId.ToString()), ("SteamAppID", steamAppId.ToString()), (NitroxUser.LAUNCHER_PATH_ENV_KEY, NitroxUser.LauncherPath) },
-                    Path.GetDirectoryName(pathToGameExe),
-                    launchArguments
+                pathToGameExe,
+                new[] { ("SteamGameId", steamAppId.ToString()), ("SteamAppID", steamAppId.ToString()), (NitroxUser.LAUNCHER_PATH_ENV_KEY, NitroxUser.LauncherPath) },
+                Path.GetDirectoryName(pathToGameExe),
+                launchArguments
             );
+#endif
+
+            return new ProcessEx(Process.Start(new ProcessStartInfo
+            {
+                FileName = GetExeFile(),
+                Arguments = $"""-applaunch {steamAppId} -nitrox "{NitroxUser.LauncherPath}" {launchArguments}"""
+            }));
         }
     }
 }

From b43dfe2d392b017a80b43453fcce1d3e7336d70f Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Thu, 14 Mar 2024 13:26:29 +0100
Subject: [PATCH 06/14] Fix Selectable drawer NRE

---
 .../Debuggers/Drawer/NitroxGUILayout.cs       |  8 ++---
 .../Drawer/UnityUI/SelectableDrawer.cs        | 36 ++++++++++++++++---
 2 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/NitroxClient/Debuggers/Drawer/NitroxGUILayout.cs b/NitroxClient/Debuggers/Drawer/NitroxGUILayout.cs
index f62e47700c..c5589155c9 100644
--- a/NitroxClient/Debuggers/Drawer/NitroxGUILayout.cs
+++ b/NitroxClient/Debuggers/Drawer/NitroxGUILayout.cs
@@ -154,7 +154,7 @@ public static float SliderField(float value, float minValue, float maxValue, flo
     /// <returns>The newly selected enum value.</returns>
     public static Enum EnumPopup(Enum selected, float buttonWidth = VALUE_WIDTH)
     {
-        return EnumPopupInternal(selected, buttonWidth);        
+        return EnumPopupInternal(selected, buttonWidth);
     }
 
     public static T EnumPopup<T>(T selected, float buttonWidth = VALUE_WIDTH) where T : Enum
@@ -183,7 +183,7 @@ bool IsFlagSet<T>(T value, T flag)
                 return (lValue & lFlag) != 0;
             };
 
-            T SetFlags<T>(T value, T flags, bool toggle)
+            object SetFlags(Type type, object value, object flags, bool toggle)
             {
                 long lValue = Convert.ToInt64(value);
                 long lFlag = Convert.ToInt64(flags);
@@ -201,7 +201,7 @@ T SetFlags<T>(T value, T flags, bool toggle)
                     lValue = 0;
                 }
 
-                return (T)Enum.ToObject(typeof(T), lValue);
+                return Enum.ToObject(type, lValue);
             };
 
             Enum[] enumValues = Enum.GetValues(enumType).Cast<Enum>().ToArray();
@@ -215,7 +215,7 @@ T SetFlags<T>(T value, T flags, bool toggle)
 
                     bool isFlagSet = IsFlagSet(selected, enumValue);
 
-                    selected = SetFlags(selected, enumValue, GUILayout.Toggle(isFlagSet, enumName, "Button", GUILayout.Width(buttonWidth)));
+                    selected = (Enum) SetFlags(enumType, selected, enumValue, GUILayout.Toggle(isFlagSet, enumName, "Button", GUILayout.Width(buttonWidth)));
                 }
             }
 
diff --git a/NitroxClient/Debuggers/Drawer/UnityUI/SelectableDrawer.cs b/NitroxClient/Debuggers/Drawer/UnityUI/SelectableDrawer.cs
index 61e9c6c0b6..fdadae7d9b 100644
--- a/NitroxClient/Debuggers/Drawer/UnityUI/SelectableDrawer.cs
+++ b/NitroxClient/Debuggers/Drawer/UnityUI/SelectableDrawer.cs
@@ -149,28 +149,56 @@ private static void DrawTransitionSpriteSwap(Selectable selectable)
         {
             GUILayout.Label("Highlighted Sprite", NitroxGUILayout.DrawerLabel, GUILayout.Width(NitroxGUILayout.DEFAULT_LABEL_WIDTH));
             NitroxGUILayout.Separator();
-            ImageDrawer.DrawTexture(selectable.spriteState.highlightedSprite.texture);
+            if (selectable.spriteState.highlightedSprite)
+            {
+                ImageDrawer.DrawTexture(selectable.spriteState.highlightedSprite.texture);
+            }
+            else
+            {
+                GUILayout.Box("Field is null", GUILayout.Width(NitroxGUILayout.VALUE_WIDTH));
+            }
         }
 
         using (new GUILayout.HorizontalScope())
         {
             GUILayout.Label("Pressed Sprite", NitroxGUILayout.DrawerLabel, GUILayout.Width(NitroxGUILayout.DEFAULT_LABEL_WIDTH));
             NitroxGUILayout.Separator();
-            ImageDrawer.DrawTexture(selectable.spriteState.pressedSprite.texture);
+            if (selectable.spriteState.pressedSprite)
+            {
+                ImageDrawer.DrawTexture(selectable.spriteState.pressedSprite.texture);
+            }
+            else
+            {
+                GUILayout.Box("Field is null", GUILayout.Width(NitroxGUILayout.VALUE_WIDTH));
+            }
         }
 
         using (new GUILayout.HorizontalScope())
         {
             GUILayout.Label("Selected Sprite", NitroxGUILayout.DrawerLabel, GUILayout.Width(NitroxGUILayout.DEFAULT_LABEL_WIDTH));
             NitroxGUILayout.Separator();
-            ImageDrawer.DrawTexture(selectable.spriteState.selectedSprite.texture);
+            if (selectable.spriteState.selectedSprite)
+            {
+                ImageDrawer.DrawTexture(selectable.spriteState.selectedSprite.texture);
+            }
+            else
+            {
+                GUILayout.Box("Field is null", GUILayout.Width(NitroxGUILayout.VALUE_WIDTH));
+            }
         }
 
         using (new GUILayout.HorizontalScope())
         {
             GUILayout.Label("Disabled Sprite", NitroxGUILayout.DrawerLabel, GUILayout.Width(NitroxGUILayout.DEFAULT_LABEL_WIDTH));
             NitroxGUILayout.Separator();
-            ImageDrawer.DrawTexture(selectable.spriteState.disabledSprite.texture);
+            if (selectable.spriteState.disabledSprite)
+            {
+                ImageDrawer.DrawTexture(selectable.spriteState.disabledSprite.texture);
+            }
+            else
+            {
+                GUILayout.Box("Field is null", GUILayout.Width(NitroxGUILayout.VALUE_WIDTH));
+            }
         }
     }
 

From 90388649b2e2c15b1159eaaa15fa4ebc53b3ee37 Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Thu, 14 Mar 2024 16:07:23 +0100
Subject: [PATCH 07/14] Add controller support for join server input and 
 refactor whole process

---
 .../Settings/NitroxSettingsManager.cs         |   2 +-
 .../MonoBehaviours/Discord/DiscordClient.cs   |   4 +-
 .../LoadingScreenVersionText.cs               |   0
 .../MonoBehaviours/Gui/MainMenu/JoinServer.cs | 373 ------------------
 .../Gui/MainMenu/JoinServerJoinWindow.cs      | 291 --------------
 .../Gui/MainMenu/JoinServerNotification.cs    |  86 ----
 .../Gui/MainMenu/JoinServerServerList.cs      |  43 --
 .../Gui/MainMenu/MainMenuNotificationPanel.cs | 177 +++++++++
 .../MainMenu/NitroxMainMenuModifications.cs   |  27 +-
 .../MainMenu/ServerJoin/JoinServerBackend.cs  | 196 +++++++++
 .../ServerJoin/MainMenuEnterPasswordPanel.cs  | 129 ++++++
 .../ServerJoin/MainMenuJoinServerPanel.cs     | 318 +++++++++++++++
 .../MainMenuCreateServerPanel.cs              |  21 +-
 .../{ => ServersList}/MainMenuServerButton.cs |  44 +--
 .../MainMenuServerListPanel.cs                |  21 +-
 .../MainMenuRightSide_OpenGroup_Patch.cs      |  21 +-
 16 files changed, 893 insertions(+), 860 deletions(-)
 rename NitroxClient/MonoBehaviours/Gui/{MainMenu => InGame}/LoadingScreenVersionText.cs (100%)
 delete mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServer.cs
 delete mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerJoinWindow.cs
 delete mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerNotification.cs
 delete mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerServerList.cs
 create mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs
 create mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
 create mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs
 create mode 100644 NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
 rename NitroxClient/MonoBehaviours/Gui/MainMenu/{ => ServersList}/MainMenuCreateServerPanel.cs (94%)
 rename NitroxClient/MonoBehaviours/Gui/MainMenu/{ => ServersList}/MainMenuServerButton.cs (88%)
 rename NitroxClient/MonoBehaviours/Gui/MainMenu/{ => ServersList}/MainMenuServerListPanel.cs (92%)

diff --git a/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs b/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs
index b9e7274be4..ee9dc1892b 100644
--- a/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs
+++ b/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using NitroxClient.GameLogic.Bases;
-using NitroxClient.MonoBehaviours.Gui.MainMenu;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
 using UnityEngine.Events;
 
 namespace NitroxClient.GameLogic.Settings;
diff --git a/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs b/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs
index 0e48eca2a7..51c194d318 100644
--- a/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs
+++ b/NitroxClient/MonoBehaviours/Discord/DiscordClient.cs
@@ -2,7 +2,7 @@
 using System.Linq;
 using DiscordGameSDKWrapper;
 using NitroxClient.Communication.Abstract;
-using NitroxClient.MonoBehaviours.Gui.MainMenu;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
 using NitroxModel;
 using NitroxModel.Core;
 using NitroxModel.Packets;
@@ -43,7 +43,7 @@ private void StartDiscordHook()
             discord = new DiscordGameSDKWrapper.Discord(CLIENT_ID, (ulong)CreateFlags.NoRequireDiscord);
             discord.SetLogHook(DiscordGameSDKWrapper.LogLevel.Debug, (level, message) => Log.Write((NitroxModel.Logger.LogLevel)level, $"[Discord] {message}"));
             activityManager = discord.GetActivityManager();
-            
+
             activityManager.RegisterSteam((uint)GameInfo.Subnautica.SteamAppId);
             activityManager.OnActivityJoinRequest += ActivityJoinRequest;
             activityManager.OnActivityJoin += ActivityJoin;
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/LoadingScreenVersionText.cs b/NitroxClient/MonoBehaviours/Gui/InGame/LoadingScreenVersionText.cs
similarity index 100%
rename from NitroxClient/MonoBehaviours/Gui/MainMenu/LoadingScreenVersionText.cs
rename to NitroxClient/MonoBehaviours/Gui/InGame/LoadingScreenVersionText.cs
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServer.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServer.cs
deleted file mode 100644
index c4236f80ba..0000000000
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServer.cs
+++ /dev/null
@@ -1,373 +0,0 @@
-using System;
-using System.Collections;
-using System.Diagnostics;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using NitroxClient.Communication.Abstract;
-using NitroxClient.Communication.Exceptions;
-using NitroxClient.Communication.MultiplayerSession;
-using NitroxClient.GameLogic.PlayerLogic.PlayerPreferences;
-using NitroxClient.Unity.Helper;
-using NitroxModel.Core;
-using NitroxModel.DataStructures.Util;
-using NitroxModel.MultiplayerSession;
-using NitroxModel_Subnautica.DataStructures;
-using UnityEngine;
-
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
-
-public class JoinServer : MonoBehaviour
-{
-    private readonly JoinServerJoinWindow joinWindow = new();
-    private PlayerPreferenceManager preferencesManager;
-    private PlayerPreference activePlayerPreference;
-    private IMultiplayerSession multiplayerSession;
-
-    private Rect serverPasswordWindowRect = new(Screen.width / 2 - 250, 200, 500, 200);
-
-    private GameObject multiplayerClient;
-
-    private string serverIp;
-    private int serverPort;
-
-    private bool shouldFocus;
-    private bool showingPasswordWindow;
-    private bool passwordEntered;
-    private string serverPassword = string.Empty;
-
-    private GameObject joinServerMenu;
-    public string MenuName => joinServerMenu.AliveOrNull()?.name ?? throw new Exception("Menu not yet initialized");
-
-    public void Setup(GameObject saveGameMenu)
-    {
-        JoinServerServerList.InitializeServerList(saveGameMenu, out joinServerMenu, out RectTransform joinServerBackground);
-        UWE.CoroutineUtils.StartCoroutineSmart(joinWindow.Initialize(joinServerBackground, OnJoinClick, () => OnCancelClick(true)));
-
-        DontDestroyOnLoad(gameObject);
-        Hide();
-    }
-
-    public async Task ShowAsync(string ip, int port)
-    {
-        NitroxServiceLocator.BeginNewLifetimeScope();
-        multiplayerSession = NitroxServiceLocator.LocateService<IMultiplayerSession>();
-        preferencesManager = NitroxServiceLocator.LocateService<PlayerPreferenceManager>();
-
-        await joinWindow.IsReady();
-
-        gameObject.SetActive(true);
-        serverIp = ip;
-        serverPort = port;
-
-        //Set Server IP in info label
-        joinWindow.SetIP(serverIp);
-
-        //Initialize elements from preferences
-        activePlayerPreference = preferencesManager.GetPreference(serverIp);
-        joinWindow.SubscribeColorChanged();
-
-        // HSV => Hue Saturation Value, HSB => Hue Saturation Brightness
-        Color.RGBToHSV(activePlayerPreference.PreferredColor(), out float hue, out _, out float brightness);
-        joinWindow.SetHSB(new Vector3(hue, 1f, brightness));
-
-        joinWindow.PlayerName = activePlayerPreference.PlayerName;
-
-        await StartMultiplayerClientAsync();
-    }
-
-    private void Hide()
-    {
-        joinWindow.UnsubscribeColorChanged();
-        gameObject.SetActive(false);
-    }
-
-    private void Update()
-    {
-        if (multiplayerSession.CurrentState.CurrentStage != MultiplayerSessionConnectionStage.AWAITING_RESERVATION_CREDENTIALS ||
-            gameObject.GetComponent<JoinServerNotification>())
-        {
-            return;
-        }
-
-        if (UnityEngine.Input.GetKeyDown(KeyCode.Return))
-        {
-            OnJoinClick();
-        }
-        else if (UnityEngine.Input.GetKeyDown(KeyCode.Escape))
-        {
-            OnCancelClick(true);
-        }
-    }
-
-    private void OnGUI()
-    {
-        if (showingPasswordWindow)
-        {
-            serverPasswordWindowRect = GUILayout.Window(
-                GUIUtility.GetControlID(FocusType.Keyboard),
-                serverPasswordWindowRect,
-                DoServerPasswordWindow,
-                Language.main.Get("Nitrox_JoinServerPasswordHeader")
-            );
-        }
-    }
-
-    private void OnDestroy()
-    {
-        joinWindow.UnsubscribeColorChanged();
-    }
-
-    private void FocusPlayerNameTextBox()
-    {
-        joinWindow.ActivateInputField();
-    }
-
-    private async System.Threading.Tasks.Task StartMultiplayerClientAsync()
-    {
-        if (!multiplayerClient)
-        {
-            multiplayerClient = new GameObject("Multiplayer Client");
-            multiplayerClient.AddComponent<Multiplayer>();
-            multiplayerSession.ConnectionStateChanged += SessionConnectionStateChangedHandler;
-        }
-
-        try
-        {
-            await multiplayerSession.ConnectAsync(serverIp, serverPort);
-        }
-        catch (ClientConnectionFailedException ex)
-        {
-            Log.ErrorSensitive("Unable to contact the remote server at: {ip}:{port}", serverIp, serverPort);
-            Log.InGame($"{Language.main.Get("Nitrox_UnableToConnect")} {serverIp}:{serverPort}");
-
-            if (serverIp.Equals("127.0.0.1"))
-            {
-                if (Process.GetProcessesByName("NitroxServer-Subnautica").Length == 0)
-                {
-                    Log.Error("No server process was found while address was 127.0.0.1");
-                    Log.InGame(Language.main.Get("Nitrox_StartServer"));
-                }
-                else
-                {
-                    Log.Error(ex);
-                    Log.InGame(Language.main.Get("Nitrox_FirewallInterfering"));
-                }
-            }
-
-            OnCancelClick(false);
-        }
-    }
-
-    private void OnCancelClick(bool returnToMpMenu)
-    {
-        StopMultiplayerClient();
-        if (returnToMpMenu)
-        {
-            MainMenuRightSide.main.OpenGroup("Multiplayer");
-        }
-
-        Hide();
-    }
-
-    private void OnJoinClick()
-    {
-        string playerName = joinWindow.PlayerName;
-
-        //https://regex101.com/r/eTWiEs/2/
-        if (!Regex.IsMatch(playerName, @"^[a-zA-Z0-9._-]{3,25}$"))
-        {
-            NotifyUser(Language.main.Get("Nitrox_InvalidUserName"));
-            return;
-        }
-
-        preferencesManager.SetPreference(serverIp, new PlayerPreference(playerName, joinWindow.GetCurrentColor()));
-
-        AuthenticationContext authenticationContext = new(playerName, passwordEntered ? Optional.Of(serverPassword) : Optional.Empty);
-
-        multiplayerSession.RequestSessionReservation(new PlayerSettings(joinWindow.GetCurrentColor().ToDto()), authenticationContext);
-    }
-
-    private void SessionConnectionStateChangedHandler(IMultiplayerSessionConnectionState state)
-    {
-        switch (state.CurrentStage)
-        {
-            case MultiplayerSessionConnectionStage.ESTABLISHING_SERVER_POLICY:
-                Log.Info("Requesting session policy info");
-                Log.InGame(Language.main.Get("Nitrox_RequestingSessionPolicy"));
-                break;
-
-            case MultiplayerSessionConnectionStage.AWAITING_RESERVATION_CREDENTIALS:
-                if (multiplayerSession.SessionPolicy.RequiresServerPassword)
-                {
-                    Log.Info("Waiting for server password input");
-                    Log.InGame(Language.main.Get("Nitrox_WaitingPassword"));
-                    showingPasswordWindow = true;
-                    shouldFocus = true;
-                }
-
-                Log.Info("Waiting for user input");
-                Log.InGame(Language.main.Get("Nitrox_WaitingUserInput"));
-                MainMenuRightSide.main.OpenGroup("Join Server");
-                FocusPlayerNameTextBox();
-                break;
-
-            case MultiplayerSessionConnectionStage.SESSION_RESERVED:
-                Log.Info("Launching game");
-                Log.InGame(Language.main.Get("Nitrox_LaunchGame"));
-                multiplayerSession.ConnectionStateChanged -= SessionConnectionStateChangedHandler;
-                preferencesManager.Save();
-
-#pragma warning disable CS0618 // God Damn it UWE...
-                Multiplayer.SubnauticaLoadingStarted();
-                IEnumerator startNewGame = uGUI_MainMenu.main.StartNewGame(GameMode.Survival);
-#pragma warning restore CS0618 // God damn it UWE...
-                StartCoroutine(startNewGame);
-                LoadingScreenVersionText.Initialize();
-
-                break;
-
-            case MultiplayerSessionConnectionStage.SESSION_RESERVATION_REJECTED:
-                Log.Info("Reservation rejected");
-                Log.InGame(Language.main.Get("Nitrox_RejectedSessionPolicy"));
-
-                MultiplayerSessionReservationState reservationState = multiplayerSession.Reservation.ReservationState;
-
-                string reservationRejectionNotification = reservationState.Describe();
-
-                NotifyUser(
-                    reservationRejectionNotification,
-                    () =>
-                    {
-                        multiplayerSession.Disconnect();
-                        multiplayerSession.ConnectAsync(serverIp, serverPort);
-                    });
-                break;
-
-            case MultiplayerSessionConnectionStage.DISCONNECTED:
-                Log.Info(Language.main.Get("Nitrox_DisconnectedSession"));
-                break;
-        }
-    }
-
-    private void NotifyUser(string notificationMessage, Action continuationAction = null)
-    {
-        if (gameObject.GetComponent<JoinServerNotification>())
-        {
-            return;
-        }
-
-        JoinServerNotification notificationDialog = gameObject.AddComponent<JoinServerNotification>();
-        notificationDialog.ShowNotification(notificationMessage, () =>
-        {
-            continuationAction?.Invoke();
-            Destroy(gameObject.GetComponent<JoinServerNotification>(), 0.0001f);
-        });
-    }
-
-    public void StopMultiplayerClient()
-    {
-        if (!multiplayerClient)
-        {
-            return;
-        }
-
-        Multiplayer.Main.StopCurrentSession();
-        Destroy(multiplayerClient);
-        multiplayerClient = null;
-        if (multiplayerSession != null)
-        {
-            multiplayerSession.ConnectionStateChanged -= SessionConnectionStateChangedHandler;
-        }
-    }
-
-    private void DoServerPasswordWindow(int windowId)
-    {
-        GUISkin GetGUISkin() => GUISkinUtils.RegisterDerivedOnce("menus.serverPassword",
-                                                                 s =>
-                                                                 {
-                                                                     s.textField.fontSize = 14;
-                                                                     s.textField.richText = false;
-                                                                     s.textField.alignment = TextAnchor.MiddleLeft;
-                                                                     s.textField.wordWrap = true;
-                                                                     s.textField.stretchHeight = true;
-                                                                     s.textField.padding = new RectOffset(10, 10, 5, 5);
-
-                                                                     s.label.fontSize = 14;
-                                                                     s.label.alignment = TextAnchor.MiddleRight;
-                                                                     s.label.stretchHeight = true;
-                                                                     s.label.fixedWidth = 80; //change this when adding new labels that need more space.
-
-                                                                     s.button.fontSize = 14;
-                                                                     s.button.stretchHeight = true;
-                                                                 });
-
-        Event e = Event.current;
-        if (e.isKey)
-        {
-            switch (e.keyCode)
-            {
-                case KeyCode.Return:
-                    OnSubmitPasswordButtonClicked();
-                    break;
-                case KeyCode.Escape:
-                    OnCancelButtonClicked();
-                    break;
-            }
-        }
-
-        GUISkinUtils.RenderWithSkin(GetGUISkin(),
-                                    () =>
-                                    {
-                                        using (new GUILayout.VerticalScope("Box"))
-                                        {
-                                            using (new GUILayout.HorizontalScope())
-                                            {
-                                                GUILayout.Label(Language.main.Get("Nitrox_JoinServerPassword"));
-                                                GUI.SetNextControlName("serverPasswordField");
-                                                serverPassword = GUILayout.TextField(serverPassword);
-                                            }
-
-                                            if (GUILayout.Button(Language.main.Get("Nitrox_SubmitPassword")))
-                                            {
-                                                HidePasswordWindow();
-                                                OnSubmitPasswordButtonClicked();
-                                            }
-
-                                            if (GUILayout.Button(Language.main.Get("Nitrox_Cancel")))
-                                            {
-                                                HidePasswordWindow();
-                                                OnCancelClick(true);
-                                            }
-                                        }
-                                    });
-
-        if (shouldFocus)
-        {
-            GUI.FocusControl("serverPasswordField");
-            shouldFocus = false;
-        }
-    }
-
-    private void OnSubmitPasswordButtonClicked()
-    {
-        SubmitPassword();
-        HidePasswordWindow();
-    }
-
-    private void SubmitPassword()
-    {
-        passwordEntered = true;
-    }
-
-    private void OnCancelButtonClicked()
-    {
-        multiplayerSession.Disconnect();
-        HidePasswordWindow();
-    }
-
-    private void HidePasswordWindow()
-    {
-        showingPasswordWindow = false;
-        shouldFocus = false;
-    }
-}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerJoinWindow.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerJoinWindow.cs
deleted file mode 100644
index df08034663..0000000000
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerJoinWindow.cs
+++ /dev/null
@@ -1,291 +0,0 @@
-using System;
-using System.Collections;
-using System.Threading.Tasks;
-using NitroxClient.GameLogic.PlayerLogic.PlayerModel.Abstract;
-using NitroxClient.GameLogic.PlayerLogic.PlayerModel.ColorSwap;
-using NitroxClient.GameLogic.PlayerLogic.PlayerModel.ColorSwap.Strategy;
-using NitroxClient.GameLogic.Settings;
-using NitroxClient.Unity.Helper;
-using TMPro;
-using UnityEngine;
-using UnityEngine.Events;
-using UnityEngine.ResourceManagement.AsyncOperations;
-using UnityEngine.UI;
-
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
-
-public class JoinServerJoinWindow
-{
-    private readonly TaskCompletionSource<bool> isInitialised = new(false);
-
-    private GameObject playerSettingsPanel;
-    private uGUI_ColorPicker colorPicker;
-    private TextMeshProUGUI lowerDetailText;
-    private uGUI_InputField playerNameInputField;
-
-    private bool isColorPickerSubscribed;
-
-    public string PlayerName
-    {
-        get => playerNameInputField.text;
-        set => playerNameInputField.text = value;
-    }
-
-    public void ActivateInputField() => playerNameInputField.ActivateInputField();
-
-    public void SetIP(string serverIp) => lowerDetailText.text = $"{Language.main.Get("Nitrox_JoinServerIpAddress")}{Environment.NewLine}{(NitroxPrefs.HideIp.Value ? "****" : serverIp)}";
-
-    public void SetHSB(Vector3 hsb) => colorPicker.SetHSB(hsb);
-
-    public Color GetCurrentColor() => colorPicker.currentColor;
-
-    public void SubscribeColorChanged()
-    {
-        if (isColorPickerSubscribed)
-        {
-            return;
-        }
-
-        colorPicker.onColorChange.AddListener(OnColorChange);
-
-        isColorPickerSubscribed = true;
-    }
-
-    public void UnsubscribeColorChanged()
-    {
-        if (!playerSettingsPanel || !isColorPickerSubscribed)
-        {
-            return;
-        }
-
-        colorPicker.onColorChange.RemoveListener(OnColorChange);
-        isColorPickerSubscribed = false;
-    }
-
-    private void OnColorChange(ColorChangeEventData eventData)
-    {
-        Color selectedColor = eventData.color;
-
-        GameObject selectedColorGameObject = playerSettingsPanel.RequireGameObject("BaseTab/SelectedColor");
-
-        Image baseTabSelectedColorImage = selectedColorGameObject.GetComponent<Image>();
-        baseTabSelectedColorImage.color = selectedColor;
-    }
-
-    //This configures and re-positions the elements on the default "ColorGreyscale" menu to suite our purposes now.
-    public IEnumerator Initialize(RectTransform joinServerBackground, UnityAction joinButtonCall, UnityAction cancelButtonCall)
-    {
-        AsyncOperationHandle<GameObject> request = AddressablesUtility.LoadAsync<GameObject>("Assets/Prefabs/Base/GeneratorPieces/BaseMoonpoolUpgradeConsole.prefab");
-        yield return request;
-        GameObject colorPickerPanelPrototype = request.Result.RequireGameObject("EditScreen/Active");
-
-        InstantiateColorPickerPanelPrototype(colorPickerPanelPrototype, out playerSettingsPanel);
-        InitializePlayerSettingsPanelElement(playerSettingsPanel, joinServerBackground);
-        InitializeBaseTabElement(playerSettingsPanel, joinServerBackground);
-        InitializeLowerDetailElement(playerSettingsPanel, out lowerDetailText);
-        InitializePlayerNameInputElement(playerSettingsPanel, out playerNameInputField);
-        InitializeColorPickerComponent(playerSettingsPanel, out colorPicker);
-        InitializeColorPickerElement(playerSettingsPanel);
-        InitializeButtonElements(playerSettingsPanel, joinServerBackground, joinButtonCall, cancelButtonCall);
-        
-        isInitialised.SetResult(true);
-    }
-
-    public Task IsReady() => isInitialised.Task;
-
-    //Join and Cancel buttons
-    private static void InitializeButtonElements(GameObject playerSettingsPanel, RectTransform joinServerBackground, UnityAction joinButtonCall, UnityAction cancelButtonCall)
-    {
-        GameObject cancelButtonGameObject = playerSettingsPanel.RequireGameObject("Button");
-        GameObject joinButtonGameObject = UnityEngine.Object.Instantiate(cancelButtonGameObject, playerSettingsPanel.transform, false);
-
-        //Click events
-        Button joinButton = joinButtonGameObject.GetComponent<Button>();
-        joinButton.onClick.AddListener(joinButtonCall);
-
-        Button cancelButton = cancelButtonGameObject.GetComponent<Button>();
-        cancelButton.onClick.AddListener(cancelButtonCall);
-
-        RectTransform joinButtonTransform = (RectTransform)joinButtonGameObject.transform;
-        joinButtonTransform.anchoredPosition = new Vector2(
-            joinServerBackground.rect.width / 2f - joinButtonTransform.rect.width / 2f + 20f,
-            -1f * (joinServerBackground.rect.height / 2f) + joinButtonTransform.rect.height / 2f + 3f);
-
-        RectTransform cancelButtonTransform = (RectTransform)cancelButtonGameObject.transform;
-        GameObject cancelButtonTextGameObject = cancelButtonTransform.RequireGameObject("Text");
-        cancelButtonTextGameObject.GetComponent<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Cancel");
-
-        cancelButtonTransform.sizeDelta = new Vector2(cancelButtonTransform.rect.width * 0.85f, cancelButtonTransform.rect.height);
-        cancelButtonTransform.anchoredPosition = new Vector2(
-            -1f * joinServerBackground.rect.width / 2f + cancelButtonTransform.rect.width / 2f,
-            -1f * (joinServerBackground.rect.height / 2f) + cancelButtonTransform.rect.height / 2f + 3f);
-
-        //Flip the button over
-        joinButtonTransform.sizeDelta = new Vector2(joinButtonTransform.rect.width * 0.85f, joinButtonTransform.rect.height);
-        joinButtonTransform.Rotate(Vector3.forward * -180);
-
-        GameObject joinButtonTextGameObject = joinButtonTransform.RequireGameObject("Text");
-        joinButtonTextGameObject.GetComponent<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Join");
-
-        //Flip the text so it is no longer upside down after flipping the button.
-        RectTransform joinButtonTextRectTransform = (RectTransform)joinButtonTextGameObject.transform;
-        joinButtonTextRectTransform.Rotate(Vector3.forward * -180);
-    }
-
-    private static void InstantiateColorPickerPanelPrototype(GameObject colorPickerPanelPrototype, out GameObject playerSettingsPanel)
-    {
-        //Create a clone of the RocketBase color picker panel.
-        playerSettingsPanel = UnityEngine.Object.Instantiate(colorPickerPanelPrototype);
-        GameObject baseTab = playerSettingsPanel.RequireGameObject("BaseTab");
-        GameObject serverNameLabel = playerSettingsPanel.RequireGameObject("Name Label");
-        GameObject stripe1Tab = playerSettingsPanel.RequireGameObject("Stripe1Tab");
-        GameObject interiorTab = playerSettingsPanel.RequireGameObject("InteriorTab");
-        GameObject nameTab = playerSettingsPanel.RequireGameObject("NameTab");
-        GameObject colorLabel = playerSettingsPanel.RequireGameObject("Color Label");
-
-        //Enables pointer events that are a required for the uGUI_ColorPicker to work.
-        CanvasGroup colorPickerCanvasGroup = playerSettingsPanel.AddComponent<CanvasGroup>();
-        colorPickerCanvasGroup.blocksRaycasts = true;
-        colorPickerCanvasGroup.ignoreParentGroups = true;
-        colorPickerCanvasGroup.interactable = true;
-
-        //Destroy everything that we know we will not be using.
-        UnityEngine.Object.Destroy(playerSettingsPanel.GetComponent<uGUI_NavigableControlGrid>());
-        UnityEngine.Object.Destroy(playerSettingsPanel.GetComponent<Image>());
-        UnityEngine.Object.Destroy(baseTab.GetComponent<Button>());
-        UnityEngine.Object.Destroy(stripe1Tab);
-        UnityEngine.Object.Destroy(interiorTab);
-        UnityEngine.Object.Destroy(nameTab);
-        UnityEngine.Object.Destroy(colorLabel);
-        UnityEngine.Object.Destroy(serverNameLabel);
-    }
-
-    //This panel acts as the parent of all other UI elements on the menu. It is parented by the cloned "SaveGame" menu.
-    private static void InitializePlayerSettingsPanelElement(GameObject playerSettingsPanel, RectTransform joinServerBackground)
-    {
-        playerSettingsPanel.SetActive(true);
-
-        RectTransform playerSettingsPanelTransform = (RectTransform)playerSettingsPanel.transform;
-        playerSettingsPanelTransform.SetParent(joinServerBackground, false);
-        playerSettingsPanelTransform.anchorMin = new Vector2(0f, 0f);
-        playerSettingsPanelTransform.anchorMax = new Vector2(1f, 1f);
-        playerSettingsPanelTransform.pivot = new Vector2(0.5f, 0.5f);
-        playerSettingsPanelTransform.localScale = Vector3.one;
-    }
-
-    //The base tab is the outline surrounding the color picker, as well as teh "Player Color" label and associated "Selected Color" image.
-    private static void InitializeBaseTabElement(GameObject playerSettingsPanel, RectTransform joinServerBackground)
-    {
-        GameObject baseTab = playerSettingsPanel.RequireGameObject("BaseTab");
-
-        //Re-position the border
-        RectTransform baseTabTransform = (RectTransform)baseTab.transform;
-        baseTabTransform.anchoredPosition = new Vector2(0.5f, 0.5f);
-        baseTabTransform.anchorMin = new Vector2(0.5f, 0.5f);
-        baseTabTransform.anchorMax = new Vector2(0.5f, 0.5f);
-        baseTabTransform.pivot = new Vector2(0.5f, 0.5f);
-
-        //Resize the border to match the new parent. Capture the original width so we can make adjustments to child controls later
-        //because the existing elements all have some really weird anchor settings the prevent them from moving automatically.
-        float originalBaseTabWidth = baseTabTransform.rect.width;
-        baseTabTransform.sizeDelta = new Vector2(joinServerBackground.rect.width, baseTabTransform.rect.height);
-
-        //Move the SelectedColor element over to the right enough to match the shrinkage of the base tab.
-        GameObject baseTabSelectedColor = baseTabTransform.RequireGameObject("SelectedColor");
-        Image baseTabSelectedColorImage = baseTabSelectedColor.GetComponent<Image>();
-        baseTabSelectedColorImage.rectTransform.anchoredPosition += new Vector2((originalBaseTabWidth - baseTabTransform.rect.width) / 2, 0);
-
-        //Place the "Player Color" label to the right of the SelectedColor image and shrink it to fit the new tab region.
-        GameObject baseTabTextGameObject = baseTabTransform.RequireGameObject("Text");
-        RectTransform baseTabTextTransform = (RectTransform)baseTabTextGameObject.transform;
-        baseTabTextTransform.anchorMin = new Vector2(0.5f, 0.5f);
-        baseTabTextTransform.anchorMax = new Vector2(0.5f, 0.5f);
-        baseTabTextTransform.pivot = new Vector2(0.5f, 0.5f);
-        baseTabTextTransform.sizeDelta = new Vector2(80, 35);
-
-        baseTabTextTransform.anchoredPosition += new Vector2(baseTabTextTransform.rect.width / 2f + 22f, 0);
-
-        baseTabTextGameObject.GetComponent<TextMeshProUGUI>().text = Language.main.Get("Nitrox_PlayerColor");
-
-        //This resizes the actual Image that outlines all of the UI elements.
-        GameObject baseTabBackgroundGameObject = baseTabTransform.RequireGameObject("Background");
-        Image baseTabBackgroundImage = baseTabBackgroundGameObject.GetComponent<Image>();
-        baseTabBackgroundImage.rectTransform.sizeDelta = new Vector2(joinServerBackground.rect.width, baseTabTransform.rect.height);
-
-        //This removes the extra "tabs" from the base texture.
-        Texture2D newBaseTabTexture = baseTabBackgroundImage.sprite.texture.Clone();
-        TextureBlock textureBlock = new TextureBlock(3, 3, 160, (int)(baseTabBackgroundImage.sprite.textureRect.height - 71f));
-        IColorSwapStrategy alphaChannelSwapper = new AlphaChannelSwapper(0f);
-        HsvSwapper baseTabBackgroundSwapper = new HsvSwapper(alphaChannelSwapper);
-        baseTabBackgroundSwapper.SetHueRange(185f, 215f);
-        baseTabBackgroundSwapper.SetAlphaRange(0f, 175f);
-        newBaseTabTexture.SwapTextureColors(baseTabBackgroundSwapper, textureBlock);
-        baseTabBackgroundImage.sprite = Sprite.Create(newBaseTabTexture, new Rect(baseTabBackgroundImage.sprite.textureRect), new Vector2(0f, 0f));
-    }
-
-    //The LowerDetail is the region that displays the current Server IP and the graphic that appears beneath it.
-    private static void InitializeLowerDetailElement(GameObject playerSettingsPanel, out TextMeshProUGUI lowerDetailText)
-    {
-        GameObject lowerDetail = playerSettingsPanel.RequireGameObject("LowerDetail");
-
-        //We use this as a reference point for positioning the LowerDetail element.
-        RectTransform baseTabTextTransform = (RectTransform)playerSettingsPanel.RequireTransform("BaseTab/Text");
-
-        RectTransform lowerDetailRectTransform = (RectTransform)lowerDetail.transform;
-        lowerDetailRectTransform.anchorMin = new Vector2(0.5f, 0.5f);
-        lowerDetailRectTransform.anchorMax = new Vector2(0.5f, 0.5f);
-        lowerDetailRectTransform.pivot = new Vector2(0.5f, 0.5f);
-        lowerDetailRectTransform.anchoredPosition = baseTabTextTransform.anchoredPosition - new Vector2(230f, -120f);
-
-        //The text element is right-aligned by default and needs to be centered for our purposes
-        GameObject lowerDetailTextGameObject = lowerDetailRectTransform.RequireGameObject("Text");
-        lowerDetailText = lowerDetailTextGameObject.GetComponent<TextMeshProUGUI>();
-        lowerDetailText.autoSizeTextContainer = true;
-        lowerDetailText.alignment = TextAlignmentOptions.Center;
-
-        RectTransform lowerDetailTextRectTransform = (RectTransform)lowerDetailTextGameObject.transform;
-        lowerDetailTextRectTransform.anchorMin = new Vector2(0.5f, 0.5f);
-        lowerDetailTextRectTransform.anchorMax = new Vector2(0.5f, 0.5f);
-        lowerDetailTextRectTransform.pivot = new Vector2(0.5f, 0.5f);
-        lowerDetailTextRectTransform.anchoredPosition = new Vector2(0, 0);
-
-        //Delete the pixels under the IP
-        UnityEngine.Object.Destroy(lowerDetail.RequireGameObject("Pixels"));
-    }
-
-    //Player name text box
-    private static void InitializePlayerNameInputElement(GameObject playerSettingsPanel, out uGUI_InputField playerNameInputField)
-    {
-        GameObject playerNameInputFieldGameObject = playerSettingsPanel.RequireGameObject("InputField");
-        RectTransform inputFieldRectTransform = (RectTransform)playerNameInputFieldGameObject.transform;
-        inputFieldRectTransform.anchoredPosition -= new Vector2(0, 15f);
-
-        playerNameInputField = playerNameInputFieldGameObject.GetComponent<uGUI_InputField>();
-        playerNameInputField.selectionColor = Color.white;
-
-        GameObject inputFieldPlaceholder = inputFieldRectTransform.RequireGameObject("Placeholder");
-        inputFieldPlaceholder.GetComponent<TextMeshProUGUI>().text = Language.main.Get("Nitrox_EnterName");
-    }
-
-    //This is the "service" that manages the click and drag events on the color picture RectTransform.
-    private static void InitializeColorPickerComponent(GameObject playerSettingsPanel, out uGUI_ColorPicker colorPicker)
-    {
-        colorPicker = playerSettingsPanel.GetComponentInChildren<uGUI_ColorPicker>();
-        colorPicker.onColorChange.RemoveAllListeners();
-
-        //Don't let users apply a greyscale just yet. We have not quality tested the existing recoloring solution to know if it will behave as expected.
-        colorPicker.saturationSlider.gameObject.SetActive(false);
-        colorPicker.SetSaturation(1f);
-    }
-
-    //This the the actual color picker that renders on the screen.
-    private static void InitializeColorPickerElement(GameObject playerSettingsPanel)
-    {
-        GameObject colorPickerGameObject = playerSettingsPanel.RequireGameObject("ColorPicker");
-        RectTransform colorPickerGameObjectTransform = (RectTransform)colorPickerGameObject.transform;
-        colorPickerGameObjectTransform.anchorMin = new Vector2(0f, 0f);
-        colorPickerGameObjectTransform.anchorMax = new Vector2(1f, 1f);
-        colorPickerGameObjectTransform.pivot = new Vector2(0.5f, 0.5f);
-        colorPickerGameObjectTransform.anchoredPosition = new Vector2(40f, 0f);
-    }
-}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerNotification.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerNotification.cs
deleted file mode 100644
index 7043064606..0000000000
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerNotification.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-using System;
-using NitroxClient.Unity.Helper;
-using UnityEngine;
-
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu
-{
-    //I'd like to see about skinning this behavior with the notification window that appears at the bottom of the screen during certain story events in the game.
-    public class JoinServerNotification : MonoBehaviour
-    {
-        private bool awaitingAcknowledgement;
-        private Action continuationAction;
-        private string notificationMessage;
-        private Rect notificationWindowRect = new Rect(Screen.width / 2 - 250, 200, 500, 150);
-
-        public void Update()
-        {
-            if (UnityEngine.Input.GetKeyDown(KeyCode.Return) ||
-                UnityEngine.Input.GetKeyDown(KeyCode.Escape))
-            {
-                AcknowledgeNotification();
-            }
-        }
-
-        public void OnGUI()
-        {
-            if (!string.IsNullOrEmpty(notificationMessage) && awaitingAcknowledgement)
-            {
-                notificationWindowRect = GUILayout.Window(GUIUtility.GetControlID(FocusType.Keyboard), notificationWindowRect, RenderUnableToJoinDialog, Language.main.Get("Nitrox_JoinServerFailed"));
-            }
-        }
-
-        public void ShowNotification(string notificationMessage, Action continuationAction)
-        {
-            this.notificationMessage = notificationMessage;
-            this.continuationAction = continuationAction;
-
-            awaitingAcknowledgement = true;
-        }
-
-        private void RenderUnableToJoinDialog(int windowId)
-        {
-            GUISkinUtils.RenderWithSkin(GetGUISkin("dialogs.server.rejected", 550), () =>
-            {
-                using (new GUILayout.VerticalScope("Box"))
-                {
-                    using (new GUILayout.HorizontalScope())
-                    {
-                        GUILayout.Label(notificationMessage);
-                    }
-
-                    if (GUILayout.Button("OK"))
-                    {
-                        AcknowledgeNotification();
-                    }
-                }
-            });
-        }
-
-        private void AcknowledgeNotification()
-        {
-            awaitingAcknowledgement = false;
-            continuationAction?.Invoke();
-        }
-
-        private GUISkin GetGUISkin(string skinName, int labelWidth)
-        {
-            return GUISkinUtils.RegisterDerivedOnce(skinName, s =>
-            {
-                s.textField.fontSize = 20;
-                s.textField.richText = false;
-                s.textField.alignment = TextAnchor.MiddleCenter;
-                s.textField.wordWrap = true;
-                s.textField.stretchHeight = true;
-                s.textField.padding = new RectOffset(10, 10, 5, 5);
-
-                s.label.fontSize = 20;
-                s.label.alignment = TextAnchor.MiddleCenter;
-                s.label.stretchHeight = true;
-                s.label.fixedWidth = labelWidth;
-
-                s.button.fontSize = 16;
-                s.button.stretchHeight = true;
-            });
-        }
-    }
-}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerServerList.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerServerList.cs
deleted file mode 100644
index 095f21cba5..0000000000
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/JoinServerServerList.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-using NitroxClient.Unity.Helper;
-using UnityEngine;
-using UnityEngine.UI;
-
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
-
-public static class JoinServerServerList
-{
-    //This method merges the cloned color picker element with the existing template for menus that appear in the "right side" region of the main menu.
-    public static void InitializeServerList(GameObject saveGameMenuPrototype, out GameObject joinServerMenu, out RectTransform joinServerBackground)
-    {
-        MainMenuRightSide rightSideMainMenu = MainMenuRightSide.main;
-
-        joinServerMenu = CloneSaveGameMenuPrototype(saveGameMenuPrototype);
-
-        joinServerMenu.transform.SetParent(rightSideMainMenu.transform, false);
-        rightSideMainMenu.groups.Add(joinServerMenu.GetComponent<MainMenuGroup>());
-
-        //Not sure what is up with this menu, but we have to use the RectTransform of the Image component as the parent for our color picker panel.
-        //Most of the UI elements seem to vanish behind this Image otherwise.
-        joinServerBackground = joinServerMenu.GetComponent<Image>().rectTransform;
-        joinServerBackground.anchorMin = new Vector2(0.5f, 0.5f);
-        joinServerBackground.anchorMax = new Vector2(0.5f, 0.5f);
-        joinServerBackground.pivot = new Vector2(0.5f, 0.5f);
-        joinServerBackground.anchoredPosition = new Vector2(joinServerBackground.anchoredPosition.x, 5f);
-    }
-
-    private static GameObject CloneSaveGameMenuPrototype(GameObject saveGameMenuPrototype)
-    {
-        GameObject joinServerMenu = Object.Instantiate(saveGameMenuPrototype);
-        Object.Destroy(joinServerMenu.RequireGameObject("Header"));
-        Object.Destroy(joinServerMenu.RequireGameObject("Scroll View"));
-        Object.Destroy(joinServerMenu.GetComponent<LayoutGroup>());
-        Object.Destroy(joinServerMenu.GetComponent<MainMenuLoadPanel>());
-        joinServerMenu.GetAllComponentsInChildren<LayoutGroup>().ForEach(Object.Destroy);
-
-        //We cannot register click events on child transforms if they are being captured here.
-        joinServerMenu.GetComponent<CanvasGroup>().blocksRaycasts = false;
-        joinServerMenu.name = "Join Server";
-
-        return joinServerMenu;
-    }
-}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs
new file mode 100644
index 0000000000..6bff0ddd35
--- /dev/null
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs
@@ -0,0 +1,177 @@
+using System;
+using System.Collections;
+using System.Linq;
+using NitroxClient.Unity.Helper;
+using TMPro;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.ResourceManagement.AsyncOperations;
+using UnityEngine.UI;
+
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
+
+public class MainMenuNotificationPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver
+{
+    public const string NAME = "MultiplayerNotification";
+
+    private static MainMenuNotificationPanel instance;
+
+    private Image loadingCircle;
+    private TextMeshProUGUI text;
+    private GameObject confirmObject;
+    private Button confirmButton;
+    private mGUI_Change_Legend_On_Select confirmButtonLegend;
+    private LegendButtonData[] savedLegendData;
+
+    private string returningMenuPanel;
+    private Action continuationAction;
+
+    public static void ShowLoading()
+    {
+        if (!instance)
+        {
+            Log.Error("Tried to use ShowLoading() while MainMenuJoinServerNotificationPanel was not ready");
+            return;
+        }
+
+        instance.confirmObject.SetActive(false);
+        instance.loadingCircle.gameObject.SetActive(true);
+        instance.text.text = "Loading";
+        MainMenuRightSide.main.OpenGroup(NAME);
+        instance.confirmButtonLegend.legendButtonConfiguration = Array.Empty<LegendButtonData>();
+    }
+
+    public static void ShowMessage(string message, string returningMenuPanel, Action continuationAction = null)
+    {
+        if (!instance)
+        {
+            Log.Error("Tried to use ShowMessage() while MainMenuJoinServerNotificationPanel was not ready");
+            return;
+        }
+
+        instance.text.text = message;
+        instance.returningMenuPanel = returningMenuPanel;
+        instance.continuationAction = continuationAction;
+        instance.confirmObject.SetActive(true);
+        instance.loadingCircle.gameObject.SetActive(false);
+        MainMenuRightSide.main.OpenGroup(NAME);
+        instance.confirmButtonLegend.legendButtonConfiguration = instance.savedLegendData;
+    }
+
+    public void Setup(GameObject savedGamesRef)
+    {
+        instance = this;
+        Destroy(transform.RequireGameObject("Scroll View"));
+        Destroy(GetComponentInChildren<TranslationLiveUpdate>());
+
+        text = GetComponentInChildren<TextMeshProUGUI>();
+        text.transform.localPosition = new Vector3(-375, 350, 0);
+        text.GetComponent<RectTransform>().sizeDelta = new Vector2(350, 280);
+
+        GameObject multiplayerButtonRef = savedGamesRef.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame");
+
+        confirmObject = Instantiate(multiplayerButtonRef, transform, false);
+        confirmObject.transform.localPosition = new Vector3(-200, 50, 0);
+        confirmObject.transform.localScale = new Vector3(1.25f, 1.25f, 1.25f);
+        confirmObject.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
+        confirmObject.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_OK");
+        confirmButton = confirmObject.RequireTransform("NewGameButton").GetComponent<Button>();
+        confirmButton.onClick.RemoveAllListeners();
+        confirmButton.onClick.AddListener(() =>
+        {
+            continuationAction?.Invoke();
+            if (!string.IsNullOrEmpty(returningMenuPanel))
+            {
+                MainMenuRightSide.main.OpenGroup(returningMenuPanel);
+            }
+        });
+
+        confirmButtonLegend = confirmButton.GetComponent<mGUI_Change_Legend_On_Select>();
+        savedLegendData = confirmButtonLegend.legendButtonConfiguration.Take(1).ToArray();
+
+        GameObject loadingCircleObject = new("LoadingCircle");
+        loadingCircle = loadingCircleObject.AddComponent<Image>();
+        loadingCircleObject.transform.SetParent(transform);
+        loadingCircleObject.transform.localPosition = new Vector3(-200, 180, 0);
+        loadingCircleObject.transform.localRotation = Quaternion.identity;
+        loadingCircleObject.transform.localScale = Vector3.one;
+    }
+
+    private IEnumerator Start()
+    {
+        AsyncOperationHandle<Texture2D> request = AddressablesUtility.LoadAsync<Texture2D>("Assets/uGUI/Sources/Sprites/HUD/Progress.png");
+        yield return request;
+
+        Texture2D tex = request.Result;
+        loadingCircle.sprite = Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), new Vector2(0.5f, 0.5f));
+        loadingCircle.type = Image.Type.Filled;
+    }
+
+    private void Update()
+    {
+        if (loadingCircle)
+        {
+            loadingCircle.transform.localRotation = Quaternion.Euler(0, 0, Time.time % 360 * 250); // 250 is the speed
+            loadingCircle.fillAmount = Mathf.Lerp(0.05f, 0.95f, Math.Abs(Time.time % 6 - 3) * 0.333f); // Lerps t fades from 0 to 1 and back to 0
+            uGUI_LegendBar.ClearButtons();
+        }
+    }
+
+    bool uGUI_INavigableIconGrid.ShowSelector => false;
+    bool uGUI_INavigableIconGrid.EmulateRaycast => false;
+    bool uGUI_INavigableIconGrid.SelectItemClosestToPosition(Vector3 worldPos) => false;
+    uGUI_INavigableIconGrid uGUI_INavigableIconGrid.GetNavigableGridInDirection(int dirX, int dirY) => null;
+    Graphic uGUI_INavigableIconGrid.GetSelectedIcon() => null;
+
+    object uGUI_INavigableIconGrid.GetSelectedItem() => confirmObject ? confirmObject : null;
+
+    public bool SelectItemInDirection(int dirX, int dirY) => SelectFirstItem();
+
+    public bool SelectFirstItem()
+    {
+        if (confirmObject)
+        {
+            SelectItem(confirmObject);
+            return true;
+        }
+
+        return false;
+    }
+
+    public void SelectItem(object item)
+    {
+        DeselectItem();
+        GameObject selectedItem = item as GameObject;
+
+        if (selectedItem && selectedItem == confirmObject)
+        {
+            confirmButton.Select();
+            confirmButtonLegend.SyncLegendBarToGUISelection();
+        }
+    }
+
+    public void DeselectItem()
+    {
+        if (confirmObject)
+        {
+            EventSystem.current.SetSelectedGameObject(null);
+        }
+        uGUI_LegendBar.ClearButtons();
+    }
+
+    public bool OnButtonDown(GameInput.Button button)
+    {
+        switch (button)
+        {
+            case GameInput.Button.UISubmit:
+            case GameInput.Button.UICancel:
+                if (confirmObject.activeSelf)
+                {
+                    confirmButton.onClick.Invoke();
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
index b6a8e9c7ca..00f547c3ba 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
@@ -1,4 +1,6 @@
 using NitroxClient.MonoBehaviours.Discord;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
 using NitroxClient.Unity.Helper;
 using TMPro;
 using UnityEngine;
@@ -11,15 +13,9 @@ public class NitroxMainMenuModifications : MonoBehaviour
 {
     private MainMenuRightSide rightSide;
 
-    private void OnEnable()
-    {
-        SceneManager.sceneLoaded += SceneManager_sceneLoaded;
-    }
+    private void OnEnable() => SceneManager.sceneLoaded += SceneManager_sceneLoaded;
 
-    private void OnDisable()
-    {
-        SceneManager.sceneLoaded -= SceneManager_sceneLoaded;
-    }
+    private void OnDisable() => SceneManager.sceneLoaded -= SceneManager_sceneLoaded;
 
     private void SceneManager_sceneLoaded(Scene scene, LoadSceneMode loadMode)
     {
@@ -63,20 +59,27 @@ GameObject CloneMainMenuLoadPanel(string panelName, string translationKey)
             return menuPanel;
         }
 
-        GameObject serverList = CloneMainMenuLoadPanel("MultiplayerServerList", "Nitrox_Multiplayer");
+        GameObject serverJoinNotification = CloneMainMenuLoadPanel(MainMenuNotificationPanel.NAME, string.Empty);
+        serverJoinNotification.AddComponent<MainMenuNotificationPanel>().Setup(savedGamesRef);
+
+        GameObject serverJoin = CloneMainMenuLoadPanel(MainMenuJoinServerPanel.NAME, "Nitrox_JoinServer");
+        serverJoin.AddComponent<MainMenuJoinServerPanel>().Setup(savedGamesRef);
+
+        GameObject serverList = CloneMainMenuLoadPanel(MainMenuServerListPanel.NAME, "Nitrox_Multiplayer");
         serverList.AddComponent<MainMenuServerListPanel>().Setup(savedGamesRef);
 
-        GameObject serverCreate = CloneMainMenuLoadPanel("MultiplayerCreateServer", "Nitrox_AddServer");
+        GameObject serverCreate = CloneMainMenuLoadPanel(MainMenuCreateServerPanel.NAME, "Nitrox_AddServer");
         serverCreate.AddComponent<MainMenuCreateServerPanel>().Setup(savedGamesRef);
 
 #if RELEASE
-            // Remove singleplayer button because SP is broken when Nitrox is injected. TODO: Allow SP to work and co-exist with Nitrox MP in the future
+            // Remove singleplayer button because SP is broken when Nitrox is injected.
+            // TODO: Allow SP to work and co-exist with Nitrox MP in the future
             startButton.SetActive(false);
 #endif
     }
 
     private void ShowMultiplayerServerList()
     {
-        rightSide.OpenGroup("MultiplayerServerList");
+        rightSide.OpenGroup(MainMenuServerListPanel.NAME);
     }
 }
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
new file mode 100644
index 0000000000..b251e73c3a
--- /dev/null
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
@@ -0,0 +1,196 @@
+using System.Collections;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using NitroxClient.Communication.Abstract;
+using NitroxClient.Communication.Exceptions;
+using NitroxClient.Communication.MultiplayerSession;
+using NitroxClient.GameLogic.PlayerLogic.PlayerPreferences;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
+using NitroxModel.Core;
+using NitroxModel.DataStructures.Util;
+using NitroxModel.MultiplayerSession;
+using NitroxModel_Subnautica.DataStructures;
+using UnityEngine;
+
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
+
+public class JoinServerBackend : MonoBehaviour
+{
+    private static JoinServerBackend instance;
+
+    public static JoinServerBackend Instance
+    {
+        get
+        {
+            if (!instance)
+            {
+                GameObject persistentGameobject = GameObject.Find("Nitrox");
+                instance = persistentGameobject.EnsureComponent<JoinServerBackend>();
+            }
+            return instance;
+        }
+    }
+
+    private PlayerPreferenceManager preferencesManager;
+    private PlayerPreference activePlayerPreference;
+    private IMultiplayerSession multiplayerSession;
+
+    private string serverIp;
+    private int serverPort;
+
+    private MainMenuEnterPasswordPanel passwordPanel;
+
+    public async Task ShowAsync(string ip, int port)
+    {
+        passwordPanel = gameObject.AddComponent<MainMenuEnterPasswordPanel>(); //TODO: Move somewhere else
+
+        serverIp = ip;
+        serverPort = port;
+        Log.Info("JoinServer.ShowAsync()");
+        NitroxServiceLocator.BeginNewLifetimeScope();
+
+        preferencesManager = NitroxServiceLocator.LocateService<PlayerPreferenceManager>();
+        activePlayerPreference = preferencesManager.GetPreference(serverIp);
+
+        multiplayerSession = NitroxServiceLocator.LocateService<IMultiplayerSession>();
+        passwordPanel.Setup(multiplayerSession);
+
+        gameObject.SetActive(true);
+        await StartMultiplayerClientAsync();
+    }
+
+    private GameObject multiplayerClient;
+
+    private async Task StartMultiplayerClientAsync()
+    {
+        if (!multiplayerClient)
+        {
+            multiplayerClient = new GameObject("Multiplayer Client");
+            multiplayerClient.AddComponent<Multiplayer>();
+            multiplayerSession.ConnectionStateChanged += SessionConnectionStateChangedHandler;
+        }
+
+        try
+        {
+            await multiplayerSession.ConnectAsync(serverIp, serverPort);
+        }
+        catch (ClientConnectionFailedException ex)
+        {
+            Log.ErrorSensitive("Unable to contact the remote server at: {ip}:{port}", serverIp, serverPort);
+            string msg = $"{Language.main.Get("Nitrox_UnableToConnect")} {serverIp}:{serverPort}";
+
+            if (serverIp.Equals("127.0.0.1"))
+            {
+                if (Process.GetProcessesByName("NitroxServer-Subnautica").Length == 0)
+                {
+                    Log.Error("No server process was found while address was 127.0.0.1");
+                    msg += $"\n{Language.main.Get("Nitrox_StartServer")}";
+                }
+                else
+                {
+                    Log.Error(ex);
+                    msg += $"\n{Language.main.Get("Nitrox_FirewallInterfering")}";
+                }
+            }
+
+            Log.InGame(msg);
+            StopMultiplayerClient(msg);
+            MainMenuNotificationPanel.ShowMessage(msg, MainMenuServerListPanel.NAME);
+        }
+    }
+
+    public void RequestSessionReservation(string playerName, Color playerColor)
+    {
+        preferencesManager.SetPreference(serverIp, new PlayerPreference(playerName, playerColor));
+
+        Optional<string> opPassword = passwordPanel.passwordEntered ? Optional.Of(passwordPanel.serverPassword) : Optional.Empty;
+        AuthenticationContext authenticationContext = new(playerName, opPassword);
+
+        multiplayerSession.RequestSessionReservation(new PlayerSettings(playerColor.ToDto()), authenticationContext);
+    }
+
+    private void SessionConnectionStateChangedHandler(IMultiplayerSessionConnectionState state)
+    {
+        switch (state.CurrentStage)
+        {
+            case MultiplayerSessionConnectionStage.ESTABLISHING_SERVER_POLICY:
+                Log.Info("Requesting session policy info");
+                Log.InGame(Language.main.Get("Nitrox_RequestingSessionPolicy"));
+                break;
+
+            case MultiplayerSessionConnectionStage.AWAITING_RESERVATION_CREDENTIALS:
+                if (multiplayerSession.SessionPolicy.RequiresServerPassword)
+                {
+                    Log.Info("Waiting for server password input");
+                    Log.InGame(Language.main.Get("Nitrox_WaitingPassword"));
+                    passwordPanel.showingPasswordWindow = true;
+                    passwordPanel.shouldFocus = true;
+                }
+
+                Log.Info("Waiting for user input");
+                Log.InGame(Language.main.Get("Nitrox_WaitingUserInput"));
+                Color.RGBToHSV(activePlayerPreference.PreferredColor(), out float hue, out float saturation, out float brightness); // HSV => Hue Saturation Value, HSB => Hue Saturation Brightness
+                MainMenuJoinServerPanel.Instance.UpdatePanelValues(serverIp, activePlayerPreference.PlayerName, new Vector3(hue, saturation, brightness));
+                MainMenuRightSide.main.OpenGroup(MainMenuJoinServerPanel.NAME);
+                break;
+
+            case MultiplayerSessionConnectionStage.SESSION_RESERVED:
+                Log.Info("Launching game");
+                Log.InGame(Language.main.Get("Nitrox_LaunchGame"));
+                multiplayerSession.ConnectionStateChanged -= SessionConnectionStateChangedHandler;
+                preferencesManager.Save();
+
+#pragma warning disable CS0618 // God Damn it UWE...
+                Multiplayer.SubnauticaLoadingStarted();
+                IEnumerator startNewGame = uGUI_MainMenu.main.StartNewGame(GameMode.Survival);
+#pragma warning restore CS0618 // God damn it UWE...
+                StartCoroutine(startNewGame);
+                LoadingScreenVersionText.Initialize();
+
+                break;
+
+            case MultiplayerSessionConnectionStage.SESSION_RESERVATION_REJECTED:
+                Log.Info("Reservation rejected");
+                Log.InGame(Language.main.Get("Nitrox_RejectedSessionPolicy"));
+
+                MultiplayerSessionReservationState reservationState = multiplayerSession.Reservation.ReservationState;
+
+                string reservationRejectionNotification = reservationState.Describe();
+
+                MainMenuNotificationPanel.ShowMessage(reservationRejectionNotification, null, () =>
+                {
+                    multiplayerSession.Disconnect();
+                    multiplayerSession.ConnectAsync(serverIp, serverPort);
+                });
+
+                break;
+
+            case MultiplayerSessionConnectionStage.DISCONNECTED:
+                Log.Info(Language.main.Get("Nitrox_DisconnectedSession"));
+                break;
+        }
+    }
+
+    // TODO: Maybe move to MainMenuServerListPanel OnEnabled
+    /// <param name="error"> If set to something it will display the message with <see cref="MainMenuNotificationPanel"/> after stopping the client</param>
+    public void StopMultiplayerClient(string error = null)
+    {
+        if (!multiplayerClient || !Multiplayer.Main)
+        {
+            return;
+        }
+
+        Multiplayer.Main.StopCurrentSession();
+        Destroy(multiplayerClient);
+        multiplayerClient = null;
+        if (multiplayerSession != null)
+        {
+            multiplayerSession.ConnectionStateChanged -= SessionConnectionStateChangedHandler;
+        }
+
+        if (error != null)
+        {
+            MainMenuNotificationPanel.ShowMessage($"Connection broke\n+{error}", MainMenuServerListPanel.NAME);
+        }
+    }
+}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs
new file mode 100644
index 0000000000..64afa115c6
--- /dev/null
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs
@@ -0,0 +1,129 @@
+using NitroxClient.Communication.Abstract;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
+using NitroxClient.Unity.Helper;
+using UnityEngine;
+
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
+
+public class MainMenuEnterPasswordPanel : MonoBehaviour
+{
+    public const string NAME = "MultiplayerEnterPassword";
+
+    private Rect serverPasswordWindowRect = new(Screen.width / 2 - 250, 200, 500, 200);
+
+    public string serverPassword;
+    public bool passwordEntered;
+    public bool shouldFocus;
+    public bool showingPasswordWindow;
+    private IMultiplayerSession multiplayerSession;
+
+    public void Setup(IMultiplayerSession _multiplayerSession)
+    {
+        multiplayerSession = _multiplayerSession;
+    }
+
+    private void OnGUI()
+    {
+        if (showingPasswordWindow)
+        {
+            serverPasswordWindowRect = GUILayout.Window(
+                GUIUtility.GetControlID(FocusType.Keyboard),
+                serverPasswordWindowRect,
+                DoServerPasswordWindow,
+                Language.main.Get("Nitrox_JoinServerPasswordHeader")
+            );
+        }
+    }
+
+    public void DoServerPasswordWindow(int windowId)
+    {
+        GUISkin GetGUISkin() => GUISkinUtils.RegisterDerivedOnce("menus.serverPassword",
+                                                                 s =>
+                                                                 {
+                                                                     s.textField.fontSize = 14;
+                                                                     s.textField.richText = false;
+                                                                     s.textField.alignment = TextAnchor.MiddleLeft;
+                                                                     s.textField.wordWrap = true;
+                                                                     s.textField.stretchHeight = true;
+                                                                     s.textField.padding = new RectOffset(10, 10, 5, 5);
+
+                                                                     s.label.fontSize = 14;
+                                                                     s.label.alignment = TextAnchor.MiddleRight;
+                                                                     s.label.stretchHeight = true;
+                                                                     s.label.fixedWidth = 80; //change this when adding new labels that need more space.
+
+                                                                     s.button.fontSize = 14;
+                                                                     s.button.stretchHeight = true;
+                                                                 });
+
+        Event e = Event.current;
+        if (e.isKey)
+        {
+            switch (e.keyCode)
+            {
+                case KeyCode.Return:
+                    OnSubmitPasswordButtonClicked();
+                    break;
+                case KeyCode.Escape:
+                    OnCancelButtonClicked();
+                    break;
+            }
+        }
+
+        GUISkinUtils.RenderWithSkin(GetGUISkin(),
+                                    () =>
+                                    {
+                                        using (new GUILayout.VerticalScope("Box"))
+                                        {
+                                            using (new GUILayout.HorizontalScope())
+                                            {
+                                                GUILayout.Label(Language.main.Get("Nitrox_JoinServerPassword"));
+                                                GUI.SetNextControlName("serverPasswordField");
+                                                serverPassword = GUILayout.TextField(serverPassword);
+                                            }
+
+                                            if (GUILayout.Button(Language.main.Get("Nitrox_SubmitPassword")))
+                                            {
+                                                HidePasswordWindow();
+                                                OnSubmitPasswordButtonClicked();
+                                            }
+
+                                            if (GUILayout.Button(Language.main.Get("Nitrox_Cancel")))
+                                            {
+                                                HidePasswordWindow();
+                                                OnCancelButtonClicked();
+                                                MainMenuRightSide.main.OpenGroup(MainMenuServerListPanel.NAME);
+                                            }
+                                        }
+                                    });
+
+        if (shouldFocus)
+        {
+            GUI.FocusControl("serverPasswordField");
+            shouldFocus = false;
+        }
+    }
+
+    private void OnSubmitPasswordButtonClicked()
+    {
+        SubmitPassword();
+        HidePasswordWindow();
+    }
+
+    private void SubmitPassword()
+    {
+        passwordEntered = true;
+    }
+
+    private void OnCancelButtonClicked()
+    {
+        multiplayerSession.Disconnect();
+        HidePasswordWindow();
+    }
+
+    private void HidePasswordWindow()
+    {
+        showingPasswordWindow = false;
+        shouldFocus = false;
+    }
+}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
new file mode 100644
index 0000000000..ff490dcac4
--- /dev/null
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
@@ -0,0 +1,318 @@
+using System.Collections;
+using System.Linq;
+using System.Text.RegularExpressions;
+using FMODUnity;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
+using NitroxClient.Unity.Helper;
+using TMPro;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.ResourceManagement.AsyncOperations;
+using UnityEngine.UI;
+using UWE;
+
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
+
+public class MainMenuJoinServerPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver, uGUI_IScrollReceiver, uGUI_IAdjustReceiver
+{
+    public const string NAME = "MultiplayerJoinServer";
+
+    public static MainMenuJoinServerPanel Instance { get; private set; }
+
+    private GameObject playerSettingsPanel;
+    private TextMeshProUGUI header;
+    private uGUI_ColorPicker colorPicker;
+    private Slider saturationSlider;
+    private uGUI_InputField playerNameInputField;
+
+    private GameObject selectedItem;
+    private GameObject[] selectableItems;
+
+    public void Setup(GameObject savedGamesRef)
+    {
+        Instance = this;
+        Destroy(transform.RequireGameObject("Scroll View"));
+        Destroy(GetComponentInChildren<TranslationLiveUpdate>());
+        header = GetComponentInChildren<TextMeshProUGUI>();
+
+        CoroutineHost.StartCoroutine(AsyncSetup(savedGamesRef)); // As JoinServer waits for AsyncSetup to be completed we can't use normal Unity IEnumerator Start()
+    }
+
+    private IEnumerator AsyncSetup(GameObject savedGamesRef)
+    {
+        AsyncOperationHandle<GameObject> request = AddressablesUtility.LoadAsync<GameObject>("Assets/Prefabs/Base/GeneratorPieces/BaseMoonpoolUpgradeConsole.prefab");
+        yield return request;
+        GameObject colorPickerPanelPrototype = request.Result.RequireGameObject("EditScreen/Active");
+
+        RectTransform parent = GetComponent<RectTransform>();
+
+        GameObject newGameButtonRef = savedGamesRef.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame/NewGameButton");
+        LegendButtonData[] defaultLegend = newGameButtonRef.GetComponent<mGUI_Change_Legend_On_Select>().legendButtonConfiguration.Take(1).ToArray();
+
+        //Create a clone of the RocketBase color picker panel.
+        playerSettingsPanel = Instantiate(colorPickerPanelPrototype, parent);
+
+        //Prepares name input field
+        GameObject inputField = playerSettingsPanel.RequireGameObject("InputField");
+        inputField.transform.SetParent(parent);
+        inputField.transform.localPosition = new Vector3(-200, 310, 0);
+        inputField.transform.localScale = Vector3.one;
+        inputField.AddComponent<mGUI_Change_Legend_On_Select>().legendButtonConfiguration = defaultLegend;
+        playerNameInputField = inputField.GetComponent<uGUI_InputField>();
+        ((TextMeshProUGUI)playerNameInputField.placeholder).text = Language.main.Get("Nitrox_EnterName");
+        playerNameInputField.textComponent.fontSizeMax = 15;
+        playerNameInputField.characterLimit = 25; // See this.OnJoinClick()
+        playerNameInputField.ActivateInputField();
+
+        //Prepares player color picker
+        GameObject colorPickerObject = playerSettingsPanel.RequireGameObject("ColorPicker");
+        colorPickerObject.transform.SetParent(parent);
+        colorPickerObject.transform.localPosition = new Vector3(-268, 175, 0);
+        colorPickerObject.transform.localScale = new Vector3(1.1f, 0.75f, 1);
+        colorPicker = colorPickerObject.GetComponentInChildren<uGUI_ColorPicker>();
+        colorPicker.pointer.localScale = new Vector3(1f, 1.46f, 1);
+        saturationSlider = colorPicker.saturationSlider;
+        saturationSlider.transform.localPosition = new Vector3(197, 0, 0);
+
+        GameObject buttonLeft = Instantiate(newGameButtonRef, parent);
+        buttonLeft.GetComponent<RectTransform>().sizeDelta = new Vector2(160, 45);
+        buttonLeft.GetComponent<mGUI_Change_Legend_On_Select>().legendButtonConfiguration = defaultLegend;
+        GameObject buttonRight = Instantiate(buttonLeft, parent);
+
+        //Prepares cancel button
+        buttonLeft.transform.SetParent(parent);
+        buttonLeft.transform.localPosition = new Vector3(-285, 40, 0);
+        buttonLeft.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Cancel");
+        Button cancelButton = buttonLeft.GetComponent<Button>();
+        cancelButton.onClick.RemoveAllListeners();
+        cancelButton.onClick.AddListener(OnCancelClick);
+
+        //Prepares join button
+        buttonRight.transform.localPosition = new Vector3(-115, 40, 0);
+        buttonRight.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Join");
+        Button joinButton = buttonRight.GetComponent<Button>();
+        joinButton.onClick.RemoveAllListeners();
+        joinButton.onClick.AddListener(OnJoinClick);
+
+        selectableItems = [inputField, colorPicker.gameObject, saturationSlider.gameObject, buttonLeft, buttonRight];
+        Destroy(playerSettingsPanel);
+    }
+
+    private void OnJoinClick()
+    {
+        string playerName = playerNameInputField.text;
+
+        //https://regex101.com/r/eTWiEs/2/
+        if (!Regex.IsMatch(playerName, @"^[a-zA-Z0-9._-]{3,25}$"))
+        {
+            MainMenuNotificationPanel.ShowMessage(Language.main.Get("Nitrox_InvalidUserName"), NAME);
+            return;
+        }
+
+        JoinServerBackend.Instance.RequestSessionReservation(playerName, colorPicker.currentColor);
+    }
+
+    private static void OnCancelClick()
+    {
+        JoinServerBackend.Instance.StopMultiplayerClient();
+        MainMenuRightSide.main.OpenGroup(MainMenuServerListPanel.NAME);
+    }
+
+    public void UpdatePanelValues(string ip, string playerName, Vector3 hsb)
+    {
+        header.text = $"    {Language.main.Get("Nitrox_JoinServer")}{ip}";
+        playerNameInputField.text = playerName;
+        colorPicker.SetHSB(hsb);
+    }
+
+    public bool OnButtonDown(GameInput.Button button)
+    {
+        if (button != GameInput.Button.UISubmit || !selectedItem)
+        {
+            return false;
+        }
+
+        if (selectedItem.TryGetComponentInChildren(out TMP_InputField inputField))
+        {
+            inputField.Select();
+            inputField.ActivateInputField();
+        }
+        else if (selectedItem.TryGetComponentInChildren(out Button buttonComponent))
+        {
+            buttonComponent.onClick.Invoke();
+        }
+        return true;
+    }
+
+    public bool OnScroll(float scrollDelta, float speedMultiplier)
+    {
+        if (EventSystem.current != null &&
+            EventSystem.current.currentSelectedGameObject == selectedItem &&
+            selectedItem.TryGetComponent(out Slider slider))
+        {
+            slider.value += scrollDelta * speedMultiplier * 0.01f;
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool OnAdjust(Vector2 adjustDelta)
+    {
+        if (selectedItem && selectedItem.TryGetComponent(out uGUI_ColorPicker selectedColorPicker))
+        {
+            return selectedColorPicker.OnAdjust(adjustDelta);
+        }
+
+        return false;
+    }
+
+    object uGUI_INavigableIconGrid.GetSelectedItem() => selectedItem;
+
+    bool uGUI_INavigableIconGrid.ShowSelector => false;
+    bool uGUI_INavigableIconGrid.EmulateRaycast => false;
+    bool uGUI_INavigableIconGrid.SelectItemClosestToPosition(Vector3 worldPos) => false;
+    uGUI_INavigableIconGrid uGUI_INavigableIconGrid.GetNavigableGridInDirection(int dirX, int dirY) => null;
+    Graphic uGUI_INavigableIconGrid.GetSelectedIcon() => null;
+
+    public void SelectItem(object item)
+    {
+        DeselectItem();
+        selectedItem = item as GameObject;
+
+        if (!selectedItem)
+        {
+            return;
+        }
+
+        if (selectedItem.TryGetComponent(out mGUI_Change_Legend_On_Select changeLegend))
+        {
+            changeLegend.SyncLegendBarToGUISelection();
+        }
+        else
+        {
+            uGUI_LegendBar.ClearButtons();
+        }
+
+        if (selectedItem == selectableItems[0])
+        {
+            selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.black);
+        }
+        else if (selectedItem == selectableItems[1])
+        {
+            colorPicker.pointer.GetComponent<Image>().color = Color.cyan;
+        }
+
+        if (selectedItem.TryGetComponentInChildren(out Selectable selectable))
+        {
+            selectable.Select();
+        }
+
+        if (!EventSystem.current.alreadySelecting)
+        {
+            EventSystem.current.SetSelectedGameObject(selectedItem);
+        }
+
+        RuntimeManager.PlayOneShot(MainMenuServerListPanel.HoverSound.path);
+    }
+
+    public void DeselectItem()
+    {
+        if (!selectedItem)
+        {
+            return;
+        }
+
+        if (selectedItem.TryGetComponent(out TMP_InputField selectedInputField))
+        {
+            //This line need to be before selectedInputField.ReleaseSelection() as it will call this method recursive leading to NRE
+            selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.white);
+            selectedInputField.DeactivateInputField();
+            selectedInputField.ReleaseSelection();
+        }
+        else if (selectedItem.TryGetComponent(out uGUI_ColorPicker selectedColorPicker))
+        {
+            selectedColorPicker.pointer.GetComponent<Image>().color = Color.white;
+        }
+
+        if (!EventSystem.current.alreadySelecting)
+        {
+            EventSystem.current.SetSelectedGameObject(null);
+        }
+
+        selectedItem = null;
+    }
+
+    public bool SelectFirstItem()
+    {
+        SelectItem(selectableItems[0]);
+        return true;
+    }
+
+    public bool SelectItemInDirection(int dirX, int dirY)
+    {
+        if (!selectedItem)
+        {
+            return SelectFirstItem();
+        }
+
+        if (selectedItem == selectableItems[0]) //Name input
+        {
+            switch (dirY)
+            {
+                case < 0:
+                    SelectItem(selectableItems[^2]);
+                    return true;
+                case > 0:
+                    SelectItem(selectableItems[1]);
+                    return true;
+            }
+        }
+
+        if (selectedItem == selectableItems[1] || selectedItem == selectableItems[2]) // ColorPicker and SaturationSlider
+        {
+            switch (dirY)
+            {
+                case < 0:
+                    SelectItem(selectableItems[0]);
+                    return true;
+                case > 0:
+                    SelectItem(selectableItems[3]);
+                    return true;
+            }
+
+            if (dirX != 0)
+            {
+                int direction = selectedItem == selectableItems[1] ? 0 : 1;
+                direction = (direction + dirX) % 2;
+
+                SelectItem(selectableItems[1 + direction]);
+                return true;
+            }
+        }
+
+        if (selectedItem == selectableItems[3] || selectedItem == selectableItems[4]) // CancelButton and ConfirmButton
+        {
+            switch (dirY)
+            {
+                case < 0:
+                    SelectItem(selectableItems[1]);
+                    return true;
+                case > 0:
+                    SelectItem(selectableItems[0]);
+                    return true;
+            }
+
+            if (dirX != 0)
+            {
+                int direction = selectedItem == selectableItems[3] ? 0 : 1;
+                direction = (direction + dirX) % 2;
+
+                SelectItem(selectableItems[3 + direction]);
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs
similarity index 94%
rename from NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs
rename to NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs
index 6209dbaa59..4d9612a167 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuCreateServerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs
@@ -8,10 +8,12 @@
 using UnityEngine.EventSystems;
 using UnityEngine.UI;
 
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
 
 public class MainMenuCreateServerPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver
 {
+    public const string NAME = "MultiplayerCreateServer";
+
     private TMP_InputField serverNameInput, serverAddressInput, serverPortInput;
     private mGUI_Change_Legend_On_Select legendChange;
 
@@ -63,18 +65,18 @@ public void Setup(GameObject savedGamesRef)
         confirmButton.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
         confirmButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_AddServer_Confirm");
         Button confirmButtonButton = confirmButton.RequireTransform("NewGameButton").GetComponent<Button>();
-        confirmButtonButton.onClick = new Button.ButtonClickedEvent();
+        confirmButtonButton.onClick.RemoveAllListeners();
         confirmButtonButton.onClick.AddListener(SaveServer);
 
         GameObject backButton = Instantiate(multiplayerButtonRef, transform, false);
         backButton.transform.localPosition = new Vector3(-200, 40, 0);
         backButton.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
-        backButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_AddServer_Back");
+        backButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Cancel");
         Button backButtonButton = backButton.RequireTransform("NewGameButton").GetComponent<Button>();
-        backButtonButton.onClick = new Button.ButtonClickedEvent();
+        backButtonButton.onClick.RemoveAllListeners();
         backButtonButton.onClick.AddListener(OnBack);
 
-        selectableItems = new[] { serverName, serverAddress, serverPort, confirmButton, backButton };
+        selectableItems = [serverName, serverAddress, serverPort, confirmButton, backButton];
         Destroy(inputFieldBlueprint);
         Destroy(transform.Find("Scroll View").gameObject);
 
@@ -124,12 +126,12 @@ public void OnBack()
         serverAddressInput.text = string.Empty;
         serverPortInput.text = string.Empty;
         DeselectAllItems();
-        MainMenuRightSide.main.OpenGroup("MultiplayerServerList");
+        MainMenuRightSide.main.OpenGroup(MainMenuServerListPanel.NAME);
     }
 
     public void OnConfirm()
     {
-        if (selectedItem.TryGetComponentInChildren(out InputField inputField))
+        if (selectedItem.TryGetComponentInChildren(out TMP_InputField inputField))
         {
             inputField.Select();
         }
@@ -157,6 +159,11 @@ public void SelectItem(object item)
 
         legendChange.SyncLegendBarToGUISelection();
 
+        if (!selectedItem)
+        {
+            return;
+        }
+
         if (selectedItem.TryGetComponent(out TMP_InputField selectedInputField))
         {
             selectedInputField.Select();
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs
similarity index 88%
rename from NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs
rename to NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs
index cadd56411f..0cf8cb945f 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerButton.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs
@@ -1,13 +1,14 @@
 using System;
 using System.Net;
 using System.Net.Sockets;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
 using NitroxClient.Unity.Helper;
 using NitroxModel.Serialization;
 using TMPro;
 using UnityEngine;
 using UnityEngine.UI;
 
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
 
 public class MainMenuServerButton : MonoBehaviour
 {
@@ -35,7 +36,7 @@ public void Init(string text, string ip, int port, bool isReadOnly)
         Destroy(tmp.GetComponent<TranslationLiveUpdate>());
 
         Button multiplayerJoinButton = newGameButtonTransform.GetComponent<Button>();
-        multiplayerJoinButton.onClick = new Button.ButtonClickedEvent();
+        multiplayerJoinButton.onClick.RemoveAllListeners();
         multiplayerJoinButton.onClick.AddListener(OnJoinButtonClicked);
 
         gameObject.AddComponent<mGUI_Change_Legend_On_Select>().legendButtonConfiguration = confirmButtonLegendData;
@@ -45,7 +46,7 @@ public void Init(string text, string ip, int port, bool isReadOnly)
         {
             GameObject delete = Instantiate(deleteButtonRef, transform, false);
             Button deleteButtonButton = delete.GetComponent<Button>();
-            deleteButtonButton.onClick = new Button.ButtonClickedEvent();
+            deleteButtonButton.onClick.RemoveAllListeners();
             deleteButtonButton.onClick.AddListener(RequestDelete);
         }
     }
@@ -68,8 +69,7 @@ public async void OnJoinButtonClicked()
     {
         if (MainMenuServerListPanel.Main.IsJoining)
         {
-            // Do not attempt to join multiple servers.
-            return;
+            return; // Do not attempt to join multiple servers.
         }
 
         MainMenuServerListPanel.Main.IsJoining = true;
@@ -92,25 +92,12 @@ public static async System.Threading.Tasks.Task OpenJoinServerMenuAsync(string s
             return;
         }
 
-        await MainMenuServerListPanel.Main.JoinServer.ShowAsync(endpoint.Address.ToString(), endpoint.Port);
+        MainMenuNotificationPanel.ShowLoading();
+        await JoinServerBackend.Instance.ShowAsync(endpoint.Address.ToString(), endpoint.Port);
     }
 
     private static IPEndPoint ResolveIPEndPoint(string serverIp, int serverPort)
     {
-        static IPAddress ResolveHostName(string hostname, int serverPort)
-        {
-            try
-            {
-                IPHostEntry hostEntry = Dns.GetHostEntry(hostname);
-                return hostEntry.AddressList[0];
-            }
-            catch (SocketException ex)
-            {
-                Log.ErrorSensitive(ex, "Unable to resolve the address {hostname}:{serverPort}", hostname, serverPort);
-                return null;
-            }
-        }
-
         UriHostNameType hostType = Uri.CheckHostName(serverIp);
         IPAddress address;
         switch (hostType)
@@ -126,11 +113,20 @@ static IPAddress ResolveHostName(string hostname, int serverPort)
                 return null;
         }
 
-        if (address == null)
+        return address != null ? new IPEndPoint(address, serverPort) : null;
+
+        static IPAddress ResolveHostName(string hostname, int serverPort)
         {
-            return null;
+            try
+            {
+                IPHostEntry hostEntry = Dns.GetHostEntry(hostname);
+                return hostEntry.AddressList[0];
+            }
+            catch (SocketException ex)
+            {
+                Log.ErrorSensitive(ex, "Unable to resolve the address {hostname}:{serverPort}", hostname, serverPort);
+                return null;
+            }
         }
-
-        return new IPEndPoint(address, serverPort);
     }
 }
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerListPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs
similarity index 92%
rename from NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerListPanel.cs
rename to NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs
index ee285ccf41..b0d35269c0 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuServerListPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs
@@ -8,10 +8,12 @@
 using UnityEngine;
 using UnityEngine.UI;
 
-namespace NitroxClient.MonoBehaviours.Gui.MainMenu;
+namespace NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
 
 public class MainMenuServerListPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver
 {
+    public const string NAME = "MultiplayerServerList";
+
     public static MainMenuServerListPanel Main;
     public static Sprite NormalSprite;
     public static Sprite SelectedSprite;
@@ -21,18 +23,12 @@ public class MainMenuServerListPanel : MonoBehaviour, uGUI_INavigableIconGrid, u
     private Transform serverAreaContent;
     private GameObject selectedServerItem;
 
-    public JoinServer JoinServer { get; private set; }
     public bool IsJoining { get; set; }
 
     public void Setup(GameObject savedGamesRef)
     {
         Main = this;
 
-        //This sucks, but the only way around it is to establish a Subnautica resources cache and reference it everywhere we need it.
-        //Given recent push-back on elaborate designs, I've just crammed it here until we can all get on the same page as far as code-quality standards are concerned.
-        JoinServer = new GameObject("NitroxJoinServer").AddComponent<JoinServer>();
-        JoinServer.Setup(savedGamesRef);
-
         MainMenuLoadMenu loadMenu = savedGamesRef.GetComponentInChildren<MainMenuLoadMenu>();
         NormalSprite = loadMenu.normalSprite;
         SelectedSprite = loadMenu.selectedSprite;
@@ -92,7 +88,7 @@ public void OnConfirm()
         if (selectedServerItem.gameObject.name == "NewServer")
         {
             DeselectAllItems();
-            MainMenuRightSide.main.OpenGroup("MultiplayerCreateServer");
+            MainMenuRightSide.main.OpenGroup(MainMenuCreateServerPanel.NAME);
         }
         else if (selectedServerItem.TryGetComponent(out MainMenuServerButton serverButton))
         {
@@ -115,6 +111,11 @@ public void SelectItem(object item)
         DeselectItem();
         selectedServerItem = item as GameObject;
 
+        if (!selectedServerItem)
+        {
+            return;
+        }
+
         if (selectedServerItem.TryGetComponentInChildren(out mGUI_Change_Legend_On_Select componentInChildren))
         {
             componentInChildren.SyncLegendBarToGUISelection();
@@ -247,14 +248,14 @@ private void CreateAddServerButton()
         txt.GetComponent<TextMeshProUGUI>().text = "Nitrox_AddServer";
 
         Button multiplayerButtonButton = multiplayerButtonInst.RequireTransform("NewGameButton").GetComponent<Button>();
-        multiplayerButtonButton.onClick = new Button.ButtonClickedEvent();
+        multiplayerButtonButton.onClick.RemoveAllListeners();
         multiplayerButtonButton.onClick.AddListener(OpenAddServerGroup);
     }
 
     public void OpenAddServerGroup()
     {
         DeselectAllItems();
-        MainMenuRightSide.main.OpenGroup("MultiplayerCreateServer");
+        MainMenuRightSide.main.OpenGroup(MainMenuCreateServerPanel.NAME);
     }
 
     public void RefreshServerEntries()
diff --git a/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs b/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs
index 4c2e22c097..abb90c934d 100644
--- a/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs
+++ b/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs
@@ -1,21 +1,20 @@
 using System.Reflection;
 using NitroxClient.MonoBehaviours.Gui.MainMenu;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
 using NitroxModel.Helper;
 
-namespace NitroxPatcher.Patches.Persistent
+namespace NitroxPatcher.Patches.Persistent;
+
+public partial class MainMenuRightSide_OpenGroup_Patch : NitroxPatch, IPersistentPatch
 {
-    public partial class MainMenuRightSide_OpenGroup_Patch : NitroxPatch, IPersistentPatch
-    {
-        private static readonly MethodInfo TARGET_METHOD = Reflect.Method((MainMenuRightSide t) => t.OpenGroup(default(string)));
+    private static readonly MethodInfo TARGET_METHOD = Reflect.Method((MainMenuRightSide t) => t.OpenGroup(default(string)));
 
-        public static void Prefix(string target)
+    public static void Prefix(string target)
+    {
+        // Stopping the client if we leave the joining process
+        if (target is not (MainMenuJoinServerPanel.NAME or MainMenuEnterPasswordPanel.NAME or MainMenuNotificationPanel.NAME))
         {
-            // Don't stop the client if the client is trying to connect (in the case: target = "Join Server")
-            // We can detect that the Join Server tab is still available because the gameobject is activated only when the tab is opened
-            if (MainMenuServerListPanel.Main.JoinServer.gameObject.activeSelf && !target.Equals(MainMenuServerListPanel.Main.JoinServer.MenuName))
-            {
-                MainMenuServerListPanel.Main.JoinServer.StopMultiplayerClient();
-            }
+            JoinServerBackend.Instance.StopMultiplayerClient();
         }
     }
 }

From d78a70047532189b8a6e4b14a6d56a3353c7da01 Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Fri, 15 Mar 2024 20:34:16 +0100
Subject: [PATCH 08/14] Add basic Array and List entry in Debugger

---
 NitroxClient/Debuggers/SceneDebugger.cs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/NitroxClient/Debuggers/SceneDebugger.cs b/NitroxClient/Debuggers/SceneDebugger.cs
index f2e202b84a..5f63cdd7e7 100644
--- a/NitroxClient/Debuggers/SceneDebugger.cs
+++ b/NitroxClient/Debuggers/SceneDebugger.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -330,6 +331,16 @@ private void DrawFields(UnityEngine.Object target)
                 {
                     field.SetValue(target, structDrawer.Draw(fieldValue));
                 }
+                else if(fieldValue != null && (field.FieldType.IsArray || typeof(IList).IsAssignableFrom(field.FieldType)))
+                {
+                    IList list = (IList)field.GetValue(target);
+                    GUILayout.Box($"Length: {list.Count}" , GUILayout.Width(NitroxGUILayout.VALUE_WIDTH));
+                }
+                else if(fieldValue != null && (typeof(IDictionary).IsAssignableFrom(field.FieldType)))
+                {
+                    IDictionary dict = (IDictionary)field.GetValue(target);
+                    GUILayout.Box($"Length: {dict.Count}" , GUILayout.Width(NitroxGUILayout.VALUE_WIDTH));
+                }
                 else
                 {
                     GUILayout.FlexibleSpace();

From 08c6ec25cde048d2fa169d99c38fefb6ddd398df Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Fri, 15 Mar 2024 20:41:51 +0100
Subject: [PATCH 09/14] Fixed bugs where not all click events where removed

onClick.RemoveAllListeners() doesn't remove all listeners, see https://docs.unity3d.com/ScriptReference/Events.UnityEventBase.RemoveAllListeners.html
---
 .../GameLogic/HUD/PdaTabs/uGUI_PlayerPingEntry.cs        | 8 ++++----
 .../Gui/MainMenu/MainMenuNotificationPanel.cs            | 2 +-
 .../Gui/MainMenu/NitroxMainMenuModifications.cs          | 4 ++--
 .../Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs   | 4 ++--
 .../MainMenu/ServersList/MainMenuCreateServerPanel.cs    | 9 ++++-----
 .../Gui/MainMenu/ServersList/MainMenuServerButton.cs     | 4 ++--
 .../Gui/MainMenu/ServersList/MainMenuServerListPanel.cs  | 2 +-
 7 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/NitroxClient/GameLogic/HUD/PdaTabs/uGUI_PlayerPingEntry.cs b/NitroxClient/GameLogic/HUD/PdaTabs/uGUI_PlayerPingEntry.cs
index 8fe370b3d8..0cff601e28 100644
--- a/NitroxClient/GameLogic/HUD/PdaTabs/uGUI_PlayerPingEntry.cs
+++ b/NitroxClient/GameLogic/HUD/PdaTabs/uGUI_PlayerPingEntry.cs
@@ -186,10 +186,10 @@ public void UpdateButtonsPosition()
 
     private void ClearButtonListeners()
     {
-        GetToggle(MuteObject).onValueChanged.RemoveAllListeners();
-        GetToggle(KickObject).onValueChanged.RemoveAllListeners();
-        GetToggle(TeleportToObject).onValueChanged.RemoveAllListeners();
-        GetToggle(TeleportToMeObject).onValueChanged.RemoveAllListeners();
+        GetToggle(MuteObject).onValueChanged = new Toggle.ToggleEvent();
+        GetToggle(KickObject).onValueChanged = new Toggle.ToggleEvent();
+        GetToggle(TeleportToObject).onValueChanged = new Toggle.ToggleEvent();
+        GetToggle(TeleportToMeObject).onValueChanged = new Toggle.ToggleEvent();
     }
 
     private IEnumerator AssignSprites()
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs
index 6bff0ddd35..6e842d2a5a 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs
@@ -76,7 +76,7 @@ public void Setup(GameObject savedGamesRef)
         confirmObject.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
         confirmObject.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_OK");
         confirmButton = confirmObject.RequireTransform("NewGameButton").GetComponent<Button>();
-        confirmButton.onClick.RemoveAllListeners();
+        confirmButton.onClick = new Button.ButtonClickedEvent();
         confirmButton.onClick.AddListener(() =>
         {
             continuationAction?.Invoke();
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
index 00f547c3ba..d609fc4ed8 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
@@ -1,4 +1,4 @@
-using NitroxClient.MonoBehaviours.Discord;
+using NitroxClient.MonoBehaviours.Discord;
 using NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
 using NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
 using NitroxClient.Unity.Helper;
@@ -39,7 +39,7 @@ private void MultiplayerMenuMods()
         buttonText.GetComponent<TranslationLiveUpdate>().translationKey = "Nitrox_Multiplayer";
 
         Button showLoadedMultiplayerButton = showLoadedMultiplayer.GetComponent<Button>();
-        showLoadedMultiplayerButton.onClick.RemoveAllListeners();
+        showLoadedMultiplayerButton.onClick = new Button.ButtonClickedEvent();
         showLoadedMultiplayerButton.onClick.AddListener(ShowMultiplayerServerList);
 
         GameObject savedGamesRef = rightSide.gameObject.RequireGameObject("SavedGames");
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
index ff490dcac4..403cf6c430 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
@@ -84,14 +84,14 @@ private IEnumerator AsyncSetup(GameObject savedGamesRef)
         buttonLeft.transform.localPosition = new Vector3(-285, 40, 0);
         buttonLeft.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Cancel");
         Button cancelButton = buttonLeft.GetComponent<Button>();
-        cancelButton.onClick.RemoveAllListeners();
+        cancelButton.onClick = new Button.ButtonClickedEvent();
         cancelButton.onClick.AddListener(OnCancelClick);
 
         //Prepares join button
         buttonRight.transform.localPosition = new Vector3(-115, 40, 0);
         buttonRight.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Join");
         Button joinButton = buttonRight.GetComponent<Button>();
-        joinButton.onClick.RemoveAllListeners();
+        joinButton.onClick = new Button.ButtonClickedEvent();
         joinButton.onClick.AddListener(OnJoinClick);
 
         selectableItems = [inputField, colorPicker.gameObject, saturationSlider.gameObject, buttonLeft, buttonRight];
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs
index 4d9612a167..301fe4a0e4 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using FMODUnity;
 using NitroxClient.Unity.Helper;
@@ -27,13 +27,12 @@ public void Setup(GameObject savedGamesRef)
 
         GameObject inputFieldRef = GameObject.Find("/Menu canvas/Panel/MainMenu/RightSide/Home/EmailBox/InputField");
         GameObject inputFieldBlueprint = Instantiate(inputFieldRef, transform, false);
+
         inputFieldBlueprint.GetComponent<RectTransform>().sizeDelta = new Vector2(300, 40);
         TMP_InputField inputFieldBlueprintInput = inputFieldBlueprint.GetComponent<TMP_InputField>();
         inputFieldBlueprintInput.characterValidation = TMP_InputField.CharacterValidation.None;
-        inputFieldBlueprintInput.onEndEdit = new TMP_InputField.SubmitEvent();
         inputFieldBlueprintInput.onSubmit = new TMP_InputField.SubmitEvent();
         inputFieldBlueprintInput.onSubmit.AddListener(_ => { SelectItemInDirection(0, 1); });
-        inputFieldBlueprintInput.onValueChanged = new TMP_InputField.OnChangeEvent();
 
         GameObject serverName = Instantiate(inputFieldBlueprint, transform, false);
         serverName.transform.localPosition = new Vector3(-160, 300, 0);
@@ -65,7 +64,7 @@ public void Setup(GameObject savedGamesRef)
         confirmButton.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
         confirmButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_AddServer_Confirm");
         Button confirmButtonButton = confirmButton.RequireTransform("NewGameButton").GetComponent<Button>();
-        confirmButtonButton.onClick.RemoveAllListeners();
+        confirmButtonButton.onClick = new Button.ButtonClickedEvent();
         confirmButtonButton.onClick.AddListener(SaveServer);
 
         GameObject backButton = Instantiate(multiplayerButtonRef, transform, false);
@@ -73,7 +72,7 @@ public void Setup(GameObject savedGamesRef)
         backButton.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
         backButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Cancel");
         Button backButtonButton = backButton.RequireTransform("NewGameButton").GetComponent<Button>();
-        backButtonButton.onClick.RemoveAllListeners();
+        backButtonButton.onClick = new Button.ButtonClickedEvent();
         backButtonButton.onClick.AddListener(OnBack);
 
         selectableItems = [serverName, serverAddress, serverPort, confirmButton, backButton];
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs
index 0cf8cb945f..575277c112 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs
@@ -36,7 +36,7 @@ public void Init(string text, string ip, int port, bool isReadOnly)
         Destroy(tmp.GetComponent<TranslationLiveUpdate>());
 
         Button multiplayerJoinButton = newGameButtonTransform.GetComponent<Button>();
-        multiplayerJoinButton.onClick.RemoveAllListeners();
+        multiplayerJoinButton.onClick = new Button.ButtonClickedEvent();
         multiplayerJoinButton.onClick.AddListener(OnJoinButtonClicked);
 
         gameObject.AddComponent<mGUI_Change_Legend_On_Select>().legendButtonConfiguration = confirmButtonLegendData;
@@ -46,7 +46,7 @@ public void Init(string text, string ip, int port, bool isReadOnly)
         {
             GameObject delete = Instantiate(deleteButtonRef, transform, false);
             Button deleteButtonButton = delete.GetComponent<Button>();
-            deleteButtonButton.onClick.RemoveAllListeners();
+            deleteButtonButton.onClick = new Button.ButtonClickedEvent();
             deleteButtonButton.onClick.AddListener(RequestDelete);
         }
     }
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs
index b0d35269c0..110082814a 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs
@@ -248,7 +248,7 @@ private void CreateAddServerButton()
         txt.GetComponent<TextMeshProUGUI>().text = "Nitrox_AddServer";
 
         Button multiplayerButtonButton = multiplayerButtonInst.RequireTransform("NewGameButton").GetComponent<Button>();
-        multiplayerButtonButton.onClick.RemoveAllListeners();
+        multiplayerButtonButton.onClick = new Button.ButtonClickedEvent();
         multiplayerButtonButton.onClick.AddListener(OpenAddServerGroup);
     }
 

From f012e8e05e08a935eaae4fa251b8eb72b0ad8f66 Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Fri, 15 Mar 2024 21:02:15 +0100
Subject: [PATCH 10/14] Add invalidation to NitroxServiceLocator.Cache when
 EndCurrentLifetimeScope() is called

---
 NitroxModel/Core/NitroxServiceLocator.cs | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/NitroxModel/Core/NitroxServiceLocator.cs b/NitroxModel/Core/NitroxServiceLocator.cs
index b51e48f91e..4c6893ec5c 100644
--- a/NitroxModel/Core/NitroxServiceLocator.cs
+++ b/NitroxModel/Core/NitroxServiceLocator.cs
@@ -132,15 +132,28 @@ private static void CheckServiceResolutionViability()
     public static class Cache<T> where T : class
     {
         private static T value;
-        public static T Value => value ??= LocateService<T>();
-        public static T ValuePreLifetime => value ??= LocateServicePreLifetime<T>();
+        public static T Value => value ??= LocateServiceAndRegister();
+        public static T ValuePreLifetime => value ??= LocateServicePreLifetimeAndRegister();
+
+        private static T LocateServiceAndRegister()
+        {
+            LifetimeScopeEnded += Invalidate;
+            return LocateService<T>();
+        }
+
+        private static T LocateServicePreLifetimeAndRegister()
+        {
+            LifetimeScopeEnded += Invalidate;
+            return LocateServicePreLifetime<T>();
+        }
 
         /// <summary>
         ///     Invalidates the cache for type <see cref="T" />. The next <see cref="Value" /> access will request from <see cref="NitroxServiceLocator" /> again.
         /// </summary>
-        public static void Invalidate()
+        public static void Invalidate(object _, EventArgs __)
         {
             value = null;
+            LifetimeScopeEnded -= Invalidate;
         }
     }
 }

From 9e76e0bd72a946be3a23992ccf6b8652421efb38 Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Fri, 15 Mar 2024 21:08:32 +0100
Subject: [PATCH 11/14] Add new UI and controller support for server password
 input

---
 .../MainMenu/NitroxMainMenuModifications.cs   |   5 +-
 .../MainMenu/ServerJoin/JoinServerBackend.cs  |  18 +-
 .../ServerJoin/MainMenuEnterPasswordPanel.cs  | 286 ++++++++++++------
 3 files changed, 205 insertions(+), 104 deletions(-)

diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
index d609fc4ed8..c4e5cf8aa1 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/NitroxMainMenuModifications.cs
@@ -1,4 +1,4 @@
-using NitroxClient.MonoBehaviours.Discord;
+using NitroxClient.MonoBehaviours.Discord;
 using NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
 using NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
 using NitroxClient.Unity.Helper;
@@ -65,6 +65,9 @@ GameObject CloneMainMenuLoadPanel(string panelName, string translationKey)
         GameObject serverJoin = CloneMainMenuLoadPanel(MainMenuJoinServerPanel.NAME, "Nitrox_JoinServer");
         serverJoin.AddComponent<MainMenuJoinServerPanel>().Setup(savedGamesRef);
 
+        GameObject serverPasswordEnter = CloneMainMenuLoadPanel(MainMenuEnterPasswordPanel.NAME, "Nitrox_JoinServerPasswordHeader");
+        serverPasswordEnter.AddComponent<MainMenuEnterPasswordPanel>().Setup(savedGamesRef);
+
         GameObject serverList = CloneMainMenuLoadPanel(MainMenuServerListPanel.NAME, "Nitrox_Multiplayer");
         serverList.AddComponent<MainMenuServerListPanel>().Setup(savedGamesRef);
 
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
index b251e73c3a..742e5c7a2d 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
@@ -38,22 +38,16 @@ public static JoinServerBackend Instance
     private string serverIp;
     private int serverPort;
 
-    private MainMenuEnterPasswordPanel passwordPanel;
-
     public async Task ShowAsync(string ip, int port)
     {
-        passwordPanel = gameObject.AddComponent<MainMenuEnterPasswordPanel>(); //TODO: Move somewhere else
-
         serverIp = ip;
         serverPort = port;
-        Log.Info("JoinServer.ShowAsync()");
         NitroxServiceLocator.BeginNewLifetimeScope();
 
         preferencesManager = NitroxServiceLocator.LocateService<PlayerPreferenceManager>();
         activePlayerPreference = preferencesManager.GetPreference(serverIp);
 
         multiplayerSession = NitroxServiceLocator.LocateService<IMultiplayerSession>();
-        passwordPanel.Setup(multiplayerSession);
 
         gameObject.SetActive(true);
         await StartMultiplayerClientAsync();
@@ -103,7 +97,7 @@ public void RequestSessionReservation(string playerName, Color playerColor)
     {
         preferencesManager.SetPreference(serverIp, new PlayerPreference(playerName, playerColor));
 
-        Optional<string> opPassword = passwordPanel.passwordEntered ? Optional.Of(passwordPanel.serverPassword) : Optional.Empty;
+        Optional<string> opPassword = MainMenuEnterPasswordPanel.LastEnteredPassword;
         AuthenticationContext authenticationContext = new(playerName, opPassword);
 
         multiplayerSession.RequestSessionReservation(new PlayerSettings(playerColor.ToDto()), authenticationContext);
@@ -119,18 +113,20 @@ private void SessionConnectionStateChangedHandler(IMultiplayerSessionConnectionS
                 break;
 
             case MultiplayerSessionConnectionStage.AWAITING_RESERVATION_CREDENTIALS:
+                Color.RGBToHSV(activePlayerPreference.PreferredColor(), out float hue, out float saturation, out float brightness); // HSV => Hue Saturation Value, HSB => Hue Saturation Brightness
+                MainMenuJoinServerPanel.Instance.UpdatePanelValues(serverIp, activePlayerPreference.PlayerName, new Vector3(hue, saturation, brightness));
+
                 if (multiplayerSession.SessionPolicy.RequiresServerPassword)
                 {
                     Log.Info("Waiting for server password input");
                     Log.InGame(Language.main.Get("Nitrox_WaitingPassword"));
-                    passwordPanel.showingPasswordWindow = true;
-                    passwordPanel.shouldFocus = true;
+                    MainMenuEnterPasswordPanel.ResetLastEnteredPassword();
+                    MainMenuRightSide.main.OpenGroup(MainMenuEnterPasswordPanel.NAME);
+                    break;
                 }
 
                 Log.Info("Waiting for user input");
                 Log.InGame(Language.main.Get("Nitrox_WaitingUserInput"));
-                Color.RGBToHSV(activePlayerPreference.PreferredColor(), out float hue, out float saturation, out float brightness); // HSV => Hue Saturation Value, HSB => Hue Saturation Brightness
-                MainMenuJoinServerPanel.Instance.UpdatePanelValues(serverIp, activePlayerPreference.PlayerName, new Vector3(hue, saturation, brightness));
                 MainMenuRightSide.main.OpenGroup(MainMenuJoinServerPanel.NAME);
                 break;
 
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs
index 64afa115c6..cb04e36f4c 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs
@@ -1,129 +1,231 @@
-using NitroxClient.Communication.Abstract;
+using System;
+using System.Linq;
+using FMODUnity;
 using NitroxClient.MonoBehaviours.Gui.MainMenu.ServersList;
 using NitroxClient.Unity.Helper;
+using NitroxModel.DataStructures.Util;
+using TMPro;
 using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
 
 namespace NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
 
-public class MainMenuEnterPasswordPanel : MonoBehaviour
+public class MainMenuEnterPasswordPanel : MonoBehaviour, uGUI_INavigableIconGrid, uGUI_IButtonReceiver
 {
     public const string NAME = "MultiplayerEnterPassword";
 
-    private Rect serverPasswordWindowRect = new(Screen.width / 2 - 250, 200, 500, 200);
+    private TMP_InputField passwordInput;
+    private mGUI_Change_Legend_On_Select legendChange;
 
-    public string serverPassword;
-    public bool passwordEntered;
-    public bool shouldFocus;
-    public bool showingPasswordWindow;
-    private IMultiplayerSession multiplayerSession;
+    private GameObject selectedItem;
+    private GameObject[] selectableItems;
 
-    public void Setup(IMultiplayerSession _multiplayerSession)
+    private static string lastEnteredPassword;
+    public static Optional<string> LastEnteredPassword => lastEnteredPassword != null ? Optional.Of(lastEnteredPassword) : Optional.Empty;
+    public static void ResetLastEnteredPassword() => lastEnteredPassword = null;
+
+    public void Setup(GameObject savedGamesRef)
+    {
+        GameObject multiplayerButtonRef = savedGamesRef.RequireGameObject("Scroll View/Viewport/SavedGameAreaContent/NewGame");
+        GameObject generalTextRef = multiplayerButtonRef.GetComponentInChildren<TextMeshProUGUI>().gameObject;
+        GameObject inputFieldRef = GameObject.Find("/Menu canvas/Panel/MainMenu/RightSide/Home/EmailBox/InputField");
+
+        GameObject passwordInputGameObject = Instantiate(inputFieldRef, transform, false);
+        passwordInputGameObject.transform.localPosition = new Vector3(-160, 300, 0);
+        passwordInputGameObject.GetComponent<RectTransform>().sizeDelta = new Vector2(300, 40);
+        passwordInput = passwordInputGameObject.GetComponent<TMP_InputField>();
+        passwordInput.characterValidation = TMP_InputField.CharacterValidation.None;
+        passwordInput.onSubmit = new TMP_InputField.SubmitEvent();
+        passwordInput.onSubmit.AddListener(_ => { SelectItemInDirection(0, 1); });
+        passwordInput.placeholder.GetComponent<TranslationLiveUpdate>().translationKey = Language.main.Get("Nitrox_JoinServerPlaceholder");
+        GameObject passwordInputDesc = Instantiate(generalTextRef, passwordInputGameObject.transform, false);
+        passwordInputDesc.transform.localPosition = new Vector3(-200, 0, 0);
+        passwordInputDesc.GetComponent<TextMeshProUGUI>().text = Language.main.Get("Nitrox_JoinServerPassword");
+
+        GameObject confirmButton = Instantiate(multiplayerButtonRef, transform, false);
+        confirmButton.transform.localPosition = new Vector3(-200, 90, 0);
+        confirmButton.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
+        confirmButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Confirm");
+        Button confirmButtonButton = confirmButton.RequireTransform("NewGameButton").GetComponent<Button>();
+        confirmButtonButton.onClick = new Button.ButtonClickedEvent();
+        confirmButtonButton.onClick.AddListener(OnConfirmButtonClicked);
+
+        GameObject backButton = Instantiate(multiplayerButtonRef, transform, false);
+        backButton.transform.localPosition = new Vector3(-200, 40, 0);
+        backButton.transform.GetChild(0).GetComponent<RectTransform>().sizeDelta = new Vector2(200, 40);
+        backButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.main.Get("Nitrox_Cancel");
+        Button backButtonButton = backButton.RequireTransform("NewGameButton").GetComponent<Button>();
+        backButtonButton.onClick = new Button.ButtonClickedEvent();
+        backButtonButton.onClick.AddListener(OnCancelClick);
+
+        selectableItems = [passwordInputGameObject, confirmButton, backButton];
+        Destroy(transform.Find("Scroll View").gameObject);
+
+        legendChange = gameObject.AddComponent<mGUI_Change_Legend_On_Select>();
+        legendChange.legendButtonConfiguration = confirmButtonButton.GetComponent<mGUI_Change_Legend_On_Select>().legendButtonConfiguration.Take(1).ToArray();
+    }
+
+    private void OnConfirmButtonClicked()
     {
-        multiplayerSession = _multiplayerSession;
+        lastEnteredPassword = passwordInput.text;
+        MainMenuRightSide.main.OpenGroup(MainMenuJoinServerPanel.NAME);
     }
 
-    private void OnGUI()
+    private static void OnCancelClick()
     {
-        if (showingPasswordWindow)
+        JoinServerBackend.Instance.StopMultiplayerClient();
+        MainMenuRightSide.main.OpenGroup(MainMenuServerListPanel.NAME);
+    }
+
+    public bool OnButtonDown(GameInput.Button button)
+    {
+        switch (button)
         {
-            serverPasswordWindowRect = GUILayout.Window(
-                GUIUtility.GetControlID(FocusType.Keyboard),
-                serverPasswordWindowRect,
-                DoServerPasswordWindow,
-                Language.main.Get("Nitrox_JoinServerPasswordHeader")
-            );
+            case GameInput.Button.UISubmit:
+                OnConfirm();
+                return true;
+            case GameInput.Button.UICancel:
+                OnBack();
+                return true;
+            default:
+                return false;
         }
     }
 
-    public void DoServerPasswordWindow(int windowId)
+    public void OnConfirm()
     {
-        GUISkin GetGUISkin() => GUISkinUtils.RegisterDerivedOnce("menus.serverPassword",
-                                                                 s =>
-                                                                 {
-                                                                     s.textField.fontSize = 14;
-                                                                     s.textField.richText = false;
-                                                                     s.textField.alignment = TextAnchor.MiddleLeft;
-                                                                     s.textField.wordWrap = true;
-                                                                     s.textField.stretchHeight = true;
-                                                                     s.textField.padding = new RectOffset(10, 10, 5, 5);
-
-                                                                     s.label.fontSize = 14;
-                                                                     s.label.alignment = TextAnchor.MiddleRight;
-                                                                     s.label.stretchHeight = true;
-                                                                     s.label.fixedWidth = 80; //change this when adding new labels that need more space.
-
-                                                                     s.button.fontSize = 14;
-                                                                     s.button.stretchHeight = true;
-                                                                 });
-
-        Event e = Event.current;
-        if (e.isKey)
-        {
-            switch (e.keyCode)
-            {
-                case KeyCode.Return:
-                    OnSubmitPasswordButtonClicked();
-                    break;
-                case KeyCode.Escape:
-                    OnCancelButtonClicked();
-                    break;
-            }
+        if (selectedItem.TryGetComponentInChildren(out TMP_InputField inputField))
+        {
+            inputField.ActivateInputField();
         }
 
-        GUISkinUtils.RenderWithSkin(GetGUISkin(),
-                                    () =>
-                                    {
-                                        using (new GUILayout.VerticalScope("Box"))
-                                        {
-                                            using (new GUILayout.HorizontalScope())
-                                            {
-                                                GUILayout.Label(Language.main.Get("Nitrox_JoinServerPassword"));
-                                                GUI.SetNextControlName("serverPasswordField");
-                                                serverPassword = GUILayout.TextField(serverPassword);
-                                            }
-
-                                            if (GUILayout.Button(Language.main.Get("Nitrox_SubmitPassword")))
-                                            {
-                                                HidePasswordWindow();
-                                                OnSubmitPasswordButtonClicked();
-                                            }
-
-                                            if (GUILayout.Button(Language.main.Get("Nitrox_Cancel")))
-                                            {
-                                                HidePasswordWindow();
-                                                OnCancelButtonClicked();
-                                                MainMenuRightSide.main.OpenGroup(MainMenuServerListPanel.NAME);
-                                            }
-                                        }
-                                    });
-
-        if (shouldFocus)
-        {
-            GUI.FocusControl("serverPasswordField");
-            shouldFocus = false;
+        if (selectedItem.TryGetComponentInChildren(out Button button))
+        {
+            button.onClick.Invoke();
         }
     }
 
-    private void OnSubmitPasswordButtonClicked()
+    public void OnBack()
     {
-        SubmitPassword();
-        HidePasswordWindow();
+        passwordInput.text = string.Empty;
+        ResetLastEnteredPassword();
+        DeselectAllItems();
+        MainMenuRightSide.main.OpenGroup(MainMenuServerListPanel.NAME);
     }
 
-    private void SubmitPassword()
+    bool uGUI_INavigableIconGrid.ShowSelector => false;
+    bool uGUI_INavigableIconGrid.EmulateRaycast => false;
+    bool uGUI_INavigableIconGrid.SelectItemClosestToPosition(Vector3 worldPos) => false;
+    uGUI_INavigableIconGrid uGUI_INavigableIconGrid.GetNavigableGridInDirection(int dirX, int dirY) => null;
+    Graphic uGUI_INavigableIconGrid.GetSelectedIcon() => null;
+
+    object uGUI_INavigableIconGrid.GetSelectedItem() => selectedItem;
+
+    public void SelectItem(object item)
     {
-        passwordEntered = true;
+        DeselectItem();
+        selectedItem = item as GameObject;
+
+        legendChange.SyncLegendBarToGUISelection();
+
+        if (!selectedItem)
+        {
+            return;
+        }
+
+        if (selectedItem.TryGetComponent(out TMP_InputField selectedInputField))
+        {
+            selectedInputField.Select();
+        }
+        else // Buttons
+        {
+            selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuServerListPanel.SelectedSprite;
+        }
+
+        if (!EventSystem.current.alreadySelecting)
+        {
+            EventSystem.current.SetSelectedGameObject(selectedItem);
+        }
+
+        selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.black);
+        RuntimeManager.PlayOneShot(MainMenuServerListPanel.HoverSound.path);
     }
 
-    private void OnCancelButtonClicked()
+    public void DeselectItem()
     {
-        multiplayerSession.Disconnect();
-        HidePasswordWindow();
+        if (!selectedItem)
+        {
+            return;
+        }
+
+        if (selectedItem.TryGetComponent(out TMP_InputField selectedInputField))
+        {
+            selectedInputField.DeactivateInputField();
+            selectedInputField.ReleaseSelection();
+        }
+        else // Buttons
+        {
+            selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuServerListPanel.NormalSprite;
+        }
+
+        if (!EventSystem.current.alreadySelecting)
+        {
+            EventSystem.current.SetSelectedGameObject(null);
+        }
+
+        selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.white);
+        selectedItem = null;
+    }
+
+    public void DeselectAllItems()
+    {
+        foreach (GameObject child in selectableItems)
+        {
+            child.GetComponentInChildren<TextMeshProUGUI>().color = Color.white;
+        }
+    }
+
+    public bool SelectFirstItem()
+    {
+        SelectItem(selectableItems[0]);
+        return true;
     }
 
-    private void HidePasswordWindow()
+    public bool SelectItemInDirection(int dirX, int dirY)
     {
-        showingPasswordWindow = false;
-        shouldFocus = false;
+        if (!selectedItem)
+        {
+            return SelectFirstItem();
+        }
+
+        if (dirX == dirY)
+        {
+            return false;
+        }
+
+        int dir = (dirX + dirY) > 0 ? 1 : -1;
+        for (int newIndex = GetSelectedIndex() + dir; newIndex >= 0 && newIndex < selectableItems.Length; newIndex += dir)
+        {
+            if (SelectItemByIndex(newIndex))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private int GetSelectedIndex() => selectedItem ? Array.IndexOf(selectableItems, selectedItem) : -1;
+
+    private bool SelectItemByIndex(int selectedIndex)
+    {
+        if (selectedIndex >= 0 && selectedIndex < selectableItems.Length)
+        {
+            SelectItem(selectableItems[selectedIndex]);
+            return true;
+        }
+
+        return false;
     }
 }

From cfbe84cf04b04deed1b1af3e18826ca74b1b1374 Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Fri, 15 Mar 2024 21:20:36 +0100
Subject: [PATCH 12/14] Refactor JoinServerBackend

---
 .../MainMenu/ServerJoin/JoinServerBackend.cs  | 158 ++++++++----------
 .../ServerJoin/MainMenuEnterPasswordPanel.cs  |   2 +-
 .../ServerJoin/MainMenuJoinServerPanel.cs     |   4 +-
 .../ServersList/MainMenuCreateServerPanel.cs  |  16 +-
 .../ServersList/MainMenuServerButton.cs       |   2 +-
 NitroxClient/MonoBehaviours/Multiplayer.cs    |  12 +-
 .../MainMenuRightSide_OpenGroup_Patch.cs      |   2 +-
 7 files changed, 88 insertions(+), 108 deletions(-)

diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
index 742e5c7a2d..d465e631ae 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
@@ -1,5 +1,6 @@
 using System.Collections;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading.Tasks;
 using NitroxClient.Communication.Abstract;
 using NitroxClient.Communication.Exceptions;
@@ -14,86 +15,18 @@
 
 namespace NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
 
-public class JoinServerBackend : MonoBehaviour
+public static class JoinServerBackend
 {
-    private static JoinServerBackend instance;
+    private static PlayerPreferenceManager preferencesManager;
+    private static PlayerPreference activePlayerPreference;
+    private static IMultiplayerSession multiplayerSession;
 
-    public static JoinServerBackend Instance
-    {
-        get
-        {
-            if (!instance)
-            {
-                GameObject persistentGameobject = GameObject.Find("Nitrox");
-                instance = persistentGameobject.EnsureComponent<JoinServerBackend>();
-            }
-            return instance;
-        }
-    }
-
-    private PlayerPreferenceManager preferencesManager;
-    private PlayerPreference activePlayerPreference;
-    private IMultiplayerSession multiplayerSession;
+    private static GameObject multiplayerClient;
 
-    private string serverIp;
-    private int serverPort;
+    private static string serverIp;
+    private static int serverPort;
 
-    public async Task ShowAsync(string ip, int port)
-    {
-        serverIp = ip;
-        serverPort = port;
-        NitroxServiceLocator.BeginNewLifetimeScope();
-
-        preferencesManager = NitroxServiceLocator.LocateService<PlayerPreferenceManager>();
-        activePlayerPreference = preferencesManager.GetPreference(serverIp);
-
-        multiplayerSession = NitroxServiceLocator.LocateService<IMultiplayerSession>();
-
-        gameObject.SetActive(true);
-        await StartMultiplayerClientAsync();
-    }
-
-    private GameObject multiplayerClient;
-
-    private async Task StartMultiplayerClientAsync()
-    {
-        if (!multiplayerClient)
-        {
-            multiplayerClient = new GameObject("Multiplayer Client");
-            multiplayerClient.AddComponent<Multiplayer>();
-            multiplayerSession.ConnectionStateChanged += SessionConnectionStateChangedHandler;
-        }
-
-        try
-        {
-            await multiplayerSession.ConnectAsync(serverIp, serverPort);
-        }
-        catch (ClientConnectionFailedException ex)
-        {
-            Log.ErrorSensitive("Unable to contact the remote server at: {ip}:{port}", serverIp, serverPort);
-            string msg = $"{Language.main.Get("Nitrox_UnableToConnect")} {serverIp}:{serverPort}";
-
-            if (serverIp.Equals("127.0.0.1"))
-            {
-                if (Process.GetProcessesByName("NitroxServer-Subnautica").Length == 0)
-                {
-                    Log.Error("No server process was found while address was 127.0.0.1");
-                    msg += $"\n{Language.main.Get("Nitrox_StartServer")}";
-                }
-                else
-                {
-                    Log.Error(ex);
-                    msg += $"\n{Language.main.Get("Nitrox_FirewallInterfering")}";
-                }
-            }
-
-            Log.InGame(msg);
-            StopMultiplayerClient(msg);
-            MainMenuNotificationPanel.ShowMessage(msg, MainMenuServerListPanel.NAME);
-        }
-    }
-
-    public void RequestSessionReservation(string playerName, Color playerColor)
+    public static void RequestSessionReservation(string playerName, Color playerColor)
     {
         preferencesManager.SetPreference(serverIp, new PlayerPreference(playerName, playerColor));
 
@@ -103,7 +36,7 @@ public void RequestSessionReservation(string playerName, Color playerColor)
         multiplayerSession.RequestSessionReservation(new PlayerSettings(playerColor.ToDto()), authenticationContext);
     }
 
-    private void SessionConnectionStateChangedHandler(IMultiplayerSessionConnectionState state)
+    private static void SessionConnectionStateChangedHandler(IMultiplayerSessionConnectionState state)
     {
         switch (state.CurrentStage)
         {
@@ -140,7 +73,7 @@ private void SessionConnectionStateChangedHandler(IMultiplayerSessionConnectionS
                 Multiplayer.SubnauticaLoadingStarted();
                 IEnumerator startNewGame = uGUI_MainMenu.main.StartNewGame(GameMode.Survival);
 #pragma warning restore CS0618 // God damn it UWE...
-                StartCoroutine(startNewGame);
+                UWE.CoroutineHost.StartCoroutine(startNewGame);
                 LoadingScreenVersionText.Initialize();
 
                 break;
@@ -167,26 +100,71 @@ private void SessionConnectionStateChangedHandler(IMultiplayerSessionConnectionS
         }
     }
 
-    // TODO: Maybe move to MainMenuServerListPanel OnEnabled
-    /// <param name="error"> If set to something it will display the message with <see cref="MainMenuNotificationPanel"/> after stopping the client</param>
-    public void StopMultiplayerClient(string error = null)
+    [SuppressMessage("Usage", "DIMA001:Dependency Injection container is used directly")]
+    public static async Task StartMultiplayerClientAsync(string ip, int port)
     {
-        if (!multiplayerClient || !Multiplayer.Main)
+        serverIp = ip;
+        serverPort = port;
+        NitroxServiceLocator.BeginNewLifetimeScope();
+
+        preferencesManager = NitroxServiceLocator.LocateService<PlayerPreferenceManager>();
+        activePlayerPreference = preferencesManager.GetPreference(serverIp);
+        multiplayerSession = NitroxServiceLocator.LocateService<IMultiplayerSession>();
+
+        if (!multiplayerClient)
         {
-            return;
+            multiplayerClient = new GameObject("Nitrox Multiplayer Client");
+            multiplayerClient.AddComponent<Multiplayer>();
+            multiplayerSession.ConnectionStateChanged += SessionConnectionStateChangedHandler;
         }
 
-        Multiplayer.Main.StopCurrentSession();
-        Destroy(multiplayerClient);
-        multiplayerClient = null;
-        if (multiplayerSession != null)
+        try
+        {
+            await multiplayerSession.ConnectAsync(serverIp, serverPort);
+        }
+        catch (ClientConnectionFailedException ex)
+        {
+            Log.ErrorSensitive("Unable to contact the remote server at: {ip}:{port}", serverIp, serverPort);
+            string msg = $"{Language.main.Get("Nitrox_UnableToConnect")} {serverIp}:{serverPort}";
+
+            if (serverIp.Equals("127.0.0.1"))
+            {
+                if (Process.GetProcessesByName("NitroxServer-Subnautica").Length == 0)
+                {
+                    Log.Error("No server process was found while address was 127.0.0.1");
+                    msg += $"\n{Language.main.Get("Nitrox_StartServer")}";
+                }
+                else
+                {
+                    Log.Error(ex);
+                    msg += $"\n{Language.main.Get("Nitrox_FirewallInterfering")}";
+                }
+            }
+
+            Log.InGame(msg);
+            StopMultiplayerClient();
+            MainMenuNotificationPanel.ShowMessage(msg, MainMenuServerListPanel.NAME);
+        }
+    }
+
+    [SuppressMessage("Usage", "DIMA001:Dependency Injection container is used directly")]
+    public static void StopMultiplayerClient()
+    {
+        if (!multiplayerClient || !Multiplayer.Main)
         {
-            multiplayerSession.ConnectionStateChanged -= SessionConnectionStateChangedHandler;
+            return;
         }
 
-        if (error != null)
+        if (multiplayerSession.CurrentState.CurrentStage != MultiplayerSessionConnectionStage.DISCONNECTED)
         {
-            MainMenuNotificationPanel.ShowMessage($"Connection broke\n+{error}", MainMenuServerListPanel.NAME);
+            multiplayerSession.Disconnect();
         }
+        multiplayerSession.ConnectionStateChanged -= SessionConnectionStateChangedHandler;
+
+        Multiplayer.Main.StopCurrentSession();
+        NitroxServiceLocator.EndCurrentLifetimeScope(); //Always do this last.
+
+        Object.Destroy(multiplayerClient);
+        multiplayerClient = null;
     }
 }
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs
index cb04e36f4c..0fb7b727cf 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuEnterPasswordPanel.cs
@@ -74,7 +74,7 @@ private void OnConfirmButtonClicked()
 
     private static void OnCancelClick()
     {
-        JoinServerBackend.Instance.StopMultiplayerClient();
+        JoinServerBackend.StopMultiplayerClient();
         MainMenuRightSide.main.OpenGroup(MainMenuServerListPanel.NAME);
     }
 
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
index 403cf6c430..876da84000 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
@@ -109,12 +109,12 @@ private void OnJoinClick()
             return;
         }
 
-        JoinServerBackend.Instance.RequestSessionReservation(playerName, colorPicker.currentColor);
+        JoinServerBackend.RequestSessionReservation(playerName, colorPicker.currentColor);
     }
 
     private static void OnCancelClick()
     {
-        JoinServerBackend.Instance.StopMultiplayerClient();
+        JoinServerBackend.StopMultiplayerClient();
         MainMenuRightSide.main.OpenGroup(MainMenuServerListPanel.NAME);
     }
 
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs
index 301fe4a0e4..2790af714a 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuCreateServerPanel.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using FMODUnity;
 using NitroxClient.Unity.Helper;
@@ -132,7 +132,7 @@ public void OnConfirm()
     {
         if (selectedItem.TryGetComponentInChildren(out TMP_InputField inputField))
         {
-            inputField.Select();
+            inputField.ActivateInputField();
         }
 
         if (selectedItem.TryGetComponentInChildren(out Button button))
@@ -172,6 +172,11 @@ public void SelectItem(object item)
             selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuServerListPanel.SelectedSprite;
         }
 
+        if (!EventSystem.current.alreadySelecting)
+        {
+            EventSystem.current.SetSelectedGameObject(selectedItem);
+        }
+
         selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.black);
         RuntimeManager.PlayOneShot(MainMenuServerListPanel.HoverSound.path);
     }
@@ -185,14 +190,19 @@ public void DeselectItem()
 
         if (selectedItem.TryGetComponent(out TMP_InputField selectedInputField))
         {
+            selectedInputField.DeactivateInputField();
             selectedInputField.ReleaseSelection();
-            EventSystem.current.SetSelectedGameObject(null);
         }
         else
         {
             selectedItem.transform.GetChild(0).GetComponent<Image>().sprite = MainMenuServerListPanel.NormalSprite;
         }
 
+        if (!EventSystem.current.alreadySelecting)
+        {
+            EventSystem.current.SetSelectedGameObject(null);
+        }
+
         selectedItem.GetComponentsInChildren<TextMeshProUGUI>().ForEach(txt => txt.color = Color.white);
         selectedItem = null;
     }
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs
index 575277c112..0146bba5ff 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerButton.cs
@@ -93,7 +93,7 @@ public static async System.Threading.Tasks.Task OpenJoinServerMenuAsync(string s
         }
 
         MainMenuNotificationPanel.ShowLoading();
-        await JoinServerBackend.Instance.ShowAsync(endpoint.Address.ToString(), endpoint.Port);
+        await JoinServerBackend.StartMultiplayerClientAsync(endpoint.Address.ToString(), endpoint.Port);
     }
 
     private static IPEndPoint ResolveIPEndPoint(string serverIp, int serverPort)
diff --git a/NitroxClient/MonoBehaviours/Multiplayer.cs b/NitroxClient/MonoBehaviours/Multiplayer.cs
index c39389ac48..0f4d8763f0 100644
--- a/NitroxClient/MonoBehaviours/Multiplayer.cs
+++ b/NitroxClient/MonoBehaviours/Multiplayer.cs
@@ -12,6 +12,7 @@
 using NitroxClient.GameLogic.PlayerLogic.PlayerModel.ColorSwap;
 using NitroxClient.MonoBehaviours.Discord;
 using NitroxClient.MonoBehaviours.Gui.MainMenu;
+using NitroxClient.MonoBehaviours.Gui.MainMenu.ServerJoin;
 using NitroxModel.Core;
 using NitroxModel.Packets;
 using NitroxModel.Packets.Processors.Abstract;
@@ -172,16 +173,7 @@ public void InitMonoBehaviours()
         public void StopCurrentSession()
         {
             SceneManager.sceneLoaded -= SceneManager_sceneLoaded;
-
-            if (multiplayerSession.CurrentState.CurrentStage != MultiplayerSessionConnectionStage.DISCONNECTED)
-            {
-                multiplayerSession.Disconnect();
-            }
-
             OnAfterMultiplayerEnd?.Invoke();
-
-            //Always do this last.
-            NitroxServiceLocator.EndCurrentLifetimeScope();
         }
 
         private static void SetLoadingComplete()
@@ -222,7 +214,7 @@ private void SceneManager_sceneLoaded(Scene scene, LoadSceneMode loadMode)
             {
                 // If we just disconnected from a multiplayer session, then we need to kill the connection here.
                 // Maybe a better place for this, but here works in a pinch.
-                StopCurrentSession();
+                JoinServerBackend.StopMultiplayerClient();
                 SceneCleaner.Open();
             }
         }
diff --git a/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs b/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs
index abb90c934d..85b4c162a7 100644
--- a/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs
+++ b/NitroxPatcher/Patches/Persistent/MainMenuRightSide_OpenGroup_Patch.cs
@@ -14,7 +14,7 @@ public static void Prefix(string target)
         // Stopping the client if we leave the joining process
         if (target is not (MainMenuJoinServerPanel.NAME or MainMenuEnterPasswordPanel.NAME or MainMenuNotificationPanel.NAME))
         {
-            JoinServerBackend.Instance.StopMultiplayerClient();
+            JoinServerBackend.StopMultiplayerClient();
         }
     }
 }

From 4a037fed3f27ec73f52a2f3c1485d492d0d34a9c Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Fri, 5 Apr 2024 13:54:24 +0200
Subject: [PATCH 13/14] Address request changes and bugs

---
 .../LanguageFiles/en.json                     | 15 +++++--------
 .../Settings/NitroxSettingsManager.cs         |  1 -
 .../MainMenu/ServerJoin/JoinServerBackend.cs  |  3 ---
 .../ServerJoin/MainMenuJoinServerPanel.cs     |  2 +-
 .../ServersList/MainMenuServerListPanel.cs    | 16 ++++++++++++--
 NitroxModel/Core/NitroxServiceLocator.cs      |  2 +-
 .../SystemsSpawner_SetupSingleton_Patch.cs    | 22 -------------------
 7 files changed, 22 insertions(+), 39 deletions(-)
 delete mode 100644 NitroxPatcher/Patches/Persistent/SystemsSpawner_SetupSingleton_Patch.cs

diff --git a/Nitrox.Assets.Subnautica/LanguageFiles/en.json b/Nitrox.Assets.Subnautica/LanguageFiles/en.json
index 5016e3b5e1..6bc005c136 100644
--- a/Nitrox.Assets.Subnautica/LanguageFiles/en.json
+++ b/Nitrox.Assets.Subnautica/LanguageFiles/en.json
@@ -1,14 +1,11 @@
 {
     "Nitrox_AddServer": "Add Server",
-    "Nitrox_AddServer_NameDescription": "Name:",
-    "Nitrox_AddServer_AddressDescription": "Host:",
-    "Nitrox_AddServer_PortDescription": "Port:",
-    "Nitrox_AddServer_NamePlaceholder": "Enter a name for the server",
-    "Nitrox_AddServer_AddressPlaceholder": "Enter the IP or address of the server",
-    "Nitrox_AddServer_PortPlaceholder": "Enter the numeric port of the server",
-    "Nitrox_AddServer_Confirm": "Create server",
-    "Nitrox_AddServer_Back": "Back",
-    "Nitrox_AddServer_InvalidInput": "You input is invalid. Please check if all text boxes are filled out.",
+    "Nitrox_AddServerAdd": "Add",
+    "Nitrox_AddServerHost": "Host:",
+    "Nitrox_AddServerName": "Name:",
+    "Nitrox_AddServerPort": "Port:",
+    "Nitrox_BuildingDesyncDetected": "Server detected a desync with the local client's buildings (go to Nitrox settings to request a resync)",
+    "Nitrox_BuildingSettings": "Base building",
     "Nitrox_Cancel": "Cancel",
     "Nitrox_CommandNotAvailable": "This command is not available in Nitrox",
     "Nitrox_ConnectTo": "Connect to",
diff --git a/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs b/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs
index ee9dc1892b..8c357405d0 100644
--- a/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs
+++ b/NitroxClient/GameLogic/Settings/NitroxSettingsManager.cs
@@ -48,7 +48,6 @@ private void MakeSettings()
                 BuildingHandler.Main.AskForResync();
             }
         }));
-                MainMenuServerListPanel.Main.RefreshServerEntries();
 
         AddSetting("Nitrox_BuildingSettings", new Setting("Nitrox_SafeBuilding", NitroxPrefs.SafeBuilding, safe => NitroxPrefs.SafeBuilding.Value = safe));
         AddSetting("Nitrox_BuildingSettings", new Setting("Nitrox_SafeBuildingLog", NitroxPrefs.SafeBuildingLog, safeLog => NitroxPrefs.SafeBuildingLog.Value = safeLog));
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
index d465e631ae..4582339d6d 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/JoinServerBackend.cs
@@ -1,6 +1,5 @@
 using System.Collections;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Threading.Tasks;
 using NitroxClient.Communication.Abstract;
 using NitroxClient.Communication.Exceptions;
@@ -100,7 +99,6 @@ private static void SessionConnectionStateChangedHandler(IMultiplayerSessionConn
         }
     }
 
-    [SuppressMessage("Usage", "DIMA001:Dependency Injection container is used directly")]
     public static async Task StartMultiplayerClientAsync(string ip, int port)
     {
         serverIp = ip;
@@ -147,7 +145,6 @@ public static async Task StartMultiplayerClientAsync(string ip, int port)
         }
     }
 
-    [SuppressMessage("Usage", "DIMA001:Dependency Injection container is used directly")]
     public static void StopMultiplayerClient()
     {
         if (!multiplayerClient || !Multiplayer.Main)
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
index 876da84000..9901af1315 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServerJoin/MainMenuJoinServerPanel.cs
@@ -120,7 +120,7 @@ private static void OnCancelClick()
 
     public void UpdatePanelValues(string ip, string playerName, Vector3 hsb)
     {
-        header.text = $"    {Language.main.Get("Nitrox_JoinServer")}{ip}";
+        header.text = $"    {Language.main.Get("Nitrox_JoinServer")} {ip}";
         playerNameInputField.text = playerName;
         colorPicker.SetHSB(hsb);
     }
diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs
index 110082814a..e5e8556832 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/ServersList/MainMenuServerListPanel.cs
@@ -43,7 +43,13 @@ public void Setup(GameObject savedGamesRef)
 
         CreateAddServerButton();
         LoadSavedServers();
-        _ = FindLANServersAsync();
+        FindLANServersAsync().ContinueWith(t =>
+        {
+            if (t is { IsFaulted: true, Exception: { } ex })
+            {
+                Log.Warn($"Failed to execute FindLANServersAsync: {ex.GetFirstNonAggregateMessage()}");
+            }
+        });
     }
 
     public bool OnButtonDown(GameInput.Button button)
@@ -272,6 +278,12 @@ public void RefreshServerEntries()
 
         CreateAddServerButton();
         LoadSavedServers();
-        _ = FindLANServersAsync();
+        FindLANServersAsync().ContinueWith(t =>
+        {
+            if (t is { IsFaulted: true, Exception: { } ex })
+            {
+                Log.Warn($"Failed to execute FindLANServersAsync: {ex.GetFirstNonAggregateMessage()}");
+            }
+        });
     }
 }
diff --git a/NitroxModel/Core/NitroxServiceLocator.cs b/NitroxModel/Core/NitroxServiceLocator.cs
index 4c6893ec5c..3c7fc20111 100644
--- a/NitroxModel/Core/NitroxServiceLocator.cs
+++ b/NitroxModel/Core/NitroxServiceLocator.cs
@@ -150,7 +150,7 @@ private static T LocateServicePreLifetimeAndRegister()
         /// <summary>
         ///     Invalidates the cache for type <see cref="T" />. The next <see cref="Value" /> access will request from <see cref="NitroxServiceLocator" /> again.
         /// </summary>
-        public static void Invalidate(object _, EventArgs __)
+        private static void Invalidate(object _, EventArgs __)
         {
             value = null;
             LifetimeScopeEnded -= Invalidate;
diff --git a/NitroxPatcher/Patches/Persistent/SystemsSpawner_SetupSingleton_Patch.cs b/NitroxPatcher/Patches/Persistent/SystemsSpawner_SetupSingleton_Patch.cs
deleted file mode 100644
index dc48a687b0..0000000000
--- a/NitroxPatcher/Patches/Persistent/SystemsSpawner_SetupSingleton_Patch.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using System;
-using System.Reflection;
-using HarmonyLib;
-using NitroxModel.Helper;
-
-namespace NitroxPatcher.Patches.Persistent;
-
-/// <summary>
-///     Patch to suppress SentrySdk NRE as it's destroyed by us
-/// </summary>
-public sealed partial class SystemsSpawner_SetupSingleton_Patch : NitroxPatch, IPersistentPatch
-{
-    private static readonly MethodInfo TARGET_METHOD = AccessTools.EnumeratorMoveNext(Reflect.Method((SystemsSpawner s) => s.SetupSingleton(default)));
-
-    public static void Finalizer(ref Exception __exception)
-    {
-        if (__exception is NullReferenceException)
-        {
-            __exception = null;
-        }
-    }
-}

From 499f6e66ff454763ca154de366f86e9af789566f Mon Sep 17 00:00:00 2001
From: Jannify <23176718+Jannify@users.noreply.github.com>
Date: Sun, 15 Sep 2024 19:56:22 +0200
Subject: [PATCH 14/14] Add missing translation string

---
 .../Gui/MainMenu/MainMenuNotificationPanel.cs               | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs
index 6e842d2a5a..496e907f9a 100644
--- a/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs
+++ b/NitroxClient/MonoBehaviours/Gui/MainMenu/MainMenuNotificationPanel.cs
@@ -36,9 +36,9 @@ public static void ShowLoading()
 
         instance.confirmObject.SetActive(false);
         instance.loadingCircle.gameObject.SetActive(true);
-        instance.text.text = "Loading";
+        instance.text.text = Language.main.Get("Nitrox_Loading");
         MainMenuRightSide.main.OpenGroup(NAME);
-        instance.confirmButtonLegend.legendButtonConfiguration = Array.Empty<LegendButtonData>();
+        instance.confirmButtonLegend.legendButtonConfiguration = [];
     }
 
     public static void ShowMessage(string message, string returningMenuPanel, Action continuationAction = null)
@@ -112,7 +112,7 @@ private void Update()
         if (loadingCircle)
         {
             loadingCircle.transform.localRotation = Quaternion.Euler(0, 0, Time.time % 360 * 250); // 250 is the speed
-            loadingCircle.fillAmount = Mathf.Lerp(0.05f, 0.95f, Math.Abs(Time.time % 6 - 3) * 0.333f); // Lerps t fades from 0 to 1 and back to 0
+            loadingCircle.fillAmount = Mathf.Lerp(0.05f, 0.95f, Math.Abs(Time.time % 6 - 3) * 0.333f); // Lerp t fades from 0 to 1 and back to 0
             uGUI_LegendBar.ClearButtons();
         }
     }