From b5098dca7b3454da208d60d4944d132ca660bb77 Mon Sep 17 00:00:00 2001
From: yyl <yyl>
Date: 星期二, 14 十月 2025 18:45:24 +0800
Subject: [PATCH] 125 战斗 子技能支持

---
 Main/System/Battle/Skill/SkillBase.cs | 1308 +++++++++++++++++++++++++++-------------------------------
 1 files changed, 614 insertions(+), 694 deletions(-)

diff --git a/Main/System/Battle/Skill/SkillBase.cs b/Main/System/Battle/Skill/SkillBase.cs
index f7009d0..639bde7 100644
--- a/Main/System/Battle/Skill/SkillBase.cs
+++ b/Main/System/Battle/Skill/SkillBase.cs
@@ -5,779 +5,699 @@
 using System.Linq;
 using System;
 
-
 public class SkillBase
 {
-	const float moveTime = 0.5f;
+    const float moveTime = 0.5f;
 
-	protected SkillEffect skillEffect;
-
-	protected HB427_tagSCUseSkill tagUseSkillAttack;
-
-	public SkillConfig skillConfig;
-
-	protected bool isFinished = false;
-
-	protected BattleField battleField = null; // 鎴樺満
-
-	protected RectTransform targetNode = null; // 鐩爣鑺傜偣
-
-	protected BattleObject caster = null; // 鏂芥硶鑰�
-
-	protected List<GameNetPackBasic> packList;
-
-	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;
-
+    protected SkillEffect skillEffect;
+    protected HB427_tagSCUseSkill tagUseSkillAttack;
+    public SkillConfig skillConfig;
+    protected bool isFinished = false;
+    protected BattleField battleField = null; // 鎴樺満
+    protected RectTransform targetNode = null; // 鐩爣鑺傜偣
+    protected BattleObject caster = null; // 鏂芥硶鑰�
+    protected List<GameNetPackBasic> packList;
+    protected List<SkillRecordAction> otherSkillActionList = new List<SkillRecordAction>();
+    protected List<H0704_tagRolePackRefresh> dropPackList = new List<H0704_tagRolePackRefresh>();
+    protected List<HB405_tagMCAddExp> expPackList = new List<HB405_tagMCAddExp>();
+    protected bool moveFinished = false;
     public int fromSkillId;
+    public bool isPlay = false;
 
-	public bool isPlay = false;
+    private Dictionary<int, BattleDrops> tempDropList = new Dictionary<int, BattleDrops>();
+    private Dictionary<int, HB422_tagMCTurnFightObjDead> tempDeadPackList = new Dictionary<int, HB422_tagMCTurnFightObjDead>();
 
+    // 鏋勯�犲嚱鏁帮細鍒濆鍖栨妧鑳藉熀纭�鏁版嵁
     public SkillBase(BattleObject _caster, SkillConfig _skillCfg, HB427_tagSCUseSkill vNetData, List<GameNetPackBasic> _packList, BattleField _battleField = null)
-	{
-		caster = _caster;
-		if (null == caster)
-		{
-			throw new Exception("SkillBase caster is null ");
-		}
-		skillConfig = _skillCfg;
-		tagUseSkillAttack = vNetData;
-		battleField = _battleField;
-		packList = _packList;
+    {
+        caster = _caster;
+        if (null == caster)
+        {
+            throw new Exception("SkillBase caster is null ");
+        }
+        skillConfig = _skillCfg;
+        tagUseSkillAttack = vNetData;
+        battleField = _battleField;
+        packList = _packList;
+    }
 
-		// Debug.LogError("start a skill id " + skillConfig.SkillID + " caster " + caster.teamHero.heroId + " pos " + caster.teamHero.positionNum + " camp " + caster.Camp);
-	}
+    // 鎶�鑳借繍琛屼富閫昏緫锛氬鐞嗘妧鑳芥晥鏋滃拰鍏朵粬鎶�鑳藉姩浣�
+    public virtual void Run()
+    {
+        if (skillEffect != null)
+        {
+            if (skillEffect.IsFinished())
+            {
+                skillEffect = null;
+                OnSkillFinished();
+            }
+            else
+            {
+                skillEffect.Run();
+            }
+            return;
+        }
 
-	public virtual void Run()
-	{
-		if (null != skillEffect)
-		{
-			if (skillEffect.IsFinished())
-			{
-				skillEffect = null;
-				OnSkillFinished();
-			}
-			else
-			{
-				skillEffect.Run();
-			}
-			return;
-		}
+        if (otherSkillActionList.Count > 0)
+        {
+            for (int i = otherSkillActionList.Count - 1; i >= 0; i--)
+            {
+                var action = otherSkillActionList[i];
+                if (action.IsFinished())
+                {
+                    otherSkillActionList.RemoveAt(i);
+                    OnSkillFinished();
+                }
+                else if (moveFinished)
+                {
+                    action.Run();
+                }
+            }
+        }
+    }
 
-		if (otherSkillAction != null)
-		{
-			if (otherSkillAction.IsFinished())
-			{
-				otherSkillAction = null;
-				OnSkillFinished();
-			}
-			else
-			{
-				if (moveFinished)
-				{
-					otherSkillAction.Run();
-				}
-			}
-			return;
-		}
-	}
+    // 鎶�鑳介噴鏀句富閫昏緫锛氬箍鎾簨浠躲�侀珮浜洰鏍囥�佹墽琛岄噴鏀�
+    public virtual void Cast()
+    {
+        // 骞挎挱鎶�鑳介噴鏀句簨浠�
+        string guid = battleField.guid;
+        TeamHero teamHero = caster.teamHero;
+        EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, guid, skillConfig, teamHero);
 
-	// 0路绉诲姩鍒拌窛绂荤洰鏍噉鐮侊紝鐨勮窛绂婚噴鏀撅紙鍙厤缃紝9999鍗冲師鍦伴噴鏀撅紝璐熸暟鍒欐槸绉诲姩鍒颁汉鐗╄儗闈紝浜虹墿瑕佽浆韬級
-	// 1路绉诲姩鍒拌窛绂婚樀瀹逛綅缃畁鐮佺殑璺濈锛堝2鍙蜂綅锛�5鍙蜂綅锛夐噴鏀撅紙鍗虫垬鍦轰腑澶绫伙級
-	public virtual void Cast()
-	{
-		// Debug.LogError("Cast skill " + skillConfig.SkillID + " cast position " + skillConfig.CastPosition + " cast mode " + skillConfig.castMode); 
-		string guid = battleField.guid;
-		TeamHero teamHero = caster.teamHero;
-		EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, guid, skillConfig, teamHero);
+        // 楂樹寒鎵�鏈夋湰娆℃妧鑳界浉鍏崇殑鐩爣
+        HighLightAllTargets();
 
-		//	楂樹寒鎵�鏈夋湰娆℃妧鑳界浉鍏崇殑鐩爣
-		HighLightAllTargets();
+        // 鏍规嵁閲婃斁妯″紡鎵ц鐩稿簲閫昏緫
+        switch (skillConfig.castMode)
+        {
+            case SkillCastMode.Self:
+                CastImpl(OnAttackFinish);
+                break;
+            case SkillCastMode.Enemy:
+                CastToEnemy();
+                break;
+            case SkillCastMode.Target:
+                CastToTarget();
+                break;
+            case SkillCastMode.Allies:
+                CastToAllies();
+                break;
+            case SkillCastMode.DashCast:
+                DashCast(OnAttackFinish);
+                break;
+            default:
+                Debug.LogError("寮哄埗缁撴潫鎶�鑳� 鏆傛椂涓嶆敮鎸佸叾浠栫殑鏂瑰紡閲婃斁 鏈夐渶姹俻lease鑱旂郴绛栧垝 鎶�鑳絠d:" + skillConfig.SkillID + " cast position " + skillConfig.CastPosition);
+                ForceFinished();
+                break;
+        }
+    }
 
