Add command registry system and sample command usage

Introduced CommandData and CommandFlags for representing and flagging commands. Added CommandRegistry for registering and executing commands via reflection. Updated TestCommand to demonstrate command registration and execution. Minor improvements to CommandAttribute and CommandRoleAttribute constructors. Updated sample scene to include TestCommand usage.

Author: maxfleetdev

Runtime/Attributes/CommandAttribute.cs

@@ -76,6 +76,17 @@ public CommandAttribute(string name, CommandRole role)
             Descrption = string.Empty;
         }
 
+        /// <summary>
+        /// Constructor for Command attribute with the command role only.
+        /// </summary>
+        /// <param name="role">This command's execution permission role</param>
+        public CommandAttribute(CommandRole role)
+        {
+            Name = string.Empty;
+            Role = CommandRole.Any;
+            Descrption = string.Empty;
+        }
+
         #endregion
     }
 }

Runtime/Attributes/CommandRoleAttribute.cs

@@ -10,6 +10,10 @@ public class CommandRoleAttribute : Attribute
     {
         public CommandRole Role { get; }
 
+        /// <summary>
+        /// Default constructor for CommandRole attribute.
+        /// </summary>
+        /// <param name="role">This command's execution permission role</param>
         public CommandRoleAttribute(CommandRole role)
         {
             Role = role;

Runtime/Core/CommandData.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Reflection;
+using UnityEngine;
+
+namespace Commander.Core
+{
+    public struct CommandData
+    {
+        public string CommandName { get; }
+        public MethodInfo MethodData { get; }
+        public object TargetClass { get; }
+        public CommandFlags Flags { get; }  // Set roles and flags?
+
+        public CommandData(string commandName, MethodInfo methodData,
+            object targetClass, CommandFlags flags = CommandFlags.None)
+        {
+            CommandName = commandName;
+            MethodData = methodData;
+            TargetClass = targetClass;
+            Flags = flags;
+        }
+
+        public bool Execute(object[] args)
+        {
+            try
+            {
+                MethodData.Invoke(TargetClass, args);
+                return true;
+            }
+            catch (Exception e)
+            {
+                Debug.LogWarning($"Could not execute {CommandName}: " + e);
+                return false;
+            }
+        }
+    }
+}

Runtime/Core/CommandData.cs.meta

@@ -0,0 +1,11 @@
+namespace Commander.Core
+{
+    [System.Flags]
+    public enum CommandFlags
+    {
+        None = 0,
+        Hidden = 1,
+        RequiresRole = 2
+        // more command flags here...
+    }
+}

Runtime/Core/CommandFlags.cs

@@ -0,0 +1,66 @@
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+
+namespace Commander.Core
+{
+    public static class CommandRegistry
+    {
+        private static Dictionary<string, CommandData> _registeredCommands =
+            new Dictionary<string, CommandData>();
+
+        public static Dictionary<string, CommandData> RegisteredCommands
+        {
+            get { return _registeredCommands; }
+        }
+
+        public static void ClearCommands()
+        {
+            _registeredCommands.Clear();
+        }
+
+        public static void RegisterCommands(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?.Trim() switch
+                {
+                    string s when s.Length > 0 => s,
+                    _ => methodInfo.Name
+                };
+
+                // Assign value of dictionary as new CommandData
+                _registeredCommands[cmdName] = new CommandData(cmdName, methodInfo, targetClass);
+                Debug.Log($"[CommandRegistry] Registered Command {cmdName}");
+            }
+            Debug.Log($"[CommandRegistry] Registered Class {targetClass.GetType().Name} with {_registeredCommands.Count} methods");
+        }
+
+        public static bool TryExecuteCommand(string commandName, object[] args)
+        {
+            // Check if command even exists
+            if (!_registeredCommands.TryGetValue(commandName, out var data))
+            {
+                Debug.Log($"No command with name {commandName}");
+                return false;
+            }
+
+            // Try executing command from CommandData
+            return data.Execute(args);
+        }
+    }
+}

Runtime/Core/CommandFlags.cs.meta

@@ -1,12 +1,31 @@
 using UnityEngine;
 using Commander;
+using Commander.Core;
 
 public class TestCommand : MonoBehaviour
 {
-    [HiddenCommand]
-    [Command("TestCommand", CommandRole.Any)]
-    public void Test()
+    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" });
     }
-}
+
+    [Command("PublicTestCommand", CommandRole.Any)]
+    public void PublicMyCommand(int a, string b)
+    {
+        Debug.Log($"Command executed with parameters: a = {a}, b = {b}");
+    }
+
+    [Command("PrivateTestCommand", CommandRole.Any)]
+    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.");
+    }
+}