add more FriendlyName definitions

Author: Elektryk-Andrzej

Code/ArgumentSystem/Arguments/VariableArgument.cs

@@ -29,7 +29,7 @@ public DynamicTryGet<Variable> GetConvertSolution(BaseToken token)
 
 public class VariableArgument<T>(string name) : Argument(name) where T : Variable
 {
-    public override string InputDescription => $"A {typeof(T).FriendlyTypeName()}";
+    public override string InputDescription => $"A {Variable.GetFriendlyName(typeof(T))}";
 
     [UsedImplicitly]
     public DynamicTryGet<T> GetConvertSolution(BaseToken token)

Code/Plugin/Commands/HelpSystem/DocsProvider.cs

@@ -462,7 +462,7 @@ private static string GetMethodHelp(Method method)
                 if (ret.LiteralReturnTypes.AreKnown(out var types))
                 {
                     typeReturn = types
-                        .Select(Value.FriendlyName)
+                        .Select(Value.GetFriendlyName)
                         .JoinStrings(" or ") + " value";
                 }
                 else
@@ -492,7 +492,7 @@ private static string GetMethodHelp(Method method)
                 if (ret.Returns.AreKnown(out var returnTypes))
                 {
                     typeReturn = returnTypes
-                        .Select(Value.FriendlyName)
+                        .Select(Value.GetFriendlyName)
                         .JoinStrings(" or ") + " value";
                 }
                 else

Code/ValueSystem/BoolValue.cs

@@ -13,4 +13,6 @@ public static implicit operator bool(BoolValue value)
     }
 
     public override string StringRep => Value.ToString().ToLower();
+
+    public override string FriendlyName => "boolean value";
 }

Code/ValueSystem/CollectionValue.cs

@@ -96,10 +96,10 @@ public static CollectionValue Insert(CollectionValue collection, Value value)
         }
 
         throw new CustomScriptRuntimeError(
-            $"Inserted value '{value}' has to be the same type as the collection ({FriendlyName(type)})."
+            $"Inserted value '{value}' has to be the same type as the collection ({GetFriendlyName(type)})."
         );
     }
-    public CollectionValue Insert(Value val) => CollectionValue.Insert(this, val);
+    public CollectionValue Insert(Value val) => Insert(this, val);
 
     /// <summary>
     /// Removes every match if <paramref name="amountToRemove"/> is -1
@@ -113,7 +113,7 @@ public static CollectionValue Remove(CollectionValue collection, Value value, in
 
         if (type.IsInstanceOfType(value))
         {
-            throw new CustomScriptRuntimeError($"Value {value.FriendlyName()} has to be the same type as the collection ({FriendlyName(type)}).");
+            throw new CustomScriptRuntimeError($"Value {value.FriendlyName} has to be the same type as the collection ({GetFriendlyName(type)}).");
         }
 
         var values = collection.CastedValues.ToList();
@@ -129,16 +129,16 @@ public static CollectionValue Remove(CollectionValue collection, Value value, in
 
         return new CollectionValue(values);
     }
-    public CollectionValue Remove(Value val, int amountToRemove = -1) => CollectionValue.Remove(this, val, amountToRemove);
+    public CollectionValue Remove(Value val, int amountToRemove = -1) => Remove(this, val, amountToRemove);
 
     public static CollectionValue RemoveAt(CollectionValue collection, int index)
     {
         return new CollectionValue(collection.CastedValues.Where((_, i) => i != index - 1));
     }
-    public CollectionValue RemoveAt(int index) => CollectionValue.RemoveAt(this, index);
+    public CollectionValue RemoveAt(int index) => RemoveAt(this, index);
 
     public static bool Contains(CollectionValue collection, Value value) => collection.CastedValues.Contains(value);
-    public bool Contains(Value val) => CollectionValue.Contains(this, val);
+    public bool Contains(Value val) => Contains(this, val);
 
     public static CollectionValue operator +(CollectionValue lhs, CollectionValue rhs)
     {
@@ -166,6 +166,8 @@ public static CollectionValue RemoveAt(CollectionValue collection, int index)
         return new CollectionValue(lhs.CastedValues.Where(val => !rhs.CastedValues.Contains(val)));
     }
 
+    public override string FriendlyName => "collection value";
+
     public override string ToString()
     {
         return $"[{string.Join(", ", CastedValues.Select(v => v.ToString()))}]";

Code/ValueSystem/DurationValue.cs

@@ -47,4 +47,6 @@ public override string StringRep
             return sb.Remove(sb.Length - 1, 1).ToString();
         }
     }
