Merge branch 'beta' of https://github.com/swiftly-solution/swiftlys2 into beta

skuzzis · skuzzis · commit 53a6c0afbdbb · 2025-11-18T10:33:10.000+02:00
diff --git a/managed/src/SwiftlyS2.Core/Modules/Menus/MenuManagerAPI.cs b/managed/src/SwiftlyS2.Core/Modules/Menus/MenuManagerAPI.cs
@@ -145,7 +145,7 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )
                 if (menu.Configuration.PlaySound)
                 {
                     scrollSound.Recipients.AddRecipient(@event.PlayerId);
-                    scrollSound.Emit();
+                    _ = scrollSound.Emit();
                     scrollSound.Recipients.RemoveRecipient(@event.PlayerId);
                 }
             }
@@ -156,18 +156,18 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )
                 if (menu.Configuration.PlaySound)
                 {
                     scrollSound.Recipients.AddRecipient(@event.PlayerId);
-                    scrollSound.Emit();
+                    _ = scrollSound.Emit();
                     scrollSound.Recipients.RemoveRecipient(@event.PlayerId);
                 }
             }
             else if (exitKey.HasFlag(@event.Key.ToKeyBind()))
             {
-                CloseMenuForPlayer(player, menu);
+                CloseMenuForPlayerInternal(player, menu, true);
 
                 if (menu.Configuration.PlaySound)
                 {
                     exitSound.Recipients.AddRecipient(@event.PlayerId);
-                    exitSound.Emit();
+                    _ = exitSound.Emit();
                     exitSound.Recipients.RemoveRecipient(@event.PlayerId);
                 }
             }
@@ -181,7 +181,7 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )
                     if (menu.Configuration.PlaySound && option.PlaySound)
                     {
                         useSound.Recipients.AddRecipient(@event.PlayerId);
-                        useSound.Emit();
+                        _ = useSound.Emit();
                         useSound.Recipients.RemoveRecipient(@event.PlayerId);
                     }
                 }
@@ -196,7 +196,7 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )
                 if (menu.Configuration.PlaySound)
                 {
                     scrollSound.Recipients.AddRecipient(@event.PlayerId);
-                    scrollSound.Emit();
+                    _ = scrollSound.Emit();
                     scrollSound.Recipients.RemoveRecipient(@event.PlayerId);
                 }
             }
@@ -207,17 +207,17 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )
                 if (menu.Configuration.PlaySound)
                 {
                     scrollSound.Recipients.AddRecipient(@event.PlayerId);
-                    scrollSound.Emit();
+                    _ = scrollSound.Emit();
                     scrollSound.Recipients.RemoveRecipient(@event.PlayerId);
                 }
             }
             else if (KeyBind.A.HasFlag(@event.Key.ToKeyBind()))
             {
-                CloseMenuForPlayer(player, menu);
+                CloseMenuForPlayerInternal(player, menu, true);
                 if (menu.Configuration.PlaySound)
                 {
                     exitSound.Recipients.AddRecipient(@event.PlayerId);
-                    exitSound.Emit();
+                    _ = exitSound.Emit();
                     exitSound.Recipients.RemoveRecipient(@event.PlayerId);
                 }
             }
@@ -231,7 +231,7 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )
                     if (menu.Configuration.PlaySound && option.PlaySound)
                     {
                         useSound.Recipients.AddRecipient(@event.PlayerId);
-                        useSound.Emit();
+                        _ = useSound.Emit();
                         useSound.Recipients.RemoveRecipient(@event.PlayerId);
                     }
                 }
@@ -247,7 +247,7 @@ private void OnClientDisconnected( IOnClientDisconnectedEvent @event )
             openMenus
                 .Where(kvp => kvp.Key == player)
                 .ToList()
-                .ForEach(kvp => CloseMenuForPlayer(player, kvp.Value));
+                .ForEach(kvp => CloseMenuForPlayerInternal(player, kvp.Value, true));
         }
     }
 
