using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Xml.Serialization;
using UnityEngine;

namespace XUtliPoolLib
{
	[Serializable]
	public class XSkillData
	{
		public static readonly string[] Skills = new string[]
		{
			"XJAComboSkill",
			"XArtsSkill",
			"XUltraSkill",
			"XCombinedSkill"
		};

		public static readonly string[] JA_Command = new string[]
		{
			"ToSkill",
			"ToJA_1_0",
			"ToJA_2_0",
			"ToJA_3_0",
			"ToJA_4_0",
			"ToJA_0_1",
			"ToJA_0_2",
			"ToJA_1_1",
			"ToJA_1_2",
			"ToJA_2_1",
			"ToJA_2_2",
			"ToJA_3_1",
			"ToJA_3_2",
			"ToJA_4_1",
			"ToJA_4_2",
			"ToJA_QTE"
		};

		public static readonly string[] Combined_Command = new string[]
		{
			"ToPhase",
			"ToPhase1",
			"ToPhase2",
			"ToPhase3",
			"ToPhase4",
			"ToPhase5",
			"ToPhase6",
			"ToPhase7",
			"ToPhase8",
			"ToPhase9"
		};

		public static readonly string[] JaOverrideMap = new string[]
		{
			"A",
			"AA",
			"AAA",
			"AAAA",
			"AAAAA",
			"AB",
			"ABB",
			"AAB",
			"AABB",
			"AAAB",
			"AAABB",
			"AAAAB",
			"AAAABB",
			"AAAAAB",
			"AAAAABB",
			"QTE"
		};

		public static readonly string[] CombinedOverrideMap = new string[]
		{
			"Phase0",
			"Phase1",
			"Phase2",
			"Phase3",
			"Phase4",
			"Phase5",
			"Phase6",
			"Phase7",
			"Phase8",
			"Phase9"
		};

		public static readonly string[] MultipleAttackOverrideMap = new string[]
		{
			"Forward",
			"RightForward",
			"Right",
			"RightBack",
			"LeftForward",
			"Left",
			"LeftBack",
			"Back"
		};

		[XmlIgnore]
		public string Prefix = null;

		[SerializeField]
		public string Name;

		[SerializeField]
		[DefaultValue(1)]
		public int TypeToken;

		[SerializeField]
		public string ClipName;

		[SerializeField]
		[DefaultValue(0)]
		public int SkillPosition;

		[SerializeField]
		[DefaultValue(false)]
		public bool IgnoreCollision;

		[SerializeField]
		[DefaultValue(true)]
		public bool NeedTarget;

		[SerializeField]
		[DefaultValue(false)]
		public bool OnceOnly;

		[SerializeField]
		[DefaultValue(false)]
		public bool ForCombinedOnly;

		[SerializeField]
		[DefaultValue(false)]
		public bool MultipleAttackSupported;

		[SerializeField]
		[DefaultValue(0.75f)]
		public float BackTowardsDecline;

		[SerializeField]
		public string PVP_Script_Name;

		[SerializeField]
		public List<XResultData> Result;

		[SerializeField]
		public List<XChargeData> Charge;

		[SerializeField]
		public List<XJAData> Ja;

		[SerializeField]
		public List<XHitData> Hit;

		[SerializeField]
		public List<XManipulationData> Manipulation;

		[SerializeField]
		public List<XFxData> Fx;

		[SerializeField]
		public List<XAudioData> Audio;

		[SerializeField]
		public List<XCameraEffectData> CameraEffect;

		[SerializeField]
		public List<XWarningData> Warning;

		[SerializeField]
		public List<XCombinedData> Combined;

		[SerializeField]
		public List<XMobUnitData> Mob;

		[SerializeField]
		public XScriptData Script;

		[SerializeField]
		public XLogicalData Logical;

		[SerializeField]
		public XCameraMotionData CameraMotion;

		[SerializeField]
		public XCameraPostEffectData CameraPostEffect;

		[SerializeField]
		public XCastChain Chain;

		[SerializeField]
		[DefaultValue(1f)]
		public float CoolDown;

		[SerializeField]
		[DefaultValue(0f)]
		public float Time;

		[SerializeField]
		[DefaultValue(false)]
		public bool Cast_Range_Rect;

		[SerializeField]
		[DefaultValue(0f)]
		public float Cast_Range_Upper;

		[SerializeField]
		[DefaultValue(0f)]
		public float Cast_Range_Lower;

		[SerializeField]
		[DefaultValue(0f)]
		public float Cast_Offset_X;

		[SerializeField]
		[DefaultValue(0f)]
		public float Cast_Offset_Z;

		[SerializeField]
		[DefaultValue(0f)]
		public float Cast_Scope;

