Project_SG_scripts.git

			@@ -3,11 +3,16 @@
			using System;
			using DG.Tweening;
			using Spine;
			using System.Linq;


			public class SkillBase
			{
			protected H0604_tagUseSkillAttack tagUseSkillAttack;
			const float moveTime = 0.5f;

			protected SkillEffect skillEffect;

			protected HB427_tagSCUseSkill tagUseSkillAttack;

			protected SkillConfig skillConfig;

			@@ -25,17 +30,26 @@

			protected int curFrame = 0;

			protected List<int> triggerFrames = new List<int>();
			protected List<GameNetPackBasic> packList;

			public SkillBase(BattleObject _caster, SkillConfig _skillCfg, H0604_tagUseSkillAttack vNetData, BattleField _battleField = null)
			protected SkillRecordAction otherSkillAction;

			protected List<H0704_tagRolePackRefresh> dropPackList = new List<H0704_tagRolePackRefresh>();

			protected List<HB405_tagMCAddExp> expPackList = new List<HB405_tagMCAddExp>();

			protected bool moveFinished = false;

			public SkillBase(BattleObject _caster, SkillConfig _skillCfg, HB427_tagSCUseSkill vNetData, List<GameNetPackBasic> _packList, BattleField _battleField = null)
			{
			caster = _caster;
			skillConfig = _skillCfg;
			tagUseSkillAttack = vNetData;
			battleField = _battleField;
			packList = _packList;

			triggerFrames.Clear();
			triggerFrames.AddRange(skillConfig.TriggerFrames);


			}

			public virtual void Run()
			@@ -43,18 +57,28 @@
			if (startCounting)
			{
			curFrame++;
			}

			if (triggerFrames.Contains(curFrame))
			if (null != skillEffect)
			{
			skillEffect.Run();
			}

			if (otherSkillAction != null)
			{
			if (otherSkillAction.IsFinished())
			{
			OnTriggerEvent(triggerFrames.IndexOf(curFrame), curFrame);
			otherSkillAction = null;
			OnSkillFinished();
			}
			else
			{
			otherSkillAction.Run();
			}
			}
			}

			protected virtual void OnTriggerEvent(int triggerIndex, int triggerFrame)
			{

			}

			public void Pause()
			{
			@@ -67,171 +91,636 @@
			startCounting = pauseState;
			}


			// 0·移动到距离目标n码，的距离释放（可配置，9999即原地释放，负数则是移动到人物背面，人物要转身）
			// 1·移动到距离阵容位置n码的距离（如2号位，5号位）释放（即战场中央此类）
			public virtual void Cast()
			{
			EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, battleField.guid, skillConfig, caster.teamHero);

			// 高亮所有本次技能相关的目标
			HighLightAllTargets();

			// 距离配成负数要转身 TurnBack
			switch (skillConfig.castMode)
			{
			case SkillCastMode.StandCast:
			PlayCastAnimation(() => DoSkillLogic(OnSkillFinished));
			case SkillCastMode.Self:
			CastImpl(OnAttackFinish);
			break;
			case SkillCastMode.MoveToTarget:
			MoveToTarget(_onComplete: () => TurnBack(() => PlayCastAnimation(() => DoSkillLogic(() => { BackToOrigin(OnSkillFinished); }))));
			case SkillCastMode.Enemy:
			CastToEnemy();
			break;
			case SkillCastMode.Target:
			CastToTarget();
			break;
			case SkillCastMode.Allies:
			CastToAllies();
			break;
			case SkillCastMode.DashCast:
			DashToTarget(() => BackToOrigin(OnSkillFinished));
			DashCast(OnAttackFinish);
			break;
			default:
			Debug.LogError("暂时不支持其他的方式释放有需求请联系策划");
			Debug.LogError("强制结束技能暂时不支持其他的方式释放有需求请联系策划技能id:" + skillConfig.SkillID + " cast position " + skillConfig.CastPosition);
			ForceFinished();
			break;
			}

			}

			// 冲刺的技能动作跟移动是同时进行的移动到目标的一瞬间就要进行技能逻辑
			protected void DashToTarget(Action _onComplete)
			// 冲撞攻击
			protected void DashCast(Action _onComplete)
			{
			TrackEntry entry = PlayCastAnimation();
			// 做一个微微的提前
			MoveToTarget(entry.TrackTime - 0.05f, () => DoSkillLogic(_onComplete));
			Debug.LogError("DashCast 还没实现");
			ForceFinished();
			// YYL TODO

			// var entry = caster.motionBase.PlayAnimation(skillConfig.GetMotionName(), false);
			// float animationTime = entry.AnimationTime;

			// int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);

			// BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();

			// RectTransform targetTrans = battleField.GetTeamNode(battleCamp, mainTargetPosNum);

			// var tweener = BattleUtility.MoveToTarget(caster.heroRectTrans, targetTrans, new Vector2(skillConfig.CastDistance, 0), animationTime * 0.9f, () =>
			// {
			// caster.motionBase.PlayAnimation(MotionName.idle, true);
			// _onComplete?.Invoke();
			// });
			// battleField.battleTweenMgr.OnPlayTween(tweener);
			}

			protected void GetTargetNode()
			protected void MoveToTarget(RectTransform target, Vector2 offset, Action _onComplete = null, float speed = 500f)
			{
			targetNode = null;

			if (skillConfig.castMode == SkillCastMode.StandCast)
			// 原地释放
			if (skillConfig.CastDistance >= 9999)
			{
			// 原地施法
			targetNode = caster.heroGo.transform as RectTransform;
			}
			else if (skillConfig.castMode == SkillCastMode.MoveToTarget \|\| skillConfig.castMode == SkillCastMode.DashCast)
			{
			if (tagUseSkillAttack.AttackID <= 0)
			{
			Debug.LogError("技能没有指定目标");
			return;
			}

			// 移动到目标位置施法
			BattleObject _mainTarget = battleField.battleObjMgr.GetBattleObject((int)tagUseSkillAttack.AttackID);
			if (_mainTarget == null)
			{
			Debug.LogError("技能指定的目标不存在");
			return;
			}

			targetNode = _mainTarget.heroGo.transform as RectTransform;
			}
			else if (skillConfig.castMode == SkillCastMode.MoveToFormation)
			{
			// TODO YYL
			targetNode = /caster.GetEnemyTeamNode();/ battleField.GetTeamNode(caster.Camp == BattleCamp.Blue ? BattleCamp.Red : BattleCamp.Blue);
			}
			else
			{
			Debug.LogError("未知的施法方式技能id：" + skillConfig.SkillID);
			_onComplete?.Invoke();
			return;
			}
			}

			protected List<BattleObject> GetTargetList()
			{
			return battleField.battleObjMgr.GetBattleObjList(tagUseSkillAttack);
			}

			protected virtual void DoSkillLogic(Action _onComplete = null)
			{
			// 子类实现具体的技能逻辑
			}

			protected TrackEntry PlayCastAnimation(Action onComplete = null)
			{
			// 播放施法动作
			MotionName motionName = skillConfig.GetMotionName();
			TrackEntry trackEntry = caster.motionBase.PlayAnimation(motionName, false, onComplete);
			return trackEntry;
			}

			public void MoveToTarget(float duration = 0.2f, Action _onComplete = null)
			{
			GetTargetNode();
			Vector2 offset = new Vector2(skillConfig.CastDistance, 0);
			RectTransform selfRect = caster.heroGo.transform as RectTransform;
			RectTransform targetRect = targetNode;

			var tweener = BattleUtility.MoveToTarget(selfRect, targetRect, offset, duration, _onComplete);
			caster.motionBase.PlayAnimation(MotionName.run, true);
			var tweener = BattleUtility.MoveToTarget(caster.heroRectTrans, target, offset, () =>
			{
			caster.motionBase.PlayAnimation(MotionName.idle, true);
			_onComplete?.Invoke();
			}, speed);
			battleField.battleTweenMgr.OnPlayTween(tweener);
			}

			public void TurnBack(Action _onComplete)
			protected void TurnBack(Action _onComplete, float forward)
			{
			if (skillConfig.CastDistance < 0)
			{
			caster.heroGo.transform.localScale = new Vector3(-1, 1, 1);
			// 转身
			Vector3 scale = caster.heroGo.transform.localScale;
			scale.x = Mathf.Abs(scale.x) * forward;
			caster.heroGo.transform.localScale = scale;
			}
			_onComplete?.Invoke();
			}

			public void BackToOrigin(Action _onComplete = null)
			protected void CastToEnemy()
			{
			RectTransform selfRect = caster.heroGo.transform as RectTransform;
			Vector2 targetAnchoredPos = Vector2.zero;
			var tween = selfRect.DOAnchorPos(targetAnchoredPos, 0.2f)
			.SetEase(Ease.Linear)
			.OnComplete(() =>
			{
			caster.heroGo.transform.localScale = Vector3.one;
			_onComplete?.Invoke();
			});

			battleField.battleTweenMgr.OnPlayTween(tween);
			RectTransform target = battleField.GetTeamNode(caster.GetEnemyCamp(), skillConfig);

			MoveToTarget(target, new Vector2(skillConfig.CastDistance, 0), () =>
			{
			// 到位置转身(不一定非要转身但是流程要写)
			TurnBack(() =>
			{
			// 到达目标位置
			CastImpl(() =>
			{
			TurnBack(
			() =>
			{
			// 回到原来的位置
			MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero,
			OnAttackFinish, 750F);
			}
			, -1f);
			});
			}, -1f);
			});
			}

			protected void HighLightAllTargets()


			protected void CastToTarget()
			{
			// 高亮所有目标
			HashSet<BattleObject> highlightList = new HashSet<BattleObject>(battleField.battleObjMgr.GetBattleObjList(tagUseSkillAttack));
			highlightList.Add(caster);
			// 目标是敌方主目标
			if (tagUseSkillAttack.HurtCount <= 0)
			{
			Debug.LogError("技能攻击包没有目标 HurtCount <= 0");
			OnSkillFinished();
			return;
			}

			int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);

			BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();

			RectTransform targetTrans = battleField.GetTeamNode(battleCamp, mainTargetPosNum);

			MoveToTarget(targetTrans, new Vector2(skillConfig.CastDistance, 0), () =>
			{
			// 到位置转身(不一定非要转身但是流程要写)
			TurnBack(() =>
			{
			// 到达目标位置
			CastImpl(() =>
			{
			TurnBack(
			() =>
			{
			RectTransform rectTransform = battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum);
			// 回到原来的位置
			MoveToTarget(rectTransform, Vector2.zero, OnAttackFinish, 750F);
			}
			, -1f);
			});
			}, -1f);
			});
			}

			protected virtual void OnAllAttackMoveFinished()
			{
			moveFinished = true;
			}

			protected void CastToAllies()
			{
			RectTransform target = battleField.GetTeamNode(caster.Camp, skillConfig);

			MoveToTarget(target, new Vector2(skillConfig.CastDistance, 0), () =>
			{
			// 到位置转身(不一定非要转身但是流程要写)
			TurnBack(() =>
			{
			// 到达目标位置
			CastImpl(() =>
			{
			TurnBack(
			() =>
			{
			// 回到原来的位置
			MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum),
			Vector2.zero, OnAttackFinish, 750F);
			}
			, -1f);
			});
			}, -1f);
			});
			}

			protected void OnAttackFinish()
			{
			TurnBack(null, 1f);
			OnAllAttackMoveFinished();
			caster.motionBase.PlayAnimation(MotionName.idle, true);
			}


			// 承载技能大部分的逻辑
			protected TrackEntry CastImpl(Action onComplete = null)
			{
			// 播放施法动作
			// onComplete是指施法动作播放完的回调不代表是技能结束
			// 具体技能结束的时间应该看技能对应的逻辑
			// 这里只提供6个动作相关的函数
			// OnSkillStart 动作第一帧
			// OnStartSkillFrameEnd 前摇结束
			// OnMiddleFrameStart 中摇开始
			// OnMiddleFrameEnd 中摇结束
			// OnFinalFrameStart 后摇开始
			// OnFinalFrameEnd 后摇结束
			return caster.motionBase.PlaySkillAnimation(skillConfig, this, onComplete);
			}

			// 技能开始
			public void OnSkillStart()
			{
			skillEffect = SkillEffectFactory.CreateSkillEffect(
			caster,
			skillConfig,
			tagUseSkillAttack
			);
			// if (skillEffect != null)
			{
			skillEffect.Play(OnHitTargets);
			}



			}

			// 技能前摇帧结束
			public virtual void OnStartSkillFrameEnd()
			{

			}

			/// <summary>
			/// 中摇开始 times=第几次循环从0开始
			/// </summary>
			/// <param name="times"></param>
			public virtual void OnMiddleFrameStart(int times)
			{
			// if (skillEffect != null)
			{
			skillEffect.OnMiddleFrameStart(times);
			}
			}

			public virtual void OnMiddleFrameEnd(int times, int hitIndex)
			{
			// if (skillEffect != null)
			{
			skillEffect.OnMiddleFrameEnd(times, hitIndex);
			}
			}

			/// <summary>
			/// 后摇开始
			/// </summary>
			public virtual void OnFinalFrameStart()
			{
			// if (skillEffect != null)
			{
			skillEffect.OnFinalFrameStart();
			}
			}

			/// <summary>
			/// 后摇结束
			/// </summary>
			public virtual void OnFinalFrameEnd()
			{
			// if (skillEffect != null)
			{
			skillEffect.OnFinalFrameEnd();
			}

			HandleDead();
			}




			protected void HighLightAllTargets()
			{
			if (skillConfig.FuncType != 2)
			return;

			// 高亮所有目标
			List<BattleObject> targetList = battleField.battleObjMgr.GetBattleObjList(tagUseSkillAttack);
			List<BattleObject> highlightList = new List<BattleObject>(targetList);
			highlightList.Add(caster);

			List<BattleObject> allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList<BattleObject>();

			caster.heroInfoBar.SetActive(false);

			for (int i = 0; i < allList.Count; i++)
			{
			BattleObject bo = allList[i];
			if (highlightList.Contains(bo))
			{
			bo.layerMgr.SetFront();
			bo.heroInfoBar.SetActive(true);
			bo.heroRectTrans.SetParent(battleField.battleRootNode.skillFrontNode, true);
			}
			else
			{
			bo.layerMgr.SetBack();
			bo.heroRectTrans.SetParent(battleField.battleRootNode.skillBackNode, true);
			}

			if (targetList.Contains(bo))
			{
			bo.heroInfoBar.SetActive(true);
			}
			else
			{
			bo.heroInfoBar.SetActive(false);
			}
			}

			caster.layerMgr.SetSortingOrder(BattleConst.ActiveHeroActionSortingOrder);

			battleField.battleRootNode.skillMaskNode.SetActive(true);

			// caster.battleField.skillMask
			// 把这些BO全高亮或者说把除了这些的都放在遮罩后面
			// YYL TODO
			}

			// 命中目标后的回调正常是以各技能的方式来处理的
			protected virtual void OnHitTargets(int _hitIndex, List<HB427_tagSCUseSkill.tagSCUseSkillHurt> hitList)
			{
			for (int i = 0; i < hitList.Count; i++)
			{
			HB427_tagSCUseSkill.tagSCUseSkillHurt hurt = hitList[i];

			BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
			if (target == null)
			{
			Debug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
			continue;
			}

			OnHitEachTarget(_hitIndex, target, hurt);
			}

			}


			protected virtual void OnHitEachTarget(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurt hurt)
			{
			// 伤害分布 (万分比)
			// Debug.LogError("skillConfig.DamageDivide.Count " + skillConfig.DamageDivide.Length + " _hitIndex " + _hitIndex);
			int[] damageDivide = skillConfig.DamageDivide[_hitIndex];

			long totalDamage = GeneralDefine.GetFactValue(hurt.HurtHP, hurt.HurtHPEx);

			// 保证所有分配项加起来等于totalDamage，避免因整除导致的误差
			List<long> damageList = BattleUtility.DivideDamageToList(damageDivide, totalDamage);
			// public uint ObjID;
			// public uint AttackTypes; // 飘血类型汇总，支持多种类型并存，如无视防御且暴击同时被格挡，二进制或运算最终值；0-失败；1-普通；2-回血；5-格挡；6-无视防御；7-暴击；9-闪避
			// public uint HurtHP; // 飘血值，求余亿部分
			// public uint HurtHPEx; // 飘血值，整除亿部分
			// public uint CurHP; // 更新剩余血量，求余亿部分
			// public uint CurHPEx; // 更新剩余血量，整除亿部分
			// public uint SuckHP; // 本次伤害转化的吸血量
			// public uint BounceHP; // 本次伤害反弹的伤害量


			// TODO YYL AttackTypes 要表现成什么样呢？支持多种类型并存，如无视防御且暴击同时被格挡，二进制或运算最终值；0-失败；1-普通；2-回血；5-格挡；6-无视防御；7-暴击；9-闪避
			target.Hurt(damageList, totalDamage, hurt, skillConfig);

			// TODO YYL 这里是要做统一计算后再hurt跟suckhp还是怎样
			caster.SuckHp(hurt.SuckHP, skillConfig);// 吸血
			caster.HurtByReflect(hurt.BounceHP, skillConfig);// 反弹伤害
			}


			protected void HandleDead()
			{
			var deadPackList = BattleUtility.FindDeadPack(packList);
			int deadCount = deadPackList.Count;

			if (deadCount <= 0)
			{
			// 如果没死亡就不用管
			return;
			}

			CheckAfterDeadhPack();

			// 处理掉落包提前distribute之后 PackManager才有掉落物所以不跟assignexp一样distribute
			foreach (var _dropPack in dropPackList)
			{
			PackageRegedit.Distribute(_dropPack);
			packList.Remove(_dropPack);
			}

			// 获取掉落物品
			var dropPack = PackManager.Instance.GetSinglePack(PackType.DropItem);
			var itemDict = dropPack.GetAllItems();
			List<ItemModel> itemList = new List<ItemModel>(
			from item in itemDict.Values
			where item != null && item.isAuction
			select item);



			// 分配掉落和经验
			var dropAssign = AssignDrops(itemList, deadCount);
			var expAssign = AssignExp(expPackList, deadCount);

			// 构造 BattleDrops 并分配
			for (int i = 0; i < deadCount; i++)
			{
			BattleObject deadTarget = battleField.battleObjMgr.GetBattleObject((int)deadPackList[i].ObjID);
			List<ItemModel> itemModelDrops = dropAssign[i];
			List<int> itemModelDropsIndexList = new List<int>(
			from item in itemModelDrops select item.gridIndex);
			BattleDrops battleDrops = new BattleDrops()
			{
			rectTransform = deadTarget.heroRectTrans,
			dropItemPackIndex = itemModelDropsIndexList,
			expDrops = expAssign[i]
			};
			deadTarget.PushDropItems(battleDrops);
			}

			// 分发死亡包

			battleField.OnObjsDead(new List<HB422_tagMCTurnFightObjDead>(deadPackList));
			foreach (var deadPack in deadPackList)
			{
			packList.Remove(deadPack);
			}
			deadPackList.Clear();
			}



			// 分配掉落
			protected List<List<ItemModel>> AssignDrops(List<ItemModel> itemList, int deadCount)
			{
			var dropAssign = new List<List<ItemModel>>(deadCount);
			for (int i = 0; i < deadCount; i++)
			dropAssign.Add(new List<ItemModel>());
			for (int i = 0; i < itemList.Count; i++)
			dropAssign[i % deadCount].Add(itemList[i]);
			return dropAssign;
			}

			// 分配经验：每个原始包都平均分配到每个死亡对象
			protected List<List<HB405_tagMCAddExp>> AssignExp(List<HB405_tagMCAddExp> expList, int deadCount)
			{
			var expAssign = new List<List<HB405_tagMCAddExp>>(deadCount);
			for (int i = 0; i < deadCount; i++)
			expAssign.Add(new List<HB405_tagMCAddExp>());

			foreach (var expPack in expList)
			{
			long totalExp = GeneralDefine.GetFactValue(expPack.Exp, expPack.ExpPoint);
			long avgExp = totalExp / deadCount;
			long remain = totalExp % deadCount;

			for (int i = 0; i < deadCount; i++)
			{
			long assignExp = avgExp + (i < remain ? 1 : 0);
			long expPoint = assignExp / 100000000;
			long exp = assignExp % 100000000;
			var newPack = new HB405_tagMCAddExp
			{
			Exp = (uint)exp,
			ExpPoint = (uint)expPoint,
			Source = expPack.Source // 保持原包来源
			};
			expAssign[i].Add(newPack);
			}
			packList.Remove(expPack);
			}
			return expAssign;
			}



			protected void CheckAfterDeadhPack()
			{
			List<int> removeIndexList = new List<int>();
			for (int i = 0; i < packList.Count; i++)
			{
			var pack = packList[i];

			// 复活基本都靠技能包
			if (pack is CustomHB426CombinePack)
			{
			var combinePack = pack as CustomHB426CombinePack;
			if (combinePack.startTag.Tag.StartsWith("Skill_"))
			{
			break; // 找到技能包就不需要再处理了
			}
			}
			else if (pack is H0704_tagRolePackRefresh)
			{
			var h0704Pack = pack as H0704_tagRolePackRefresh;
			if (h0704Pack.PackType == (byte)PackType.DropItem)
			{
			// 掉落的
			if (h0704Pack.IsBind == 1)
			{
			// 掉落的物品
			dropPackList.Add(h0704Pack);
			removeIndexList.Add(i);
			}
			else if (h0704Pack.IsBind == 0)
			{
			// 替换的
			}
			}
			}
			else if (pack is HB405_tagMCAddExp)
			{
			var h405Pack = pack as HB405_tagMCAddExp;

			//B4 05 获得经验 #tagMCAddExp 通知获得的经验，
			//可用于做经验获得表现 Source = 2 时为主线击杀怪物获得经验
			if (h405Pack.Source == 2)
			{
			expPackList.Add(h405Pack);
			removeIndexList.Add(i);
			}
			}

			}

			for (int i = removeIndexList.Count - 1; i >= 0; i--)
			{
			packList.RemoveAt(removeIndexList[i]);
			}
			}
			public virtual bool IsFinished()
			{
			return isFinished;
			if (skillEffect != null)
			{
			if (!skillEffect.IsFinished())
			{
			return false;
			}
			else
			{
			OnSkillFinished();
			skillEffect = null;
			}
			}

			if (isFinished && moveFinished)
			{
			List<BattleObject> allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList<BattleObject>();
			for (int i = 0; i < allList.Count; i++)
			{
			BattleObject bo = allList[i];
			bo.layerMgr.SetFront();
			bo.heroRectTrans.SetParent(battleField.GetTeamNode(bo.Camp, bo.teamHero.positionNum), true);
			bo.heroInfoBar.SetActive(true);
			}
			battleField.battleRootNode.skillMaskNode.SetActive(false);




			return true;
			}
			else
			{
			return false;
			}
			}

			public virtual void ForceFinished()
			{
			skillEffect?.ForceFinished();
			isFinished = true;
			moveFinished = true;

			while (packList.Count > 0)
			{
			var pack = packList[0];
			packList.RemoveAt(0);

			if (pack is CustomHB426CombinePack)
			{
			var combinePack = pack as CustomHB426CombinePack;
			if (combinePack.startTag.Tag.StartsWith("Skill_"))
			{
			BattleDebug.LogError("other skill casting " + combinePack.startTag.Tag);
			otherSkillAction = combinePack.CreateSkillAction();

			// 强制结束其他技能
			otherSkillAction.ForceFinish();
			return;
			}
			}
			PackageRegedit.Distribute(pack);
			}
			}

			public void OnSkillFinished()
			{
			if (skillEffect != null)
			{
			if (!skillEffect.IsFinished())
			{
			return;
			}
			}

			while (packList.Count > 0)
			{
			var pack = packList[0];
			packList.RemoveAt(0);

			if (pack is CustomHB426CombinePack)
			{
			var combinePack = pack as CustomHB426CombinePack;
			if (combinePack.startTag.Tag.StartsWith("Skill_"))
			{
			BattleDebug.LogError("other skill casting " + combinePack.startTag.Tag);
			otherSkillAction = combinePack.CreateSkillAction();
			return;
			}
			}
			PackageRegedit.Distribute(pack);
			}

			isFinished = true;
			}

			#if UNITY_EDITOR_STOP_USING
			public virtual List<BattleObject> GetTargetList(BattleField _battleField)
			{
			SkillTargetType targetType = SkillTargetType.Enemy;
			SkillTargetRangeType rangeType = SkillTargetRangeType.LowestHP;

			List<BattleObject> affectList = _battleField.battleObjMgr.GetTargetList(caster, targetType, rangeType);
			return affectList;
			}

			public virtual List<Dictionary<int, List<int>>> GetDamageList(BattleField _battleField)
			{
			Debug.LogError("SkillBase GetDamageList should be overridden by derived class");
			return null;
			}
			#endif
			}