v3.0.0

.github/workflows/main.yml

@@ -1,4 +1,4 @@
-name: .NET 7 Build and Release
+name: .NET 8 Build and Release
 
 on:
   pull_request:

CustomCommands/CustomCommands.cs

@@ -9,24 +9,26 @@ namespace CustomCommands;
 public partial class CustomCommands : BasePlugin, IPluginConfig<CustomCommandsConfig>
 {
     public override string ModuleName => "CustomCommands";
-    public override string ModuleVersion => "2.1.0";
+    public override string ModuleVersion => "3.0.0";
     public override string ModuleAuthor => "HerrMagic";
     public override string ModuleDescription => "Create your own commands per config";
 
     public CustomCommandsConfig Config { get; set; } = new();
-    private readonly IRegisterCommands RegisterCommands;
-    private readonly IPluginGlobals PluginGlobals;
-    private readonly ILoadJson LoadJson;
-    private readonly IEventManager EventManager;
+    private readonly IRegisterCommands _registerCommands;
+    private readonly IPluginGlobals _pluginGlobals;
+    private readonly ILoadJson _loadJson;
+    private readonly IEventManager _eventManager;
+    private readonly IReplaceTagsFunctions _replaceTagsFunctions;
 
     public CustomCommands(IRegisterCommands RegisterCommands, ILogger<CustomCommands> Logger, 
-                            IPluginGlobals PluginGlobals, ILoadJson LoadJson, IEventManager EventManager)
+                            IPluginGlobals PluginGlobals, ILoadJson LoadJson, IEventManager EventManager, IReplaceTagsFunctions ReplaceTagsFunctions)
     {
         this.Logger = Logger;
-        this.RegisterCommands = RegisterCommands;
-        this.PluginGlobals = PluginGlobals;
-        this.LoadJson = LoadJson;
-        this.EventManager = EventManager;
+        _registerCommands = RegisterCommands;
+        _pluginGlobals = PluginGlobals;
+        _loadJson = LoadJson;
+        _eventManager = EventManager;
+        _replaceTagsFunctions = ReplaceTagsFunctions;
     }
 
     public void OnConfigParsed(CustomCommandsConfig config)
@@ -45,26 +47,29 @@ public override void Load(bool hotReload)
         Logger.LogInformation(
             $"{ModuleName} loaded!");
 
-        PluginGlobals.Config = Config;
+        _pluginGlobals.Config = Config;
+        Config.Prefix = _replaceTagsFunctions.ReplaceColorTags(Config.Prefix);
 
-        var comms = LoadJson.GetCommandsFromJsonFiles(ModuleDirectory);
+        var comms = Task.Run(async () => await _loadJson.GetCommandsFromJsonFiles(ModuleDirectory)).Result;
 
         if (comms == null)
         {
             Logger.LogError("No commands found please create a config file");
             return;
         }
 
-        EventManager.RegisterListeners();
+        _eventManager.RegisterListeners();
 
         if (comms != null) 
         {
-            PluginGlobals.CustomCommands = comms;
+            _pluginGlobals.CustomCommands = comms;
+
+            _registerCommands.CheckForDuplicateCommands();
+            _registerCommands.ConvertingCommandsForRegister();
 
-            comms = RegisterCommands.CheckForDuplicateCommands(comms);
             // Add commands from the JSON file to the server
-            foreach (var com in comms)
-                RegisterCommands.AddCommands(com);
+            foreach (var cmd in _pluginGlobals.CustomCommands)
+                _registerCommands.AddCommands(cmd);
         }
     }
 }

CustomCommands/CustomCommandsConfig.cs

@@ -6,6 +6,8 @@ namespace CustomCommands;
 
 public class CustomCommandsConfig : BasePluginConfig
 {
+    public override int Version { get; set; } = 2;
+
     [JsonPropertyName("IsPluginEnabled")]
     public bool IsPluginEnabled { get; set; } = true;
 
@@ -14,4 +16,7 @@ public class CustomCommandsConfig : BasePluginConfig
 
     [JsonPropertyName("Prefix")]
     public string Prefix { get; set; } = $"[{ChatColors.Yellow}Info{ChatColors.Default}] ";
+
+    [JsonPropertyName("RegisterCommandsAsCSSFramework")]
+    public bool RegisterCommandsAsCSSFramework { get; set; } = true;
 }

CustomCommands/CustomCommandsServiceCollection.cs

