fixed SettingsTextArea sending outdated messages

Author: marchellcx

LabExtended/API/Settings/Entries/SettingsKeyBind.cs

@@ -142,11 +142,14 @@ internal override void Internal_Updated()
 
             _isPressed = IsPressed;
 
-            LastPressTime = Time.realtimeSinceStartup;
+            if (IsPressed)
+            {
+                LastPressTime = Time.realtimeSinceStartup;
 
-            HandlePress(IsPressed);
-            
-            OnPressed.InvokeSafe(this);
+                HandlePress(IsPressed);
+
+                OnPressed.InvokeSafe(this);
+            }
         }
 
         /// <summary>

LabExtended/API/Settings/Entries/SettingsTextArea.cs

@@ -79,19 +79,15 @@ public SSTextArea.FoldoutMode FoldoutMode
         public string Text
         {
             get => Base.Label;
-            set
-            {
-                Base.Label = value;
-                SendText(value);
-            }
+            set => SendText(value);
         }
-        
+
         /// <summary>
         /// Sends a text update.
         /// </summary>
         /// <param name="text">The text to set.</param>
         public void SendText(string text)
-            => Player?.Connection?.Send(new SSSUpdateMessage(Base, writer => writer.WriteString(text)));
+            => Base.SendLabelUpdate(text, true, hub => hub != null && hub == Player.ReferenceHub);
 
         /// <summary>
         /// Returns a string that represents the current state of the SettingsTextArea instance.

LabExtended/API/Settings/Menus/SettingsMenu.cs

@@ -145,4 +145,17 @@ public void ShowMenu()
 
         SettingsManager.SyncEntries(Player);
     }
+
+    /// <summary>
+    /// Synchronizes the current player's settings entries with the settings manager.
+    /// </summary>
+    /// <remarks>This method has no effect if the player is not available. Call this method to ensure that any
+    /// changes to the player's settings are reflected in the settings manager.</remarks>
+    public void SyncEntries()
+    {
+        if (!Player)
+            return;
+
+        SettingsManager.SyncEntries(Player);
+    }
 }

LabExtended/API/Settings/SettingsManager.cs

@@ -63,62 +63,71 @@ 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 (player.settingsMenuLookup?.Count > 0)
         {
-            if (menuEntry.Value.IsHidden)
-                continue;
-
-            if (!string.IsNullOrWhiteSpace(menuEntry.Value.Header) && !headers.Contains(menuEntry.Value.CustomId))
+            foreach (var menuEntry in player.settingsMenuLookup)
             {
-                headers.Add(menuEntry.Value.CustomId);
+                if (menuEntry.Value.IsHidden)
+                    continue;
 
-                list.Add(new SSGroupHeader(menuEntry.Value.Header,
-                    menuEntry.Value.HeaderReducedPadding, menuEntry.Value.HeaderHint));
-            }
+                if (!string.IsNullOrWhiteSpace(menuEntry.Value.Header) && !headers.Contains(menuEntry.Value.CustomId))
+                {
+                    headers.Add(menuEntry.Value.CustomId);
 
-            foreach (var menuSetting in menuEntry.Value.Entries)
-            {
-                if (menuSetting?.Base == null)
-                    continue;
+                    list.Add(new SSGroupHeader(menuEntry.Value.Header,
+                        menuEntry.Value.HeaderReducedPadding, menuEntry.Value.HeaderHint));
+                }
 
-                if (!menuSetting.Player)
-                    continue;
+                foreach (var menuSetting in menuEntry.Value.Entries)
+                {
+                    if (menuSetting?.Base == null)
+                        continue;
 
-                if (menuSetting.IsHidden)
-                    continue;
+                    if (!menuSetting.Player)
+                        continue;
+
+                    if (menuSetting.IsHidden)
+                        continue;
 
-                list.Add(menuSetting.Base);
+                    list.Add(menuSetting.Base);
+                }
             }
         }
 
-        foreach (var settingsEntry in player.settingsIdLookup)
+        if (player.settingsIdLookup?.Count > 0)
         {
-            if (settingsEntry.Value?.Base == null)
-                continue;
+            foreach (var settingsEntry in player.settingsIdLookup)
+            {
+                if (settingsEntry.Value?.Base == null)
+                    continue;
 
-            if (!settingsEntry.Value.Player)
-                continue;
+                if (!settingsEntry.Value.Player)
+                    continue;
 
-            if (settingsEntry.Value.IsHidden)
-                continue;
+                if (settingsEntry.Value.IsHidden)
+                    continue;
 
-            if (settingsEntry.Value.Menu != null)
-                continue;
+                if (settingsEntry.Value.Menu != null)
+                    continue;
 
-            list.Add(settingsEntry.Value.Base);
+                list.Add(settingsEntry.Value.Base);
+            }
         }
 
         var playerSettings = DictionaryPool<Assembly, ServerSpecificSettingBase[]>.Shared.Rent(GlobalSettingsByAssembly); // todo Use SendOnJoinFilter
 
