// ***********************************************************************
// Assembly         : Game
// Author           : Kimch
// Created          : 2020-09-02
// Description      :
// Last Modified By : 
// Last Modified On : 
// ***********************************************************************
// <copyright file= "Cha_Skill" company="Kimch"></copyright>
// <summary></summary>
// ***********************************************************************

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.ResourceManagement.AsyncOperations;

namespace G
{
	/// <summary>
	/// 角色技能
	/// </summary>
	public class Cha_Skill : MonoBehaviour
	{
		class SkillInfo
		{
			public readonly List<GameObject> prefabs = new List<GameObject>();
			public readonly List<GameObject> instances = new List<GameObject>();

			public GameObject instance => instances[0];
			public GameObject instance2 => instances[1];

			public bool isInit;

			public int repeat;
			public int repeatCount;
			public float repeatDelay;
			public int repeatDamage;
			//public Vector3 repeatPosition;
		}

		#region Field 

		private Transform _mytransform;

		/// <summary>
		/// 
		/// </summary>
		private Transform _chaRHand;

		/// <summary>
		/// 
		/// </summary>
		private float _baseDamage = 1f;
		public float skillatk;

		private int _skillAttack;
		private int _motionKind;

		private int _gSkillAttack;
		private int _gMotionKind;

		/// <summary>
		/// 施法延迟
		/// </summary>
		private float _castingDelay;

		private float _repeatAtk;
		private bool _repeat;
		private int _repeatTime;
		private int _repeatKind;
		private float _repeatDelay;
		/// <summary>
		/// 
		/// </summary>
		private float _currentDelay = 10f;

		private EntityMainPlayer _scriptCha1;
		private int _skillIndex = -1;

		private Ef_rotfog _scriptRotfog;

		private float _ptOffDelay = 10f;

		public Transform swordwind;

		public Transform rapidstab;

		public Transform supersword;

		public Transform energypillar;

		public Transform pt_attackup;

		public Transform pt_defenceup;

		public Transform pt_boom;

		public Transform pt_poison;

		public Transform ef_gather;

		public Transform deathhand;

		public Transform chosun;

		public Transform junwui;

		public Transform jin;

		public Transform ef_rotfog;

		public Transform fincanon;

		public Transform swordrain_b;

		public Transform swordrain_s;

		public Transform swordrain;

		public Transform wing;

		public Transform ef_groundbreak;

		public Transform bombsphere;

		public Transform lightningblade;

		private Transform directionArrow;

		private Transform pt_ki;

		private Transform c_fincanon;

		private Transform c_groundbreak;

		private Transform c_bombsphere;

		private const int MAX_SKILL_COUNT = 40;
		private readonly SkillInfo[] _skillInfos = new SkillInfo[MAX_SKILL_COUNT];
		private Cha_Sound _scriptSound;

		#endregion

		#region Method