+
+    public override string FriendlyName => "duration value";
 }

Code/ValueSystem/NumberValue.cs

@@ -13,4 +13,5 @@ public static implicit operator decimal(NumberValue value)
     }
 
     public override string StringRep => Value.ToString();
+    public override string FriendlyName => "number value";
 }

Code/ValueSystem/PlayerValue.cs

@@ -24,6 +24,8 @@ public PlayerValue(IEnumerable<Player> players)
 
     public override int HashCode =>
         Players.Select(plr => plr.UserId).GetEnumerableHashCode().HasErrored(out var error, out var val)
-        ? throw new TosoksFuckedUpException(error)
-        : val;
+            ? throw new TosoksFuckedUpException(error)
+            : val;
+
+    public override string FriendlyName => "player value";
 }

Code/ValueSystem/ReferenceValue.cs

@@ -16,6 +16,8 @@ public override bool EqualCondition(Value other)
 
     public override int HashCode => Value.GetHashCode();
 
+    public override string FriendlyName => "reference value";
+
     public override string ToString()
     {
         return $"<{Value.GetType().GetAccurateName()} reference | {Value.GetHashCode()}>";
@@ -25,4 +27,6 @@ public override string ToString()
 public class ReferenceValue<T>(T? value) : ReferenceValue(value)
 {
     public new T Value => (T) base.Value;
+
+    public override string FriendlyName => $"reference value of type {typeof(T).GetAccurateName()}";
 }

Code/ValueSystem/TextValue.cs

@@ -32,6 +32,8 @@ public static implicit operator string(TextValue value)
 
     public override string StringRep => Value;
 
+    public override string FriendlyName => "text value";
+    
     public static string ParseValue(string text, Script script) => ExpressionRegex.Replace(text, match =>
     {
         if (match.Value.StartsWith("~")) return match.Value[1..];
@@ -64,12 +66,17 @@ public static string ParseValue(string text, Script script) => ExpressionRegex.R
     });
 }
 
-public class DynamicTextValue(string text, Script script) : TextValue(text, script);
+public class DynamicTextValue(string text, Script script) : TextValue(text, script)
+{
+    public override string FriendlyName => "dynamic text value";
+}
 
 public class StaticTextValue(string text) : TextValue(text, null)
 {
     public static implicit operator StaticTextValue(string text)
     {
         return new(text);
     }
+
+    public override string FriendlyName => "static text value";
 }

Code/ValueSystem/TypeOfValue.cs

@@ -35,7 +35,7 @@ public TypesOfValue(params Type[] types) : base(types)
     }
 
     private readonly Type[] _types;
-    public override string ToString() => $"{string.Join(" or ", _types.Select(Value.FriendlyName))} value";
+    public override string ToString() => $"{string.Join(" or ", _types.Select(t => t))} value";
 }
 
 public class UnknownTypeOfValue() : TypeOfValue((Type?)null)
@@ -46,7 +46,7 @@ public class UnknownTypeOfValue() : TypeOfValue((Type?)null)
 public class SingleTypeOfValue(Type type) : TypeOfValue(type)
 {
     public readonly Type Type = type;
-    public override string ToString() => $"{Value.FriendlyName(Type)} value";
+    public override string ToString() => Value.GetFriendlyName(Type);
 }
 
 public class TypeOfValue<T>() : SingleTypeOfValue(typeof(T))