-        if (player.settingsByAssembly != null)
+        if (player.settingsByAssembly?.Count > 0)
             playerSettings.AddRange(player.settingsByAssembly);
 
         foreach (var sssByAssemblyEntry in playerSettings) 
         {
             var pluginAssembly = sssByAssemblyEntry.Key;
             var collection = sssByAssemblyEntry.Value;
 
-            if (collection.First() is not SSGroupHeader)
+            if (collection?.Length < 1)
+                continue;
+
+            if (collection[0] is not SSGroupHeader)
             {
                 var pluginName = PluginLoader.Plugins.TryGetFirst(o => o.Value.Equals(pluginAssembly), out var result) 
                     ? result.Key.Name 
@@ -137,6 +146,7 @@ public static void SyncEntries(this ExPlayer player)
         player.Send(new SSSEntriesPack(ListPool<ServerSpecificSettingBase>.Shared.ToArrayReturn(list), Version));
 
         ListPool<string>.Shared.Return(headers);
+        DictionaryPool<Assembly, ServerSpecificSettingBase[]>.Shared.Return(playerSettings);
     }
 
     /// <summary>
@@ -898,7 +908,7 @@ internal static void OnResponseMessage(NetworkConnection connection, SSSClientRe
                         entry.Menu.OnTextInput(textArea);
                         break;
 
-                    case SettingsKeyBind keyBind:
+                    case SettingsKeyBind keyBind when keyBind.IsPressed:
                         entry.Menu.OnKeyBindPressed(keyBind);
                         break;
 

LabExtended/Utilities/FileUtils.cs

@@ -38,6 +38,68 @@ static FileUtils()
             nonIndentedSettings.Converters.Add(new StringEnumConverter(new CamelCaseNamingStrategy(), true));
         }
 
+        /// <summary>
+        /// Creates a directory path by combining the specified path segments, ensuring that all intermediate
+        /// directories exist.
+        /// </summary>
+        /// <remarks>If any intermediate directories in the specified path do not exist, they are created.
+        /// Path segments that include file extensions are treated as files and do not result in directory creation for
+        /// that segment. This method is useful for preparing a file path and ensuring the directory structure exists
+        /// before file operations.</remarks>
+        /// <param name="parts">An array of path segments to combine. Each segment represents a part of the final path. Cannot be null or
+        /// empty.</param>
+        /// <returns>The absolute path created by combining the specified segments. The returned path is fully qualified.</returns>
+        public static string CreatePath(params string[] parts)
+        {
+            for (var x = 0; x < parts.Length; x++)
+            {
+                var part = parts[x];
+                var extension = Path.GetExtension(part);
+
+                if (!string.IsNullOrEmpty(extension) && (x + 1 >= parts.Length || !string.IsNullOrEmpty(Path.GetExtension(parts[x + 1]))))
+                    continue;
+
+                var currentPath = string.Join(Path.DirectorySeparatorChar.ToString(), parts.Take(x + 1));
+
+                if (!Directory.Exists(currentPath))
+                    Directory.CreateDirectory(currentPath);
+            }
+
+            return Path.GetFullPath(Path.Combine(parts));
+        }
+
+        /// <summary>
+        /// Creates all directories and subdirectories in the specified file path that do not already exist.
+        /// </summary>
+        /// <remarks>This method does not create the file itself; it only ensures that all directories in
+        /// the specified path exist. If the directories already exist, no action is taken. The returned path is the
+        /// absolute path corresponding to the input.</remarks>
+        /// <param name="filePath">The full or relative path of the file for which to ensure all parent directories exist. Cannot be null or
+        /// empty.</param>
+        /// <returns>A fully qualified file path with all necessary directories created.</returns>
+        public static string CreatePath(string filePath)
+        {
+            filePath = Path.GetFullPath(filePath);
+
+            var parts = filePath.Split(Path.DirectorySeparatorChar);
+
+            for (var x = 0; x < parts.Length; x++)
+            {
+                var part = parts[x];
+                var extension = Path.GetExtension(part);
+
+                if (!string.IsNullOrEmpty(extension) && (x + 1 >= parts.Length || !string.IsNullOrEmpty(Path.GetExtension(parts[x + 1]))))
+                    continue;
+
+                var currentPath = string.Join(Path.DirectorySeparatorChar.ToString(), parts.Take(x + 1));
+
+                if (!Directory.Exists(currentPath))
+                    Directory.CreateDirectory(currentPath);
+            }
+
+            return filePath;
+        }
+
         /// <summary>
         /// Attempts to save a binary file to the specified directory using the provided writer delegate.
         /// </summary>
@@ -713,7 +775,30 @@ public static bool TryLoadYamlFile<T>(string filePath, IDeserializer? deserializ
                 return false;
             }
         }
-        
+
+        /// <summary>
+        /// Attempts to load and deserialize a YAML file from the specified path parts into an object of the given type.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to deserialize the YAML content into.</typeparam>
+        /// <param name="pathParts">An array of path segments that are combined to form the full file path to the YAML file. Cannot be null or
+        /// empty.</param>
+        /// <param name="type">The type to use for deserialization. Must be compatible with <typeparamref name="T"/>.</param>
+        /// <param name="deserializer">The YAML deserializer to use. If null, a default deserializer is used.</param>
+        /// <param name="result">When this method returns, contains the deserialized object if the operation succeeds; otherwise, the default
+        /// value for <typeparamref name="T"/>.</param>
+        /// <returns><see langword="true"/> if the YAML file is successfully loaded and deserialized; otherwise, <see
+        /// langword="false"/>.</returns>
+        public static bool TryLoadYamlFile<T>(string[] pathParts, Type type, IDeserializer? deserializer, out T result)
+        {
+            if (pathParts == null || pathParts.Length == 0)
+            {
+                result = default!;
+                return false;
+            }
+
+            return TryLoadYamlFile(Path.Combine(pathParts), type, deserializer, out result);
+        }
+
         /// <summary>
         /// Attempts to load and deserialize a YAML file into an object of type <typeparamref name="T"/>.
         /// </summary>