		/// <summary>
		/// 
		/// </summary>
		/// <param name="damage"></param>
		public void SetBaseDamage(float damage)
		{
			_baseDamage = damage;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="attack"></param>
		/// <param name="skillAttack"></param>
		/// <param name="motionKind"></param>
		public void SetSkill(int attack, int skillAttack, int motionKind)
		{
			_skillAttack = Mathf.Max(1, skillAttack);
		}

		/// <summary>
		/// 设置
		/// </summary>
		/// <param name="attack"></param>
		/// <param name="skillAttack"></param>
		/// <param name="motionKind"></param>
		public void SetGeneralSkill(int attack, int skillAttack, int motionKind)
		{
			_gSkillAttack = (int)(attack * skillAttack * 0.01f);
			_gSkillAttack = Mathf.Max(1, _gSkillAttack);
			_gMotionKind = motionKind;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="hand"></param>
		public void SetRHand(Transform hand)
		{
			_chaRHand = hand;
		}

		/// <summary>
		/// 角色技能
		/// </summary>
		/// <param name="index"></param>
		/// <param name="general"></param>
		/// <returns></returns>
		public float SkillOn(int index, bool general)
		{
			float result = 10;

			_scriptCha1.SkillStart();
			//pt_ki.particleEmitter().emit = true;
			//_rigidbody.drag = 20f;
			_scriptCha1.drag = 20f;

			_skillIndex = index;
			ef_rotfog.position = _mytransform.position;
			_scriptRotfog.RotfogOn(1.5f, 40f, 800, 150, 0.5f);
			Time.timeScale = 0.1f;
			if (!general)
			{
				//var skillItem = ItemProxy.Instance.GetStaticItem<ItemSkill>(skill_index + 2001);

				//motionkind = skillItem.kind;// script_DBskill.ss[skill_index, 0]._kind;
				//cur_skill_grade[skill_index] = Mathf.Max(0, cur_skill_grade[skill_index]);
				skillatk = _scriptCha1.sourceTotalAttack;//  skillItem.attackpoint;// script_DBskill.ss[skill_index, cur_skill_grade[skill_index]]._attackpoint;

				//result = skillItem.cooltime;// script_DBskill.ss[skill_index, 0]._cooltime;
			}
			else
			{
				_motionKind = _gMotionKind;
				skillatk = _gSkillAttack;
				_skillIndex += 21;
			}

			// 		
			if (_motionKind == 1)
			{
				directionArrow.GetComponent<Renderer>().enabled = true;
				_scriptCha1.PlayAnimation(EntityPlayer.Hash_Cast1);
				//script_cha1.PlayAnim("cast1");
			}
			else if (_motionKind == 2)
			{
				GameCamera.Instance.ZoomIn(20, 16, 0.3f);
				_scriptCha1.PlayAnimation(EntityPlayer.Hash_Cast2);

				if (_skillIndex == 13 || _skillIndex == 15)
				{
					jin.gameObject.SetActive(true);
					jin.position = _mytransform.position + _mytransform.forward * 0.2f + Vector3.up * 0.01f;
				}
				else if (_skillIndex == 19)
				{
					wing.gameObject.SetActive(true);
				}
			}
			else if (_motionKind == 3)
			{
				directionArrow.GetComponent<Renderer>().enabled = true;

				_scriptCha1.PlayAnimation(EntityPlayer.Hash_Cast3);
				if (_skillIndex == 8)
				{
					ef_gather.position = _mytransform.position + Vector3.up * 0.22f;
					ef_gather.gameObject.SetActive(true);
					ef_gather.GetComponent<Ef_energy_gather>().SetTex(0, 1.2f);
				}
				else if (_skillIndex == 9)
				{
					ef_gather.position = _mytransform.position + Vector3.up * 0.22f;
					ef_gather.gameObject.SetActive(true);
					ef_gather.GetComponent<Ef_energy_gather>().SetTex(1, 0.8f);
				}
			}
			else if (_motionKind == 4)
			{
				directionArrow.GetComponent<Renderer>().enabled = true;
				//script_cha1.PlayAnim("cast4");
				_scriptCha1.PlayAnimation(EntityPlayer.Hash_Cast4);
				if (_skillIndex == 16)
				{
					jin.gameObject.SetActive(true);
					jin.position = _mytransform.position + Vector3.up * 0.01f;
					if (c_fincanon == null)
					{
						c_fincanon = Instantiate(fincanon, _mytransform.position, _mytransform.rotation);
						c_fincanon.GetComponent<Rigidbody>().mass = skillatk * _baseDamage * 0.01f;
						c_fincanon.parent = _mytransform;
					}
					else
					{
						c_fincanon.gameObject.SetActive(true);
						c_fincanon.position = _mytransform.position;
						c_fincanon.rotation = _mytransform.rotation;
						c_fincanon.parent = _mytransform;
					}
				}
			}
			return result;
		}

		/// <summary>
		/// 宠物技能
		/// </summary>
		/// <param name="index"></param>
		public void PetSkillOn(int index)
		{
			ef_rotfog.position = _mytransform.position;
			_scriptRotfog.RotfogOn(3f, 4f, 80, 5, 3f);
			GameCamera.Instance.ZoomIn(5, 15, 1f);
			switch (index)
			{
				case 0:
					_scriptCha1.CallHorse();
					break;
				case 1:
					_scriptCha1.Fly();
					break;
			}
		}

		/// <summary>
		/// 延迟技能
		/// </summary>
		/// <param name="index"></param>
		public void DelaySkill(int index)
		{
			if (c_groundbreak == null)
			{
				c_groundbreak = Instantiate(ef_groundbreak, _mytransform.position, Quaternion.identity);
			}
			else
			{
				c_groundbreak.position = _mytransform.position;
				c_groundbreak.gameObject.SetActive(true);
			}

			int damage = _scriptCha1.sourceTotalAttack;
			c_groundbreak.GetComponent<Rigidbody>().mass = damage;
			switch (index)
			{
				case 2:
					c_groundbreak.localScale = Vector3.one * 0.5f;
					GameCamera.Instance.Hitcam2(2f);
					break;
				case 19:
					c_groundbreak.localScale = Vector3.one * 1f;
					GameCamera.Instance.Hitcam2(4f);
					Time.timeScale = 0.6f;
					StartCoroutine(ResetTimeScale());
					c_bombsphere = Object.Instantiate(bombsphere, _mytransform.position, Quaternion.identity);
					Object.Destroy(c_bombsphere.gameObject, 1.2f);
					break;
			}
		}

		/// <summary>
		/// 重复技能
		/// </summary>
		/// <param name="kind"></param>
		/// <param name="count"></param>
		/// <param name="delay"></param>
		/// <param name="next"></param>
		public void Repeatskill(int kind, int count, float delay, bool next = false)
		{
			_repeat = true;
			_repeatKind = kind;
			_repeatTime = count;
			_repeatDelay = delay;
			_currentDelay = _repeatDelay;

			if (next)
				return;

			switch (_repeatKind)
			{
				case 8:
					{
						Vector3 rndPos = transform.position + Random.onUnitSphere * Random.Range(0.3f, 0.6f);
						rndPos.y = 0f;
						if (!TryNewOrGetSkillInfo(_repeatKind, out var skillInfo) && _repeatTime > 0)
						{
							int instance_index = Mathf.Max(1, _repeatTime);
							skillInfo.instances[instance_index].transform.SetPositionAndRotation(rndPos + Vector3.up * 0.05f, _mytransform.rotation);
							skillInfo.instances[instance_index].GetComponent<SkillBase>().damage = Mathf.Max(1, skillInfo.repeatDamage);
							skillInfo.instances[instance_index].SetActive(true);
						}
					}
					break;
				case 11:
					{
						var rndpos = _mytransform.position + _mytransform.forward * 0.3f + _mytransform.right * Random.Range(-0.2f, 0.2f);
						rndpos.y = 0.01f;
						var skillInfo = _skillInfos[10];
						skillInfo.instance.transform.position = rndpos;
						skillInfo.instance.GetComponent<Rigidbody>().mass = _repeatAtk;
						GameCamera.Instance.Hitcam2(1.5f);
					}
					break;
				case 17:
					{
						Vector3 rndPos;
						if (_scriptCha1.targetEnemy)
							rndPos = _scriptCha1.targetEnemy.position;
						else
							rndPos = transform.position + Random.onUnitSphere * Random.Range(0.2f, 0.35f);
						rndPos.y = -1f;

						if (!TryNewOrGetSkillInfo(17, out var skillInfo) && _repeatTime > 0)
						{
							int instance_index = Mathf.Max(0, 5 - _repeatTime);
							skillInfo.instances[instance_index].GetComponent<Rigidbody>().mass = skillInfo.repeatDamage;
							skillInfo.instances[instance_index].transform.position = rndPos;
							skillInfo.instances[instance_index].SetActive(true);
							GameCamera.Instance.Hitcam2(1.2f);
						}
					}
					break;
				case 25:
					{
						float num = (3 - _repeatTime) * 45;
						Vector3 eulerAngles = _mytransform.eulerAngles;
						var tempradian = (num - eulerAngles.y + 90f) * 0.01745f;
						var rndpos = _mytransform.position + 0.3f * Vector3.right * Mathf.Cos(tempradian) + 0.3f * Vector3.forward * Mathf.Sin(tempradian);
						rndpos.y = -1f;

						var skillInfo = _skillInfos[10];
						skillInfo.instances[_repeatTime + 1].GetComponent<Rigidbody>().mass = _repeatAtk;
						skillInfo.instances[_repeatTime + 1].transform.localScale = Vector3.one + Vector3.up * Random.Range(-0.1f, 0.5f);
						skillInfo.instances[_repeatTime + 1].transform.localScale *= Random.Range(0.7f, 1.2f);
						skillInfo.instances[_repeatTime + 1].transform.position = rndpos;
						skillInfo.instances[_repeatTime + 1].gameObject.SetActive(true);
						break;
					}
				case 29:
					{
						var rndpos = _mytransform.position + _mytransform.forward * (0.1f + 0.14f * (6 - _repeatTime)) + _mytransform.right * Random.Range(-0.1f, 0.1f);
						rndpos.y = -1f;
						var skillInfo = _skillInfos[28];

						skillInfo.instances[_repeatTime + 1].GetComponent<Rigidbody>().mass = _repeatAtk;
						skillInfo.instances[_repeatTime + 1].transform.position = rndpos;
						skillInfo.instances[_repeatTime + 1].gameObject.SetActive(true);
					}
					break;
				case 31:
					{
						var skillInfo = _skillInfos[30];
						skillInfo.instance.GetComponent<Rigidbody>().mass = _repeatAtk;
						skillInfo.instance.transform.position = _mytransform.position;
						skillInfo.instance.transform.rotation = Quaternion.Euler(0f, _repeatTime * 60, 0f);
						skillInfo.instance.SetActive(true);
					}
					break;
			}
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="index"></param>
		/// <param name="args"></param>
		public void FireSkill(int index, int[] args)
		{
			_scriptCha1.SkillStart();
			_scriptSound.PlaySound("bt_jin");

			pt_ki.particleEmitter().emit = false;

			int damage = _scriptCha1.sourceTotalAttack * args[2] / 100 + args[1];

			switch (index)
			{
				case 1:
					Sk_1_();
					break;
				case 2:
					Sk_2_wheelwind(damage, args);
					break;
				case 3:
					Sk_3_();
					break;
				case 4:
					Sk_4_(damage);
					break;
				case 5:
					Sk_05_(damage);
					break;
				case 6:
					Sk_06_Async(damage, args);
					break;
				case 7:
					Sk_07_(damage);
					break;
				case 8:
					Sk_08_Async(damage, args);
					//Sk_08_(damage);
					break;
				case 9:
					Sk_09_(damage);
					break;
				case 10:
					Sk_10_(damage);
					break;
				case 11:
					Sk_11_(damage, args);
					break;
				case 12:
					Sk_12_Async(damage, args);
					break;
				case 13:
					Sk_13_Async(damage, args);
					break;
				case 14:
					Sk_14_Async(damage, args);
					break;
				case 15:
					Sk_15_(damage, args);
					break;
				case 16:
					Sk_16_(damage, args);
					break;
				case 17:
					Sk_17_Async(damage, args);
					break;
				case 18:
					Sk_18_(damage, args);
					break;
				case 19:
					Sk_19_(damage, args);
					break;
				case 20:
					Sk_20_Async(damage, args);
					break;
				case 21:
					Sk_21_Feilong_Async(damage, args[6], args[8]);
					break;
				case 22:
					Sk_22_(damage, args);
					break;
				case 23:
					Sk_23_(damage, args);
					break;
				case 24:
					Sk_24_(damage, args);
					break;
				case 25:
					Sk_25_(damage, args);
					break;
				case 26:
					Sk_26_(damage, args);
					break;
				case 27:
					Sk_27_(damage, args);
					break;
				case 28:
					Sk_28_(damage, args);
					break;
				case 29:
					Sk_29_(damage, args);
					break;
				case 30:
					Sk_30_(damage, args);
					break;
				case 31:
					Sk_31_(damage, args);
					break;
				case 32:
					Sk_32_(damage, args);
					break;
				case 33:
					Sk_33_(damage, args);
					break;
				case 34:
					Sk_34_(damage, args);
					break;
				case 35:
					Sk_35_(damage, args);
					break;
				case 36:
					Sk_36_(damage, args);
					break;
				case 37:
					Sk_37_(damage, args);
					break;
				case 38:
					Sk_38_(damage, args);
					break;
				case 39:
					Sk_39_(damage, args);
					break;
				case 40:
					Sk_40_(damage, args);
					break;
			}
			_skillIndex = -1;

			GameLevel.Instance.OnSkill(index);
			MissionProxy.Instance.OnEvent(MissionProxy.使用指定技能, 1, index);
		}

		public IEnumerator Pt_Off(Transform _pt)
		{
			yield return new WaitForSeconds(_ptOffDelay);
			//_pt.particleEmitter().emit = false;
		}

		public void BoomOn(int index, bool collider)
		{
			pt_boom.GetComponent<Ef_boom>().SetTex(index, _mytransform.position, collider);
		}

		public IEnumerator ResetTimeScale()
		{
			yield return new WaitForSeconds(0.5f);
			Time.timeScale = 1f;
			BoomOn(0, false);
		}

		public IEnumerator BambooFin()
		{
			yield return new WaitForSeconds(3.5f);
			//c_crow.particleEmitter().emit = false;
			//c_bamboobase.particleEmitter().emit = false;
		}

		/// <summary>
		/// 
		/// </summary>
		private void Sk_AttackUp()
		{
			//pt_attackup.particleEmitter().emit = false;
			_scriptCha1.ResetAtk();
		}

		/// <summary>
		/// 
		/// </summary>
		private void Sk_DefenceUp()
		{
			var skillInfo = _skillInfos[2];
			skillInfo.instance.SetActive(false);
			_scriptCha1.ResetDef();
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public IEnumerator Sk_SwordDance()
		{
			yield return new WaitForSeconds(0.5f);
			_scriptCha1.StopAnimation();
			//AnimationState comein = script_cha1.PlayAnimQueued("change_in_atk");
			//comein.speed = 0.5f;
			//_scriptCha1.PlayAnimation("change_in_atk");
			_scriptCha1.entityView.Appear();
			_scriptCha1.StartControl();
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public IEnumerator Sk_Mirage()
		{
			yield return new WaitForSeconds(1f);
			_scriptCha1.entityView.Appear();
			_scriptCha1.StartControl();
			_scriptCha1.PlayAnimation("attackex2_impact");
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="kind"></param>
		/// <param name="skillInfo"></param>
		/// <returns>is New</returns>
		private bool TryNewOrGetSkillInfo(int kind, out SkillInfo skillInfo)
		{
			int index = kind - 1;
			skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;
				return true;
			}
			return false;
		}

		private void Sk_1_()
		{
			_scriptCha1.PlayAnimation("jumpattack_air");
			//AnimationState animationState = script_cha1.PlayAnimQueued("jumpattack_impact");
			//animationState.speed = 0.25f;	
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="damage"></param>
		private async void Sk_2_wheelwind(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation(EntityPlayer.Hash_WheelWind);
			int index = 1;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;
				var wheelwind = await LoadAssetAsync("sk_wheelwind").Task;
				var instance = Instantiate(wheelwind, _mytransform);
				instance.transform.localPosition = Vector3.zero;
				skillInfo.instances.Add(instance);
			}
			if (args.Length > 9 && args[8] > 0)
				skillInfo.instance.GetComponent<SkillWheelwind>().SetTornado(args[8], args[9]);

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
		}

		private void Sk_3_()
		{
			_scriptCha1.PlayAnimation(EntityPlayer.Hash_Skill03);

			int index = 2;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var instance = Instantiate(pt_defenceup, _mytransform.position, Quaternion.identity);
				skillInfo.instances.Add(instance.gameObject);
			}
			else
			{
				CancelInvoke(nameof(Sk_DefenceUp));
			}
			pt_boom.GetComponent<Ef_boom>().SetTex(1, _mytransform.position, true);
			_scriptCha1.DefenceUp(100, 0);
			Invoke(nameof(Sk_DefenceUp), skillatk);
		}

		private void Sk_4_(int damage)
		{
			_scriptCha1.PlayAnimation("rapidstab");
			int index = 3;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var instance = Instantiate(rapidstab, _mytransform.position + _mytransform.forward * 0.25f + Vector3.up * 0.04f, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
			skillInfo.instance.transform.position = _mytransform.position + _mytransform.forward * 0.25f + Vector3.up * 0.04f;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
		}

		private void Sk_05_(int damage)
		{
			//script_cha1.SetAnimSpeed("attackex3", 0.35f);
			_scriptCha1.PlayAnimation("attackex3");
			//temp = script_cha1.PlayAnimQueued("attackex3_impact");
			//temp.speed = 0.25f;
			int index = 4;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var instance = Instantiate(lightningblade, _mytransform.position + Vector3.up * 0.05f, _mytransform.rotation);
				instance.parent = _mytransform;
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
		}

		/// <summary>
		/// 幽灵剑
		/// </summary>
		/// <param name="damage"></param>
		/// <param name="args"></param>
		private async void Sk_06_Async(int damage, int[] args)
		{
			//script_cha1.PlayAnimation("skill03");
			int index = 5;

			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var prefab = await LoadAssetAsync("sk_spiritsword").Task;

				var instance = Instantiate(prefab);
				skillInfo.instances.Add(instance.gameObject);
			}

			var sword1 = skillInfo.instance.GetComponent<SkillSpiritSword>();
			sword1.Reset();
			sword1.swordCount = args[6];
			sword1.power = damage;

			skillInfo.instance.transform.SetPositionAndRotation(_mytransform.position + Vector3.up * 0.2f, _mytransform.rotation);
			skillInfo.instance.SetActive(true);
		}

		private void Sk_07_(int damage)
		{
			_scriptCha1.PlayAnimation("skill03");
			//ParticleEmitter particleEmitter = pt_attackup.particleEmitter();
			//if (!particleEmitter.emit)
			//{
			//	particleEmitter.emit = true;
			//}
			//else
			//{
			//	CancelInvoke(nameof(Sk_AttackUp));
			//}
			pt_boom.GetComponent<Ef_boom>().SetTex(0, _mytransform.position, true);
			_scriptCha1.AttackUp(0, 150);
			Invoke(nameof(Sk_AttackUp), skillatk);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="damage"></param>
		private void Sk_08_(int damage)
		{
			_scriptCha1.PlayAnimation("skill02");

			ef_gather.position = _mytransform.position + Vector3.up * 0.22f;
			ef_gather.gameObject.SetActive(true);
			ef_gather.GetComponent<Ef_energy_gather>().SetTex(0, 1.2f);

			int index = 7;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var instance = Instantiate(pt_poison, _mytransform.position + Vector3.up * 0.22f, Quaternion.identity);
				instance.parent = _mytransform;
				skillInfo.instances.Add(instance.gameObject);
			}
			skillInfo.instance.GetComponent<Rigidbody>().mass = Mathf.Max(1, damage);
		}

		/// <summary>
		/// 如来神掌
		/// </summary>
		/// <param name="damage"></param>
		private async void Sk_08_Async(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation(EntityPlayer.Hash_Skill02);
			const int MAX_RLSZ_AMOUNT = 10;
			if (TryNewOrGetSkillInfo(8, out SkillInfo skillInfo))
			{
				var prefab = await LoadAssetAsync("sk_rlsz").Task;
				var instance = Instantiate(prefab);
				skillInfo.instances.Add(instance);

				for (int i = 0; i < MAX_RLSZ_AMOUNT; i++)
				{
					instance = Instantiate(prefab);
					instance.transform.localScale = Vector3.one * (0.6f - i * 0.03f);
					skillInfo.instances.Add(instance);
				}
			}

			if (_scriptCha1.targetEnemy)
			{
				var targetPos = _scriptCha1.targetEnemy.position;
				var forward = (targetPos - _mytransform.position).normalized;
				skillInfo.instance.transform.SetPositionAndRotation(targetPos + Vector3.up * 0.05f, Quaternion.LookRotation(forward));
			}
			else
			{
				skillInfo.instance.transform.SetPositionAndRotation(_mytransform.position + Vector3.up * 0.05f, _mytransform.rotation);
			}
			skillInfo.instance.GetComponent<SkillBase>().damage = Mathf.Max(1, damage);
			skillInfo.instance.SetActive(true);

			int amoutIndex = (int)Cha_Moves.ArgIndex.Amount;
			if (args != null && args.Length > amoutIndex)
			{
				int count = Mathf.Min(MAX_RLSZ_AMOUNT, args[amoutIndex]);
				if (count > 0)
				{
					skillInfo.repeatDamage = damage;
					skillInfo.repeatCount = count;
					skillInfo.repeatDelay = 1f;
					Repeatskill(8, count, 0.3f, true);
				}
			}
		}

		private void Sk_09_(int damage)
		{
			_scriptCha1.PlayAnimation("skill04");
			ef_gather.position = _mytransform.position + Vector3.up * 0.22f;
			ef_gather.gameObject.SetActive(true);
			ef_gather.GetComponent<Ef_energy_gather>().SetTex(1, 0.8f);

			int index = 8;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var instance = Instantiate(deathhand, _mytransform.position + Vector3.up * 0.05f, _mytransform.rotation);
				instance.parent = _mytransform;
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
		}

		private void Sk_10_(int damage)
		{
			_scriptCha1.PlayAnimation("skill_chargesmash");
			int index = 9;
			var skillInfo = _skillInfos[index];

			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var instance = Instantiate(supersword, _chaRHand.position, _chaRHand.rotation);
				instance.up = _chaRHand.forward;
				instance.parent = _chaRHand;
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
		}

		private void Sk_11_(int damage, int[] args)
		{
			_scriptCha1.Invincibility(5f);
			_scriptCha1.PlayAnimation("skill03");
			_repeatAtk = damage;

			int index = 10;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var instance = Object.Instantiate(energypillar);
				skillInfo.instances.Add(instance.gameObject);
			}

			Repeatskill(11, 5, 0.8f);
		}

		/// <summary>
		/// 独孤九剑
		/// </summary>
		/// <param name="damage"></param>
		/// <param name="args"></param>
		private async void Sk_12_Async(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill01");

			if (TryNewOrGetSkillInfo(12, out SkillInfo skillInfo))
			{
				var sworddance = await LoadAssetAsync("sk_sworddance").Task;
				var instance = Instantiate(sworddance);
				skillInfo.instances.Add(instance.gameObject);
				//sworddance = await LoadAssetAsync("sk_sworddance2").Task;
				//instance = Instantiate(sworddance);
				//skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<SkillBase>().damage = damage;
			skillInfo.instance.transform.SetPositionAndRotation(_mytransform.position + Vector3.up * 0.05f, Quaternion.LookRotation(-_mytransform.forward + _mytransform.right));
			skillInfo.instance.SetActive(true);
			if (args != null && args.Length > (int)Cha_Moves.ArgIndex.Special1 && args[(int)Cha_Moves.ArgIndex.Special1] > 0)
				skillInfo.instance.GetComponent<SkillBase>().special1 = args[(int)Cha_Moves.ArgIndex.Special1];
			//if (args[7] == 0)
			//{
			//	skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			//	skillInfo.instance.transform.SetPositionAndRotation(_mytransform.position + Vector3.up * 0.05f, Quaternion.LookRotation(-_mytransform.forward + _mytransform.right));
			//	skillInfo.instance.SetActive(true);
			//}
			//else
			//{
			//	skillInfo.instance2.GetComponent<Rigidbody>().mass = damage;
			//	skillInfo.instance2.transform.SetPositionAndRotation(_mytransform.position + Vector3.up * 0.05f, Quaternion.LookRotation(-_mytransform.forward + _mytransform.right));
			//	skillInfo.instance2.SetActive(true);
			//}
			_scriptCha1.entityView.Disappear();
			_scriptCha1.StopControl();
			StartCoroutine(Sk_SwordDance());
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="damage"></param>
		/// <param name="args"></param>
		private async void Sk_13_Async(int damage, int[] args)
		{
			if (TryNewOrGetSkillInfo(13, out SkillInfo skillInfo))
			{
				var skillAsset = await LoadAssetAsync("sk_machine").Task;
				for (int i = 0; i < 2; i++)
				{
					var instance = Instantiate(skillAsset);
					instance.SetActive(false);
					skillInfo.instances.Add(instance);
				}
			}

			//_scriptCha1.PlayAnimation("skill03");
			_scriptCha1.Invincibility(0.5f);

			if (args.Length >= 7)
			{
				int count = args[6];
				float life = args[7] * 0.001f;
				for (int i = 0; i < count; i++)
				{
					skillInfo.instances[i].SetActive(true);
					//skillInfo.instances[i].GetComponent<SkillGuard>().SetDamage(damage);
					//skillInfo.instances[i].GetComponent<SkillGuard>().lifeTime = life;
					skillInfo.instances[i].transform.position = transform.TransformPoint(Vector3.forward * 0.2f);
					skillInfo.instances[i].transform.rotation = transform.rotation;
				}
			}

			//if (TryNewOrGetSkillInfo(13, out SkillInfo skillInfo))
			//{
			//	var skillAsset = await LoadAssetAsync("sk_guard").Task;
			//	for (int i = 0; i < 2; i++)
			//	{
			//		var instance = Instantiate(skillAsset);
			//		instance.SetActive(false);
			//		skillInfo.instances.Add(instance);
			//	}
			//}

			//_scriptCha1.PlayAnimation("skill03");
			//_scriptCha1.Invincibility(1f);

			//if (args.Length >= 7)
			//{
			//	int count = args[6];
			//	float life = args[7] * 0.001f;
			//	for (int i = 0; i < count; i++)
			//	{
			//		skillInfo.instances[i].SetActive(true);
			//		skillInfo.instances[i].GetComponent<SkillGuard>().SetDamage(damage);
			//		skillInfo.instances[i].GetComponent<SkillGuard>().lifeTime = life;
			//		skillInfo.instances[i].transform.position = transform.TransformPoint(Vector3.forward * 0.2f);
			//		skillInfo.instances[i].transform.rotation = transform.rotation;
			//	}
			//} 
			//jin.gameObject.SetActive(true);
			//jin.position = _mytransform.position + _mytransform.forward * 0.2f + Vector3.up * 0.01f;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="damage"></param>
		/// <param name="args"></param>
		private async void Sk_14_Async(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill04");
			_scriptCha1.Invincibility(2f);

			if (TryNewOrGetSkillInfo(14, out SkillInfo skillInfo))
			{
				var dragonhead = await LoadAssetAsync("sk_dragonhead").Task;
				var instance = Instantiate(dragonhead, _mytransform.position - _mytransform.forward * 0.2f, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<AllyDamage>().physicsDamage = damage;
			skillInfo.instance.SetActive(true);

			//有目标
			if (_scriptCha1.targetEnemy)
			{
				var targetPos = _scriptCha1.targetEnemy.position;
				var forward = (targetPos - _mytransform.position).normalized;
				skillInfo.instance.transform.SetPositionAndRotation(targetPos - forward * 0.4f, Quaternion.LookRotation(forward));
			}
			else
			{
				var targetPos = _mytransform.TransformPoint(-Vector3.forward * 0.2f);
				skillInfo.instance.transform.SetPositionAndRotation(targetPos, _mytransform.rotation);
			}
		}

		private void Sk_15_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");
			_scriptCha1.Invincibility(4f);

			int index = 14;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;
				var instance = Instantiate(chosun, _mytransform.position + _mytransform.forward * 0.2f, chosun.localRotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = skillatk * _baseDamage * 0.01f;
			skillInfo.instance.SetActive(false);
			skillInfo.instance.SetActive(true);
			skillInfo.instance.transform.position = _mytransform.position + _mytransform.forward * 0.2f;
			skillInfo.instance.transform.rotation = chosun.localRotation;

			GameCamera.Instance.LookTarget(skillInfo.instance.transform, 28, 0.5f);

			jin.gameObject.SetActive(true);
			jin.position = _mytransform.position + _mytransform.forward * 0.2f + Vector3.up * 0.01f;

		}

		private void Sk_16_(int damage, int[] args)
		{
			jin.gameObject.SetActive(true);
			jin.position = _mytransform.position + Vector3.up * 0.01f;
			if (c_fincanon == null)
			{
				c_fincanon = Instantiate(fincanon, _mytransform.position, _mytransform.rotation);
				c_fincanon.GetComponent<Rigidbody>().mass = skillatk * _baseDamage * 0.01f;
				c_fincanon.parent = _mytransform;
			}
			else
			{
				c_fincanon.gameObject.SetActive(true);
				c_fincanon.position = _mytransform.position;
				c_fincanon.rotation = _mytransform.rotation;
				c_fincanon.parent = _mytransform;
			}

			_scriptCha1.PlayAnimation("skill03");
			//temp = script_cha1.PlayAnimQueued("skill03");
			//temp.speed = 0.2f;
		}

		/// <summary>
		/// 竹子
		/// </summary>
		/// <param name="damage"></param>
		/// <param name="args"></param>
		private async void Sk_17_Async(int damage, int[] args)
		{
			const int MAX_COUNT = 5;
			if (TryNewOrGetSkillInfo(17, out SkillInfo skillInfo))
			{
				var bamboo = await LoadAssetAsync("sk_bamboo").Task;
				for (int i = 0; i < MAX_COUNT; i++)
				{
					var instance = Object.Instantiate(bamboo);
					instance.SetActive(false);
					skillInfo.instances.Add(instance);
				}
			}

			_scriptCha1.PlayAnimation("skill03");

			StartCoroutine(BambooFin());

			if (args.Length >= 7)
			{
				int count = Mathf.Min(MAX_COUNT, args[6]);
				skillInfo.repeatDamage = damage;
				skillInfo.repeatCount = count;
				skillInfo.repeatDelay = 1f;
				Repeatskill(17, count, 1f);
			}
			else
			{
				Repeatskill(17, 1, 1f);
			}
		}

		private void Sk_18_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");

			int index = 17;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var instance = Instantiate(swordrain_s, _mytransform.position, Quaternion.identity);
				skillInfo.instances.Add(instance.gameObject);
				var instance2 = Instantiate(swordrain, _mytransform.position + Vector3.up * 1f, _mytransform.rotation);
				skillInfo.instances.Add(instance2.gameObject);
				var instance3 = Instantiate(swordrain_b, _mytransform.position + Vector3.up * -0.1f, _mytransform.rotation);
				skillInfo.instances.Add(instance3.gameObject);
			}

			skillInfo.instances[0].SetActive(true);
			skillInfo.instances[0].transform.position = _mytransform.position;
			skillInfo.instances[1].SetActive(true);
			skillInfo.instances[1].transform.position = _mytransform.position + Vector3.up * 1f;
			skillInfo.instances[1].transform.rotation = _mytransform.rotation;
			skillInfo.instances[2].SetActive(true);
			skillInfo.instances[2].transform.position = _mytransform.position + Vector3.up * -0.1f;
			skillInfo.instances[2].transform.rotation = _mytransform.rotation;
			skillInfo.instances[2].GetComponent<Rigidbody>().mass = skillatk * _baseDamage * 0.01f;
		}

		private void Sk_19_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("wing");
			//temp = script_cha1.PlayAnimQueued("wing_i");
			//temp.speed = 0.2f;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="damage"></param>
		/// <param name="args"></param>
		private async void Sk_20_Async(int damage, int[] args)
		{
			//script_cha1.PlayAnimation(EntityMainPlayer.Hash_Skill01);
			int index = 19;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;
				var prefab = await LoadAssetAsync("sk_swordwind").Task;
				for (int i = 0; i < 4; i++)
				{
					var instance = Instantiate(prefab);
					instance.SetActive(false);
					skillInfo.instances.Add(instance);
				}
			}

			for (int i = 0; i < 4; i++)
			{
				var instance = skillInfo.instances[i];
				if (!instance.activeSelf)
				{
					instance.GetComponent<Rigidbody>().mass = damage;
					instance.transform.SetPositionAndRotation(_mytransform.position, _mytransform.rotation);
					instance.SetActive(true);
					break;
				}
			}
		}

		/// <summary>
		/// 飞龙
		/// </summary>
		/// <param name="swordCount"></param>
		/// <param name="damage"></param>
		private async void Sk_21_Feilong_Async(int damage, int swordCount, int swordType)
		{
			int index = 21 - 1;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				var prefab = await LoadAssetAsync("general_spiritsword").Task;
				for (int i = 0; i < 6; i++)
				{
					var instance = Instantiate(prefab);
					instance.SetActive(false);
					skillInfo.instances.Add(instance.gameObject);
				}
				skillInfo.isInit = true;
				_skillInfos[index] = skillInfo;
			}

			for (int i = 0; i < skillInfo.instances.Count; i++)
			{
				var go = skillInfo.instances[i];
				if (!go.activeSelf)
				{
					var sword2 = go.GetComponent<SpiritSword2>();
					sword2.power = damage;
					sword2.swordCount += swordCount;
					sword2.maxHitCount = 12;
					go.transform.position = _mytransform.position + Vector3.up * 0.2f;
					go.transform.rotation = Quaternion.Euler(0f, GlobalUtils.RndAngle, 0f);
					go.SetActive(true);

					swordCount--;
					if (swordCount <= 0)
					{
						break;
					}
				}
			}

			if (swordType != 0)
				Sk_14_Async(damage, null);
		}

		private async void Sk_22_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill_chargesmash");
			int index = 21;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;
				var load_skobj = await LoadAssetAsync("general_spinaxe").Task;
				var instance = Instantiate(load_skobj.transform, _chaRHand.position + _chaRHand.forward * 0.2f, _chaRHand.rotation);
				instance.parent = _chaRHand;

				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
			//skillInfo.instance.transform.GetChild(0).particleEmitter().emit = true;

			_ptOffDelay = 2.5f;
			StartCoroutine(Pt_Off(skillInfo.instance.transform.GetChild(0)));
		}

		private async void Sk_23_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");

			int index = 22;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_fly").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + Vector3.up * 0.1f, Quaternion.identity);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.transform.position = _mytransform.position + Vector3.up * 0.1f;
			skillInfo.instance.SetActive(true);
		}

		private async void Sk_24_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");

			int index = 23;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_sister").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = skillatk;
			skillInfo.instance.transform.position = _mytransform.position;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
			skillInfo.instance.SetActive(true);
		}

		private async void Sk_25_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");

			int index = 24;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				GameObject gameObject = await LoadAssetAsync("general_icebg").Task;
				var instance = Object.Instantiate(gameObject.transform, _mytransform.position + _mytransform.forward * 0.15f + Vector3.up * 0.01f, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);

				var load_skobj = await LoadAssetAsync("general_ice_spear").Task;
				skillInfo.prefabs.Add(load_skobj);

				for (int i = 0; i < 5; i++)
				{
					instance = Object.Instantiate(load_skobj.transform, Vector3.zero, Quaternion.Euler(0f, Random.Range(0, 360), 0f));
					skillInfo.instances.Add(instance.gameObject);
				}
			}

