add "cooldown" argument to CustomCommand flag

Author: Elektryk-Andrzej

Code/FlagSystem/Flags/CustomCommandFlag.cs

@@ -1,13 +1,15 @@
 using CommandSystem;
 using JetBrains.Annotations;
 using LabApi.Features.Permissions;
+using LabApi.Features.Wrappers;
 using RemoteAdmin;
 using SER.Code.Helpers.Exceptions;
 using SER.Code.Helpers.Extensions;
 using SER.Code.Helpers.ResultSystem;
 using SER.Code.ScriptSystem;
 using SER.Code.ScriptSystem.Structures;
 using SER.Code.TokenSystem;
+using SER.Code.TokenSystem.Tokens;
 using SER.Code.ValueSystem;
 using SER.Code.VariableSystem.Bases;
 using SER.Code.VariableSystem.Variables;
@@ -81,6 +83,12 @@ public class CustomCommandFlag : Flag
             "You can provide multiple ranks, and if the player has any of the listed ranks, they will be able to use the command.",
             AddNeededRank,
             false
+        ),
+        new(
+            "cooldown",
+            "The time the player has to wait before being able to use the command again.",
+            AddCooldown,
+            false
         )
     ];
 
@@ -169,6 +177,8 @@ public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out s
         public ConsoleType ConsoleTypes { get; set; } = ConsoleType.Server;
         public string[] Usage { get; set; } = [];
         public string[] NeededRanks { get; set; } = [];