@@ -322,7 +322,7 @@ public void OpenMenuForPlayer( IPlayer player, IMenuAPI menu )
             if (menu.Parent.ParentMenu == currentMenu)
             {
                 // We are transitioning from the current menu to one of its submenus.
-                // To show the submenu, we first need to close the current (parent) menu, see CloseMenuForPlayer.
+                // To show the submenu, we first need to close the current (parent) menu.
                 // The parent menu may have an onClosed callback registered in onClosedCallbacks.
                 // If we do not remove that callback temporarily, closing the parent menu here
                 // would incorrectly invoke the callback even though the user is only navigating
@@ -333,12 +333,12 @@ public void OpenMenuForPlayer( IPlayer player, IMenuAPI menu )
                 //   3. Re-register the callback so it will only be invoked later, when the
                 //      logical end of the menu flow is reached and the menu is truly closed.
                 _ = onClosedCallbacks.TryRemove((player, currentMenu), out var callback);
-                CloseMenuForPlayer(player, currentMenu);
+                CloseMenuForPlayerInternal(player, currentMenu, false);
                 _ = onClosedCallbacks.AddOrUpdate((player, currentMenu), callback, ( _, _ ) => callback);
             }
             else
             {
-                CloseMenuForPlayer(player, currentMenu);
+                CloseMenuForPlayerInternal(player, currentMenu, false);
             }
         }
 
@@ -358,15 +358,36 @@ public void CloseMenu( IMenuAPI menu )
         Core.PlayerManager
             .GetAllPlayers()
             .ToList()
-            .ForEach(player => CloseMenuForPlayer(player, menu));
+            .ForEach(player => CloseMenuForPlayerInternal(player, menu, true));
     }
 
     public void CloseMenuForPlayer( IPlayer player, IMenuAPI menu )
+    {
+        CloseMenuForPlayerInternal(player, menu, true);
+    }
+
+    public void CloseAllMenus()
+    {
+        openMenus.ToList().ForEach(kvp =>
+        {
+            var currentMenu = kvp.Value;
+            while (currentMenu != null)
+            {
+                currentMenu.HideForPlayer(kvp.Key);
+                MenuClosed?.Invoke(this, new MenuManagerEventArgs { Player = kvp.Key, Menu = currentMenu });
+                currentMenu = currentMenu.Parent.ParentMenu;
+            }
+            _ = openMenus.TryRemove(kvp.Key, out _);
+        });
+    }
+
+    private void CloseMenuForPlayerInternal( IPlayer player, IMenuAPI menu, bool reopenParent )
     {
         if (!openMenus.TryGetValue(player, out var currentMenu) || currentMenu != menu)
         {
             return;
         }
+
         if (onClosedCallbacks.TryRemove((player, menu), out var onClosed) && onClosed != null)
         {
             onClosed(player, menu);
@@ -377,25 +398,10 @@ public void CloseMenuForPlayer( IPlayer player, IMenuAPI menu )
             menu.HideForPlayer(player);
             MenuClosed?.Invoke(this, new MenuManagerEventArgs { Player = player, Menu = menu });
 
-            if (menu.Parent.ParentMenu != null)
+            if (reopenParent && menu.Parent.ParentMenu != null)
             {
                 OpenMenuForPlayer(player, menu.Parent.ParentMenu);
             }
         }
     }
-
-    public void CloseAllMenus()
-    {
-        openMenus.ToList().ForEach(kvp =>
-        {
-            var currentMenu = kvp.Value;
-            while (currentMenu != null)
-            {
-                currentMenu.HideForPlayer(kvp.Key);
-                MenuClosed?.Invoke(this, new MenuManagerEventArgs { Player = kvp.Key, Menu = currentMenu });
-                currentMenu = currentMenu.Parent.ParentMenu;
-            }
-            _ = openMenus.TryRemove(kvp.Key, out _);
-        });
-    }
 }
diff --git a/managed/src/SwiftlyS2.Core/Natives/GameFunctions.cs b/managed/src/SwiftlyS2.Core/Natives/GameFunctions.cs
@@ -2,12 +2,12 @@
 using System.Text;
 using Spectre.Console;
 using SwiftlyS2.Shared.Natives;