			//skillInfo.instance.transform.particleEmitter().emit = true;
			skillInfo.instance.transform.position = _mytransform.position + _mytransform.forward * 0.15f + Vector3.up * 0.01f;
			skillInfo.instance.transform.rotation = _mytransform.rotation;

			_repeatAtk = skillatk;
			_ptOffDelay = 6f;
			StartCoroutine(Pt_Off(skillInfo.instance.transform));
			Repeatskill(_skillIndex, 5, 0.12f);
		}

		private async void Sk_26_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");

			int index = 25;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_sworddance").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position, Quaternion.identity);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.transform.position = _mytransform.position;
			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
		}

		private async void Sk_27_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation(EntityPlayer.Hash_WheelWind);

			int index = 26;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_axedance").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.transform.position = _mytransform.position;
			skillInfo.instance.SetActive(true);
		}

		private async void Sk_28_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill04");

			int index = 27;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_arrowrain").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + Vector3.up * 1f - _mytransform.forward * 0.7f, _mytransform.rotation);
				instance.parent = _mytransform;
				skillInfo.instances.Add(instance.gameObject);

				load_skobj = await LoadAssetAsync("general_arrowrain_base").Task;
				instance = Object.Instantiate(load_skobj.transform, _mytransform.position + Vector3.up * -0.03f + _mytransform.forward * 0.35f, _mytransform.rotation);
				instance.parent = _mytransform;
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instances[0].SetActive(true);
			skillInfo.instances[0].transform.position = _mytransform.position + Vector3.up * 1f - _mytransform.forward * 0.7f;
			skillInfo.instances[0].transform.rotation = _mytransform.rotation;

			skillInfo.instances[1].GetComponent<Rigidbody>().mass = damage;
			skillInfo.instances[1].SetActive(true);
			skillInfo.instances[1].transform.position = _mytransform.position + Vector3.up * -0.03f + _mytransform.forward * 0.35f;
			skillInfo.instances[1].transform.rotation = _mytransform.rotation;
		}

		private async void Sk_29_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");

			int index = 28;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_risespear").Task;
				for (int i = 0; i < 7; i++)
				{
					var instance = Object.Instantiate(load_skobj.transform, _mytransform.position, _mytransform.rotation);
					skillInfo.instances.Add(instance.gameObject);
				}
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			_repeatAtk = skillatk;
			Repeatskill(_skillIndex, 6, 0.1f);
		}

		private async void Sk_30_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill02");

			int index = 29;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_meteo").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + Vector3.up * 4.2f - _mytransform.forward * 5.5f, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.transform.position = _mytransform.position + Vector3.up * 4.2f - _mytransform.forward * 5.5f;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
			skillInfo.instance.gameObject.SetActive(true);
		}

		private async void Sk_31_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");

			int index = 30;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_mirage").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + Vector3.up * 4.2f - _mytransform.forward * 5.5f, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;

			_repeatAtk = damage;
			Repeatskill(31, 6, 0.05f);
			StartCoroutine(Sk_Mirage());
			_scriptCha1.entityView.Disappear();
			_scriptCha1.StopControl();
		}

		private async void Sk_32_(int damage, int[] args)
		{
			//script_cha1.PlayAnim("dodge");
			//temp = script_cha1.PlayAnimQueued("attackex2");
			//temp.speed = 0.28f;
			//temp.layer = 2;
			//temp = script_cha1.PlayAnimQueued("attackex2_impact");
			//temp.speed = 0.25f;
			//temp.layer = 2;
			_scriptCha1.AddForwardForce(180f);

			int index = 31;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_edge_wheel").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + Vector3.up * 0.1f + _mytransform.forward * 0.2f, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.transform.position = _mytransform.position + Vector3.up * 0.1f + _mytransform.forward * 0.2f;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
			skillInfo.instance.SetActive(true);
		}

		private async void Sk_33_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill04");

			int index = 32;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_swamp").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + Vector3.up * 0.01f + _mytransform.forward * 0.5f, Quaternion.identity);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.transform.position = _mytransform.position + Vector3.up * 0.01f + _mytransform.forward * 0.5f;
			skillInfo.instance.SetActive(true);
		}

		private async void Sk_34_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill04");

			int index = 33;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_multispear").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + Vector3.up * 0.1f, _mytransform.rotation);

				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.transform.position = _mytransform.position + Vector3.up * 0.1f;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
			skillInfo.instance.SetActive(true);
		}

		private async void Sk_35_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");

			int index = 34;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_fincanon").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position, _mytransform.rotation);
				instance.parent = _mytransform;

				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = skillatk;
			skillInfo.instance.SetActive(true);
			skillInfo.instance.transform.position = _mytransform.position;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
			skillInfo.instance.transform.parent = _mytransform;

			this.GetComponent<Collider>().enabled = false;
			_scriptCha1.Invincibility(3f);

		}
		private async void Sk_36_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation(EntityPlayer.Hash_WheelWind);

			int index = 35;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_flowerfan").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + Vector3.up * 0.1f, _mytransform.rotation);

				skillInfo.instances.Add(instance.gameObject);
			}
			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.transform.position = _mytransform.position + Vector3.up * 0.1f;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
			skillInfo.instance.SetActive(true);
		}

		private async void Sk_37_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");

			int index = 36;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_chain").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position - Vector3.up * 0.1f, Quaternion.identity);

				skillInfo.instances.Add(instance.gameObject);
			}
			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
			skillInfo.instance.transform.position = _mytransform.position - Vector3.up * 0.1f;
		}

		private async void Sk_38_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill03");
			int index = 37;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_arrow_poison").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + _mytransform.forward * 0.05f + Vector3.up * 0.07f, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
			skillInfo.instance.transform.position = _mytransform.position + _mytransform.forward * 0.1f + Vector3.up * 0.07f;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
		}

		private async void Sk_39_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("rapidstab");
			int index = 38;

			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_rapidthrust").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + _mytransform.forward * 0.15f + Vector3.up * 0.05f, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}
			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
			skillInfo.instance.transform.position = _mytransform.position + _mytransform.forward * 0.15f + Vector3.up * 0.05f;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
		}

		private async void Sk_40_(int damage, int[] args)
		{
			_scriptCha1.PlayAnimation("skill04");

			int index = 39;
			var skillInfo = _skillInfos[index];
			if (skillInfo == null)
			{
				skillInfo = new SkillInfo();
				_skillInfos[index] = skillInfo;

				var load_skobj = await LoadAssetAsync("general_elec_shock").Task;
				var instance = Object.Instantiate(load_skobj.transform, _mytransform.position + _mytransform.forward * 0.22f + Vector3.up * 0.06f, _mytransform.rotation);
				skillInfo.instances.Add(instance.gameObject);
			}

			skillInfo.instance.GetComponent<Rigidbody>().mass = damage;
			skillInfo.instance.SetActive(true);
			skillInfo.instance.transform.position = _mytransform.position + _mytransform.forward * 0.22f + Vector3.up * 0.06f;
			skillInfo.instance.transform.rotation = _mytransform.rotation;
		}

		private void UpdateSkill()
		{
			if (_skillIndex != -1)
			{
				_castingDelay += Time.unscaledDeltaTime;
				if (_castingDelay > 1f)
				{
					_scriptCha1.drag = 10f;

					Time.timeScale = 1f;
					//script_cha1.StopAnim();
					//FireSkill(_skillIndex);
					_castingDelay = 0f;
					directionArrow.GetComponent<Renderer>().enabled = false;
				}
			}

			if (!_repeat || _currentDelay <= 0f)
			{
				return;
			}

			_currentDelay -= Time.unscaledDeltaTime;
			if (_currentDelay <= 0f)
			{
				_repeatTime--;
				if (_repeatTime > 0)
				{
					Repeatskill(_repeatKind, _repeatTime, _repeatDelay);
				}
				else
				{
					_repeat = false;
				}
			}
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="name"></param>
		/// <returns></returns>
		private AsyncOperationHandle<GameObject> LoadAssetAsync(string name)
		{
			string key = $"skill/{name}.prefab";
			return AssetProxy.Instance.TryGetAssetAsync<GameObject>(key, nameof(Cha_Skill));
		}

		/// <summary>
		/// 预加载
		/// </summary>
		private void PreloadAsset()
		{
			StartCoroutine(PreloadAssetCO());
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		private IEnumerator PreloadAssetCO()
		{
			yield return new WaitForSeconds(2f);
			//LoadAssetAsync("general_spiritsword");
		}

		#endregion

		#region Unity

		private void Awake()
		{
			_mytransform = this.transform;
		}

		private void Start()
		{
			AssetProxy.Instance.CreateReleasePool(nameof(Cha_Skill));

			_scriptCha1 = GetComponent<EntityMainPlayer>();
			_scriptSound = GetComponent<Cha_Sound>();
			_scriptRotfog = ef_rotfog.GetComponent<Ef_rotfog>();

			pt_ki = _mytransform.Find("pt_ki");
			directionArrow = _mytransform.Find("directionArrow");

			this.PreloadAsset();
		}

		private void OnDestroy()
		{
			AssetProxy.Instance.RemoveReleasePool(nameof(Cha_Skill));
		}

		// Update is called once per frame
		private void FixedUpdate()
		{
			UpdateSkill();
		}

#if !UNITY_WEBGL && UNITY_EDITOR
		private void OnGUI()
		{
			if (KGMOptions.Instance != null && KGMOptions.Instance.技能开关)
				for (int i = 0; i < 40; i++)
				{
					if (GUILayout.Button($"{i + 1}", GUILayout.MinWidth(100), GUILayout.MinHeight(50)))
					{
						int[] args = new int[10];
						FireSkill(i + 1, args);
					}
				}
		}
#endif

		#endregion
	}
}