Refactor and enhance command registry system

Moved CommandRegistry to a new location and improved its logic, including static and instance command registration, auto-registration on load, and case-insensitive command execution. Updated CommandData with parameter retrieval and improved error logging. Adjusted TestCommand usage to match new API and file structure. Cleaned up obsolete files and reorganized sample commands.

Author: maxfleetdev

Runtime/Core/CommandData.cs

@@ -6,11 +6,17 @@ namespace Commander.Core
 {
     public struct CommandData
     {
+        #region Properties
+
         public string CommandName { get; }
         public MethodInfo MethodData { get; }
         public object TargetClass { get; }
         public CommandFlags Flags { get; }  // Set roles and flags?
 
+        #endregion
+
+        #region Constructors
+
         public CommandData(string commandName, MethodInfo methodData,
             object targetClass, CommandFlags flags = CommandFlags.None)
         {
@@ -20,6 +26,24 @@ public CommandData(string commandName, MethodInfo methodData,
             Flags = flags;
         }
 
+        #endregion
+
+        #region Command Logic
+
+        /// <summary>
+        /// Retrieves the parameters assigned to this command
+        /// </summary>
+        /// <returns></returns>
+        public object[] GetParameters()
+        {
+            return MethodData.GetParameters();
+        }
+
+        /// <summary>
+        /// Tries to execute a method with given parameters
+        /// </summary>
+        /// <param name="args">Parameters of the method</param>
+        /// <returns>Execution was successful</returns>
         public bool Execute(object[] args)
         {
             try
@@ -29,9 +53,11 @@ public bool Execute(object[] args)
             }
             catch (Exception e)
             {
-                Debug.LogWarning($"Could not execute {CommandName}: " + e);
+                Debug.LogWarning($"[CommandData] Could not execute '{CommandName}': " + e);
                 return false;
             }
         }
+
+        #endregion
     }
 }

Runtime/Core/CommandFlags.cs

@@ -6,6 +6,6 @@ public enum CommandFlags
         None = 0,
         Hidden = 1,
         RequiresRole = 2
-        // more command flags here...
+        // more command flags here...?
     }
 }

Runtime/Core/CommandRegistry.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+
+namespace Commander.Core
+{
+    public static class CommandRegistry
+    {
+        #region Properties
+
+        // key = unqiue command name
+        // value = CommandData
+        private static Dictionary<string, CommandData> _registeredCommands =
+            new Dictionary<string, CommandData>();
+
+        /// <summary>
+        /// All command name keys and their CommandData value
+        /// </summary>
+        public static Dictionary<string, CommandData> RegisteredCommands
+        {
+            get { return _registeredCommands; }
+        }
+
+        #endregion
+
+        #region Lifecycle
+
+        /// <summary>
+        /// Clears all commands within the Registry
+        /// </summary>
+        public static void ClearCommands()
+        {
+            _registeredCommands.Clear();
+        }
+
+        /// <summary>
+        /// Called before the first scene loads. Registers all application static commands
+        /// </summary>
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        private static void AutoRegister()
+        {
+            ClearCommands();
+            RegisterStaticCommands();
+        }
+
+        #endregion
+
+        #region Command Registering
+
+        /// <summary>
+        /// Registers a MonoBehaviour class which includes the Command Attribute. 
+        /// </summary>
+        /// <param name="targetClass">Class that contains Command Methods</param>
+        public static void RegisterInstanceCommands(object targetClass = null)
+        {
+            var targetMethods = targetClass.GetType().GetMethods(
+                BindingFlags.Instance |
+                BindingFlags.Public |
+                BindingFlags.NonPublic
+            );
+
+            foreach (var methodInfo in targetMethods)
+            {
+                // Check if method has attribute
+                var cmdAttribute = methodInfo.GetCustomAttribute<CommandAttribute>();
+                if (cmdAttribute == null)
+                {
+                    continue;
+                }
+
+                // Use method name if commandname not present
+                string cmdName = cmdAttribute.Name?.ToLower().Trim() switch
+                {
+                    string s when s.Length > 0 => s,
+                    _ => methodInfo.Name
+                };
+
+                if (_registeredCommands.ContainsKey(cmdName))
+                {
+                    Debug.Log($"[CommandRegistry] Comamnd already registered with name '{cmdName}'");
+                    continue;
+                }
+
+                // Assign value of dictionary as new CommandData
+                _registeredCommands[cmdName] = new CommandData(cmdName, methodInfo, targetClass);
+                Debug.Log($"[CommandRegistry] Registered Command '{cmdName}'");
+            }
+        }
+
+        /// <summary>
+        /// Registers all static classes found within the App Domain. Called at initialisation
+        /// </summary>
+        public static void RegisterStaticCommands()
+        {
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                foreach (var type in assembly.GetTypes())
+                {
+                    var methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+                    foreach (var method in methods)
+                    {
+                        var attr = method.GetCustomAttribute<CommandAttribute>();
+                        if (attr == null)
+                        {
+                            continue;
+                        }
+                        string cmdName = string.IsNullOrWhiteSpace(attr.Name) ? method.Name : attr.Name;
+                        _registeredCommands[cmdName] = new CommandData(cmdName, method, null);
+                        Debug.Log($"[CommandRegistry] Registered Static Command '{cmdName}'");
+                    }
+                }
+            }
+        }
+
+        #endregion
+
+        #region Command Execution
+
+        public static bool TryExecuteCommand(string commandName, object[] args)
+        {
+            // Ensures no character-case mistakes occur
+            commandName = commandName.ToLower();
+
+            // Check if command even exists
+            if (!_registeredCommands.TryGetValue(commandName, out var data))
+            {
+                Debug.Log($"[CommandRegistry] No command with name '{commandName}'");
+                return false;
+            }
+            
+            // Try executing command from CommandData
+            return data.Execute(args);
+        }
+
+        #endregion
+    }
+}

…me/Core/Registry/CommandRegistry.cs.meta Runtime/Core/CommandRegistry.cs.metaRuntime/Core/Registry/CommandRegistry.cs.meta renamed to Runtime/Core/CommandRegistry.cs.meta Runtime/Core/Registry/CommandRegistry.cs.meta renamed to Runtime/Core/CommandRegistry.cs.meta

@@ -6,10 +6,8 @@ public class TestCommand : MonoBehaviour
 {
     void Awake()
     {
-        CommandRegistry.RegisterCommands(this);
-        CommandRegistry.TryExecuteCommand("PublicTestCommand", new object[2] { 1, "String" });
-        CommandRegistry.TryExecuteCommand("NoCommand", new object[2] { 1, "String" });
-        CommandRegistry.TryExecuteCommand("PrivateTestCommand", new object[2] { 1, "String" });
+        CommandRegistry.RegisterInstanceCommands(this);
+        CommandRegistry.TryExecuteCommand("publictestcommand", new object[2] { "Test", "test" });
     }
 
     [Command("PublicTestCommand", CommandRole.Any)]
@@ -23,9 +21,4 @@ private void PrivateMyCommand(int a, string b)
     {
         Debug.Log($"Command executed with parameters: a = {a}, b = {b}");
     }
-
-    private void NonCommandMethod()
-    {
-        Debug.Log("This method is not a command and will not be registered.");
-    }
 }