rework enum system for better enum flags

Author: Elektryk-Andrzej

Code/ArgumentSystem/Arguments/EnumArgument.cs

@@ -11,12 +11,21 @@ namespace SER.Code.ArgumentSystem.Arguments;
 
 public class EnumArgument<TEnum> : Argument where TEnum : struct, Enum
 {
+    private readonly bool _isFlag;
+    
     public EnumArgument(string name) : base(name)
     {
         HelpInfoStorage.UsedEnums.Add(typeof(TEnum));
+        
+        if (typeof(TEnum).IsDefined(typeof(FlagsAttribute), false))
+        {
+            _isFlag = true;
+        }
     }
-    
-    public override string InputDescription => $"{typeof(TEnum).GetAccurateName()} enum value - found using 'serhelp {typeof(TEnum).GetAccurateName()}' command";
+
+    public override string InputDescription => 
+        $"{typeof(TEnum).AccurateName} enum value - found using 'serhelp {typeof(TEnum).AccurateName}' command"
+        + (_isFlag ? ". Use '|' character to provide multiple e.g. Val1|Val2|Val3" : "");
 
     [UsedImplicitly]
     public DynamicTryGet<TEnum> GetConvertSolution(BaseToken token)
@@ -42,19 +51,43 @@ public DynamicTryGet<TEnum> GetConvertSolution(BaseToken token)
         });
     }
 
-    public static TryGet<TEnum> Convert(BaseToken token, Script script)
+    public static TryGet<TEnum> Convert(BaseToken token, Script script, bool isFlag)
     {
-        if (Convert(token, script, typeof(TEnum)).HasErrored(out var error, out var value))
+        if (!isFlag)
         {
-            return error;
-        }
+            if (ConvertOne(token.GetBestTextRepresentation(script), typeof(TEnum))
+                .HasErrored(out var error, out var value))
+            {
+                return error;
+            }
 
-        return (TEnum)value;
+            return (TEnum)value;
+        }
+
+        ulong result = 0;
+        foreach (var part in token
+                     .GetBestTextRepresentation(script)
+                     .Split(['|'], StringSplitOptions.RemoveEmptyEntries))
+        {
+            if (ConvertOne(part, typeof(TEnum)).HasErrored(out var error, out var value))
+            {
+                return error;
+            }
+            
+            result |= System.Convert.ToUInt64(value);
+        }
+
+        return (TEnum)Enum.ToObject(typeof(TEnum), result);
     }
 
-    public static TryGet<object> Convert(BaseToken token, Script script, Type enumType)
+    public static TryGet<TEnum> ConvertOne(string stringRep)
     {
-        var stringRep = token.GetBestTextRepresentation(script);
+        return ConvertOne(stringRep, typeof(TEnum)).OnSuccess(v => (TEnum)v);
+    }
+
+    public static TryGet<object> ConvertOne(string stringRep, Type enumType)
+    {
+        stringRep = stringRep.Trim();
 
         // only allow exact matches or matches with the first letter not capitalized
         if (Enum.IsDefined(enumType, stringRep) || 
@@ -63,11 +96,11 @@ public static TryGet<object> Convert(BaseToken token, Script script, Type enumTy
             return Enum.Parse(enumType, stringRep, true);
         }
 
-        return $"Value '{token.RawRep}' is not a {enumType.GetAccurateName()} enum value.";
+        return $"Value '{stringRep}' is not a {enumType.AccurateName} enum value.";
     }
-    
+
     private TryGet<TEnum> InternalConvert(BaseToken token)
     {
-        return Convert(token, Script);
+        return Convert(token, Script, _isFlag);
     }
 }

Code/ArgumentSystem/Arguments/EnumTypeArgument.cs

@@ -14,7 +14,8 @@ public DynamicTryGet<T> ResolveEnums<T>(
     {
         foreach (var enumType in handlers.Keys)
         {
-            if (EnumArgument< /* dummy type */ RoomName>.Convert(token, Script, enumType).HasErrored(out _, out var enumValue))
+            if (EnumArgument< /* dummy type */ RoomName>.ConvertOne(token.GetBestTextRepresentation(Script), enumType)
+                .HasErrored(out _, out var enumValue))
             {
                 continue;
             }

Code/ArgumentSystem/Arguments/FlagsArgument.cs

@@ -22,21 +22,6 @@ namespace SER.Code.ArgumentSystem;
 public class ProvidedArguments(Method method)
 {
     private Dictionary<(string name, Type type), List<DynamicTryGet>> ArgumentValues { get; } = [];
-
-    public T? GetNullableFlags<T>(string argName) where T : struct, Enum
-    {
-        return GetValueNullableStruct<T, FlagsArgument<T>>(argName);
-    }
-    
-    public T GetFlags<T>(string argName) where T : struct, Enum
-    {
-        return GetValue<T, FlagsArgument<T>>(argName);
-    }
-    
-    public Type GetEnumType(string argName)
-    {
-        return GetValue<Type, EnumTypeArgument>(argName);
-    }
 
     public T GetVariable<T>(string argName) where T : Variable
     {

Code/ArgumentSystem/BaseArguments/EnumHandlingArgument.cs

@@ -19,7 +19,7 @@ public class SetPrimitiveObjectPropertiesMethod : SynchronousMethod
 
         new EnumArgument<PrimitiveType>("type")    { DefaultValue = new(null, "not changing") },
         new ColorArgument("color")                 { DefaultValue = new(null, "not changing") },
-        new FlagsArgument<PrimitiveFlags>("flags") { DefaultValue = new(null, "not changing") },
+        new EnumArgument<PrimitiveFlags>("flags")  { DefaultValue = new(null, "not changing") },
     ];
 
     public override void Execute()
@@ -28,6 +28,6 @@ public override void Execute()
 
         if (Args.GetNullableEnum<PrimitiveType>("type")    is { } type)  toy.Type  = type;
         if (Args.GetNullableColor("color")                 is { } color) toy.Color = color;
-        if (Args.GetNullableFlags<PrimitiveFlags>("flags") is { } flags) toy.Flags = flags;
+        if (Args.GetNullableEnum<PrimitiveFlags>("flags")  is { } flags) toy.Flags = flags;
     }
 }

Code/ArgumentSystem/ProvidedArguments.cs

@@ -198,7 +198,7 @@ protected override IParseResult InternalParse(BaseToken[] tokens)
                 return new Error(rs + $"A player expression expects to have only one argument, but {tokens.Length - 1} were provided.");
         }
 
-        if (EnumArgument<PlayerProperty>.Convert(tokens.Last(), Script)
+        if (EnumArgument<PlayerProperty>.ConvertOne(tokens.Last().GetBestTextRepresentation(Script))
             .HasErrored(out var error, out var property))
         {
             return new Error(rs + error);