Merge pull request #13 from Tosoks67/main

Value Equals fix; switch style fix

Author: Elektryk-Andrzej

ValueSystem/CollectionValue.cs

@@ -49,7 +49,17 @@ public Type Type
             if (CastedValues == Array.Empty<Value>()) field = value;
         }
     } = null!;
-    
+
+    public override bool EqualCondition(Value other)
+    {
+        if (other is not CollectionValue otherP || otherP.CastedValues.Length != CastedValues.Length) return false;
+        for (int i = 0; i < CastedValues.Length; i++)
+        {
+            if (!CastedValues[i].EqualCondition(otherP.CastedValues[i])) return false;
+        }
+        return true;
+    }
+
     public TryGet<Value> GetAt(int index)
     {
         if (index < 1) return $"Provided index {index}, but index cannot be less than 1";

ValueSystem/LiteralValue.cs

@@ -9,6 +9,8 @@ public abstract class LiteralValue(object value) : Value
 
     public object Value => value;
 
+    public override bool EqualCondition(Value other) => other is LiteralValue otherP && Value.Equals(otherP.Value);
+
     public override string ToString()
     {
         return StringRep;

ValueSystem/PlayerValue.cs

@@ -15,4 +15,6 @@ public PlayerValue(IEnumerable<Player> players)
     }
 
     public Player[] Players { get; }
+
+    public override bool EqualCondition(Value other) => other is PlayerValue otherP && Players.SequenceEqual(otherP.Players);
 }

ValueSystem/ReferenceValue.cs

@@ -8,6 +8,12 @@ public class ReferenceValue(object? value) : Value
     public bool IsValid => value is not null;
     public object Value => value ?? throw new ScriptRuntimeError("Value of reference is invalid.");
 
+    public override bool EqualCondition(Value other)
+    {
+        if (other is not ReferenceValue otherP || !IsValid || !otherP.IsValid) return false;
+        return Value.Equals(otherP.Value);
+    }
+
     public override string ToString()
     {
         return $"<{Value.GetType().GetAccurateName()} reference | {Value.GetHashCode()}>";

ValueSystem/Value.cs

@@ -6,31 +6,33 @@ namespace SER.ValueSystem;
 
 public abstract class Value
 {
+    public abstract bool EqualCondition(Value other);
+
     public static Value Parse(object obj)
     {
         if (obj is null) throw new AndrzejFuckedUpException();
         if (obj is Value v) return v;
 
         return obj switch
         {     
-            bool b     => new BoolValue(b),
-            byte n     => new NumberValue(n),
-            sbyte n    => new NumberValue(n),
-            short n    => new NumberValue(n),
-            ushort n   => new NumberValue(n),
-            int n      => new NumberValue(n),
-            uint n     => new NumberValue(n),
-            long n     => new NumberValue(n),
-            ulong n    => new NumberValue(n),
-            float n    => new NumberValue((decimal)n),
-            double n   => new NumberValue((decimal)n),
-            decimal n  => new NumberValue(n),
-            string s   => new TextValue(s),
-            TimeSpan t => new DurationValue(t),
-            Player p   => new PlayerValue(p),
-            IEnumerable<Player> ps => new PlayerValue(ps),
-            IEnumerable e => new CollectionValue(e),
-            _             => new ReferenceValue(obj),
+            bool b                  => new BoolValue(b),
+            byte n                  => new NumberValue(n),
+            sbyte n                 => new NumberValue(n),
+            short n                 => new NumberValue(n),
+            ushort n                => new NumberValue(n),
+            int n                   => new NumberValue(n),
+            uint n                  => new NumberValue(n),
+            long n                  => new NumberValue(n),
+            ulong n                 => new NumberValue(n),
+            float n                 => new NumberValue((decimal)n),
+            double n                => new NumberValue((decimal)n),
+            decimal n               => new NumberValue(n),
+            string s                => new TextValue(s),
+            TimeSpan t              => new DurationValue(t),
+            Player p                => new PlayerValue(p),
+            IEnumerable<Player> ps  => new PlayerValue(ps),
+            IEnumerable e           => new CollectionValue(e),
+            _                       => new ReferenceValue(obj),
         };
     }
 
@@ -41,11 +43,11 @@ public override int GetHashCode()
     {
         return this switch
         {
-            LiteralValue => ((LiteralValue)this).Value.GetHashCode(),
-            PlayerValue => ((PlayerValue)this).Players.GetHashCode(), // Returns the hash code of the reference, not the value
+            LiteralValue    => ((LiteralValue)this).Value.GetHashCode(),
+            PlayerValue     => ((PlayerValue)this).Players.GetHashCode(), // Returns the hash code of the reference, not the value
             CollectionValue => ((CollectionValue)this).CastedValues.GetHashCode(), // Returns the hash code of the reference, not the value
-            ReferenceValue => ((ReferenceValue)this).Value.GetHashCode(), // Might return the hash code of the reference, not the value
-            _ => throw new TosoksFuckedUpException("undefined value type")
+            ReferenceValue  => ((ReferenceValue)this).Value.GetHashCode(), // Might return the hash code of the reference, not the value
+            _               => throw new TosoksFuckedUpException("undefined value type")
         };
     }
 
@@ -56,11 +58,9 @@ public override bool Equals(object obj)
 
     public static bool operator ==(Value? lhs, Value? rhs)
     {
+        if (lhs is null && rhs is null) return true;
         if (lhs is null || rhs is null || lhs.GetType() != rhs.GetType()) return false;
-        return (lhs is LiteralValue && ((LiteralValue)lhs).Value.Equals(((LiteralValue)rhs).Value)) ||
-                (lhs is PlayerValue && ((PlayerValue)lhs).Players.SequenceEqual(((PlayerValue)rhs).Players)) ||
-                (lhs is CollectionValue && ((CollectionValue)lhs).CastedValues.SequenceEqual(((CollectionValue)rhs).CastedValues)) ||
-                (lhs is ReferenceValue && ((ReferenceValue)lhs).Value.Equals(((ReferenceValue)lhs).Value));
+        return lhs.EqualCondition(rhs);
     }
 
     public static bool operator ==(Value? lhs, object? rhs)