+        public TimeSpan PlayerCooldown { get; set; } = TimeSpan.Zero;
+        public Dictionary<Player, DateTime> NextEligableDateForPlayer { get; } = [];
         public string GetHelp(ArraySegment<string> arguments)
         {
             return $"Description: {Description}\n" +
@@ -180,18 +190,14 @@ public string GetHelp(ArraySegment<string> arguments)
 
     public CustomCommand Command = null!;
 
-    public static Result RunAttachedScript(CustomCommand requestingCommand, ScriptExecutor sender, string[] args)
+    public static Result RunAttachedScript(CustomCommand cmd, ScriptExecutor sender, string[] args)
     {
-        if (requestingCommand.NeededRanks.Any() && sender is IPlayerExecutor { Player: { } player })
+        if (sender is IPlayerExecutor { Player: { } player } && HandlePlayer(cmd, player) is { } plrErr)
         {
-            if (player.UserGroup is not { } group || requestingCommand.NeededRanks.All(rank => group.Name != rank))
-            {
-                return "This command is reserved for players with a rank: " +
-                       $"{requestingCommand.NeededRanks.JoinStrings(", ")}";
-            }
+            return plrErr;
         }
 
-        if (!ScriptCommands.TryGetValue(requestingCommand, out var flag))
+        if (!ScriptCommands.TryGetValue(cmd, out var flag))
         {
             return "The script that was supposed to handle this command was not found.";
         }
@@ -203,16 +209,16 @@ public static Result RunAttachedScript(CustomCommand requestingCommand, ScriptEx
         }
 
         var slices = outSlices.ToArray();
-        if (slices.Length < requestingCommand.Usage.Length)
+        if (slices.Length < cmd.Usage.Length)
         {
             return "Not enough arguments. " +
-                   $"Expected {requestingCommand.Usage.Length} but got {slices.Length}.";
+                   $"Expected {cmd.Usage.Length} but got {slices.Length}.";
         }
 
-        if (slices.Length > requestingCommand.Usage.Length)
+        if (slices.Length > cmd.Usage.Length)
         {
             return "Too many arguments. " +
-                   $"Expected {requestingCommand.Usage.Length} but got {slices.Length}.";
+                   $"Expected {cmd.Usage.Length} but got {slices.Length}.";
         }
 
         if (Script.CreateByScriptName(flag.ScriptName, sender)
@@ -221,10 +227,10 @@ public static Result RunAttachedScript(CustomCommand requestingCommand, ScriptEx
             return error;
         }
 
-        for (var index = 0; index < requestingCommand.Usage.Length; index++)
+        for (var index = 0; index < cmd.Usage.Length; index++)
         {
             var slice = slices[index];
-            var argVariable = requestingCommand.Usage[index];
+            var argVariable = cmd.Usage[index];
             var name = argVariable[0].ToString().ToLower() + argVariable[1..];
 
             if (Tokenizer.GetTokenFromSlice(slice, null!, 0)
@@ -243,6 +249,30 @@ public static Result RunAttachedScript(CustomCommand requestingCommand, ScriptEx
         script.Run(RunContext.Command);
         return true;
     }
+
+    private static string? HandlePlayer(CustomCommand cmd, Player plr)
+    {
+        var hasRank = plr.UserGroup is not { } group || cmd.NeededRanks.All(rank => group.Name != rank);
+        if (cmd.NeededRanks.Any() && hasRank)
+        {
+            return "This command is reserved for players with a rank: " +
+                   $"{cmd.NeededRanks.JoinStrings(", ")}";
+        }
+
+        if (cmd.PlayerCooldown <= TimeSpan.Zero)
+        {
+            return null;
+        }
+
+        if (cmd.NextEligableDateForPlayer.TryGetValue(plr, out var nextEligableDate) && nextEligableDate < DateTime.UtcNow)
+        {
+            return $"You are on cooldown! You can use this command in " +
+                   $"{(nextEligableDate - DateTime.UtcNow).Seconds} seconds.";
+        }
+        
+        cmd.NextEligableDateForPlayer[plr] = DateTime.UtcNow + cmd.PlayerCooldown;
+        return null;
+    }
 
     private Result AddArguments(string[] args)
     {
@@ -288,4 +318,23 @@ private Result AddNeededRank(string[] args)
         Command.NeededRanks = args;
         return true;
     }
+    
+    private Result AddCooldown(string[] args)
+    {
+        switch (args.Length)
+        {
+            case < 1: return "Cooldown requires a duration value.";
+            case > 2: return $"Cooldown expects only a single duration value, got given {args.Length} instead.";
+        }
+
+        var rawValue = args[0];
+        if (Tokenizer.GetTokenFromString(rawValue, null, null).HasErrored(out _, out var token) 
+            || token is not DurationToken durationToken)
+        {
+            return $"Value '{rawValue}' is not a valid duration.";
+        }
+
+        Command.PlayerCooldown = durationToken.Value;
+        return true;
+    }
 }

Code/Helpers/Attributes/OnNewRoundAttribute.cs

@@ -0,0 +1,23 @@
+using System.Reflection;
+
+namespace SER.Code.Helpers.Attributes;
+
+/// <summary>
+/// Used on methods meant to clean up data after a round is over.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method)]
+public class ClearDataAttribute : Attribute
+{
+    public static void RunAttachedMethods()
+    {
+        var methods = Assembly.GetExecutingAssembly()
+            .GetTypes()
+            .SelectMany(t => t.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)) 
+            .Where(m => m.GetCustomAttribute<ClearDataAttribute>() != null);
+        
+        foreach (var method in methods)
+        {
+            method.Invoke(null, null);
+        }
+    }
+}

Code/Helpers/ResultSystem/TryGet.cs

@@ -11,6 +11,12 @@ public sealed class TryGet<TValue>(TValue? value, string? errorMsg)
     private bool WasSuccess => string.IsNullOrEmpty(errorMsg);
     public Result Result => new(WasSuccess, ErrorMsg ?? "");
 
+    [Pure]
+    public bool HasErrored()
+    {
+        return !WasSuccess;
+    }
+    
     [Pure]
     public bool HasErrored([NotNullWhen(true)] out string? error)
     {

Code/TokenSystem/Tokenizer.cs

@@ -158,7 +158,7 @@ public static TryGet<BaseToken[]> TokenizeLine(IEnumerable<Slice> slices, Script
         return tokens.Select(t => t.Value!).ToArray();
     }
 
-    public static TryGet<BaseToken> GetTokenFromSlice(Slice slice, Script scr, uint? lineNum)
+    public static TryGet<BaseToken> GetTokenFromSlice(Slice slice, Script? scr, uint? lineNum)
     {
         var tokenCollection = slice is CollectionSlice 
             ? OrderedImportanceTokensFromCollectionSlices 
@@ -167,7 +167,7 @@ public static TryGet<BaseToken> GetTokenFromSlice(Slice slice, Script scr, uint?
         foreach (var tokenType in tokenCollection)
         {
             var token = tokenType.CreateInstance<BaseToken>();
-            switch (token.TryInit(slice, scr, lineNum))
+            switch (token.TryInit(slice, scr!, lineNum))
             {
                 case BaseToken.Success: return token;
                 case BaseToken.Ignore: continue;
@@ -177,7 +177,23 @@ public static TryGet<BaseToken> GetTokenFromSlice(Slice slice, Script scr, uint?
         }
 
         var unspecified = new BaseToken();
-        unspecified.TryInit(slice, scr, lineNum);
+        unspecified.TryInit(slice, scr!, lineNum);
         return unspecified;
     }
+
+    public static TryGet<BaseToken> GetTokenFromString(string str, Script? scr, uint? lineNum)
+    {
+        if (SliceLine(str).HasErrored(out var err, out var slices))
+        {
+            return err;
+        }
+
+        var bettaSlices = slices as Slice[] ?? slices.ToArray();
+        if (bettaSlices.Length > 1)
+        {
+            return $"Value '{str}' contains multiple slices.";
+        }
+        
+        return GetTokenFromSlice(bettaSlices.First(), scr, lineNum);
+    }
 }

Code/TokenSystem/Tokens/LiteralValueToken.cs

@@ -19,8 +19,7 @@ protected set
             field = value;
         }
     } = null!;
-
-    public TryGet<LiteralValue> ExactValue => Value;
+    
     TryGet<Value> IValueToken.Value() => Value;
     public TypeOfValue PossibleValues => new TypeOfValue<T>();
     public bool IsConstant => true;