-		//	璺濈閰嶆垚璐熸暟瑕佽浆韬� TurnBack
-		switch (skillConfig.castMode)
-		{
-			case SkillCastMode.Self:
-				CastImpl(OnAttackFinish);
-				break;
-			case SkillCastMode.Enemy:
-				CastToEnemy();
-				break;
-			case SkillCastMode.Target:
-				CastToTarget();
-				break;
-			case SkillCastMode.Allies:
-				CastToAllies();
-				break;
-			case SkillCastMode.DashCast:
-				DashCast(OnAttackFinish);
-				break;
-			default:
-				Debug.LogError("寮哄埗缁撴潫鎶�鑳� 鏆傛椂涓嶆敮鎸佸叾浠栫殑鏂瑰紡閲婃斁 鏈夐渶姹傝鑱旂郴绛栧垝 鎶�鑳絠d:" + skillConfig.SkillID + " cast position " + skillConfig.CastPosition);
-				ForceFinished();
-				break;
-		}
+    // 鍐叉挒鏀诲嚮妯″紡锛堝緟瀹炵幇锛�
+    protected void DashCast(Action _onComplete)
+    {
+        Debug.LogError("DashCast 杩樻病瀹炵幇");
+        ForceFinished();
+    }
 
-	}
+    // 瀵规晫鏂归噴鏀炬妧鑳斤細绉诲姩鍒版晫鏂瑰尯鍩熻繘琛屾敾鍑�
+    protected void CastToEnemy()
+    {
+        RectTransform target = battleField.GetTeamNode(caster.GetEnemyCamp(), skillConfig);
+        ExecuteMoveAndCastSequence(target, () =>
+        {
+            MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero, OnAttackFinish, 750F);
+        });
+    }
 
-	//	鍐叉挒鏀诲嚮
-	protected void DashCast(Action _onComplete)
-	{
-		Debug.LogError("DashCast 杩樻病瀹炵幇");
-		ForceFinished();
-		//	YYL TODO
+    // 瀵规寚瀹氱洰鏍囬噴鏀炬妧鑳斤細绉诲姩鍒颁富瑕佺洰鏍囦綅缃繘琛屾敾鍑�
+    protected void CastToTarget()
+    {
+        if (tagUseSkillAttack.HurtCount <= 0)
+        {
+            Debug.LogError("鎶�鑳芥敾鍑诲寘娌℃湁鐩爣 HurtCount <= 0");
+            OnSkillFinished();
+            return;
+        }
 
-		// 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);
 
-		// int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);
+        ExecuteMoveAndCastSequence(targetTrans, () =>
+        {
+            RectTransform rectTransform = battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum);
+            MoveToTarget(rectTransform, Vector2.zero, OnAttackFinish, 750F);
+        });
+    }
 
-		// BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();
+    // 瀵瑰弸鏂归噴鏀炬妧鑳斤細绉诲姩鍒板弸鏂瑰尯鍩熻繘琛屾不鐤楁垨澧炵泭
+    protected void CastToAllies()
+    {
+        RectTransform target = battleField.GetTeamNode(caster.Camp, skillConfig);
+        ExecuteMoveAndCastSequence(target, () =>
+        {
+            MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero, OnAttackFinish, 750F);
+        });
+    }
 
-		// RectTransform targetTrans = battleField.GetTeamNode(battleCamp, mainTargetPosNum);
+    // 鎵ц绉诲姩-鏂芥硶-杩斿洖搴忓垪锛氶�氱敤鐨勭Щ鍔ㄦ敾鍑绘祦绋�
+    private void ExecuteMoveAndCastSequence(RectTransform target, Action onReturnComplete)
+    {
+        MoveToTarget(target, new Vector2(skillConfig.CastDistance, 0), () =>
+        {
+            TurnBack(() =>
+            {
+                CastImpl(() =>
+                {
+                    TurnBack(() => 
+                    {
+                        try
+                        {
+                            onReturnComplete?.Invoke(); // 娣诲姞寮傚父澶勭悊闃叉鍥炶皟寮傚父瀵艰嚧鐘舵�佷笉瀹屾暣
+                        }
+                        catch (Exception ex)
+                        {
+                            Debug.LogError($"ExecuteMoveAndCastSequence鍥炶皟寮傚父: {ex.Message}");
+                            throw;
+                        }
+                    }, -1f);
+                });
+            }, -1f);
+        });
+    }
 
