Priority for SettingsMenu

Author: marchellcx

LabExtended/API/Settings/Menus/SettingsMenu.cs

@@ -31,6 +31,11 @@ public abstract class SettingsMenu
     /// </summary>
     public virtual bool HeaderReducedPadding { get; } = false;
 
+    /// <summary>
+    /// Gets the priority of the menu. Higher priority menus are displayed first.
+    /// </summary>
+    public virtual int Priority { get; } = 1;
+
     /// <summary>
     /// Gets the player assigned to this menu.
     /// </summary>

LabExtended/API/Settings/SettingsManager.cs

@@ -63,6 +63,34 @@ public static void SyncEntries(this ExPlayer player)
         var list = ListPool<ServerSpecificSettingBase>.Shared.Rent();
         var headers = ListPool<string>.Shared.Rent();
 
+        foreach (var menuEntry in player.settingsMenuLookup)
+        {
+            if (menuEntry.Value.IsHidden)
+                continue;
+
+            if (!string.IsNullOrWhiteSpace(menuEntry.Value.Header) && !headers.Contains(menuEntry.Value.CustomId))
+            {
+                headers.Add(menuEntry.Value.CustomId);
+
+                list.Add(new SSGroupHeader(menuEntry.Value.Header,
+                    menuEntry.Value.HeaderReducedPadding, menuEntry.Value.HeaderHint));
+            }
+
+            foreach (var menuSetting in menuEntry.Value.Entries)
+            {
+                if (menuSetting?.Base == null)
+                    continue;
+
+                if (!menuSetting.Player)
+                    continue;
+
+                if (menuSetting.IsHidden)
+                    continue;
+
+                list.Add(menuSetting.Base);
+            }
+        }
+
         foreach (var settingsEntry in player.settingsIdLookup)
         {
             if (settingsEntry.Value?.Base == null)
@@ -75,18 +103,7 @@ public static void SyncEntries(this ExPlayer player)
                 continue;
 
             if (settingsEntry.Value.Menu != null)
-            {
-                if (settingsEntry.Value.Menu.IsHidden)
-                    continue;
-
-                if (!string.IsNullOrWhiteSpace(settingsEntry.Value.Menu.Header) && !headers.Contains(settingsEntry.Value.Menu.CustomId))
-                {
-                    headers.Add(settingsEntry.Value.Menu.CustomId);
-
-                    list.Add(new SSGroupHeader(settingsEntry.Value.Menu.Header,
-                        settingsEntry.Value.Menu.HeaderReducedPadding, settingsEntry.Value.Menu.HeaderHint));
-                }
-            }
+                continue;
 
             list.Add(settingsEntry.Value.Base);
         }
@@ -494,6 +511,7 @@ public static bool AddMenu(this ExPlayer player, SettingsMenu menu)
         menu.Entries = ListPool<SettingsEntry>.Shared.ToArrayReturn(entries);
 
         player.settingsMenuLookup.Add(menu.CustomId, menu);
+        player.settingsMenuLookup.Order(true, m => m.Value.Priority);
 
         if (!string.IsNullOrEmpty(menu.Header))
         {
@@ -776,6 +794,9 @@ private static void OnPlayerVerified(ExPlayer player)
                 }
             }
 
+            if (player.settingsMenuLookup.Count > 0)
+                player.settingsMenuLookup.Order(true, m => m.Value.Priority);
+
             if (player.settingsIdLookup.Count > 0)
                 SyncEntries(player);
         }

LabExtended/Extensions/CollectionExtensions.cs

@@ -549,6 +549,40 @@ public static void For<T>(this IEnumerator<T> enumerator, Action<int, T> action,
     #endregion
 
     #region Dictionary Extensions
+    /// <summary>
+    /// Reorders the elements of the dictionary in place according to a specified key selector and sort direction.
+    /// </summary>
+    /// <remarks>This method clears and repopulates the dictionary to reflect the new order. The ordering is
+    /// determined by the integer value returned from the selector function for each key-value pair. Note that the order
+    /// of elements in a standard IDictionary{TKey, TValue} implementation is not guaranteed; use this method only with
+    /// dictionary types that preserve insertion order, such as Dictionary{TKey, TValue} in .NET Core 3.0 and later, or
+    /// OrderedDictionary.</remarks>
+    /// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
+    /// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
+    /// <param name="dict">The dictionary whose elements are to be reordered. Cannot be null.</param>
+    /// <param name="descending">true to sort the dictionary in descending order; otherwise, false for ascending order.</param>
+    /// <param name="selector">A function to extract the sort key from each key-value pair. Cannot be null.</param>
+    /// <exception cref="ArgumentNullException">Thrown if dict or selector is null.</exception>
+    public static void Order<TKey, TValue>(this Dictionary<TKey, TValue> dict, bool descending, Func<KeyValuePair<TKey, TValue>, int> selector)
+    {
+        if (dict is null)
+            throw new ArgumentNullException(nameof(dict));
+
+        if (selector is null)
+            throw new ArgumentNullException(nameof(selector));
+
+        var ordered = (descending
+            ? dict.OrderByDescending(selector)
+            : dict.OrderBy(selector)).ToList();
+
+        dict.Clear();
+
+        foreach (var pair in ordered)
+            dict[pair.Key] = pair.Value;
+
+        ordered.Clear();
+    }
+
     /// <summary>
     /// Attempts find a key by pair value.
     /// </summary>