raulsntos
commented
1 year ago You should be able to implement this with extension methods, for example:
public static class VariantExtensions
{
public static bool IsEqualsTo(this Variant left, Variant right)
{
if (left.VariantType != right.VariantType)
{
return false;
}
return switch left.VariantType
{
Variant.Type.Nil => true,
Variant.Type.Bool => left.AsBool() == right.AsBool(),
Variant.Type.Int => left.AsInt64() == right.AsInt64(),
Variant.Type.Float => left.AsDouble() == right.AsDouble(),
// ...
}
}
}Basically you can use the Variant.VariantType property to determine the type of a Variant and then get the value as the correct type and compare them since at that point they are normal C# types.
You can also choose to ignore Variant.VariantType and just convert to the type you want anyway which is valid because Variant allows that, for example your variant can be a double like 4.2 and if you use .AsInt64() that will give you 4 which is a lossy conversion, at that point you basically lose type safety.
Being strict about the type results in a comparison like the === operator in JavaScript and ignoring the type results in a comparison like the == operator in JavaScript. I don't know what your requirements are, do you need 2 and "2" to be considered equal? What about 2 and 2.0?
Alternatively, if you are implementing your system in C# you might prefer to use generics and the IEquatable<T> interface, for example:
public bool CompareTwoValues<T>(T left, T right) where T : IEquatable<T>
{
return left.Equals(right);
}If you need, you can restrict T to only allow types that are compatible with Variant by using the [MustBeVariant] attribute:
public bool CompareTwoValues<[MustBeVariant] T>(T left, T right) where T : IEquatable
{
return left.Equals(right);
}All primitive C# types and Godot structs implement IEquatable<T>.
You may also consider implementing a IEqualityComparer<Variant> instead.
Describe how your proposal will work, with code, pseudo-code, mock-ups, and/or diagrams
Doesn't apply.
It does apply. Proposals are meant to propose a solution to an existing problem; otherwise, it might be a better fit for a discussion. Are you asking to implement IEquatable<Variant> in Variant? Or the Variant::evaluate method from C++? Or the ==, >, <, <=, and >= operators?
Is there a reason why this should be core and not an add-on in the asset library?
This is a C++ Variant feature that can only be made available in C# via the Godot mono module.
As described above, this can be worked around in multiple ways depending on the requirements of your system. I personally don't consider this necessary to be in core and wouldn't want to encourage more usage of untyped APIs than what's already available in Godot APIs.
Also, I wouldn't use the Variant type for anything other than interop with Godot APIs. The Variant type was implemented because a lot of Godot APIs are untyped so we needed some type to use there in C# and System.Object (which is what we use in 3.x instead) was too open (which resulted in runtime errors when you use a type that's not compatible with Variant and bad performance from boxing value types).
MikeSchulze
AThousandShips
waldnercharles
Describe the project you are working on
I will implement a Goal Oriented Action Planning system for my game in Godot.
My intent is to be able to define and assign character actions, their precondition and effects checks inside the Godot editor. For that purpose I expect to be able to compare values, like the character's current state with the action's preconditions and effects, in order to select or discard the action for a potential future plan. The values to compare type might be an int, float, string, etc.
Describe the problem or limitation you are having in your project
Suppose you have this resource as an Action's precondition check definition.
In C# you should be able to compare the character's current state value with the action's precondition value regardless of the type of the Variant value. However, Variant to Variant comparisons aren't exposed in the C# Variant class so the following aren't possible:
C++ Variant also offers
However, none of these are available for use in C#.
Describe the feature / enhancement and how it helps to overcome the problem or limitation
Expose methods in C# to compare Variant values without casting them and without being aware of their type.
Describe how your proposal will work, with code, pseudo-code, mock-ups, and/or diagrams
Doesn't apply.
If this enhancement will not be used often, can it be worked around with a few lines of script?
This can be worked around by explicitly knowing the type of the values to compare and using that knowledge in C# to cast the values to the appropriate type and then do the comparison in a case by case basis.
Is there a reason why this should be core and not an add-on in the asset library?
This is a C++ Variant feature that can only be made available in C# via the Godot mono module.