-		// 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 MoveToTarget(RectTransform target, Vector2 offset, Action _onComplete = null, float speed = 500f)
+    {
+        if (skillConfig.CastDistance >= 9999)
+        {
+            _onComplete?.Invoke();
+            return;
+        }
 
-	protected void MoveToTarget(RectTransform target, Vector2 offset, Action _onComplete = null, float speed = 500f)
-	{
-		//	鍘熷湴閲婃斁
-		if (skillConfig.CastDistance >= 9999)
-		{
-			_onComplete?.Invoke();
-			return;
-		}
+        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);
+    }
 
-		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);
+    // 杞韩閫昏緫锛氭牴鎹妧鑳介厤缃鐞嗚鑹茶浆鍚�
+    protected void TurnBack(Action _onComplete, float forward)
+    {
+        if (skillConfig.CastDistance < 0)
+        {
+            Vector3 scale = caster.heroGo.transform.localScale;
+            scale.x = Mathf.Abs(scale.x) * forward;
+            caster.heroGo.transform.localScale = scale;
+        }
+        _onComplete?.Invoke();
+    }
 
-		// Debug.LogError("move to tarrget " + target.name + " offset " + offset + " speed " + speed + " time " + tweener.Duration());
-	}
+    // 鏀诲嚮瀹屾垚鍚庣殑澶勭悊锛氳浆韬�佹仮澶嶇姸鎬併�佹挱鏀惧緟鏈哄姩鐢�
+    protected void OnAttackFinish()
+    {
+        TurnBack(null, 1f);
+        OnAllAttackMoveFinished();
+        caster.motionBase.PlayAnimation(MotionName.idle, true);
+    }
 
-	protected void TurnBack(Action _onComplete, float forward)
-	{
-		if (skillConfig.CastDistance < 0)
-		{
-			//	杞韩
-			Vector3 scale = caster.heroGo.transform.localScale;
-			scale.x = Mathf.Abs(scale.x) * forward;
-			caster.heroGo.transform.localScale = scale;
-		}
-		_onComplete?.Invoke();
-	}
+    // 鎵�鏈夋敾鍑荤Щ鍔ㄥ畬鎴愬悗鐨勫鐞嗭細鎭㈠UI鏄剧ず鐘舵��
+    protected virtual void OnAllAttackMoveFinished()
+    {
+        moveFinished = true;
+        List<BattleObject> allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList<BattleObject>();
+        foreach (BattleObject bo in allList)
+        {
+            bo.layerMgr.SetFront();
+            bo.heroInfoBar.SetActive(true);
+        }
+        battleField.battleRootNode.skillMaskNode.SetActive(false);
+    }
 
-	protected void CastToEnemy()
-	{
+    // 鎵ц鎶�鑳介噴鏀惧姩鐢诲拰閫昏緫锛氭挱鏀炬柦娉曞姩浣滃苟鎻愪緵鍥炶皟
+    protected TrackEntry CastImpl(Action onComplete = null)
+    {
+        return caster.motionBase.PlaySkillAnimation(skillConfig, this, tagUseSkillAttack.BattleType == 4, onComplete);
+    }
 
-		RectTransform target = battleField.GetTeamNode(caster.GetEnemyCamp(), skillConfig);
+    // 鎶�鑳藉紑濮嬪洖璋冿細澶勭悊姝讳骸銆佸瓙鎶�鑳姐�佹妧鑳芥晥鏋滃垵濮嬪寲
+    public void OnSkillStart()
+    {
+        HandleDead();
+        skillEffect = SkillEffectFactory.CreateSkillEffect(caster, skillConfig, tagUseSkillAttack);
+        skillEffect.Play(OnHitTargets);
+        foreach (var subSkillPack in tagUseSkillAttack.subSkillList)
+        {
+            RecordAction recordAction = CustomHB426CombinePack.CreateSkillAction(battleField.guid, new List<GameNetPackBasic>() { subSkillPack });
+            battleField.recordPlayer.ImmediatelyPlay(recordAction);
+        }
+        isPlay = true;
+    }
 
-		MoveToTarget(target, new Vector2(skillConfig.CastDistance, 0), () =>
-		{
-			//	鍒颁綅缃浆韬�(涓嶄竴瀹氶潪瑕佽浆韬� 浣嗘槸娴佺▼瑕佸啓)
-			TurnBack(() =>
-			{
-				//	鍒拌揪鐩爣浣嶇疆
-				CastImpl(() =>
-				{
-					TurnBack(
-						() =>
-						{
-							//	鍥炲埌鍘熸潵鐨勪綅缃�
-							MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero, 
-								OnAttackFinish, 750F);
-						}
-					, -1f);
-				});
-			}, -1f);
-		});
-	}
+    // 鎶�鑳藉墠鎽囩粨鏉熷洖璋�
+    public virtual void OnStartSkillFrameEnd() { }
 
+    // 鎶�鑳戒腑鎽囧紑濮嬪洖璋冿細閫氱煡鎶�鑳芥晥鏋滃鐞嗕腑鎽囧紑濮�
+    public virtual void OnMiddleFrameStart(int times)
+    {
+        skillEffect?.OnMiddleFrameStart(times); // 淇锛氭坊鍔犵┖鍊兼鏌�
+    }
 
+    // 鎶�鑳戒腑鎽囩粨鏉熷洖璋冿細閫氱煡鎶�鑳芥晥鏋滃鐞嗕腑鎽囩粨鏉�
+    public virtual void OnMiddleFrameEnd(int times, int hitIndex)
+    {
+        skillEffect?.OnMiddleFrameEnd(times, hitIndex); // 淇锛氭坊鍔犵┖鍊兼鏌�
+    }
 
