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

[ScriptPath("res://Scripts/Bullets/MoveTowardsPlayer.cs")]
public class MoveTowardsPlayer : Sprite2D, IBullet
{
	public new class MethodName : Sprite2D.MethodName
	{
		public new static readonly StringName _Ready = "_Ready";

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

	public new class PropertyName : Sprite2D.PropertyName
	{
		public static readonly StringName grazed = "grazed";

		public static readonly StringName node = "node";

		public static readonly StringName anim = "anim";

		public static readonly StringName type = "type";

		public static readonly StringName HP = "HP";

		public static readonly StringName generatedFrom = "generatedFrom";

		public static readonly StringName homing = "homing";

		public static readonly StringName startDelay = "startDelay";

		public static readonly StringName liveTime = "liveTime";

		public static readonly StringName speed = "speed";

		public static readonly StringName dir = "dir";
	}

	public new class SignalName : Sprite2D.SignalName
	{
	}

	[Export(PropertyHint.None, "")]
	private float homing;

	[Export(PropertyHint.None, "")]
	private float startDelay;

	[Export(PropertyHint.None, "")]
	private float liveTime = -100f;

	[Export(PropertyHint.None, "")]
	private float speed = 1f;

	public Vector2 dir;

	private const float angleFix = -90f;

	public bool grazed { get; set; }

	public Node2D node { get; set; }

	[Export(PropertyHint.None, "")]
	public AnimationPlayer anim { get; set; }

	[Export(PropertyHint.None, "")]
	public IBullet.Type type { get; set; }

	[Export(PropertyHint.None, "")]
	public int HP { get; set; } = 1;

	public BulletGenerator generatedFrom { get; set; }

	public Action<Node> onShot { get; set; }

	public override void _Ready()
	{
		if (node == null)
		{
			Node2D node2D = (node = this);
		}
		dir = base.GlobalPosition.DirectionTo(BattleDR.current.soul.GlobalPosition);
		LookAt(BattleDR.current.soul.GlobalPosition);
		base.RotationDegrees += -90f;
	}

	public override void _Process(double delta)
	{
		if (startDelay > 0f)
		{
			startDelay -= Main.deltaTime;
			_Ready();
			return;
		}
		if (liveTime > 0f)
		{
			liveTime -= Main.deltaTime;
		}
		else if (liveTime > -50f)
		{
			QueueFree();
		}
		base.GlobalPosition += dir * speed * Main.deltaTime;
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	internal static List<MethodInfo> GetGodotMethodList()
	{
		return new List<MethodInfo>(2)
		{
			new MethodInfo(MethodName._Ready, 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._Ready && args.Count == 0)
		{
			_Ready();
			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._Ready)
		{
			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.grazed)
		{
			grazed = VariantUtils.ConvertTo<bool>(in value);
			return true;
		}
		if (name == PropertyName.node)
		{
			node = VariantUtils.ConvertTo<Node2D>(in value);
			return true;
		}
		if (name == PropertyName.anim)
		{
			anim = VariantUtils.ConvertTo<AnimationPlayer>(in value);
			return true;
		}
		if (name == PropertyName.type)
		{
			type = VariantUtils.ConvertTo<IBullet.Type>(in value);
			return true;
		}
		if (name == PropertyName.HP)
		{
			HP = VariantUtils.ConvertTo<int>(in value);
			return true;
		}
		if (name == PropertyName.generatedFrom)
		{
			generatedFrom = VariantUtils.ConvertTo<BulletGenerator>(in value);
			return true;
		}
		if (name == PropertyName.homing)
		{
			homing = VariantUtils.ConvertTo<float>(in value);
			return true;
		}
		if (name == PropertyName.startDelay)
		{
			startDelay = VariantUtils.ConvertTo<float>(in value);
			return true;
		}
		if (name == PropertyName.liveTime)
		{
			liveTime = VariantUtils.ConvertTo<float>(in value);
			return true;
		}
		if (name == PropertyName.speed)
		{
			speed = VariantUtils.ConvertTo<float>(in value);
			return true;
		}
		if (name == PropertyName.dir)
		{
			dir = VariantUtils.ConvertTo<Vector2>(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.grazed)
		{
			value = VariantUtils.CreateFrom<bool>(grazed);
			return true;
		}
		if (name == PropertyName.node)
		{
			value = VariantUtils.CreateFrom<Node2D>(node);
			return true;
		}
		if (name == PropertyName.anim)
		{
			value = VariantUtils.CreateFrom<AnimationPlayer>(anim);
			return true;
		}
		if (name == PropertyName.type)
		{
			value = VariantUtils.CreateFrom<IBullet.Type>(type);
			return true;
		}
		if (name == PropertyName.HP)
		{
			value = VariantUtils.CreateFrom<int>(HP);
			return true;
		}
		if (name == PropertyName.generatedFrom)
		{
			value = VariantUtils.CreateFrom<BulletGenerator>(generatedFrom);
			return true;
		}
		if (name == PropertyName.homing)
		{
			value = VariantUtils.CreateFrom(in homing);
			return true;
		}
		if (name == PropertyName.startDelay)
		{
			value = VariantUtils.CreateFrom(in startDelay);
			return true;
		}
		if (name == PropertyName.liveTime)
		{
			value = VariantUtils.CreateFrom(in liveTime);
			return true;
		}
		if (name == PropertyName.speed)
		{
			value = VariantUtils.CreateFrom(in speed);
			return true;
		}
		if (name == PropertyName.dir)
		{
			value = VariantUtils.CreateFrom(in dir);
			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.Bool, PropertyName.grazed, PropertyHint.None, "", PropertyUsageFlags.ScriptVariable, exported: false),
			new PropertyInfo(Variant.Type.Object, PropertyName.node, PropertyHint.None, "", PropertyUsageFlags.ScriptVariable, exported: false),
			new PropertyInfo(Variant.Type.Object, PropertyName.anim, PropertyHint.NodeType, "AnimationPlayer", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true),
			new PropertyInfo(Variant.Type.Int, PropertyName.type, PropertyHint.Enum, "Normal,Blue,Orange,Green,Yellow,Block", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true),
			new PropertyInfo(Variant.Type.Int, PropertyName.HP, PropertyHint.None, "", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true),
			new PropertyInfo(Variant.Type.Object, PropertyName.generatedFrom, PropertyHint.None, "", PropertyUsageFlags.ScriptVariable, exported: false),
			new PropertyInfo(Variant.Type.Float, PropertyName.homing, PropertyHint.None, "", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true),
			new PropertyInfo(Variant.Type.Float, PropertyName.startDelay, PropertyHint.None, "", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true),
			new PropertyInfo(Variant.Type.Float, PropertyName.liveTime, PropertyHint.None, "", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true),
			new PropertyInfo(Variant.Type.Float, PropertyName.speed, PropertyHint.None, "", PropertyUsageFlags.Default | PropertyUsageFlags.ScriptVariable, exported: true),
			new PropertyInfo(Variant.Type.Vector2, PropertyName.dir, PropertyHint.None, "", PropertyUsageFlags.ScriptVariable, exported: false)
		};
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	protected override void SaveGodotObjectData(GodotSerializationInfo info)
	{
		base.SaveGodotObjectData(info);
		info.AddProperty(PropertyName.grazed, Variant.From<bool>(grazed));
		info.AddProperty(PropertyName.node, Variant.From<Node2D>(node));
		info.AddProperty(PropertyName.anim, Variant.From<AnimationPlayer>(anim));
		info.AddProperty(PropertyName.type, Variant.From<IBullet.Type>(type));
		info.AddProperty(PropertyName.HP, Variant.From<int>(HP));
		info.AddProperty(PropertyName.generatedFrom, Variant.From<BulletGenerator>(generatedFrom));
		info.AddProperty(PropertyName.homing, Variant.From(in homing));
		info.AddProperty(PropertyName.startDelay, Variant.From(in startDelay));
		info.AddProperty(PropertyName.liveTime, Variant.From(in liveTime));
		info.AddProperty(PropertyName.speed, Variant.From(in speed));
		info.AddProperty(PropertyName.dir, Variant.From(in dir));
	}

	[EditorBrowsable(EditorBrowsableState.Never)]
	protected override void RestoreGodotObjectData(GodotSerializationInfo info)
	{
		base.RestoreGodotObjectData(info);
		if (info.TryGetProperty(PropertyName.grazed, out var value))
		{
			grazed = value.As<bool>();
		}
		if (info.TryGetProperty(PropertyName.node, out var value2))
		{
			node = value2.As<Node2D>();
		}
		if (info.TryGetProperty(PropertyName.anim, out var value3))
		{
			anim = value3.As<AnimationPlayer>();
		}
		if (info.TryGetProperty(PropertyName.type, out var value4))
		{
			type = value4.As<IBullet.Type>();
		}
		if (info.TryGetProperty(PropertyName.HP, out var value5))
		{
			HP = value5.As<int>();
		}
		if (info.TryGetProperty(PropertyName.generatedFrom, out var value6))
		{
			generatedFrom = value6.As<BulletGenerator>();
		}
		if (info.TryGetProperty(PropertyName.homing, out var value7))
		{
			homing = value7.As<float>();
		}
		if (info.TryGetProperty(PropertyName.startDelay, out var value8))
		{
			startDelay = value8.As<float>();
		}
		if (info.TryGetProperty(PropertyName.liveTime, out var value9))
		{
			liveTime = value9.As<float>();
		}
		if (info.TryGetProperty(PropertyName.speed, out var value10))
		{
			speed = value10.As<float>();
		}
		if (info.TryGetProperty(PropertyName.dir, out var value11))
		{
			dir = value11.As<Vector2>();
		}
	}
}