Implemented Auto-Data Conversion

Author: maxfleetdev

Commander/Runtime/Core/CommandParser.cs

@@ -1,28 +1,46 @@
 using System;
+using System.Globalization;
+using System.Linq;
 
 public static class CommandParser
 {
-    public static void Parse(string rawInput, out string command, out string[] args)
-    {
-        if (string.IsNullOrWhiteSpace(rawInput))
-        {
-            command = "";
-            args    = Array.Empty<string>();
-            return;
-        }
-
-        int idx = rawInput.IndexOf(' ');
-        if (idx < 0)
-        {
-            command = rawInput;
-            args    = Array.Empty<string>();
-        }
-        else
-        {
-            command = rawInput.Substring(0, idx);
-            var rest = rawInput.Substring(idx + 1);
-
-            args = rest.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
-        }
+    public static void StringToCommand(string rawInput, out string command, out string[] args)
+    {
+        // TODO: Keep in single string when surrounded in quotes
+        var parts = rawInput.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
+        if (parts.Length == 0)
+        {
+            command = "";
+            args = Array.Empty<string>();
+            return;
+        }
+
+        // Return variables
+        command = parts[0];
+        args = parts.Length > 1? parts.Skip(1).ToArray() : Array.Empty<string>();
+    }
+
+    // Convert string into it's given type. E.g "1" = int, "STATE_IDLE" = enum, etc...
+    public static object ConvertStringToType(string raw, Type targetType)
+    {
+        // String Conversion
+        if (targetType == typeof(string))
+        {
+            return raw;
+        }
+
+        // Enum Conversion
+        if (targetType.IsEnum)
+        {
+            return Enum.Parse(targetType, raw, ignoreCase: true);
+        }
+
+        // IConvertible Primitive Converison
+        if (typeof(IConvertible).IsAssignableFrom(targetType))
+        {
+            return Convert.ChangeType(raw, targetType, CultureInfo.InvariantCulture);
+        }
+
+        throw new InvalidOperationException($"No converter for type {targetType.Name}");
     }
 }

Commander/Runtime/Core/CommandRegistry.cs

@@ -23,7 +23,7 @@ public static class CommandRegistry
 
         #endregion
 
-        #region Methods
+        #region Lifecycle
 
         /// <summary>
         /// Register given MonoBehaviour's methods as commands.
@@ -71,39 +71,79 @@ public static void RegisterCommand(MonoBehaviour target)
                 // Log the registration of commands
                 Debug.Log($"[CommandRegistry] Registered {target.GetType().Name} with {_commands.Count} methods.");
             }
-        }
-
-        public static void ExecuteCommand(string commandName, params object[] parameters)
-        {
-            if (_commands.TryGetValue(commandName, out var list))
-            {
-                foreach (var (mi, target) in list)
-                {
-                    try
-                    {
-                        mi.Invoke(target, parameters);
-                    }
-                    catch (Exception ex)
-                    {
-                        Debug.LogError($"Error executing command '{commandName}': {ex.Message}");
-                    }
-                }
-            }
-            else
-            {
-                Debug.LogWarning($"Command '{commandName}' not found.");
-            }
-        }
-
+        }
+
         public static void ClearCommands()
         {
             _commands.Clear();
             if (ShowDebugLogs)
             {
                 Debug.Log("[CommandRegistry] Cleared all commands.");
             }
-        }
-
+        }
+
         #endregion
-    }
+
+        #region Command Execution
+
+        public static void ExecuteCommand(string commandInput)
+        {
+            CommandParser.StringToCommand(commandInput, out string command, out string[] arguments);
+            ExecuteCommand(command, arguments);
+        }
+
+        private static void ExecuteCommand(string commandName, string[] rawArgs)
+        {
+            if (!_commands.TryGetValue(commandName, out var entries))
+            {
+                Debug.LogWarning($"Command '{commandName}' not found.");
+                return;
+            }
+
+            foreach (var (mi, target) in entries)
+            {
+                var paramInfos = mi.GetParameters();
+                if (paramInfos.Length != rawArgs.Length)
+                {
+                    Debug.LogError($"Command '{commandName}' expects {paramInfos.Length} args, got {rawArgs.Length}");
+                    continue;
+                }
+
+                var converted = new object[rawArgs.Length];
+                bool conversionFailed = false;
+                for (int i = 0; i < rawArgs.Length; i++)
+                {
+                    var t = paramInfos[i].ParameterType;
+                    try
+                    {
+                        converted[i] = CommandParser.ConvertStringToType(rawArgs[i], t);
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.LogError(
+                          $"Command '{commandName}': failed to convert \"{rawArgs[i]}\" to {t.Name}: {e.Message}");
+                        conversionFailed = true;
+                        break;
+                    }
+                }
+
+                if (conversionFailed)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    mi.Invoke(target, converted);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogError(
+                      $"Error executing '{commandName}': {ex.InnerException?.Message ?? ex.Message}");
+                }
+            }
+        }
+    }
+
+    #endregion
 }