-	protected void CastToTarget()
-	{
-		// 鐩爣鏄晫鏂逛富鐩爣
-		if (tagUseSkillAttack.HurtCount <= 0)
-		{
-			Debug.LogError("鎶�鑳芥敾鍑诲寘娌℃湁鐩爣 HurtCount <= 0");
-			OnSkillFinished();
-			return;
-		}
+    // 鎶�鑳藉悗鎽囧紑濮嬪洖璋冿細閫氱煡鎶�鑳芥晥鏋滃鐞嗗悗鎽囧紑濮�
+    public virtual void OnFinalFrameStart()
+    {
+        skillEffect?.OnFinalFrameStart(); // 淇锛氭坊鍔犵┖鍊兼鏌�
+    }
 
-		int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);
+    // 鎶�鑳藉悗鎽囩粨鏉熷洖璋冿細閫氱煡鎶�鑳芥晥鏋滃鐞嗗悗鎽囩粨鏉�
+    public virtual void OnFinalFrameEnd()
+    {
+        skillEffect?.OnFinalFrameEnd(); // 淇锛氭坊鍔犵┖鍊兼鏌�
+    }
 
-		BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();
+    // 楂樹寒鎵�鏈夌浉鍏崇洰鏍囷細璁剧疆鏂芥硶鑰呭拰鐩爣鐨勬樉绀哄眰绾�
+    protected void HighLightAllTargets()
+    {
+        caster.layerMgr.SetSortingOrder(BattleConst.ActiveHeroActionSortingOrder);
 
-		RectTransform targetTrans = battleField.GetTeamNode(battleCamp, mainTargetPosNum);
+        if (skillConfig.FuncType != 2)
+            return;
 
-		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);
-		});
-	}
+        List<BattleObject> targetList = battleField.battleObjMgr.GetBattleObjList(tagUseSkillAttack);
+        List<BattleObject> highlightList = new List<BattleObject>(targetList) { caster };
+        List<BattleObject> allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList<BattleObject>();
+        
+        // 淇锛氫娇鐢℉ashSet浼樺寲鎬ц兘锛岄伩鍏嶉噸澶嶈缃�
+        var targetSet = new HashSet<BattleObject>(targetList);
+        var highlightSet = new HashSet<BattleObject>(highlightList);
+        
+        caster.heroInfoBar.SetActive(false);
 
-	protected virtual void OnAllAttackMoveFinished()
-	{
-		moveFinished = true;
-		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);
-		// Debug.LogError("OnAllAttackMoveFinished skill " + skillConfig.SkillID + " cast position " + skillConfig.CastPosition + " cast mode " + skillConfig.castMode); 
-	}
+        foreach (BattleObject bo in allList)
+        {
+            bool isHighlight = highlightSet.Contains(bo);
+            bool isTarget = targetSet.Contains(bo);
+            
+            if (isHighlight)
+            {
+                bo.layerMgr.SetFront();
+            }
+            else
+            {
+                bo.layerMgr.SetBack();
+            }
 
-	protected void CastToAllies()
-	{
-		RectTransform target = battleField.GetTeamNode(caster.Camp, skillConfig);
+            bo.heroInfoBar.SetActive(isTarget);
+        }
 
-		MoveToTarget(target, new Vector2(skillConfig.CastDistance, 0), () =>
-		{
-			//	鍒颁綅缃浆韬�(涓嶄竴瀹氶潪瑕佽浆韬� 浣嗘槸娴佺▼瑕佸啓)
-			TurnBack(() =>
-			{
-				//	鍒拌揪鐩爣浣嶇疆
-				CastImpl(() =>
-				{
-					TurnBack(
-						() =>
-						{
-							//	鍥炲埌鍘熸潵鐨勪綅缃�
-							MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum),
-								Vector2.zero, OnAttackFinish, 750F);
-						}
-					, -1f);
-				});
-			}, -1f);
-		});
-	}
+        battleField.battleRootNode.skillMaskNode.SetActive(true);
+        battleField.battleRootNode.SetSortingOrder();
+    }
 
