+scripts

1 files changed, 348 insertions, 0 deletions

diff --git a/Client/Assets/Scripts/XUtliPoolLib/XSkillData.cs b/Client/Assets/Scripts/XUtliPoolLib/XSkillData.cs
new file mode 100644
index 00000000..be8deb5e
--- /dev/null
+++ b/Client/Assets/Scripts/XUtliPoolLib/XSkillData.cs
@@ -0,0 +1,348 @@
+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);

+			}

+		}

+	}

+}