update forge

addons/forge/resources/statescript/NumericCoercionResolver.cs

@@ -0,0 +1,20 @@
+// Copyright © Gamesmiths Guild.
+
+using System;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript;
+
+internal sealed class NumericCoercionResolver(IPropertyResolver innerResolver, Type targetType) : IPropertyResolver
+{
+	private readonly IPropertyResolver _innerResolver = innerResolver;
+
+	public Type ValueType { get; } = targetType;
+
+	public Variant128 Resolve(GraphContext graphContext)
+	{
+		Variant128 sourceValue = _innerResolver.Resolve(graphContext);
+		return StatescriptNumericCompatibility.Coerce(sourceValue, _innerResolver.ValueType, ValueType);
+	}
+}

addons/forge/resources/statescript/NumericCoercionResolver.cs.uid

@@ -0,0 +1 @@
+uid://b21gkd4yj5xqm

addons/forge/resources/statescript/StatescriptNumericCompatibility.cs

@@ -0,0 +1,171 @@
+// Copyright © Gamesmiths Guild.
+
+using System;
+using System.Globalization;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript;
+
+internal static class StatescriptNumericCompatibility
+{
+	public static bool CanCoerce(Type sourceType, Type targetType)
+	{
+		if (sourceType == targetType)
+		{
+			return true;
+		}
+
+		if (!IsNumericType(sourceType) || !IsNumericType(targetType))
+		{
+			return false;
+		}
+
+		if (IsIntegralType(targetType))
+		{
+			return IsIntegralType(sourceType);
+		}
+
+		return IsFloatingPointType(targetType);
+	}
+
+	public static Variant128 Coerce(Variant128 value, Type sourceType, Type targetType)
+	{
+		if (!CanCoerce(sourceType, targetType))
+		{
+			throw new InvalidOperationException(
+				$"Cannot coerce Statescript numeric value from '{sourceType}' to '{targetType}'.");
+		}
+
+		object numericValue = GetNumericValue(sourceType, value);
+		return targetType switch
+		{
+			_ when targetType == typeof(byte) => new Variant128(
+				Convert.ToByte(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(sbyte) => new Variant128(
+				Convert.ToSByte(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(char) => new Variant128(
+				Convert.ToChar(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(short) => new Variant128(
+				Convert.ToInt16(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(ushort) => new Variant128(
+				Convert.ToUInt16(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(int) => new Variant128(
+				Convert.ToInt32(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(uint) => new Variant128(
+				Convert.ToUInt32(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(long) => new Variant128(
+				Convert.ToInt64(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(ulong) => new Variant128(
+				Convert.ToUInt64(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(float) => new Variant128(
+				Convert.ToSingle(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(double) => new Variant128(
+				Convert.ToDouble(numericValue, CultureInfo.InvariantCulture)),
+			_ when targetType == typeof(decimal) => new Variant128(
+				Convert.ToDecimal(numericValue, CultureInfo.InvariantCulture)),
+			_ => throw new InvalidOperationException(
+				$"Cannot coerce Statescript numeric value to unsupported target type '{targetType}'."),
+		};
+	}
+
+	public static bool IsNumericType(Type type)
+	{
+		return type == typeof(byte)
+			|| type == typeof(sbyte)
+			|| type == typeof(char)
+			|| type == typeof(short)
+			|| type == typeof(ushort)
+			|| type == typeof(int)
+			|| type == typeof(uint)
+			|| type == typeof(long)
+			|| type == typeof(ulong)
+			|| type == typeof(float)
+			|| type == typeof(double)
+			|| type == typeof(decimal);
+	}
+
+	private static bool IsFloatingPointType(Type type)
+	{
+		return type == typeof(float) || type == typeof(double) || type == typeof(decimal);
+	}
+
+	private static bool IsIntegralType(Type type)
+	{
+		return type == typeof(byte)
+			|| type == typeof(sbyte)
+			|| type == typeof(char)
+			|| type == typeof(short)
+			|| type == typeof(ushort)
+			|| type == typeof(int)
+			|| type == typeof(uint)
+			|| type == typeof(long)
+			|| type == typeof(ulong);
+	}
+
+	private static object GetNumericValue(Type type, Variant128 value)
+	{
+		if (type == typeof(byte))
+		{
+			return value.AsByte();
+		}
+
+		if (type == typeof(sbyte))
+		{
+			return value.AsSByte();
+		}
+
+		if (type == typeof(char))
+		{
+			return value.AsChar();
+		}
+
+		if (type == typeof(short))
+		{
+			return value.AsShort();
+		}
+
+		if (type == typeof(ushort))
+		{
+			return value.AsUShort();
+		}
+
+		if (type == typeof(int))
+		{
+			return value.AsInt();
+		}
+
+		if (type == typeof(uint))
+		{
+			return value.AsUInt();
+		}
+
+		if (type == typeof(long))
+		{
+			return value.AsLong();
+		}
+
+		if (type == typeof(ulong))
+		{
+			return value.AsULong();
+		}
+
+		if (type == typeof(float))
+		{
+			return value.AsFloat();
+		}
+
+		if (type == typeof(double))
+		{
+			return value.AsDouble();
+		}
+
+		if (type == typeof(decimal))
+		{
+			return value.AsDecimal();
+		}
+
+		throw new InvalidOperationException(
+			$"Cannot read Statescript numeric value from unsupported source type '{type}'.");
+	}
+}

addons/forge/resources/statescript/StatescriptNumericCompatibility.cs.uid

@@ -0,0 +1 @@
+uid://bmmwqoyo6m0y8

addons/forge/resources/statescript/StatescriptResolverResource.cs

@@ -1,5 +1,7 @@
 // Copyright © Gamesmiths Guild.
 
+using System;
+using System.Linq;
 using Gamesmiths.Forge.Core;
 using Gamesmiths.Forge.Statescript;
 using Gamesmiths.Forge.Statescript.Properties;
@@ -62,4 +64,112 @@ public partial class StatescriptResolverResource : Resource
 	{
 		return new VariantResolver(default, typeof(int));
 	}
+
+	protected static void DefineAndBindInputProperty(
+		Graph graph,
+		ForgeNode runtimeNode,
+		string propertyName,
+		byte index,
+		IPropertyResolver resolver)
+	{
+		var propertyKey = new StringKey(propertyName);
+		graph.VariableDefinitions.DefineProperty(
+			propertyKey,
+			AdaptResolverForExpectedInput(runtimeNode, index, resolver));
+		runtimeNode.BindInput(index, propertyKey);
+	}
+
+	protected static bool NeedsNumericInputAdaptation(
+		ForgeNode runtimeNode,
+		byte index,
+		Type actualType)
+	{
+		if (index >= runtimeNode.InputProperties.Length)
+		{
+			return false;
+		}
+
+		Type expectedType = runtimeNode.InputProperties[index].ExpectedType;
+		return expectedType != typeof(Variant128)
+			&& expectedType != actualType
+			&& StatescriptNumericCompatibility.CanCoerce(actualType, expectedType);
+	}
+
+	protected static IPropertyResolver AdaptResolverForExpectedType(
+		IPropertyResolver resolver,
+		Type expectedType)
+	{
+		if (expectedType == typeof(Variant128) || expectedType == resolver.ValueType)
+		{
+			return resolver;
+		}
+
+		if (StatescriptNumericCompatibility.CanCoerce(resolver.ValueType, expectedType))
+		{
+			return new NumericCoercionResolver(resolver, expectedType);
+		}
+
+		return resolver;
+	}
+
+	protected static IPropertyResolver PromoteIntegralResolverToFloatingPoint(
+		IPropertyResolver resolver,
+		Type preferredFloatingType)
+	{
+		if (!StatescriptNumericCompatibility.IsNumericType(resolver.ValueType)
+			|| IsFloatingPointType(resolver.ValueType))
+		{
+			return resolver;
+		}
+
+		return AdaptResolverForExpectedType(resolver, preferredFloatingType);
+	}
+
+	protected static Type GetPreferredFloatingPointType(params IPropertyResolver[] resolvers)
+	{
+		foreach (Type resolverType in resolvers.Select(resolver => resolver.ValueType))
+		{
+			if (resolverType == typeof(double) || resolverType == typeof(decimal))
+			{
+				return typeof(double);
+			}
+		}
+
+		foreach (IPropertyResolver resolver in resolvers)
+		{
+			if (resolver.ValueType == typeof(float))
+			{
+				return typeof(float);
+			}
+		}
+
+		return typeof(double);
+	}
+
+	protected static bool IsVectorOrQuaternionType(Type type)
+	{
+		return type == typeof(System.Numerics.Vector2)
+			|| type == typeof(System.Numerics.Vector3)
+			|| type == typeof(System.Numerics.Vector4)
+			|| type == typeof(System.Numerics.Quaternion);
+	}
+
+	private static IPropertyResolver AdaptResolverForExpectedInput(
+		ForgeNode runtimeNode,
+		byte index,
+		IPropertyResolver resolver)
+	{
+		if (index >= runtimeNode.InputProperties.Length)
+		{
+			return resolver;
+		}
+
+		Type expectedType = runtimeNode.InputProperties[index].ExpectedType;
+		return AdaptResolverForExpectedType(resolver, expectedType);
+	}
+
+	private static bool IsFloatingPointType(Type type)
+	{
+		return type == typeof(float) || type == typeof(double) || type == typeof(decimal);
+	}
 }

addons/forge/resources/statescript/StatescriptVariableTypeConverter.cs

@@ -21,6 +21,18 @@ namespace Gamesmiths.Forge.Godot.Resources.Statescript;
 /// </summary>
 public static class StatescriptVariableTypeConverter
 {
+	private static readonly StatescriptVariableType[] _authoringTypes =
+	[
+		StatescriptVariableType.Bool,
+		StatescriptVariableType.Int,
+		StatescriptVariableType.Double,
+		StatescriptVariableType.Vector2,
+		StatescriptVariableType.Vector3,
+		StatescriptVariableType.Vector4,
+		StatescriptVariableType.Plane,
+		StatescriptVariableType.Quaternion,
+	];
+
 	private static readonly Dictionary<StatescriptVariableType, Type> _typeMap = new()
 	{
 		[StatescriptVariableType.Bool] = typeof(bool),
@@ -43,23 +55,36 @@ public static class StatescriptVariableTypeConverter
 		[StatescriptVariableType.Quaternion] = typeof(System.Numerics.Quaternion),
 	};
 
-	private static readonly Dictionary<Type, StatescriptVariableType> _reverseTypeMap = [];
-
-	static StatescriptVariableTypeConverter()
+	private static readonly Dictionary<Type, StatescriptVariableType> _authoringTypeMap = new()
 	{
-		foreach (KeyValuePair<StatescriptVariableType, Type> kvp in _typeMap)
-		{
-			_reverseTypeMap[kvp.Value] = kvp.Key;
-		}
-	}
+		[typeof(bool)] = StatescriptVariableType.Bool,
+		[typeof(byte)] = StatescriptVariableType.Int,
+		[typeof(sbyte)] = StatescriptVariableType.Int,
+		[typeof(char)] = StatescriptVariableType.Int,
+		[typeof(short)] = StatescriptVariableType.Int,
+		[typeof(ushort)] = StatescriptVariableType.Int,
+		[typeof(int)] = StatescriptVariableType.Int,
+		[typeof(uint)] = StatescriptVariableType.Int,
+		[typeof(long)] = StatescriptVariableType.Int,
+		[typeof(ulong)] = StatescriptVariableType.Int,
+		[typeof(float)] = StatescriptVariableType.Double,
+		[typeof(double)] = StatescriptVariableType.Double,
+		[typeof(decimal)] = StatescriptVariableType.Double,
+		[typeof(SysVector2)] = StatescriptVariableType.Vector2,
+		[typeof(SysVector3)] = StatescriptVariableType.Vector3,
+		[typeof(SysVector4)] = StatescriptVariableType.Vector4,
+		[typeof(System.Numerics.Plane)] = StatescriptVariableType.Plane,
+		[typeof(System.Numerics.Quaternion)] = StatescriptVariableType.Quaternion,
+	};
 
 	/// <summary>
-	/// Gets all supported variable type values.
+	/// Gets all supported designer-facing authoring types.
 	/// </summary>
-	/// <returns>All values of <see cref="StatescriptVariableType"/>.</returns>
+	/// <returns>The subset of <see cref="StatescriptVariableType"/> values exposed for authoring in the Godot editor.
+	/// </returns>
 	public static StatescriptVariableType[] GetAllTypes()
 	{
-		return (StatescriptVariableType[])Enum.GetValues(typeof(StatescriptVariableType));
+		return [.. _authoringTypes];
 	}
 
 	/// <summary>
@@ -80,28 +105,26 @@ public static class StatescriptVariableTypeConverter
 	/// <returns><see langword="true"/> if a matching variable type was found.</returns>
 	public static bool TryFromSystemType(Type type, out StatescriptVariableType variableType)
 	{
-		return _reverseTypeMap.TryGetValue(type, out variableType);
+		return _authoringTypeMap.TryGetValue(type, out variableType);
 	}
 
 	/// <summary>
 	/// Checks whether the given <see cref="Type"/> is compatible with the specified variable type.
 	/// </summary>
 	/// <remarks>
-	/// For <see cref="Variant128"/> (wildcard type), all types are compatible. Otherwise, strict type matching is used
-	/// with no implicit numeric conversions.
+	/// For <see cref="Variant128"/> (wildcard type), all types are compatible. Otherwise, exact type matches are
+	/// accepted, and numeric types are also considered compatible when
+	/// <see cref="StatescriptNumericCompatibility.CanCoerce(Type, Type)"/> can adapt the authored value to the expected
+	/// runtime type. This allows integral-to-integral and numeric-to-floating-point compatibility, but not
+	/// floating-point-to-integral coercion.
 	/// </remarks>
 	/// <param name="expectedType">The expected type from the node declaration.</param>
 	/// <param name="variableType">The variable type to check.</param>
 	/// <returns><see langword="true"/> if the types are compatible.</returns>
 	public static bool IsCompatible(Type expectedType, StatescriptVariableType variableType)
 	{
-		if (expectedType == typeof(Variant128))
-		{
-			return true;
-		}
-
 		Type actualType = ToSystemType(variableType);
-		return expectedType == actualType;
+		return IsCompatible(expectedType, actualType);
 	}
 
 	/// <summary>
@@ -174,7 +197,33 @@ public static class StatescriptVariableTypeConverter
 	/// <returns>A human-readable name for the type.</returns>
 	public static string GetDisplayName(StatescriptVariableType variableType)
 	{
-		return variableType.ToString();
+		return variableType switch
+		{
+			StatescriptVariableType.Byte => "Int",
+			StatescriptVariableType.SByte => "Int",
+			StatescriptVariableType.Char => "Int",
+			StatescriptVariableType.Int => "Int",
+			StatescriptVariableType.UInt => "Int",
+			StatescriptVariableType.Long => "Int",
+			StatescriptVariableType.ULong => "Int",
+			StatescriptVariableType.Short => "Int",
+			StatescriptVariableType.UShort => "Int",
+			StatescriptVariableType.Decimal => "Float",
+			StatescriptVariableType.Double => "Float",
+			StatescriptVariableType.Float => "Float",
+			_ => variableType.ToString(),
+		};
+	}
+
+	internal static bool IsCompatible(Type expectedType, Type actualType)
+	{
+		if (expectedType == typeof(Variant128))
+		{
+			return true;
+		}
+
+		return expectedType == actualType
+			|| StatescriptNumericCompatibility.CanCoerce(actualType, expectedType);
 	}
 
 	private static Variant128 ToForgeVector2(GodotVector2 v)

addons/forge/resources/statescript/resolvers/ACosHResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ACosHResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "ACosH";
+
+	protected override string PropertyNamePrefix => "__acosh";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new ACosHResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ACosHResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://ua6xttpaqtx3

addons/forge/resources/statescript/resolvers/ACosResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ACosResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "ACos";
+
+	protected override string PropertyNamePrefix => "__acos";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new ACosResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ACosResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bq0oh51duv5l8

addons/forge/resources/statescript/resolvers/ASinHResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ASinHResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "ASinH";
+
+	protected override string PropertyNamePrefix => "__asinh";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new ASinHResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ASinHResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://c36ndfu5e0bh8

addons/forge/resources/statescript/resolvers/ASinResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ASinResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "ASin";
+
+	protected override string PropertyNamePrefix => "__asin";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new ASinResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ASinResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://jb4s37nicvyr

addons/forge/resources/statescript/resolvers/ATan2ResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ATan2ResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "ATan2";
+
+	protected override string PropertyNamePrefix => "__atan2";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new ATan2Resolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ATan2ResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://dfq0vlrg7fu83

addons/forge/resources/statescript/resolvers/ATanHResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ATanHResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "ATanH";
+
+	protected override string PropertyNamePrefix => "__atanh";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new ATanHResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ATanHResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bqt6be18wb8f8

addons/forge/resources/statescript/resolvers/ATanResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ATanResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "ATan";
+
+	protected override string PropertyNamePrefix => "__atan";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new ATanResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ATanResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bhmn58hn6c83p

addons/forge/resources/statescript/resolvers/AbsResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class AbsResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Abs";
+
+	protected override string PropertyNamePrefix => "__abs";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new AbsResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/AbsResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://cl5dlem7o8qhh

addons/forge/resources/statescript/resolvers/ActivationDataResolverResource.cs

@@ -68,7 +68,7 @@ public partial class ActivationDataResolverResource : StatescriptResolverResourc
 
 		// Define the variable so the data binder's SetVar call succeeds at runtime.
 		// Check if the variable is already defined to avoid duplicates when multiple nodes bind the same field.
-		var alreadyDefined = false;
+		bool alreadyDefined = false;
 		foreach (VariableDefinition existing in graph.VariableDefinitions.VariableDefinitions)
 		{
 			if (existing.Name == variableName)
@@ -84,6 +84,17 @@ public partial class ActivationDataResolverResource : StatescriptResolverResourc
 				new VariableDefinition(variableName, default, clrType));
 		}
 
+		if (NeedsNumericInputAdaptation(runtimeNode, index, clrType))
+		{
+			DefineAndBindInputProperty(
+				graph,
+				runtimeNode,
+				$"__activation_{nodeId}_{index}",
+				index,
+				new VariableResolver(variableName, clrType));
+			return;
+		}
+
 		runtimeNode.BindInput(index, variableName);
 	}
 

addons/forge/resources/statescript/resolvers/AddResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class AddResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Add";
+
+	protected override string PropertyNamePrefix => "__add";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new AddResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/AddResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://cm23kjjecsqkk

addons/forge/resources/statescript/resolvers/AndResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class AndResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "And";
+
+	protected override string PropertyNamePrefix => "__and";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new AndResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/AndResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://dj6r5ytmvhb10

addons/forge/resources/statescript/resolvers/AngleResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class AngleResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Angle";
+
+	protected override string PropertyNamePrefix => "__angle";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new AngleResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/AngleResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://jch7nucjdqdx

addons/forge/resources/statescript/resolvers/ArrayVariableResolverResource.cs

@@ -0,0 +1,45 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Core;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+using Godot.Collections;
+
+using ForgeNode = Gamesmiths.Forge.Statescript.Node;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ArrayVariableResolverResource : StatescriptResolverResource
+{
+	[Export]
+	public StatescriptVariableType ValueType { get; set; } = StatescriptVariableType.Int;
+
+	[Export]
+	public Array<Variant> ArrayValues { get; set; } = [];
+
+	[Export]
+	public bool IsArrayExpanded { get; set; }
+
+	public override string ResolverTypeId => "ArrayVariable";
+
+	public override void BindInput(Graph graph, ForgeNode runtimeNode, string nodeId, byte index)
+	{
+		var propertyName = new StringKey($"__array_{nodeId}_{index}");
+		graph.VariableDefinitions.DefineProperty(propertyName, BuildResolver(graph));
+		runtimeNode.BindInput(index, propertyName);
+	}
+
+	public override IPropertyResolver BuildResolver(Graph graph)
+	{
+		var values = new Variant128[ArrayValues.Count];
+		for (int i = 0; i < ArrayValues.Count; i++)
+		{
+			values[i] = StatescriptVariableTypeConverter.GodotVariantToForge(ArrayValues[i], ValueType);
+		}
+
+		return new ArrayVariableResolver(values, StatescriptVariableTypeConverter.ToSystemType(ValueType));
+	}
+}

addons/forge/resources/statescript/resolvers/ArrayVariableResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://nncg8107buwu

addons/forge/resources/statescript/resolvers/CbrtResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class CbrtResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Cbrt";
+
+	protected override string PropertyNamePrefix => "__cbrt";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new CbrtResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/CbrtResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://dqus52x4ayvtg

addons/forge/resources/statescript/resolvers/CeilResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class CeilResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Ceil";
+
+	protected override string PropertyNamePrefix => "__ceil";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		operandResolver = PromoteIntegralResolverToFloatingPoint(
+			operandResolver,
+			GetPreferredFloatingPointType(operandResolver));
+		return new CeilResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/CeilResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://vupt7axu4yjt

addons/forge/resources/statescript/resolvers/ClampMagnitudeResolverResource.cs

@@ -0,0 +1,26 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ClampMagnitudeResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "ClampMagnitude";
+
+	protected override string PropertyNamePrefix => "__clampmag";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		rightResolver = AdaptResolverForExpectedType(rightResolver, typeof(float));
+		return new ClampMagnitudeResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ClampMagnitudeResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://di6bytena8enu

addons/forge/resources/statescript/resolvers/ClampResolverResource.cs

@@ -0,0 +1,26 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ClampResolverResource : TernaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Clamp";
+
+	protected override string PropertyNamePrefix => "__clamp";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver firstResolver,
+		IPropertyResolver secondResolver,
+		IPropertyResolver thirdResolver,
+		Graph graph)
+	{
+		return new ClampResolver(firstResolver, secondResolver, thirdResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ClampResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://dyc7kddjdolth

addons/forge/resources/statescript/resolvers/ComparisonResolverResource.cs

@@ -37,6 +37,12 @@ public partial class ComparisonResolverResource : StatescriptResolverResource
 	[Export]
 	public StatescriptResolverResource? Right { get; set; }
 
+	[Export]
+	public bool LeftFolded { get; set; }
+
+	[Export]
+	public bool RightFolded { get; set; }
+
 	/// <inheritdoc/>
 	public override void BindInput(Graph graph, ForgeNode runtimeNode, string nodeId, byte index)
 	{

addons/forge/resources/statescript/resolvers/ConcatenateResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ConcatenateResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Concatenate";
+
+	protected override string PropertyNamePrefix => "__concat";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new ConcatenateResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ConcatenateResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://cmrahroqyhao5

addons/forge/resources/statescript/resolvers/ConjugateResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ConjugateResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Conjugate";
+
+	protected override string PropertyNamePrefix => "__conjugate";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new ConjugateResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ConjugateResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://1v23fvukfbm1

addons/forge/resources/statescript/resolvers/CopySignResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class CopySignResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "CopySign";
+
+	protected override string PropertyNamePrefix => "__copysign";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new CopySignResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/CopySignResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://cp53wwvh6wtpb

addons/forge/resources/statescript/resolvers/CosHResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class CosHResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "CosH";
+
+	protected override string PropertyNamePrefix => "__cosh";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new CosHResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/CosHResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://2pul8hguveqr

addons/forge/resources/statescript/resolvers/CosResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class CosResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Cos";
+
+	protected override string PropertyNamePrefix => "__cos";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new CosResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/CosResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bc08ilmh2crkt

addons/forge/resources/statescript/resolvers/CrossResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class CrossResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Cross";
+
+	protected override string PropertyNamePrefix => "__cross";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new CrossResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/CrossResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://cpu33vntj1c34

addons/forge/resources/statescript/resolvers/DegToRadResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class DegToRadResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "DegToRad";
+
+	protected override string PropertyNamePrefix => "__degtorad";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new DegToRadResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/DegToRadResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://c14mxc32u4rrh

addons/forge/resources/statescript/resolvers/DistanceResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class DistanceResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Distance";
+
+	protected override string PropertyNamePrefix => "__distance";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new DistanceResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/DistanceResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bq8oi7lr3ome5

addons/forge/resources/statescript/resolvers/DistanceSquaredResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class DistanceSquaredResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "DistanceSquared";
+
+	protected override string PropertyNamePrefix => "__dist2";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new DistanceSquaredResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/DistanceSquaredResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bort1qclaick7

addons/forge/resources/statescript/resolvers/DivideResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class DivideResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Divide";
+
+	protected override string PropertyNamePrefix => "__divide";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new DivideResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/DivideResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://dchlcihlglcdc

addons/forge/resources/statescript/resolvers/DotCoordinateResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class DotCoordinateResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "DotCoordinate";
+
+	protected override string PropertyNamePrefix => "__dotcoordinate";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new DotCoordinateResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/DotCoordinateResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://rsttqpktx8kc

addons/forge/resources/statescript/resolvers/DotNormalResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class DotNormalResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "DotNormal";
+
+	protected override string PropertyNamePrefix => "__dotnormal";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new DotNormalResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/DotNormalResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://cajc2qaswbj6u

addons/forge/resources/statescript/resolvers/DotResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class DotResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Dot";
+
+	protected override string PropertyNamePrefix => "__dot";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new DotResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/DotResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bw03e7dkf852b

addons/forge/resources/statescript/resolvers/EResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using System;
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class EResolverResource : TypedConstantResolverResourceBase
+{
+	public override string ResolverTypeId => "E";
+
+	protected override string PropertyNamePrefix => "__e";
+
+	protected override IPropertyResolver CreateResolver(Type valueType)
+	{
+		return new EResolver(valueType);
+	}
+}

addons/forge/resources/statescript/resolvers/EResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://q18fgodpw1nh

addons/forge/resources/statescript/resolvers/EulerAnglesFromQuaternionResolverResource.cs

@@ -0,0 +1,28 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+using ForgeEulerOrder = Gamesmiths.Forge.Statescript.Properties.EulerOrder;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class EulerAnglesFromQuaternionResolverResource : UnaryNestedResolverResourceBase
+{
+	[Export]
+	public ForgeEulerOrder Order { get; set; } = ForgeEulerOrder.XYZ;
+
+	public override string ResolverTypeId => "EulerAnglesFromQuaternion";
+
+	protected override string PropertyNamePrefix => "__eulerfromquat";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new EulerAnglesFromQuaternionResolver(
+			operandResolver,
+			new VariantResolver(new Variant128((int)Order), typeof(int)));
+	}
+}

addons/forge/resources/statescript/resolvers/EulerAnglesFromQuaternionResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://ff1sjaqxaubq

addons/forge/resources/statescript/resolvers/ExpResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ExpResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Exp";
+
+	protected override string PropertyNamePrefix => "__exp";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new ExpResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ExpResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://c5t6w3pvhedbw

addons/forge/resources/statescript/resolvers/FloorResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class FloorResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Floor";
+
+	protected override string PropertyNamePrefix => "__floor";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		operandResolver = PromoteIntegralResolverToFloatingPoint(
+			operandResolver,
+			GetPreferredFloatingPointType(operandResolver));
+		return new FloorResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/FloorResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://yfw58s1q18vm

addons/forge/resources/statescript/resolvers/InverseResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class InverseResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Inverse";
+
+	protected override string PropertyNamePrefix => "__inverse";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new InverseResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/InverseResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bkgn2wskesfre

addons/forge/resources/statescript/resolvers/LengthResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class LengthResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Length";
+
+	protected override string PropertyNamePrefix => "__length";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new LengthResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/LengthResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://diqyhlprfb1yn

addons/forge/resources/statescript/resolvers/LengthSquaredResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class LengthSquaredResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "LengthSquared";
+
+	protected override string PropertyNamePrefix => "__length2";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new LengthSquaredResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/LengthSquaredResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://dc60ghgb0kgth

addons/forge/resources/statescript/resolvers/LerpResolverResource.cs

@@ -0,0 +1,39 @@
+// Copyright © Gamesmiths Guild.
+
+using System;
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class LerpResolverResource : TernaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Lerp";
+
+	protected override string PropertyNamePrefix => "__lerp";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver firstResolver,
+		IPropertyResolver secondResolver,
+		IPropertyResolver thirdResolver,
+		Graph graph)
+	{
+		if (IsVectorOrQuaternionType(firstResolver.ValueType) || IsVectorOrQuaternionType(secondResolver.ValueType))
+		{
+			thirdResolver = AdaptResolverForExpectedType(thirdResolver, typeof(float));
+		}
+		else
+		{
+			Type preferredFloatingType = GetPreferredFloatingPointType(firstResolver, secondResolver, thirdResolver);
+			firstResolver = PromoteIntegralResolverToFloatingPoint(firstResolver, preferredFloatingType);
+			secondResolver = PromoteIntegralResolverToFloatingPoint(secondResolver, preferredFloatingType);
+			thirdResolver = PromoteIntegralResolverToFloatingPoint(thirdResolver, preferredFloatingType);
+		}
+
+		return new LerpResolver(firstResolver, secondResolver, thirdResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/LerpResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://dc3avdnhexa2q

addons/forge/resources/statescript/resolvers/Log10ResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class Log10ResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Log10";
+
+	protected override string PropertyNamePrefix => "__log10";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new Log10Resolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/Log10ResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://coqk8brmbdtdb

addons/forge/resources/statescript/resolvers/Log2ResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class Log2ResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Log2";
+
+	protected override string PropertyNamePrefix => "__log2";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new Log2Resolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/Log2ResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bgnylfxdn6q57

addons/forge/resources/statescript/resolvers/LogResolverResource.cs

@@ -0,0 +1,22 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class LogResolverResource : UnaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Log";
+
+	protected override string PropertyNamePrefix => "__log";
+
+	protected override IPropertyResolver CreateResolver(IPropertyResolver operandResolver, Graph graph)
+	{
+		return new LogResolver(operandResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/LogResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://c47kw60drqkla

addons/forge/resources/statescript/resolvers/LookAtResolverResource.cs

@@ -0,0 +1,26 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class LookAtResolverResource : TernaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "LookAt";
+
+	protected override string PropertyNamePrefix => "__lookat";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver firstResolver,
+		IPropertyResolver secondResolver,
+		IPropertyResolver thirdResolver,
+		Graph graph)
+	{
+		return new LookAtResolver(firstResolver, secondResolver, thirdResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/LookAtResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://cx7fcmcwooyuf

addons/forge/resources/statescript/resolvers/MaxResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class MaxResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Max";
+
+	protected override string PropertyNamePrefix => "__max";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new MaxResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/MaxResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://qwceer0fwycl

addons/forge/resources/statescript/resolvers/MinResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class MinResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Min";
+
+	protected override string PropertyNamePrefix => "__min";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new MinResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/MinResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://eifyl705u3gv

addons/forge/resources/statescript/resolvers/ModuloResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class ModuloResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Modulo";
+
+	protected override string PropertyNamePrefix => "__modulo";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new ModuloResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/ModuloResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://uff681gfceto

addons/forge/resources/statescript/resolvers/MoveTowardsResolverResource.cs

@@ -0,0 +1,34 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class MoveTowardsResolverResource : TernaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "MoveTowards";
+
+	protected override string PropertyNamePrefix => "__movetowards";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver firstResolver,
+		IPropertyResolver secondResolver,
+		IPropertyResolver thirdResolver,
+		Graph graph)
+	{
+		if (StatescriptNumericCompatibility.IsNumericType(firstResolver.ValueType)
+			&& StatescriptNumericCompatibility.IsNumericType(secondResolver.ValueType))
+		{
+			firstResolver = AdaptResolverForExpectedType(firstResolver, typeof(float));
+			secondResolver = AdaptResolverForExpectedType(secondResolver, typeof(float));
+		}
+
+		thirdResolver = AdaptResolverForExpectedType(thirdResolver, typeof(float));
+		return new MoveTowardsResolver(firstResolver, secondResolver, thirdResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/MoveTowardsResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://b8h5iv8btpf2m

addons/forge/resources/statescript/resolvers/MultiplyResolverResource.cs

@@ -0,0 +1,25 @@
+// Copyright © Gamesmiths Guild.
+
+using Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers.Bases;
+using Gamesmiths.Forge.Statescript;
+using Gamesmiths.Forge.Statescript.Properties;
+using Godot;
+
+namespace Gamesmiths.Forge.Godot.Resources.Statescript.Resolvers;
+
+[Tool]
+[GlobalClass]
+public partial class MultiplyResolverResource : BinaryNestedResolverResourceBase
+{
+	public override string ResolverTypeId => "Multiply";
+
+	protected override string PropertyNamePrefix => "__multiply";
+
+	protected override IPropertyResolver CreateResolver(
+		IPropertyResolver leftResolver,
+		IPropertyResolver rightResolver,
+		Graph graph)
+	{
+		return new MultiplyResolver(leftResolver, rightResolver);
+	}
+}

addons/forge/resources/statescript/resolvers/MultiplyResolverResource.cs.uid

@@ -0,0 +1 @@
+uid://bls6qlyxbp0wo