-	protected void OnAttackFinish()
-	{
-		TurnBack(null, 1f);
-		OnAllAttackMoveFinished();
-		caster.motionBase.PlayAnimation(MotionName.idle, true);
-	}
+    // 鍛戒腑鐩爣鍥炶皟锛氬鐞嗘墍鏈夎鍛戒腑鐨勭洰鏍�
+    protected virtual void OnHitTargets(int _hitIndex, List<HB427_tagSCUseSkill.tagSCUseSkillHurt> hitList)
+    {
+        foreach (var hurt in hitList)
+        {
+            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 TrackEntry CastImpl(Action onComplete = null)
-	{
-		// 鎾斁鏂芥硶鍔ㄤ綔
-		//	onComplete鏄寚鏂芥硶鍔ㄤ綔鎾斁瀹岀殑鍥炶皟 涓嶄唬琛ㄦ槸鎶�鑳界粨鏉�
-		//	鍏蜂綋鎶�鑳界粨鏉熺殑鏃堕棿搴旇鐪嬫妧鑳藉搴旂殑閫昏緫
-		//	杩欓噷鍙彁渚�6涓姩浣滅浉鍏崇殑鍑芥暟
-		// OnSkillStart 鍔ㄤ綔绗竴甯�
-		// OnStartSkillFrameEnd 鍓嶆憞缁撴潫
-		// OnMiddleFrameStart 涓憞寮�濮�
-		// OnMiddleFrameEnd 涓憞缁撴潫
-		// OnFinalFrameStart 鍚庢憞寮�濮�
-		// OnFinalFrameEnd 鍚庢憞缁撴潫
+    // 澶勭悊鍗曚釜鐩爣琚懡涓細搴旂敤浼ゅ鍜屾柦娉曡�呮晥鏋�
+    protected virtual void OnHitEachTarget(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurt hurt)
+    {
+        List<int> damageDivide = new List<int>();
+        if (_hitIndex == 0 && skillConfig.DamageDivide.Length <= 0)
+        {
+            damageDivide.Add(10000);
+        }
+        else
+        {
+            if (skillConfig.DamageDivide.Length <= _hitIndex)
+            {
+                Debug.LogError("鎶�鑳戒激瀹冲垎甯冮厤缃敊璇� skillId: " + skillConfig.SkillID + " hitIndex: " + _hitIndex);
+                damageDivide.Add(10000);
+            }
+            else
+            {
+                damageDivide = skillConfig.DamageDivide[_hitIndex].ToList();
+            }
+        }
 
-		return caster.motionBase.PlaySkillAnimation(skillConfig, this, onComplete);
-	}
+        // 浼ゅ鍒嗗竷璁$畻鍜屽簲鐢�
+        long totalDamage = GeneralDefine.GetFactValue(hurt.HurtHP, hurt.HurtHPEx);
+        List<long> damageList = BattleUtility.DivideDamageToList(damageDivide.ToArray(), totalDamage);
 
-	//	鎶�鑳藉紑濮�
-	public void OnSkillStart()
-	{
-		HandleDead();
-		skillEffect = SkillEffectFactory.CreateSkillEffect(
-				caster,
-				skillConfig,
-				tagUseSkillAttack
-			);
+        // 鑾峰彇涓存椂鏁版嵁骞跺簲鐢ㄤ激瀹�
+        int objID = (int)target.ObjID;
+        tempDropList.TryGetValue(objID, out BattleDrops battleDrops);
+        tempDeadPackList.TryGetValue(objID, out HB422_tagMCTurnFightObjDead deadPack);
+        target.Hurt(damageList, totalDamage, hurt, skillConfig, _hitIndex, battleDrops, deadPack);
 
-		skillEffect.Play(OnHitTargets);
-		isPlay = true;
+        // 澶勭悊鏂芥硶鑰呯浉鍏虫晥鏋�
+        caster.SuckHp(hurt.SuckHP, skillConfig);
+        caster.HurtByReflect(hurt.BounceHP, skillConfig);
+    }
 
-	}
+    // 澶勭悊姝讳骸鐩稿叧閫昏緫锛氬垎閰嶆帀钀藉拰缁忛獙
+    protected void HandleDead()
+    {
+        var deadPackList = BattleUtility.FindDeadPack(packList);
+        if (deadPackList.Count <= 0) return;
 
-	//	鎶�鑳藉墠鎽囧抚缁撴潫
-	public virtual void OnStartSkillFrameEnd()
-	{
-	
-	}
+        CheckAfterDeadhPack();
 
-	/// <summary>
-	/// 涓憞寮�濮� times=绗嚑娆″惊鐜� 浠�0寮�濮�
-	/// </summary>
-	/// <param name="times"></param>
-	public virtual void OnMiddleFrameStart(int times)
-	{
-		skillEffect.OnMiddleFrameStart(times);
-	}
+        // 淇锛氬厛鏀堕泦瑕佸垹闄ょ殑鍖咃紝閬垮厤鍦╢oreach涓慨鏀归泦鍚�
+        var dropPacksToRemove = new List<H0704_tagRolePackRefresh>(dropPackList);
+        foreach (var _dropPack in dropPacksToRemove)
+        {
+            PackageRegedit.Distribute(_dropPack);
+            packList.Remove(_dropPack);
+        }
 
-	public virtual void OnMiddleFrameEnd(int times, int hitIndex)
-	{
-		skillEffect.OnMiddleFrameEnd(times, hitIndex);
-	}
+        // 鑾峰彇骞跺垎閰嶆帀钀界墿鍝佸拰缁忛獙
+        var dropPack = PackManager.Instance.GetSinglePack(PackType.DropItem);
+        var itemDict = dropPack.GetAllItems();
+        List<ItemModel> itemList = new List<ItemModel>(itemDict.Values.Where(item => item != null && item.isAuction));
 
-	/// <summary>
-	/// 鍚庢憞寮�濮�
-	/// </summary>
-	public virtual void OnFinalFrameStart()
-	{
-		skillEffect.OnFinalFrameStart();
-	}
+        var dropAssign = AssignDrops(itemList, deadPackList.Count);
+        var expAssign = AssignExp(expPackList, deadPackList.Count);
 
-	/// <summary>
-	/// 鍚庢憞缁撴潫
-	/// </summary>
-	public virtual void OnFinalFrameEnd()
-	{	
-		skillEffect.OnFinalFrameEnd();
+        // 鏋勯�燘attleDrops骞剁紦瀛�
+        for (int i = 0; i < deadPackList.Count; i++)
+        {
+            int objID = (int)deadPackList[i].ObjID;
+            BattleObject deadTarget = battleField.battleObjMgr.GetBattleObject(objID);
+            
+            // 淇锛氭坊鍔犵┖鍊兼鏌�
+            if (deadTarget == null)
+            {
+                Debug.LogError($"鎵句笉鍒版浜$洰鏍囷紝ObjID: {objID}");
+                continue;
+            }
+            
+            List<int> itemIndexList = dropAssign[i].Select(item => item.gridIndex).ToList();
+            
+            BattleDrops battleDrops = new BattleDrops()
+            {
+                rectTransform = deadTarget.heroRectTrans,
+                dropItemPackIndex = itemIndexList,
+                expDrops = expAssign[i]
+            };
 
-		//	杞Щ鍒版浜″寘 battleobject.hurt 鏈�鍚庝竴鍑荤殑鏃跺�欐挱鏀�
-		
-	}
-
-
-
-
-	protected void HighLightAllTargets()
-	{
-		caster.layerMgr.SetSortingOrder(BattleConst.ActiveHeroActionSortingOrder);
-
-		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);
-			}
-		}
-
-
-		battleField.battleRootNode.skillMaskNode.SetActive(true);
-		battleField.battleRootNode.SetSortingOrder();
-		// caster.battleField.skillMask
-		//	鎶婅繖浜汢O鍏ㄩ珮浜� 鎴栬�呰鎶婇櫎浜嗚繖浜涚殑閮芥斁鍦ㄩ伄缃╁悗闈�
-		//	YYL TODO
-	}
-
-	//	鍛戒腑鐩爣鍚庣殑鍥炶皟 姝e父鏄互鍚勬妧鑳界殑鏂瑰紡鏉ュ鐞嗙殑
-	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);
-
-		// 淇濊瘉鎵�鏈夊垎閰嶉」鍔犺捣鏉ョ瓑浜巘otalDamage锛岄伩鍏嶅洜鏁撮櫎瀵艰嚧鐨勮宸�
-		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-闂伩
-
-
-		int objID = (int)target.ObjID;
-		tempDropList.TryGetValue(objID, out BattleDrops battleDrops);
-		tempDeadPackList.TryGetValue(objID, out HB422_tagMCTurnFightObjDead deadPack);
-		target.Hurt(damageList, totalDamage, hurt, skillConfig, _hitIndex, battleDrops, deadPack);
-
-		//	TODO YYL 杩欓噷鏄鍋氱粺涓�璁$畻鍚庡啀hurt璺焥uckhp杩樻槸鎬庢牱
-		caster.SuckHp(hurt.SuckHP, skillConfig);//	鍚歌
-		caster.HurtByReflect(hurt.BounceHP, skillConfig);// 鍙嶅脊浼ゅ
-	}
-
-	private Dictionary<int, BattleDrops> tempDropList = new Dictionary<int, BattleDrops>();
-
-	private Dictionary<int, HB422_tagMCTurnFightObjDead> tempDeadPackList = new Dictionary<int, HB422_tagMCTurnFightObjDead>();
-
-	protected void HandleDead()
-	{
-		var deadPackList = BattleUtility.FindDeadPack(packList);
-		int deadCount = deadPackList.Count;
-
-		if (deadCount <= 0)
-		{
-			//	濡傛灉娌℃浜″氨涓嶇敤绠�
-			return;
-		}
-
-		CheckAfterDeadhPack();
-
-		// 澶勭悊鎺夎惤鍖� 鎻愬墠distribute涔嬪悗 PackManager鎵嶆湁鎺夎惤鐗� 鎵�浠ヤ笉璺焌ssignexp涓�鏍穌istribute
-		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);
-
-
+            // 淇锛氶伩鍏嶅瓧鍏搁敭鍐茬獊锛屼娇鐢ㄥ畨鍏ㄧ殑娣诲姞鏂瑰紡
+            if (!tempDropList.ContainsKey(objID))
+            {
+                tempDropList.Add(objID, battleDrops);
+            }
+            else
+            {
+                Debug.LogWarning($"tempDropList涓凡瀛樺湪ObjID={objID}鐨勮褰曪紝灏嗚鐩栧師鍊�");
+                tempDropList[objID] = battleDrops; // 瑕嗙洊鐜版湁鍊�
+            }
 
