deltarune-yellow-translation/Scripts-new/Chain.cs

using System.Collections.Generic;
using System.ComponentModel;
using Godot;
using Godot.Bridge;
using Godot.NativeInterop;

[ScriptPath("res://Scripts/Envirioment/Chain.cs")]
public class Chain : Node2D
{
	public new class MethodName : Node2D.MethodName
	{
		public new static readonly StringName _EnterTree = "_EnterTree";

		public static readonly StringName SetPos = "SetPos";

		public new static readonly StringName _Process = "_Process";
	}

	public new class PropertyName : Node2D.PropertyName
	{
		public static readonly StringName chains = "chains";

		public static readonly StringName matchPos = "matchPos";

		public static readonly StringName target = "target";
	}

	public new class SignalName : Node2D.SignalName
	{
	}

	[Export(PropertyHint.None, "")]
	private Node2D[] chains;

	[Export(PropertyHint.None, "")]
	private Node2D matchPos;

	[Export(PropertyHint.None, "")]
	private Node2D target;

	public override void _EnterTree()
	{
		if (matchPos != null)
		{
			CallDeferred("SetPos");
		}
	}

	private void SetPos()
	{
		base.GlobalPosition = matchPos.GlobalPosition;
	}

	public override void _Process(double delta)
	{
		for (int i = 0; i < chains.Length; i++)
		{
			chains[i].GlobalPosition = base.GlobalPosition.Lerp(target.GlobalPosition, (float)(i + 1) / (float)(chains.Length + 1));
		}
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	internal static List<MethodInfo> GetGodotMethodList()
	{
		return new List<MethodInfo>(3)
		{
			new MethodInfo(MethodName._EnterTree, new PropertyInfo(Variant.Type.Nil, "", PropertyHint.None, "", PropertyUsageFlags.Default, exported: false), MethodFlags.Normal, null, null),
			new MethodInfo(MethodName.SetPos, new PropertyInfo(Variant.Type.Nil, "", PropertyHint.None, "", PropertyUsageFlags.Default, exported: false), MethodFlags.Normal, null, null),
			new MethodInfo(MethodName._Process, new PropertyInfo(Variant.Type.Nil, "", PropertyHint.None, "", PropertyUsageFlags.Default, exported: false), MethodFlags.Normal, new List<PropertyInfo>
			{
				new PropertyInfo(Variant.Type.Float, "delta", PropertyHint.None, "", PropertyUsageFlags.Default, exported: false)
			}, null)
		};
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	protected override bool InvokeGodotClassMethod(in godot_string_name method, NativeVariantPtrArgs args, out godot_variant ret)
	{
		if (method == MethodName._EnterTree && args.Count == 0)
		{
			_EnterTree();
			ret = default(godot_variant);
			return true;
		}
		if (method == MethodName.SetPos && args.Count == 0)
		{
			SetPos();
			ret = default(godot_variant);
			return true;
		}
		if (method == MethodName._Process && args.Count == 1)
		{
			_Process(VariantUtils.ConvertTo<double>(in args[0]));
			ret = default(godot_variant);
			return true;
		}
		return base.InvokeGodotClassMethod(in method, args, out ret);
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	protected override bool HasGodotClassMethod(in godot_string_name method)
	{
		if (method == MethodName._EnterTree)
		{
			return true;
		}
		if (method == MethodName.SetPos)
		{
			return true;
		}
		if (method == MethodName._Process)
		{
			return true;
		}
		return base.HasGodotClassMethod(in method);
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	protected override bool SetGodotClassPropertyValue(in godot_string_name name, in godot_variant value)
	{
		if (name == PropertyName.chains)
		{
			chains = VariantUtils.ConvertToSystemArrayOfGodotObject<Node2D>(in value);
			return true;
		}
		if (name == PropertyName.matchPos)
		{
			matchPos = VariantUtils.ConvertTo<Node2D>(in value);
			return true;
		}
		if (name == PropertyName.target)
		{
			target = VariantUtils.ConvertTo<Node2D>(in value);
			return true;
		}
		return base.SetGodotClassPropertyValue(in name, in value);
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
	{
		if (name == PropertyName.chains)
		{
			GodotObject[] array = chains;
			value = VariantUtils.CreateFromSystemArrayOfGodotObject(array);
			return true;
		}
		if (name == PropertyName.matchPos)
		{
			value = VariantUtils.CreateFrom(in matchPos);
			return true;
		}
		if (name == PropertyName.target)
		{
			value = VariantUtils.CreateFrom(in target);
			return true;
		}
		return base.GetGodotClassPropertyValue(in name, out value);
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	internal static List<PropertyInfo> GetGodotPropertyList()
	{
		return new List<PropertyInfo>
		{
			new PropertyInfo(Variant.Type.Array, PropertyName.chains, PropertyHint.TypeString, "24/34:Node2D", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true),
			new PropertyInfo(Variant.Type.Object, PropertyName.matchPos, PropertyHint.NodeType, "Node2D", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true),
			new PropertyInfo(Variant.Type.Object, PropertyName.target, PropertyHint.NodeType, "Node2D", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true)
		};
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	protected override void SaveGodotObjectData(GodotSerializationInfo info)
	{
		base.SaveGodotObjectData(info);
		StringName name = PropertyName.chains;
		GodotObject[] array = chains;
		info.AddProperty(name, Variant.CreateFrom(array));
		info.AddProperty(PropertyName.matchPos, Variant.From(in matchPos));
		info.AddProperty(PropertyName.target, Variant.From(in target));
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	protected override void RestoreGodotObjectData(GodotSerializationInfo info)
	{
		base.RestoreGodotObjectData(info);
		if (info.TryGetProperty(PropertyName.chains, out var value))
		{
			chains = value.AsGodotObjectArray<Node2D>();
		}
		if (info.TryGetProperty(PropertyName.matchPos, out var value2))
		{
			matchPos = value2.As<Node2D>();
		}
		if (info.TryGetProperty(PropertyName.target, out var value3))
		{
			target = value3.As<Node2D>();
		}
	}
}