-using SwiftlyS2.Shared.SchemaDefinitions;
 
 namespace SwiftlyS2.Core.Natives;
 
 internal static class GameFunctions
 {
+    private static readonly bool IsWindows = System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows);
     public static unsafe delegate* unmanaged< CTakeDamageInfo*, nint, nint, nint, Vector*, Vector*, float, int, int, void*, void > pCTakeDamageInfo_Constructor;
     public static unsafe delegate* unmanaged< nint, Ray_t*, Vector, Vector, CTraceFilter*, CGameTrace*, void > pTraceShape;
     public static unsafe delegate* unmanaged< Vector, Vector, BBox_t, CTraceFilter*, CGameTrace*, void > pTracePlayerBBox;
@@ -16,7 +16,8 @@ internal static class GameFunctions
     public static unsafe delegate* unmanaged< nint, nint, float, void > pSetOrAddAttribute;
     public static unsafe delegate* unmanaged< int, nint, nint > pGetWeaponCSDataFromKey;
     public static unsafe delegate* unmanaged< nint, uint, nint, byte, CUtlSymbolLarge, byte, int, nint, nint, void > pDispatchParticleEffect;
-    public static unsafe delegate* unmanaged< nint, uint, float, nint, byte, void > pTerminateRound;
+    public static unsafe delegate* unmanaged< nint, uint, float, nint, byte, void > pTerminateRoundLinux;
+    public static unsafe delegate* unmanaged< nint, float, uint, nint, byte, void > pTerminateRoundWindows;
     public static unsafe delegate* unmanaged< nint, Vector*, QAngle*, Vector*, void > pTeleport;
     public static int TeleportOffset => NativeOffsets.Fetch("CBaseEntity::Teleport");
     public static int CommitSuicideOffset => NativeOffsets.Fetch("CBasePlayerPawn::CommitSuicide");
@@ -43,7 +44,14 @@ public static void Initialize()
             pSetOrAddAttribute = (delegate* unmanaged< nint, IntPtr, float, void >)NativeSignatures.Fetch("CAttributeList::SetOrAddAttributeValueByName");
             pGetWeaponCSDataFromKey = (delegate* unmanaged< int, nint, nint >)NativeSignatures.Fetch("GetWeaponCSDataFromKey");
             pDispatchParticleEffect = (delegate* unmanaged< nint, uint, nint, byte, CUtlSymbolLarge, byte, int, nint, nint, void >)NativeSignatures.Fetch("DispatchParticleEffect");
-            pTerminateRound = (delegate* unmanaged< nint, uint, float, nint, byte, void >)NativeSignatures.Fetch("CGameRules::TerminateRound");
+            if (IsWindows)
+            {
+                pTerminateRoundWindows = (delegate* unmanaged< nint, float, uint, nint, byte, void >)NativeSignatures.Fetch("CGameRules::TerminateRound");
+            }
+            else
+            {
+                pTerminateRoundLinux = (delegate* unmanaged< nint, uint, float, nint, byte, void >)NativeSignatures.Fetch("CGameRules::TerminateRound");
+            }
             pTeleport = (delegate* unmanaged< nint, Vector*, QAngle*, Vector*, void >)((void**)NativeMemoryHelpers.GetVirtualTableAddress("server", "CBaseEntity"))[TeleportOffset];
         }
     }
@@ -60,7 +68,14 @@ public static void TerminateRound( nint gameRules, uint reason, float delay )
         {
             unsafe
             {
-                pTerminateRound(gameRules, reason, delay, 0, 0);
+                if (IsWindows)
+                {
+                    pTerminateRoundWindows(gameRules, delay, reason, 0, 0);
+                }
+                else
+                {
+                    pTerminateRoundLinux(gameRules, reason, delay, 0, 0);
+                }
             }
         }
         catch (Exception e)
diff --git a/managed/src/TestPlugin/TestPlugin.cs b/managed/src/TestPlugin/TestPlugin.cs
@@ -36,6 +36,7 @@
 using System.Collections.Concurrent;
 using Dia2Lib;
 using System.Reflection.Metadata;