-		// 鍒嗛厤鎺夎惤鍜岀粡楠�
-		var dropAssign = AssignDrops(itemList, deadCount);
-		var expAssign = AssignExp(expPackList, deadCount);
+            if (!tempDeadPackList.ContainsKey(objID))
+            {
+                tempDeadPackList.Add(objID, deadPackList[i]);
+            }
+            else
+            {
+                Debug.LogWarning($"tempDeadPackList涓凡瀛樺湪ObjID={objID}鐨勮褰曪紝灏嗚鐩栧師鍊�");
+                tempDeadPackList[objID] = deadPackList[i]; // 瑕嗙洊鐜版湁鍊�
+            }
+        }
 
-		// 鏋勯�� 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]
-			};
+        // 淇锛氶伩鍏嶅湪閬嶅巻鏃朵慨鏀归泦鍚堬紝鍏堟敹闆嗗悗鍒犻櫎
+        var deadPacksToRemove = new List<GameNetPackBasic>(deadPackList.Cast<GameNetPackBasic>());
+        foreach (var deadPack in deadPacksToRemove)
+        {
+            packList.Remove(deadPack);
+        }
+    }
 
-			tempDropList.Add((int)deadPackList[i].ObjID, battleDrops);
-			// deadTarget.PushDropItems(battleDrops);
-		}
+    // 鍒嗛厤鎺夎惤鐗╁搧锛氬皢鎺夎惤鐗╁搧骞冲潎鍒嗛厤缁欐浜″璞�
+    protected List<List<ItemModel>> AssignDrops(List<ItemModel> itemList, int deadCount)
+    {
+        var dropAssign = new List<List<ItemModel>>();
+        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;
+    }
 