		[SerializeField]
		[DefaultValue(0f)]
		public float Cast_Scope_Shift;

		[SerializeField]
		[DefaultValue(1f)]
		public float CameraTurnBack;

		public static bool PreLoad = false;

		public XSkillData()
		{
			this.TypeToken = 1;
			this.NeedTarget = true;
			this.BackTowardsDecline = 0.75f;
			this.CameraTurnBack = 1f;
			this.CoolDown = 1f;
		}

		public static XSkillData PreLoadSkillForTemp(string skillprefix, string name, bool force = false)
		{
			XSkillData data = XSingleton<XResourceLoaderMgr>.singleton.GetData<XSkillData>(skillprefix + name, ".txt");
			data.Prefix = skillprefix;
			bool flag = (int) Application.platform == 7 || (int)Application.platform == 0 || force;
			if (flag)
			{
				XSkillData.PreLoadSkillResEx(data, 1);
			}
			else
			{
				XSkillData.PreLoadSkillRes(data, 1);
			}
			return data;
		}

		public static void PreLoadSkillRes(XSkillData data, int count)
		{
			bool flag = !string.IsNullOrEmpty(data.ClipName);
			if (flag)
			{
				XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.ClipName, true, false);
			}
			bool flag2 = data.Fx != null;
			if (flag2)
			{
				for (int i = 0; i < data.Fx.Count; i++)
				{
					XSingleton<XResourceLoaderMgr>.singleton.CreateInAdvance(data.Fx[i].Fx, count, ECreateHideType.DisableParticleRenderer);
				}
			}
			bool flag3 = data.Result != null;
			if (flag3)
			{
				for (int j = 0; j < data.Result.Count; j++)
				{
					bool longAttackEffect = data.Result[j].LongAttackEffect;
					if (longAttackEffect)
					{
						XSingleton<XResourceLoaderMgr>.singleton.CreateInAdvance(data.Result[j].LongAttackData.End_Fx, count, ECreateHideType.DisableParticleRenderer);
						XSingleton<XResourceLoaderMgr>.singleton.CreateInAdvance(data.Result[j].LongAttackData.Prefab, count, ECreateHideType.DisableParticleRenderer);
					}
				}
			}
		}

		public static void PreLoadSkillResEx(XSkillData data, int count)
		{
			bool flag = !string.IsNullOrEmpty(data.ClipName);
			if (flag)
			{
				XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.ClipName, true, false);
				bool multipleAttackSupported = data.MultipleAttackSupported;
				if (multipleAttackSupported)
				{
					XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.ClipName + "_right_forward", true, false);
					XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.ClipName + "_right", true, false);
					XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.ClipName + "_right_back", true, false);
					XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.ClipName + "_left_forward", true, false);
					XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.ClipName + "_left", true, false);
					XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.ClipName + "_left_back", true, false);
					XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.ClipName + "_back", true, false);
				}
			}
			bool flag2 = data.Fx != null;
			if (flag2)
			{
				for (int i = 0; i < data.Fx.Count; i++)
				{
					XSingleton<XResourceLoaderMgr>.singleton.CreateInAdvance(data.Fx[i].Fx, count, ECreateHideType.DisableParticleRenderer);
				}
			}
			bool flag3 = data.Hit != null && data.Hit.Count > 0;
			if (flag3)
			{
				XSingleton<XResourceLoaderMgr>.singleton.CreateInAdvance(data.Hit[0].Fx, 1, ECreateHideType.DisableParticleRenderer);
			}
			bool flag4 = data.Warning != null;
			if (flag4)
			{
				for (int j = 0; j < data.Warning.Count; j++)
				{
					XSingleton<XResourceLoaderMgr>.singleton.CreateInAdvance(data.Warning[j].Fx, count, ECreateHideType.DisableParticleRenderer);
				}
			}
			bool flag5 = data.Result != null;
			if (flag5)
			{
				for (int k = 0; k < data.Result.Count; k++)
				{
					bool longAttackEffect = data.Result[k].LongAttackEffect;
					if (longAttackEffect)
					{
						XSingleton<XResourceLoaderMgr>.singleton.CreateInAdvance(data.Result[k].LongAttackData.End_Fx, count, ECreateHideType.DisableParticleRenderer);
						XSingleton<XResourceLoaderMgr>.singleton.CreateInAdvance(data.Result[k].LongAttackData.Prefab, count, ECreateHideType.DisableParticleRenderer);
					}
				}
			}
			bool flag6 = data.CameraMotion != null && !string.IsNullOrEmpty(data.CameraMotion.Motion);
			if (flag6)
			{
				XSingleton<XResourceLoaderMgr>.singleton.GetXAnimation(data.CameraMotion.Motion, true, false);
			}
		}
	}
}