+using Microsoft.Diagnostics.Tracing.Parsers.MicrosoftWindowsTCPIP;
 
 namespace TestPlugin;
 
@@ -631,6 +632,12 @@ public void GetIpCommand( ICommandContext context )
 
     //     Core.Menus.OpenMenu(player, settingsMenu);
     // }
+    [Command("ed")]
+    public void EndRoundCommand( ICommandContext _ )
+    {
+        var gameRules = Core.EntitySystem.GetGameRules()!;
+        gameRules.TerminateRound(RoundEndReason.CTsWin, 10.0f);
+    }
 
     [Command("tm")]
     public void TestMenuCommand( ICommandContext context )
@@ -656,16 +663,42 @@ public void TestMenuCommand( ICommandContext context )
             .AddOption(new ButtonMenuOption("Cancel") { CloseAfterClick = true })
             .Build();
 
-        var menu = Core.MenusAPI
+        var shopMenu = Core.MenusAPI
             .CreateBuilder()
             .Design.SetMenuTitle("Shop Menu")
-            .AddOption(new SubmenuMenuOption("Item 1", confirmMenu))
-            .AddOption(new SubmenuMenuOption("Item 2", confirmMenu))
-            .AddOption(new SubmenuMenuOption("Item 3", confirmMenu))
-            .AddOption(new SubmenuMenuOption("Item 4", confirmMenu))
+            .AddOption(new SubmenuMenuOption("Item 1", async () =>
+            {
+                await Task.Delay(100);
+                return confirmMenu;
+            }))
+            .AddOption(new SubmenuMenuOption("Item 2", async () =>
+            {
+                await Task.Delay(100);
+                return confirmMenu;
+            }))
+            .AddOption(new SubmenuMenuOption("Item 3", async () =>
+            {
+                await Task.Delay(100);
+                return confirmMenu;
+            }))
+            .AddOption(new SubmenuMenuOption("Item 4", async () =>
+            {
+                await Task.Delay(100);
+                return confirmMenu;
+            }))
+            .Build();
+
+        var mainMenu = Core.MenusAPI
+            .CreateBuilder()
+            .Design.SetMenuTitle("Menu")
+            .AddOption(new SubmenuMenuOption("Shop", async () =>
+            {
+                await Task.Delay(100);
+                return shopMenu;
+            }))
             .Build();
 