-		// battleField.OnObjsDead(new List<HB422_tagMCTurnFightObjDead>(deadPackList));
-		foreach (var deadPack in deadPackList)
-		{
-			tempDeadPackList.Add((int)deadPack.ObjID, deadPack);
-			packList.Remove(deadPack);
-		}
-	}
+    // 鍒嗛厤缁忛獙鍊硷細灏嗙粡楠屽寘骞冲潎鍒嗛厤缁欐瘡涓浜″璞�
+    protected List<List<HB405_tagMCAddExp>> AssignExp(List<HB405_tagMCAddExp> expList, int deadCount)
+    {
+        var expAssign = new List<List<HB405_tagMCAddExp>>();
+        for (int i = 0; i < deadCount; i++)
+            expAssign.Add(new List<HB405_tagMCAddExp>());
 
+        // 淇锛氭鏌ラ櫎闆堕闄�
+        if (deadCount == 0)
+        {
+            Debug.LogWarning("AssignExp: deadCount涓�0锛屾棤娉曞垎閰嶇粡楠�");
+            return expAssign;
+        }
 
+        // 淇锛氬厛鏀堕泦瑕佸垹闄ょ殑鍖咃紝閬垮厤鍦╢oreach涓慨鏀筽ackList
+        var expPacksToRemove = new List<HB405_tagMCAddExp>();
 
-	// 鍒嗛厤鎺夎惤
-	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;
-	}
+        foreach (var expPack in expList)
+        {
+            long totalExp = GeneralDefine.GetFactValue(expPack.Exp, expPack.ExpPoint);
+            long avgExp = totalExp / deadCount;
+            long remain = totalExp % deadCount;
 
-	// 鍒嗛厤缁忛獙锛氭瘡涓師濮嬪寘閮藉钩鍧囧垎閰嶅埌姣忎釜姝讳骸瀵硅薄
-	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>());
+            for (int i = 0; i < deadCount; i++)
+            {
+                long assignExp = avgExp + (i < remain ? 1 : 0);
+                var newPack = new HB405_tagMCAddExp
+                {
+                    Exp = (uint)(assignExp % 100000000),
+                    ExpPoint = (uint)(assignExp / 100000000),
+                    Source = expPack.Source
+                };
+                expAssign[i].Add(newPack);
+            }
+            expPacksToRemove.Add(expPack);
+        }
+        
+        // 缁熶竴鍒犻櫎鏀堕泦鐨勫寘
+        foreach (var pack in expPacksToRemove)
+        {
+            packList.Remove(pack);
+        }
 
-		foreach (var expPack in expList)
-		{
-			long totalExp = GeneralDefine.GetFactValue(expPack.Exp, expPack.ExpPoint);
-			long avgExp = totalExp / deadCount;
-			long remain = totalExp % deadCount;
+        return expAssign;
+    }
 
-			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 combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
+                break;
+                
+            if (pack is H0704_tagRolePackRefresh h0704Pack && h0704Pack.PackType == (byte)PackType.DropItem && h0704Pack.IsBind == 1)
+            {
+                dropPackList.Add(h0704Pack);
+                removeIndexList.Add(i);
+            }
+            
+            if (pack is HB405_tagMCAddExp h405Pack && h405Pack.Source == 2)
+            {
+                expPackList.Add(h405Pack);
+                removeIndexList.Add(i);
+            }
+        }
 
+        for (int i = removeIndexList.Count - 1; i >= 0; i--)
+            packList.RemoveAt(removeIndexList[i]);
+    }
 
-	protected void CheckAfterDeadhPack()
-	{
-		List<int> removeIndexList = new List<int>();
-		for (int i = 0; i < packList.Count; i++)
-		{
-			var pack = packList[i];
+    // 妫�鏌ユ妧鑳芥槸鍚﹀畬鎴愶細缁煎悎妫�鏌ユ墍鏈夊畬鎴愭潯浠�
+    public virtual bool IsFinished()
+    {
+        if (!isPlay) return false;
+        
 
-			// 	澶嶆椿鍩烘湰閮介潬鎶�鑳藉寘
-			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;
+        // 妫�鏌ユ妧鑳芥晥鏋滄槸鍚﹀畬鎴�
+        if (skillEffect != null)
+        {
+            if (!skillEffect.IsFinished()) return false;
+            skillEffect = null;
+            OnSkillFinished();
+            return false;
+        }
 
-				//B4 05 鑾峰緱缁忛獙 #tagMCAddExp 閫氱煡鑾峰緱鐨勭粡楠岋紝
-				//鍙敤浜庡仛缁忛獙鑾峰緱琛ㄧ幇 Source = 2 鏃朵负涓荤嚎鍑绘潃鎬墿鑾峰緱缁忛獙
-				if (h405Pack.Source == 2)
-				{
-					expPackList.Add(h405Pack);
-					removeIndexList.Add(i);
-				}
-			}
+        // 妫�鏌ュ叾浠栨妧鑳藉姩浣滄槸鍚﹀畬鎴�
+        if (otherSkillActionList.Count > 0)
+        {
+            for (int i = otherSkillActionList.Count - 1; i >= 0; i--)
+            {
+                var action = otherSkillActionList[i];
+                if (action.IsFinished())
+                {
+                    otherSkillActionList.RemoveAt(i);
+                    OnSkillFinished();
+                }
+            }
+            if (otherSkillActionList.Count > 0) return false;
+        }
 
-		}
+        // 妫�鏌ユ渶缁堝畬鎴愮姸鎬�
+        if (isFinished && moveFinished)
+        {
+            if (packList.Count > 0)
+            {
+                OnSkillFinished();
+                return false;
+            }
 
-		for (int i = removeIndexList.Count - 1; i >= 0; i--)
-		{
-			packList.RemoveAt(removeIndexList[i]);
-		}
-	}
-	public virtual bool IsFinished()
-	{
-		if (!isPlay)
-		{
-			return false;
-		}
+            return true;
+        }
 
-		if (skillEffect != null)
-		{
-			if (!skillEffect.IsFinished())
-			{
-				return false;
-			}
-			else
-			{
-				skillEffect = null;
-				OnSkillFinished();	
-				return false;		
-			}
-		}
+        return false;
+    }
 
-		if (otherSkillAction != null)
-		{
-			if (!otherSkillAction.IsFinished())
-			{
-				return false;
-			}
-			else
-			{
-				otherSkillAction = null;
-				OnSkillFinished();
-				return false;
-			}
-		}
 