@@ -9,6 +9,7 @@ public class CustomCommandsServiceCollection : IPluginServiceCollection<CustomCo
 {
     public void ConfigureServices(IServiceCollection services)
     {
+        // Scans the interface in the CustomCommands.Interfaces namespace and adds the classes that implement the interface to the service collection automatically
         services.Scan(scan => scan
             .FromAssemblyOf<IRegisterCommands>()
             .AddClasses()

CustomCommands/Interfaces/ILoadJson.cs

@@ -4,11 +4,52 @@ namespace CustomCommands.Interfaces;
 
 public interface ILoadJson
 {
-    List<Commands> GetCommandsFromJsonFiles(string path);
+    /// <summary>
+    /// Retrieves a list of commands from JSON files located in the specified path.
+    /// </summary>
+    /// <param name="path">The path where the JSON files are located.</param>
+    /// <returns>A list of commands.</returns>
+    Task<List<Commands>> GetCommandsFromJsonFiles(string path);
+
+    /// <summary>
+    /// Checks if an .example file exists in the specified path and creates a default config file if it doesn't exist.
+    /// </summary>
+    /// <param name="path">The path to check for the example file.</param>
     void CheckForExampleFile(string path);
-    bool IsValidJsonSyntax(string jsonString);
+
+    /// <summary>
+    /// Checks if the JSON file has a valid syntax.
+    /// </summary>
+    /// <param name="path">The path to the JSON file.</param>
+    /// <param name="json">The json string.</param>
+    /// <returns>True if the JSON syntax is valid, false otherwise.</returns>
+    bool IsValidJsonSyntax(string json, string path);
+
+    /// <summary>
+    /// Validates the list of commands loaded from a JSON file.
+    /// </summary>
+    /// <param name="comms">The list of commands to validate.</param>
+    /// <param name="path">The path of the JSON file.</param>
+    /// <returns>True if all commands are valid, false otherwise.</returns>
     bool ValidateObject(List<Commands>? comms, string path);
+
+    /// <summary>
+    /// Logs the details of a command.
+    /// </summary>
+    /// <param name="comms">The command to log.</param>
     void LogCommandDetails(Commands comms);
+
+    /// <summary>
+    /// Validates the PrintTo property of the Commands object and checks if the required message properties are set based on the PrintTo value.
+    /// </summary>
+    /// <param name="comms">The Commands object to validate.</param>
+    /// <returns>True if the PrintTo property is valid and the required message properties are set; otherwise, false.</returns>
     bool PrintToCheck(Commands comms);
+
+    /// <summary>
+    /// Validates a dynamic message by checking if it is a string or an array.
+    /// </summary>
+    /// <param name="message">The dynamic message to validate.</param>
+    /// <returns>True if the message is a string or an array, otherwise false.</returns>
     bool ValidateMessage(dynamic message);
 }

CustomCommands/Interfaces/IMessageManager.cs

@@ -5,6 +5,11 @@ namespace CustomCommands.Interfaces;
 
 public interface IMessageManager
 {
+    /// <summary>
+    /// Sends a message based on the specified command and target receiver.
+    /// </summary>
+    /// <param name="player">The player who triggered the command.</param>
+    /// <param name="cmd">The command containing the message and target receiver.</param>
     void SendMessage(CCSPlayerController player, Commands cmd);
     void PrintToCenterClient(CCSPlayerController player, Commands cmd);
     void PrintToAllCenter(Commands cmd);

CustomCommands/Interfaces/IPluginUtilities.cs

@@ -5,7 +5,49 @@ namespace CustomCommands.Interfaces;
 
 public interface IPluginUtilities
 {
+    /// <summary>
+    /// Adds the css_ prefix to each alias.
+    /// This will help cs# tell this command belongs to the framework.
+    /// </summary>
+    /// <param name="input"></param>
+    /// <returns></returns>
+    string[] AddCSSTagsToAliases(List<string> input);
+
+    /// <summary>
+    /// Splits a string by comma, semicolon, or whitespace characters.
+    /// </summary>
+    /// <param name="str">The string to be split.</param>
+    /// <returns>An array of strings containing the split substrings.</returns>
     string[] SplitStringByCommaOrSemicolon(string str);
+
+    /// <summary>
+    /// Executes the server commands from the command object
+    /// </summary>
+    /// <param name="cmd"></param>
+    /// <param name="player"></param>
     void ExecuteServerCommands(Commands cmd, CCSPlayerController player);
+
+    /// <summary>
+    /// Issue the specified command to the specified client (mimics that client typing the command at the console).
+    /// Note: Only works for some commands, marked with the FCVAR_CLIENT_CAN_EXECUTE flag (not many).
+    /// </summary>
+    /// <param name="cmd"></param>
+    /// <param name="player"></param>
+    void ExecuteClientCommands(Commands cmd, CCSPlayerController player);
+
+    /// <summary>
+    /// Issue the specified command directly from the server (mimics the server executing the command with the given player context).
+    /// <remarks>Works with server commands like `kill`, `explode`, `noclip`, etc. </remarks>
+    /// </summary>
+    /// <param name="cmd"></param>
+    /// <param name="player"></param>
+    void ExecuteClientCommandsFromServer(Commands cmd, CCSPlayerController player);
+
+    /// <summary>
+    /// Checks if the player has the required permissions to execute the command
+    /// </summary>
+    /// <param name="player"></param>
+    /// <param name="permissions"></param>
+    /// <returns></returns>
     bool RequiresPermissions(CCSPlayerController player, Permission permissions);
 }

CustomCommands/Interfaces/IRegisterCommands.cs

@@ -4,6 +4,23 @@ namespace CustomCommands.Interfaces;
 
 public interface IRegisterCommands
 {
+    /// <summary>
+    /// Adds custom commands to the plugin.
+    /// </summary>
+    /// <param name="com">The command to add.</param>
     void AddCommands(Commands cmd);
-    List<Commands> CheckForDuplicateCommands(List<Commands> comms);
+
+    /// <summary>
+    /// Checks for duplicate commands in the provided list and removes them.
+    /// </summary>
+    void CheckForDuplicateCommands();
+
+    /// <summary>
+    /// Converts custom commands stored in the global plugin state by processing each command string, 
+    /// splitting it by commas or semicolons, and adjusting the command structure.
+    /// 
+    /// The method clones each command, assigns a new unique ID, and processes its arguments.
+    /// Each split command is then added back to the global list with updated formatting.
+    /// </summary>
+    void ConvertingCommandsForRegister();
 }

CustomCommands/Interfaces/IReplaceTagsFunctions.cs

@@ -4,9 +4,40 @@ namespace CustomCommands.Interfaces;
 
 public interface IReplaceTagsFunctions
 {
-    string[] ReplaceTags(string[] input, CCSPlayerController player);
+    /// <summary>
+    /// Replaces tags in the input array with their corresponding values.
+    /// </summary>
+    /// <param name="input">The array of strings containing tags to be replaced.</param>
+    /// <param name="player">The CCSPlayerController object used for tag replacement.</param>
+    /// <returns>The array of strings with tags replaced.</returns>
+    string[] ReplaceTags(dynamic input, CCSPlayerController player);
+
+    /// <summary>
+    /// Replaces language tags in the input string with the corresponding localized value.
+    /// Language tags are defined within curly braces, e.g. "{LANG=LocalizerTag}".
+    /// If a language tag is found, it is replaced with the localized value from the CustomCommands plugin's Localizer.
+    /// If the localized value is not found, a default message is returned.
+    /// </summary>
+    /// <param name="input">The input string to process.</param>
+    /// <returns>The input string with language tags replaced with localized values.</returns>
     string ReplaceLanguageTags(string input);
+
+    /// <summary>
+    /// Replaces tags in the input string with corresponding values based on the provided player information.
+    /// </summary>
+    /// <param name="input">The input string containing tags to be replaced.</param>
+    /// <param name="player">The CCSPlayerController object representing the player.</param>
+    /// <param name="safety">A boolean value indicating whether to replace the {PLAYERNAME} tag. Default is true.</param>
+    /// <returns>The modified string with replaced tags.</returns>
     string ReplaceMessageTags(string input, CCSPlayerController player, bool safety = true);
     string ReplaceColorTags(string input);
-    string[] WrappedLine(dynamic message);
+
+    /// <summary>
+    /// Splits the input into an array of strings. If the input is a string, it will be split by newlines. If the input is an array, each element will be split by newlines.
+    /// </summary>
+    /// <param name="input">This should be a string[] or a string</param>
+    /// <returns>An array of strings representing the lines of the input.</returns>
+    List<string> WrappedLine(dynamic message);
+
+    string ReplaceRandomTags(string message);
 }

CustomCommands/Model/CommandsConfig.cs

@@ -1,8 +1,9 @@
 namespace CustomCommands.Model;
 
-public class Commands
+public class Commands :  ICloneable
 {
     public Guid ID { get; set; } = Guid.NewGuid();
+    public string? Argument { get; set; }
     public string Title { get; set; } = "";
     public string Description { get; set; } = "Description";
     public string Command { get; set; } = "";
@@ -11,18 +12,48 @@ public class Commands
     public CenterElement CenterMessage { get; set; } = new();
     public Sender PrintTo { get; set; } = Sender.ClientChat;
     public List<string> ServerCommands { get; set; } = new();
-    public Permission Permission { get; set; } = new();
+    public List<string> ClientCommands { get; set; } = new();
+    public List<string> ClientCommandsFromServer { get; set; } = new();
+    public Permission? Permission { get; set; } = new();
+    public bool IsRegisterable { get; set; } = true;
+
+    public object Clone()
+    {
+        return new Commands() 
+        {
+            ID = ID,
+            Argument = Argument,
+            Title = Title,
+            Description = Description,
+            Command = Command,
+            Cooldown = Cooldown,
+            Message = Message,
+            CenterMessage = CenterMessage,
+            PrintTo = PrintTo,
+            ServerCommands = new List<string>(ServerCommands),
+            ClientCommands = new List<string>(ClientCommands),
+            ClientCommandsFromServer = new List<string>(ClientCommandsFromServer),
+            Permission = Permission?.Clone() as Permission,
+            IsRegisterable = IsRegisterable
+        };
+    }
 }
 public class Cooldown
 {
     public int CooldownTime { get; set; } = 0;
     public bool IsGlobal { get; set; } = false;
     public string CooldownMessage { get; set; } = "";
 }
-public class Permission
+public class Permission :  ICloneable
 {
     public bool RequiresAllPermissions { get; set; } = false;
     public List<string> PermissionList { get; set; } = new();
+
+    public object Clone()
+    {
+        return MemberwiseClone();
+    }
+
 }
 public class CenterElement
 {