-        Core.MenusAPI.OpenMenu(menu, ( player, menu ) =>
+        Core.MenusAPI.OpenMenu(mainMenu, ( player, menu ) =>
         {
             Console.WriteLine($"{menu.Configuration.Title} closed for player: {player.Controller.PlayerName}");
         });
diff --git a/src/server/players/manager.cpp b/src/server/players/manager.cpp
@@ -210,8 +210,14 @@ void CheckTransmitHook(void* _this, CCheckTransmitInfo** ppInfoList, int infoCou
         auto& pInfo = ppInfoList[i];
         int playerid = pInfo->m_nPlayerSlot.Get();
         if (!playermanager->IsPlayerOnline(playerid))
+        {
             continue;
+        }
         auto player = playermanager->GetPlayer(playerid);
+        if (!player)
+        {
+            continue;
+        }
 
         auto& blockedBits = player->GetBlockedTransmittingBits();
 
@@ -275,12 +281,21 @@ bool ClientConnectHook(void* _this, CPlayerSlot slot, const char* pszName, uint6
     static auto playermanager = g_ifaceService.FetchInterface<IPlayerManager>(PLAYERMANAGER_INTERFACE_VERSION);
     auto playerid = slot.Get();
     auto player = playermanager->RegisterPlayer(playerid);
-    player->Initialize(playerid);
+    // player->Initialize(playerid);
+    if (!player)
+    {
+        return false;
+    }
+
     player->SetUnauthorizedSteamID(xuid);
 
     if (g_pOnClientConnectCallback)
+    {
         if (reinterpret_cast<bool (*)(int)>(g_pOnClientConnectCallback)(playerid) == false)
+        {
             return false;
+        }
+    }
 
     return reinterpret_cast<decltype(&ClientConnectHook)>(g_pClientConnectHook->GetOriginal())(_this, slot, pszName, xuid, pszNetworkID, unk1, pRejectReason);
 }
@@ -291,8 +306,8 @@ void OnClientConnectedHook(void* _this, CPlayerSlot slot, const char* pszName, u
     auto playerid = slot.Get();
     if (bFakePlayer)
     {
-        auto player = playermanager->RegisterPlayer(playerid);
-        player->Initialize(playerid);
+        playermanager->RegisterPlayer(playerid);
+        // player->Initialize(playerid);
     }
     else
     {
@@ -326,10 +341,11 @@ IPlayer* CPlayerManager::RegisterPlayer(int playerid)
     if (g_Players[playerid] != nullptr)
         UnregisterPlayer(playerid);
 
-    g_Players[playerid] = new CPlayer();
-    g_Players[playerid]->Initialize(playerid);
+    auto player = new CPlayer();
+    player->Initialize(playerid);
+    g_Players[playerid] = player;
 
-    return g_Players[playerid];
+    return player;
 }
 
 void CPlayerManager::UnregisterPlayer(int playerid)
@@ -341,11 +357,13 @@ void CPlayerManager::UnregisterPlayer(int playerid)
 
     static auto vgui = g_ifaceService.FetchInterface<IVGUI>(VGUI_INTERFACE_VERSION);
 
-    vgui->UnregisterForPlayer(g_Players[playerid]);
-
-    g_Players[playerid]->Shutdown();
-    delete g_Players[playerid];
+    auto player = g_Players[playerid];
     g_Players[playerid] = nullptr;
+
+    vgui->UnregisterForPlayer(player);
+
+    player->Shutdown();
+    delete player;
 }
 
 IPlayer* CPlayerManager::GetPlayer(int playerid)
diff --git a/src/server/players/player.cpp b/src/server/players/player.cpp

Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )`
`145`	`145`	`if (menu.Configuration.PlaySound)`
`146`	`146`	`{`
`147`	`147`	`scrollSound.Recipients.AddRecipient(@event.PlayerId);`
`148`		`- scrollSound.Emit();`
	`148`	`+ _ = scrollSound.Emit();`
`149`	`149`	`scrollSound.Recipients.RemoveRecipient(@event.PlayerId);`
`150`	`150`	`}`
`151`	`151`	`}`
`@@ -156,18 +156,18 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )`
`156`	`156`	`if (menu.Configuration.PlaySound)`
`157`	`157`	`{`
`158`	`158`	`scrollSound.Recipients.AddRecipient(@event.PlayerId);`
`159`		`- scrollSound.Emit();`
	`159`	`+ _ = scrollSound.Emit();`
`160`	`160`	`scrollSound.Recipients.RemoveRecipient(@event.PlayerId);`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`	`else if (exitKey.HasFlag(@event.Key.ToKeyBind()))`
`164`	`164`	`{`
`165`		`- CloseMenuForPlayer(player, menu);`
	`165`	`+ CloseMenuForPlayerInternal(player, menu, true);`
`166`	`166`
`167`	`167`	`if (menu.Configuration.PlaySound)`
`168`	`168`	`{`
`169`	`169`	`exitSound.Recipients.AddRecipient(@event.PlayerId);`
`170`		`- exitSound.Emit();`
	`170`	`+ _ = exitSound.Emit();`
`171`	`171`	`exitSound.Recipients.RemoveRecipient(@event.PlayerId);`
`172`	`172`	`}`
`173`	`173`	`}`
`@@ -181,7 +181,7 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )`
`181`	`181`	`if (menu.Configuration.PlaySound && option.PlaySound)`
`182`	`182`	`{`
`183`	`183`	`useSound.Recipients.AddRecipient(@event.PlayerId);`
`184`		`- useSound.Emit();`
	`184`	`+ _ = useSound.Emit();`
`185`	`185`	`useSound.Recipients.RemoveRecipient(@event.PlayerId);`
`186`	`186`	`}`
`187`	`187`	`}`
`@@ -196,7 +196,7 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )`
`196`	`196`	`if (menu.Configuration.PlaySound)`
`197`	`197`	`{`
`198`	`198`	`scrollSound.Recipients.AddRecipient(@event.PlayerId);`
`199`		`- scrollSound.Emit();`
	`199`	`+ _ = scrollSound.Emit();`
`200`	`200`	`scrollSound.Recipients.RemoveRecipient(@event.PlayerId);`
`201`	`201`	`}`
`202`	`202`	`}`
`@@ -207,17 +207,17 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )`
`207`	`207`	`if (menu.Configuration.PlaySound)`
`208`	`208`	`{`
`209`	`209`	`scrollSound.Recipients.AddRecipient(@event.PlayerId);`
`210`		`- scrollSound.Emit();`
	`210`	`+ _ = scrollSound.Emit();`
`211`	`211`	`scrollSound.Recipients.RemoveRecipient(@event.PlayerId);`
`212`	`212`	`}`
`213`	`213`	`}`
`214`	`214`	`else if (KeyBind.A.HasFlag(@event.Key.ToKeyBind()))`
`215`	`215`	`{`
`216`		`- CloseMenuForPlayer(player, menu);`
	`216`	`+ CloseMenuForPlayerInternal(player, menu, true);`
`217`	`217`	`if (menu.Configuration.PlaySound)`
`218`	`218`	`{`
`219`	`219`	`exitSound.Recipients.AddRecipient(@event.PlayerId);`
`220`		`- exitSound.Emit();`
	`220`	`+ _ = exitSound.Emit();`
`221`	`221`	`exitSound.Recipients.RemoveRecipient(@event.PlayerId);`
`222`	`222`	`}`
`223`	`223`	`}`
`@@ -231,7 +231,7 @@ private void KeyStateChange( IOnClientKeyStateChangedEvent @event )`
`231`	`231`	`if (menu.Configuration.PlaySound && option.PlaySound)`
`232`	`232`	`{`
`233`	`233`	`useSound.Recipients.AddRecipient(@event.PlayerId);`
`234`		`- useSound.Emit();`
	`234`	`+ _ = useSound.Emit();`
`235`	`235`	`useSound.Recipients.RemoveRecipient(@event.PlayerId);`
`236`	`236`	`}`
`237`	`237`	`}`
`@@ -247,7 +247,7 @@ private void OnClientDisconnected( IOnClientDisconnectedEvent @event )`
`247`	`247`	`openMenus`
`248`	`248`	`.Where(kvp => kvp.Key == player)`
`249`	`249`	`.ToList()`
`250`		`- .ForEach(kvp => CloseMenuForPlayer(player, kvp.Value));`
	`250`	`+ .ForEach(kvp => CloseMenuForPlayerInternal(player, kvp.Value, true));`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`
`@@ -322,7 +322,7 @@ public void OpenMenuForPlayer( IPlayer player, IMenuAPI menu )`
`322`	`322`	`if (menu.Parent.ParentMenu == currentMenu)`
`323`	`323`	`{`
`324`	`324`	`// We are transitioning from the current menu to one of its submenus.`
`325`		`- // To show the submenu, we first need to close the current (parent) menu, see CloseMenuForPlayer.`
	`325`	`+ // To show the submenu, we first need to close the current (parent) menu.`
`326`	`326`	`// The parent menu may have an onClosed callback registered in onClosedCallbacks.`
`327`	`327`	`// If we do not remove that callback temporarily, closing the parent menu here`
`328`	`328`	`// would incorrectly invoke the callback even though the user is only navigating`
`@@ -333,12 +333,12 @@ public void OpenMenuForPlayer( IPlayer player, IMenuAPI menu )`
`333`	`333`	`// 3. Re-register the callback so it will only be invoked later, when the`
`334`	`334`	`// logical end of the menu flow is reached and the menu is truly closed.`
`335`	`335`	`_ = onClosedCallbacks.TryRemove((player, currentMenu), out var callback);`
`336`		`- CloseMenuForPlayer(player, currentMenu);`
	`336`	`+ CloseMenuForPlayerInternal(player, currentMenu, false);`
`337`	`337`	`_ = onClosedCallbacks.AddOrUpdate((player, currentMenu), callback, ( _, _ ) => callback);`
`338`	`338`	`}`
`339`	`339`	`else`
`340`	`340`	`{`
`341`		`- CloseMenuForPlayer(player, currentMenu);`
	`341`	`+ CloseMenuForPlayerInternal(player, currentMenu, false);`
`342`	`342`	`}`
`343`	`343`	`}`
`344`	`344`
`@@ -358,15 +358,36 @@ public void CloseMenu( IMenuAPI menu )`
`358`	`358`	`Core.PlayerManager`
`359`	`359`	`.GetAllPlayers()`
`360`	`360`	`.ToList()`
`361`		`- .ForEach(player => CloseMenuForPlayer(player, menu));`
	`361`	`+ .ForEach(player => CloseMenuForPlayerInternal(player, menu, true));`
`362`	`362`	`}`
`363`	`363`
`364`	`364`	`public void CloseMenuForPlayer( IPlayer player, IMenuAPI menu )`
	`365`	`+ {`
	`366`	`+ CloseMenuForPlayerInternal(player, menu, true);`
	`367`	`+ }`
	`368`	`+`
	`369`	`+ public void CloseAllMenus()`
	`370`	`+ {`
	`371`	`+ openMenus.ToList().ForEach(kvp =>`
	`372`	`+ {`
	`373`	`+ var currentMenu = kvp.Value;`
	`374`	`+ while (currentMenu != null)`
	`375`	`+ {`
	`376`	`+ currentMenu.HideForPlayer(kvp.Key);`
	`377`	`+ MenuClosed?.Invoke(this, new MenuManagerEventArgs { Player = kvp.Key, Menu = currentMenu });`
	`378`	`+ currentMenu = currentMenu.Parent.ParentMenu;`
	`379`	`+ }`
	`380`	`+ _ = openMenus.TryRemove(kvp.Key, out _);`
	`381`	`+ });`
	`382`	`+ }`
	`383`	`+`
	`384`	`+ private void CloseMenuForPlayerInternal( IPlayer player, IMenuAPI menu, bool reopenParent )`
`365`	`385`	`{`
`366`	`386`	`if (!openMenus.TryGetValue(player, out var currentMenu) \|\| currentMenu != menu)`
`367`	`387`	`{`
`368`	`388`	`return;`
`369`	`389`	`}`
	`390`	`+`
`370`	`391`	`if (onClosedCallbacks.TryRemove((player, menu), out var onClosed) && onClosed != null)`
`371`	`392`	`{`
`372`	`393`	`onClosed(player, menu);`
`@@ -377,25 +398,10 @@ public void CloseMenuForPlayer( IPlayer player, IMenuAPI menu )`
`377`	`398`	`menu.HideForPlayer(player);`
`378`	`399`	`MenuClosed?.Invoke(this, new MenuManagerEventArgs { Player = player, Menu = menu });`
`379`	`400`
`380`		`- if (menu.Parent.ParentMenu != null)`
	`401`	`+ if (reopenParent && menu.Parent.ParentMenu != null)`
`381`	`402`	`{`
`382`	`403`	`OpenMenuForPlayer(player, menu.Parent.ParentMenu);`
`383`	`404`	`}`
`384`	`405`	`}`
`385`	`406`	`}`
`386`		`-`
`387`		`- public void CloseAllMenus()`
`388`		`- {`
`389`		`- openMenus.ToList().ForEach(kvp =>`
`390`		`- {`
`391`		`- var currentMenu = kvp.Value;`
`392`		`- while (currentMenu != null)`
`393`		`- {`
`394`		`- currentMenu.HideForPlayer(kvp.Key);`
`395`		`- MenuClosed?.Invoke(this, new MenuManagerEventArgs { Player = kvp.Key, Menu = currentMenu });`
`396`		`- currentMenu = currentMenu.Parent.ParentMenu;`
`397`		`- }`
`398`		`- _ = openMenus.TryRemove(kvp.Key, out _);`
`399`		`- });`
`400`		`- }`
`401`	`407`	`}`