+    // 寮哄埗缁撴潫鎶�鑳斤細绔嬪嵆缁撴潫鎵�鏈夋妧鑳界浉鍏崇殑澶勭悊
+    public virtual void ForceFinished()
+    {
+        skillEffect?.ForceFinished();
+        
+        otherSkillActionList.ForEach(action => action.ForceFinish());
+        otherSkillActionList.Clear();
 
-		if (isFinished && moveFinished)
-		{
-			if (packList.Count > 0)
-			{
-				OnSkillFinished();
-				return false;
-			}
+        isFinished = true;
+        moveFinished = true;
+        isPlay = true;
 
-			return true;
-		}
-		else
-		{
-			return false;
-		}
-	}
+        // 澶勭悊鎵�鏈夊墿浣欏寘
+        while (packList.Count > 0)
+        {
+            var pack = packList[0];
+            packList.RemoveAt(0);
 
-	public virtual void ForceFinished()
-	{
-		skillEffect?.ForceFinished();
-		if (otherSkillAction != null)
-		{
-			otherSkillAction.ForceFinish();
-			otherSkillAction = null;
-		}
-		isFinished = true;
-		moveFinished = true;
-		isPlay = true;
+            if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
+            {
+                var otherSkillAction = combinePack.CreateSkillAction();
+                otherSkillAction.fromSkillId = skillConfig.SkillID;
+                otherSkillAction.ForceFinish();
+            }
+            else
+            {
+                if (pack is CustomB421ActionPack actionPack)
+                    actionPack.Distribute();
+                PackageRegedit.Distribute(pack);
+            }
+        }
+    }
 
-		while (packList.Count > 0)
-		{
-			var pack = packList[0];
-			packList.RemoveAt(0);
+    // 鎶�鑳藉畬鎴愬鐞嗭細姝e父瀹屾垚鏃剁殑娓呯悊宸ヤ綔
+    public void OnSkillFinished()
+    {
+        // 淇锛氫娇鐢ㄥ惊鐜唬鏇块�掑綊锛岄伩鍏嶆爤婧㈠嚭椋庨櫓
+        try
+        {
+            while (true)
+            {
+                // 楠岃瘉鎶�鑳芥晥鏋滄槸鍚﹀畬鎴�
+                if (skillEffect != null && !skillEffect.IsFinished()) 
+                    return;
+                    
+                if (skillEffect != null)
+                {
+                    skillEffect = null;
+                    continue; // 浣跨敤continue浠f浛閫掑綊璋冪敤
+                }
 
-			if (pack is CustomHB426CombinePack combinePack)
-			{
-				if (combinePack.startTag.Tag.StartsWith("Skill_"))
-				{
-					otherSkillAction = combinePack.CreateSkillAction();
-					otherSkillAction.fromSkillId = skillConfig.SkillID;
-					//	寮哄埗缁撴潫鍏朵粬鎶�鑳�
-					otherSkillAction.ForceFinish();
-					continue;
-				}
-			}
-			else if (pack is CustomB421ActionPack actionPack)
-			{
-				actionPack.Distribute();
-			}
-			PackageRegedit.Distribute(pack);
-		}
-	}
+                // 楠岃瘉鍏朵粬鎶�鑳藉姩浣滄槸鍚﹀畬鎴�
+                if (otherSkillActionList.Count > 0)
+                {
+                    bool hasFinishedAction = false;
+                    for (int i = otherSkillActionList.Count - 1; i >= 0; i--)
+                    {
+                        var action = otherSkillActionList[i];
+                        if (action.IsFinished())
+                        {
+                            otherSkillActionList.RemoveAt(i);
+                            hasFinishedAction = true;
+                        }
+                    }
+                    if (hasFinishedAction)
+                    {
+                        continue; // 浣跨敤continue浠f浛閫掑綊璋冪敤
+                    }
+                    return;
+                }
 
-	public void OnSkillFinished()
-	{
-		if (skillEffect != null)
-		{
-			if (!skillEffect.IsFinished())
-			{
-				return;
-			}
-			else
-			{
-				skillEffect = null;
-				OnSkillFinished();
-			}
-			
-		}
+                break; // 娌℃湁鏇村闇�瑕佸鐞嗙殑锛岄��鍑哄惊鐜�
+            }
 
-		if (otherSkillAction != null)
-		{
-			if (!otherSkillAction.IsFinished())
-			{
-				return;
-			}
-			else
-			{
-				otherSkillAction = null;
-				OnSkillFinished();
-			}
-		}
+            // 澶勭悊鍓╀綑鍖�
+            while (packList.Count > 0)
+            {
+                var pack = packList[0];
+                packList.RemoveAt(0);
 
-		while (packList.Count > 0)
-		{
-			var pack = packList[0];
-			packList.RemoveAt(0);
+                if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
+                {
+                    BattleDebug.LogError("other skill casting " + combinePack.startTag.Tag);
+                    var otherSkillAction = combinePack.CreateSkillAction();
+                    otherSkillAction.fromSkillId = skillConfig.SkillID;
+                    return;
+                }
 
-			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.fromSkillId = skillConfig.SkillID;
-					return;
-				}
-			}
-			else if (pack is CustomB421ActionPack actionPack)
-			{
-				actionPack.Distribute();
-			}
+                if (pack is CustomB421ActionPack actionPack)
+                    actionPack.Distribute();
+                PackageRegedit.Distribute(pack);
+            }
+        }
+        catch (Exception ex)
+        {
+            Debug.LogError($"OnSkillFinished寮傚父: {ex.Message}锛屾妧鑳絀D={skillConfig.SkillID}");
+            // 纭繚鐘舵�佷竴鑷存�э紝鍗充娇鍑虹幇寮傚父涔熻鏍囪瀹屾垚
+            isFinished = true;
+            throw; // 閲嶆柊鎶涘嚭寮傚父渚涗笂灞傚鐞�
+        }
 
-			// Debug.LogError("Distribute pack " + pack.GetType().ToString());
-			PackageRegedit.Distribute(pack);
-		}
+        isFinished = true;
+    }
 
-		isFinished = true;
-	}
+    // 娣诲姞娓呯悊鏂规硶锛氶槻姝㈠唴瀛樻硠婕�
+    public virtual void Cleanup()
+    {
+        tempDropList?.Clear();
+        tempDeadPackList?.Clear();
+        otherSkillActionList?.Clear();
+        dropPackList?.Clear();
+        expPackList?.Clear();
+        
+        skillEffect = null;
+        packList = null;
+    }
 }
\ No newline at end of file

--
Gitblit v1.8.0