命格 重构战斗代码

yyl

2 天以前 d1ec6bf485cf9179d157554eaef7a2339233dd03

命格 重构战斗代码

 Main/Component/UI/Effect/BattleEffectPlayer.cs

@@ -684,12 +684,11 @@

    public void BindBone(BattleObject battleObject, string v)
    {
        if (battleObject == null || battleObject.motionBase == null || battleObject.motionBase.skeletonAnim == null)
        var skeletonAnim = battleObject?.GetSkeletonAnimation();
        if (skeletonAnim == null)
        {
            return;
        }

        var skeletonAnim = battleObject.motionBase.skeletonAnim;

        Bone bone = skeletonAnim.skeleton.FindBone(v);
        isBindBone = false;

 Main/System/Battle/BattleConst.cs

@@ -84,6 +84,8 @@
    public const int BreakArmor = 100007; // 贯穿

    public const int Parry = 100008; // 招架

    public const int CompletelyDodge = 100009;//  绝对闪避
    
    #endregion


 Main/System/Battle/BattleField/BattleField.cs

@@ -651,9 +651,9 @@

        foreach (var obj in blueTeam)
        {
            obj.heroGo.SetActive(true);
            obj.motionBase.PlayAnimation(MotionName.run, true);
            RectTransform trans = obj.heroRectTrans;
            obj.SetActive(true);
            obj.PlayAnimation(MotionName.run, true);
            RectTransform trans = obj.GetRectTransform();
            trans.anchoredPosition = new Vector2(-800, 0);
            tween = trans.DOAnchorPos(Vector2.zero, 1f).SetEase(Ease.Linear);
            battleTweenMgr.OnPlayTween(tween);
@@ -663,7 +663,7 @@
        {
            foreach (var obj in blueTeam)
            {
                obj.motionBase.PlayAnimation(MotionName.idle, true);
                obj.PlayAnimation(MotionName.idle, true);
            }

            // 播放战斗开始的特效

 Main/System/Battle/BattleField/RecordActions/BuffMountAction.cs

@@ -46,7 +46,7 @@
                    tipsInfo.useBuffColor = true;
                    tipsInfo.isDebuff = skillConfig.IsDebuff();

                    obj.heroInfoBar.ShowTips(tipsInfo);
                    obj.ShowTips(tipsInfo);
                }
            }


 Main/System/Battle/BattleField/RecordActions/DeathRecordAction.cs

@@ -185,7 +185,7 @@
        bool isComplete = false;

        //  如果没有释放技能 则直接死亡
        if (deadObj.motionBase.CanStartDeath())
        if (deadObj.CanStartDeath())
        {
            PerformDrop(deadObj);

@@ -201,7 +201,7 @@
        return () =>
        {
            //  还没播放死亡 并且没释放其他技能
            if (!playDeath && deadObj.motionBase.CanStartDeath())
            if (!playDeath && deadObj.CanStartDeath())
            {
                PerformDrop(deadObj);

@@ -212,7 +212,7 @@
                playDeath = true;
            }
            
            if (deadObj.isReborning)
            if (deadObj.IsReborning())
            {
                isComplete = true;
            }

 Main/System/Battle/BattleField/RecordActions/RebornRecordAction.cs

@@ -78,14 +78,14 @@
            Sequence sequence = DOTween.Sequence();

            //  播放复活特效
            battleField.battleEffectMgr.PlayEffect(battleObj, BattleConst.RebornEffectID, battleObj.heroRectTrans, battleObj.Camp, battleObj.teamHero.modelScale);
            battleField.battleEffectMgr.PlayEffect(battleObj, BattleConst.RebornEffectID, battleObj.GetRectTransform(), battleObj.Camp, battleObj.teamHero.modelScale);

            //  渐变
            battleObj.motionBase.skeletonAnim.skeleton.A = 0f;
            battleObj.SetSkeletonAlpha(0f);

            sequence.Append(DOVirtual.Float(0f, 1f, tweenDuration / battleField.speedRatio, value =>
            {
                battleObj.motionBase.skeletonAnim.skeleton.A = value;
                battleObj.SetSkeletonAlpha(value);
            }));

            tweenSeq.Join(sequence);
@@ -120,7 +120,7 @@
        foreach (var bo in rebornObjs)
        {
            var battleObj = bo;
            battleObj.motionBase.skeletonAnim.skeleton.A = 1f;
            battleObj.SetSkeletonAlpha(1f);
            battleObj.AfterReborn();
        }


 Main/System/Battle/BattleField/RecordActions/SkillRecordAction.cs

@@ -175,7 +175,7 @@
        if (isCast)
            return;

        if (skillBase.caster.motionBase.CanCastSkill(skillBase.skillConfig))
        if (skillBase.caster.CanCastSkillAnimation(skillBase.skillConfig))
        {
            // Debug.LogError("cast skill id is " + skillBase.skillConfig.SkillID);


 Main/System/Battle/BattleHUDWin.cs

@@ -157,7 +157,7 @@
    {
        if (damageInfo.targetDamageList.Count == 0) return;

        RectTransform heroRect = damageInfo.hurtObj.heroRectTrans;
        RectTransform heroRect = damageInfo.hurtObj.GetRectTransform();
        if (heroRect == null) return;

        DamageContent content = CreateDamageContent();
@@ -186,7 +186,7 @@
    {
        if (damageInfo.casterDamageList.Count == 0) return;

        RectTransform heroRect = damageInfo.casterObj.heroRectTrans;
        RectTransform heroRect = damageInfo.casterObj.GetRectTransform();
        if (heroRect == null) return;

        // 创建单个DamageContent显示所有施法者伤害

 Main/System/Battle/BattleObject/BattleObjMgr.cs

@@ -46,7 +46,7 @@
            if (teamHero != null)
            {
                BattleObject battleObj = BattleObjectFactory.CreateBattleObject(battleField, posNodeList, teamHero, _Camp);
                battleObj.heroGo.SetActive(active);
                battleObj.SetActive(active);
                allBattleObjDict.Add(battleObj.ObjID, battleObj);
                campDict.Add(teamHero.positionNum, battleObj);
                battleObj.SetSpeedRatio(battleField.speedRatio);

 Main/System/Battle/BattleObject/BattleObject.cs

@@ -26,7 +26,7 @@
    Burned = 1 << 5
}

public class BattleObject
public abstract class BattleObject
{
    public BattleField battleField;

@@ -40,197 +40,162 @@

    public TeamHero teamHero { get; protected set; }

    public MotionBase motionBase;

    public GameObject heroGo
    {
        get;
        private set;
    }

    protected BattleDrops m_battleDrops;

    private RectTransform m_heroRectTrans;


    public RectTransform heroRectTrans
    {
        get
        {
            if (m_heroRectTrans == null)
            {
                m_heroRectTrans = heroGo.GetComponent<RectTransform>();
            }
            return m_heroRectTrans;
        }
    }

    protected Action onDeathAnimationComplete;

    protected Renderer[] renderers;

    private List<HB405_tagMCAddExp> hB405_tagMCAddExps = new List<HB405_tagMCAddExp>();
    public BattleHeroInfoBar heroInfoBar;

    public bool isReborning = false;

    public BattleObject(BattleField _battleField)
    {
        battleField = _battleField;
    }

    public virtual void Init(GameObject _heroGo, TeamHero _teamHero, BattleCamp _camp)
    public abstract void Init(TeamHero _teamHero, BattleCamp _camp);

    public abstract void Run();

    public abstract void Pause();

    public abstract void Resume();

    public abstract void Destroy();

    // ============ 动画相关抽象方法（替代 motionBase 直接调用） ============
    
    /// <summary>
    /// 播放动画
    /// </summary>
    public abstract void PlayAnimation(MotionName motionName, bool loop);
    
    /// <summary>
    /// 显示幻影残影
    /// </summary>
    public abstract void ShowIllusionShadow(bool show, Color? color = null);
    
    /// <summary>
    /// 播放技能动画
    /// </summary>
    public abstract Spine.TrackEntry PlaySkillAnimation(SkillConfig skillConfig, SkillBase skillBase, bool isCounter, Action onComplete);
    
    /// <summary>
    /// 检查是否可以开始死亡
    /// </summary>
    public abstract bool CanStartDeath();
    
    /// <summary>
    /// 检查是否可以释放技能
    /// </summary>
    public abstract bool CanCastSkillAnimation(SkillConfig skillConfig);
    
    /// <summary>
    /// 获取骨骼动画组件（用于特效挂载等）
    /// </summary>
    public abstract SkeletonAnimation GetSkeletonAnimation();
    
    /// <summary>
    /// 设置骨骼动画透明度
    /// </summary>
    public abstract void SetSkeletonAlpha(float alpha);
    
    /// <summary>
    /// 获取 RectTransform（用于移动等操作）
    /// </summary>
    public virtual RectTransform GetRectTransform() => null;
    
    /// <summary>
    /// 获取 GameObject
    /// </summary>
    public virtual GameObject GetGameObject() => null;
    
    /// <summary>
    /// 获取 Transform（用于特效挂载等）
    /// </summary>
    public virtual Transform GetTransform() => null;
    
    /// <summary>
    /// 获取世界坐标位置
    /// </summary>
    public virtual Vector3 GetPosition() => Vector3.zero;
    
    /// <summary>
    /// 获取血条信息栏
    /// </summary>
    public virtual BattleHeroInfoBar GetHeroInfoBar() => null;
    
    /// <summary>
    /// 刷新Buff显示
    /// </summary>
    public virtual void RefreshBuff(List<HB428_tagSCBuffRefresh> buffList) { }
    
    /// <summary>
    /// 更新血量显示
    /// </summary>
    public virtual void UpdateHP(float percentage) { }
    
    /// <summary>
    /// 是否正在复活中
    /// </summary>
    public virtual bool IsReborning() => false;
    
    /// <summary>
    /// 设置复活状态
    /// </summary>
    public virtual void SetReborning(bool value) { }
    
    /// <summary>
    /// 设置 GameObject 激活状态
    /// </summary>
    public virtual void SetActive(bool active) { }
    
    /// <summary>
    /// 重置位置到原点
    /// </summary>
    public virtual void ResetPosition() { }
    
    /// <summary>
    /// 设置朝向（通过缩放）
    /// </summary>
    public virtual void SetFacing(float direction) { }
    
    /// <summary>
    /// 重置朝向（朝向右边）
    /// </summary>
    public virtual void ResetFacing() { }
    
    /// <summary>
    /// 停止所有移动动画
    /// </summary>
    public virtual void StopMoveAnimation() { }
    
    /// <summary>
    /// 显示提示信息（简单版本）
    /// </summary>
    public virtual void ShowTips(string message, bool useArtText = false, bool followCharacter = true, float scaleRatio = 1f) { }
    
    /// <summary>
    /// 显示提示信息（完整版本）
    /// </summary>
    public virtual void ShowTips(BattleHeroInfoBar.TipsInfo tipsInfo) { }
    
    /// <summary>
    /// 设置死亡状态（Hero 特定）
    /// </summary>
    public virtual void SetDeath() { }
    
    /// <summary>
    /// 复活后处理（Hero 特定）
    /// </summary>
    public virtual void AfterReborn() { }
    
    /// <summary>
    /// 复活前准备（Hero 特定）
    /// </summary>
    public virtual void PreReborn(bool reviveSelf = false) { }
    
    /// <summary>
    /// 复活动作（Hero 特定）
    /// </summary>
    public virtual void OnReborn(HB427_tagSCUseSkill.tagSCUseSkillHurt vNetData, bool reviveSelf = false, RecordAction parentAction = null) { }

    public virtual void OnObjInfoRefresh(H0418_tagObjInfoRefresh _refreshInfo)
    {
        heroGo = _heroGo;
        teamHero = _teamHero;
        Camp = _camp;
        motionBase = new MotionBase();
        motionBase.Init(heroGo.GetComponentInChildren<SkeletonAnimation>(true));
        buffMgr = new BattleObjectBuffMgr();
        buffMgr.Init(this);

        buffMgr.onIsControlChanged += OnControledChange;

        layerMgr = new BattleObjectLayerMgr();
        layerMgr.Init(this);

        renderers = heroGo.GetComponentsInChildren<Renderer>(true);

        heroInfoBar = heroGo.GetComponentInChildren<BattleHeroInfoBar>(true);
        heroInfoBar.SetBattleObject(this);

        //  根据阵营翻转血条
        var heroInfoBarScale = heroInfoBar.transform.localScale;
        heroInfoBarScale.x *= Camp == BattleCamp.Red ? 1 : -1;
        heroInfoBar.transform.localScale = heroInfoBarScale;
        if (battleField is StoryBattleField && (battleField as StoryBattleField).battleState == StoryBattleState.Break)
        {
            //主线关卡休息中的不显示血条
            heroInfoBar.SetActive(false);
        }
        else
        {
            heroInfoBar.SetActive(true);
        }
        SetFront();
        // 子类实现
    }


    public virtual void Run()
    {
        motionBase.Run();
        heroInfoBar.Run();
        buffMgr.Run();
    }

    public virtual void Pause()
    {
        motionBase.Pause();
    }

    public virtual void Resume()
    {
        motionBase.Resume();
    }

    public virtual void Destroy()
    {

        motionBase.Release();
        motionBase = null;
        buffMgr.onIsControlChanged -= OnControledChange;
        buffMgr.Release();
        buffMgr = null;
        teamHero = null;
        ObjID = 0;

        if (heroGo != null)
        {
            GameObject.DestroyImmediate(heroGo);
            heroGo = null;
        }
    }

    //  有变化了才会调用这个函数
    private void OnControledChange(int groupType, bool value)
    {
        //  这里是受到硬控时候 需要表现的动画
        if (groupType == BattleConst.HardControlGroup)
        {
            //  从没被硬控到被硬控
            if (value)
            {
                motionBase.SetControledAnimation();
            }
            else
            {
                motionBase.CancelControledAnimation();
            }
        }
    }

    public void OnObjInfoRefresh(H0418_tagObjInfoRefresh _refreshInfo)
    {
        // 天子的挑战拦截血条,不拦截怒气
        BattleObject boss = battleField.FindBoss();
        if (boss != null && battleField.MapID == 30020 && boss.ObjID == _refreshInfo.ObjID && _refreshInfo.RefreshType != (ushort)PlayerDataType.XP)
            return;
        switch ((PlayerDataType)_refreshInfo.RefreshType)
        {
            case PlayerDataType.HP:
                long toHp = GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                if (!IsTianziBoss())
                {
                    heroInfoBar.UpdateHP(teamHero.curHp, toHp, teamHero.maxHp, false);
                }
                teamHero.curHp = GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                // Debug.LogError("OnObjInfoRefresh " + teamHero.curHp);
                break;
            case PlayerDataType.MaxHP:
                teamHero.maxHp = GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                if (!IsTianziBoss())
                {
                    heroInfoBar.UpdateHP(teamHero.curHp, teamHero.curHp, teamHero.maxHp, false);
                }
                break;
            case PlayerDataType.XP:
                long toXp = GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                heroInfoBar.UpdateXP(teamHero.rage, toXp, 100);
                teamHero.rage = (int)GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                break;
            default:
                Debug.LogError("BattleObject.ObjInfoRefresh 出现意外类型 " + _refreshInfo.RefreshType.ToString());
                break;
        }
    }

    // public void ObjPropertyRefreshView(HB418_tagSCObjPropertyRefreshView vNetData)
    // {
    //     // 天子的挑战拦截血条,不拦截怒气
    //     BattleObject boss = battleField.FindBoss();
    //     if (boss != null && battleField.MapID == 30020 && boss.ObjID == vNetData.ObjID && vNetData.RefreshType != (ushort)PlayerDataType.XP)
    //         return;
    //     switch ((PlayerDataType)vNetData.RefreshType)
    //     {
    //         case PlayerDataType.HP:
    //             long toHp = GeneralDefine.GetFactValue(vNetData.Value, vNetData.ValueEx);
    //             heroInfoBar.UpdateHP(teamHero.curHp, toHp, teamHero.maxHp, false);
    //             teamHero.curHp = GeneralDefine.GetFactValue(vNetData.Value, vNetData.ValueEx);
    //             break;
    //         case PlayerDataType.MaxHP:
    //             teamHero.maxHp = GeneralDefine.GetFactValue(vNetData.Value, vNetData.ValueEx);
    //             heroInfoBar.UpdateHP(teamHero.curHp, teamHero.curHp, teamHero.maxHp, false);
    //             break;
    //         case PlayerDataType.XP:
    //             long toXp = GeneralDefine.GetFactValue(vNetData.Value, vNetData.ValueEx);
    //             heroInfoBar.UpdateXP(teamHero.rage, toXp, 100);
    //             teamHero.rage = (int)GeneralDefine.GetFactValue(vNetData.Value, vNetData.ValueEx);
    //             break;
    //         default:
    //             Debug.LogError("BattleObject.ObjPropertyRefreshView 出现意外类型 " + vNetData.RefreshType.ToString());
    //             break;
    //     }
    // }

    //  眩晕
    public bool IsStunned()
@@ -315,250 +280,17 @@
        return true;
    }

    public virtual DeathRecordAction Hurt(BattleHurtParam battleHurtParam, SkillRecordAction _parentSkillAction = null)
    {
        DeathRecordAction recordAction = null;
        bool isLastHit = battleHurtParam.hitIndex >= battleHurtParam.skillConfig.DamageDivide.Length - 1;
        bool firstHit = battleHurtParam.hitIndex == 0;
        
        // 添加调试日志
        bool isHealing = BattleUtility.IsHealing(battleHurtParam.hurt);
    
        BattleDmgInfo dmgInfo = PopDamage(battleHurtParam);
    public abstract DeathRecordAction Hurt(BattleHurtParam battleHurtParam, SkillRecordAction _parentSkillAction = null);

    public abstract void OnDodgeBegin();

        // ============ 应用目标的血量和护盾变化 ============
        ApplyHurtToTarget(battleHurtParam, isLastHit);
    public abstract void OnDodgeEnd(Action _complete = null);

        //  这里
        if (dmgInfo.IsType(DamageType.Dodge) /*&& !buffMgr.isControled[BattleConst.HardControlGroup]*/)//如果被控制了还闪避了 要看看服务器怎么处理了
        {
            if (isLastHit)
            {
                DodgeFinishAction dodgeFinish = new DodgeFinishAction(battleField, this);
                // 【使用 BattleField.recordPlayer】
                // 原因：闪避完成动作是目标角色的独立行为，不是技能内部产生的
                // 虽然是在Hurt过程中触发，但是闪避动作本身是目标的反应，应该由主RecordPlayer管理
                // 使用InsertRecord可以插到队列最前面，保证闪避表现的优先级
                battleField.recordPlayer.InsertRecord(dodgeFinish);
            }
    public abstract void OnDeath(Action _onDeathAnimationComplete, bool withoutAnime = false);

            if (firstHit)
            {
                OnDodgeBegin();
            }
        }
    protected abstract BattleDmgInfo PopDamage(BattleHurtParam battleHurtParam);

        bool isFatalAttack = (null != battleHurtParam.deadPack) && isLastHit;

        if (isFatalAttack)
        {
            if (null != battleHurtParam.battleDrops)
            {
                PushDropItems(battleHurtParam.battleDrops);
            }
            recordAction = battleField.OnObjsDead(new List<BattleDeadPack>() { battleHurtParam.deadPack }, _parentSkillAction, _parentSkillAction);

        }
        else
        {
            if (dmgInfo.IsType(DamageType.Block))
            {
                battleField.battleEffectMgr.PlayEffect(this, BattleConst.BlockEffectID, heroRectTrans, Camp, teamHero.modelScale);
            }
            // else
            // {
            if ((dmgInfo.IsType(DamageType.Damage) || dmgInfo.IsRealdamage()))
            {
                if (!buffMgr.isControled[BattleConst.HardControlGroup])
                {
                    battleField.soundManager.PlayEffectSound(teamHero.heroConfig.HitSFX, false);
                    motionBase.PlayAnimation(MotionName.hit, false);
                }
            }
            // }

        }

        return recordAction;
    }

    /// <summary>
    /// 应用目标的血量和护盾变化
    /// </summary>
    private void ApplyHurtToTarget(BattleHurtParam battleHurtParam, bool isLastHit)
    {
        BattleHurtObj hurter = battleHurtParam.hurter;
        
        // 应用血量变化
        teamHero.curHp = hurter.toHp;
        
        // foreach (var obj in battleField.battleObjMgr.allBattleObjDict.Values)
        // {
        //     Debug.LogError($"[ApplyHurtToTarget] ObjID: {obj.ObjID}, Name: {obj.teamHero.heroConfig.Name}, CurHp: {obj.teamHero.curHp}, MaxHp: {obj.teamHero.maxHp} Skill {battleHurtParam.hB427_TagSCUseSkill.packUID} ");
        // }


#if UNITY_EDITOR
        // 最后一击时验证血量是否与服务器一致
        if (isLastHit)
        {
            BattleUtility.ValidateHpConsistency(battleHurtParam, "目标受伤");
        }
#endif
    }

    const float pingpongTime = 0.4f;
    //  闪避开始
    public virtual void OnDodgeBegin()
    {
        RectTransform rectTrans = heroRectTrans;
        var tween = rectTrans.DOAnchorPos(new Vector3(-30, 0, 0), pingpongTime)
            .SetEase(Ease.OutCubic);

        motionBase.ShowIllusionShadow(true);

        DamageNumConfig damageNumConfig = DamageNumConfig.Get((int)DamageType.Dodge);

        string dodgeStr = ((char)damageNumConfig.prefix).ToString();

        heroInfoBar.ShowTips(dodgeStr, true, false);

        tween.onComplete += () =>
        {
            motionBase.ShowIllusionShadow(false);
        };


        battleField.soundManager.PlayEffectSound(BattleConst.DodgeSoundID);

        battleField.battleTweenMgr.OnPlayTween(tween);
    }

    //  闪避结束
    public virtual void OnDodgeEnd(Action _complete = null)
    {
        RectTransform rectTrans = heroRectTrans;

        var tween = rectTrans.DOAnchorPos(Vector3.zero, pingpongTime)
                            .SetEase(Ease.OutCubic);

        tween.onComplete += () =>
        {
            _complete?.Invoke();
        };

        battleField.battleTweenMgr.OnPlayTween(tween);
    }

    public virtual void OnDeath(Action _onDeathAnimationComplete, bool withoutAnime = false)
    {
        buffMgr.RemoveAllBuff();
        battleField.soundManager.PlayEffectSound(teamHero.heroConfig.DeathSFX, false);
        if (withoutAnime)
        {
            SetDeath();
            _onDeathAnimationComplete?.Invoke();
        }
        else
        {
            motionBase.PlayDeadAnimation(() =>
            {
                SetDeath();
                _onDeathAnimationComplete?.Invoke();
            });
        }
    }

    public void SetDeath()
    {
        teamHero.isDead = true;
        OnDeadAnimationComplete();
    }

    protected virtual void OnDeadAnimationComplete()
    {
        //  或许看看溶解特效？ YYL TODO
        heroGo.SetActive(false);

        //  防止给死亡对象又上buff
        buffMgr.RemoveAllBuff();
    }

    //  释放者就是复活者时调用
    public void PreReborn(bool reviveSelf = false)
    {
        heroGo.SetActive(true);
        motionBase.skeletonAnim.skeleton.A = 0f;
        motionBase.skeletonAnim.LateUpdate();
        heroRectTrans.anchoredPosition = Vector2.zero;
        motionBase.ResetForReborn(reviveSelf);
    }

    //  复活action
    public void OnReborn(HB427_tagSCUseSkill.tagSCUseSkillHurt vNetData, bool reviveSelf = false, RecordAction parentAction = null)
    {
        isReborning = true;
        heroGo.SetActive(true);
        motionBase.ResetForReborn(reviveSelf);
        heroRectTrans.anchoredPosition = Vector2.zero;
        motionBase.skeletonAnim.skeleton.A = 0f;
        motionBase.skeletonAnim.LateUpdate();

    }

    public void AfterReborn()
    {
        //  清空所有
        motionBase.ResetForReborn(false);
        isReborning = false;
    }


    // 伤害还要看 是否闪避 暴击 and so on 需要有一个DamageType 服务器应该会给
    protected virtual BattleDmgInfo PopDamage(BattleHurtParam battleHurtParam)
    {
        BattleDmgInfo battleDmgInfo = new BattleDmgInfo(battleField.guid, battleHurtParam);
        // 天子的挑战拦截血条逻辑
        BattleObject boss = battleField.FindBoss();
        // 修复：battleHurtParam.hurtObj.ObjID -> battleHurtParam.hurter.hurtObj.ObjID
        if (boss != null && battleField.MapID == 30020 && boss.ObjID == battleHurtParam.hurter.hurtObj.ObjID)
        {
            EventBroadcast.Instance.Broadcast(EventName.BATTLE_DAMAGE_TAKEN, battleDmgInfo);
            return battleDmgInfo;
        }
        else
        {
            heroInfoBar.UpdateDamage(battleDmgInfo);

            // YYL TODO 是否需要挂在在自身的follow点上
            EventBroadcast.Instance.Broadcast(EventName.BATTLE_DAMAGE_TAKEN, battleDmgInfo);
            return battleDmgInfo;
        }

    }

    /// <summary>
    /// 为施法者创建伤害信息（吸血/反伤）
    /// </summary>
    protected virtual BattleDmgInfo PopDamageForCaster(BattleHurtParam battleHurtParam)
    {
        // 传入 isCasterView=true 表示这是施法者视角
        BattleDmgInfo battleDmgInfo = new BattleDmgInfo(battleField.guid, battleHurtParam, _isCasterView: true);
        
        BattleObject boss = battleField.FindBoss();
        if (boss != null && battleField.MapID == 30020 && boss.ObjID == this.ObjID)
        {
            EventBroadcast.Instance.Broadcast(EventName.BATTLE_DAMAGE_TAKEN, battleDmgInfo);
            return battleDmgInfo;
        }
        else
        {
            heroInfoBar.UpdateDamage(battleDmgInfo);
            EventBroadcast.Instance.Broadcast(EventName.BATTLE_DAMAGE_TAKEN, battleDmgInfo);
            return battleDmgInfo;
        }
    }
    protected abstract BattleDmgInfo PopDamageForCaster(BattleHurtParam battleHurtParam);

    public RectTransform GetAliasTeamNode()
    {
@@ -575,26 +307,16 @@
        return Camp == BattleCamp.Red ? BattleCamp.Blue : BattleCamp.Red;
    }

    public void HaveRest()
    {
        // YYL TODO
        //  休息状态
        //  多一个zzz的一个特效
        heroGo.SetActive(true);
        motionBase.HaveRest();
        heroRectTrans.anchoredPosition = Vector2.zero;
        heroInfoBar.HaveRest();
        isReborning = false;
    public abstract void HaveRest();

        SetFront();
    }
    protected BattleDrops m_battleDrops;

    public void PushDropItems(BattleDrops _battleDrops)
    public virtual void PushDropItems(BattleDrops _battleDrops)
    {
        m_battleDrops = _battleDrops;
    }

    public void PerformDrop()
    public virtual void PerformDrop()
    {
        if (null == m_battleDrops)
            return;
@@ -603,7 +325,7 @@
            EventName.BATTLE_DROP_ITEMS, battleField.guid, m_battleDrops, OnPerformDropFinish);
    }

    protected void OnPerformDropFinish()
    protected virtual void OnPerformDropFinish()
    {
        m_battleDrops = null;
    }
@@ -618,85 +340,13 @@
        layerMgr.SetFront();
    }

    public void SetSpeedRatio(float ratio)
    {
        motionBase.SetSpeedRatio(ratio);
        heroInfoBar.SetSpeedRatio(ratio);
    }
    public abstract void SetSpeedRatio(float ratio);

    public void OnObjPropertyRefreshView(HB418_tagSCObjPropertyRefreshView vNetData)
    {
        // 天子的挑战拦截血条,不拦截怒气
        BattleObject boss = battleField.FindBoss();
        if (boss != null && battleField.MapID == 30020 && boss.ObjID == vNetData.ObjID && vNetData.RefreshType != (ushort)PlayerDataType.XP)
            return;

        // public uint ObjID;
        // public ushort RefreshType;    // 同0418刷新类型，如血量、怒气
        // public uint AttackTypes;    // 飘字类型汇总，支持多种类型并存，如无视防御且暴击同时被格挡，二进制或运算最终值；0-失败；1-普通；2-回血；5-格挡；6-无视防御；7-暴击；9-闪避
        // public uint Value;    // 更新值
        // public uint ValueEx;    // 更新值，如果是大数值的此值为整除亿部分
        // public byte DiffType;    // 变化类型，0-减少；1-增加
        // public uint DiffValue;    // 变化值
        // public uint DiffValueEx;    // 变化值，如果是大数值的此值为整除亿部分
        // public uint SkillID;    // 使用的技能表ID
        // public uint RelatedSkillID;    // 关联的技能ID，一般是主技能ID，非主技能额外触发的为0

        long diffValue = GeneralDefine.GetFactValue(vNetData.DiffValue, vNetData.DiffValueEx);
        diffValue *= vNetData.DiffType == 0 ? -1 : 1;

        long newValue = GeneralDefine.GetFactValue(vNetData.Value, vNetData.ValueEx);


        switch ((PlayerDataType)vNetData.RefreshType)
        {
            case PlayerDataType.HP:
                long toHp = GeneralDefine.GetFactValue(vNetData.Value, vNetData.ValueEx);
                bool isMinus = teamHero.curHp > toHp;
                if (!IsTianziBoss())
                {
                    heroInfoBar.UpdateHP(teamHero.curHp, toHp, teamHero.maxHp, false);
                }
                teamHero.curHp = newValue;
                // Debug.LogError("OnObjPropertyRefreshView " + teamHero.curHp);
                break;
            case PlayerDataType.MaxHP:
                teamHero.maxHp = newValue;
                if (!IsTianziBoss())
                {
                    heroInfoBar.UpdateHP(teamHero.curHp, teamHero.curHp, teamHero.maxHp, false);
                }
                break;
            case PlayerDataType.XP:
                long toXp = newValue;
                heroInfoBar.UpdateXP(teamHero.rage, toXp, 100);
                teamHero.rage = (int)newValue;

                DamageNumConfig damageNumConfig = DamageNumConfig.Get((int)DamageType.RageUp);
                string message = BattleUtility.ConvertToArtFont(damageNumConfig, diffValue);
                heroInfoBar.ShowTips(new BattleHeroInfoBar.TipsInfo()
                {
                    message = message,
                    useArtText = true,
                    followCharacter = true,
                    scaleRatio = 1f,
                    isRage = true
                });
                break;
            default:
                Debug.LogError("BattleObject.ObjPropertyRefreshView 出现意外类型 " + vNetData.RefreshType.ToString());
                break;
        }
    }
    public abstract void OnObjPropertyRefreshView(HB418_tagSCObjPropertyRefreshView vNetData);


#if UNITY_EDITOR_STOP_USING
    public void EditorRevive()
    {
        teamHero.curHp = 100;
        heroGo.SetActive(true);
        motionBase.PlayAnimation(MotionName.idle, true);
    }
    public abstract void EditorRevive();

    public List<int> TryAttack(BattleObject obj, SkillConfig skillConfig)
    {
@@ -744,7 +394,7 @@
            long totalReflect = casterDmgInfo.casterDamageList.Sum(d => d.damage);
            if (totalReflect > 0 && !buffMgr.isControled[BattleConst.HardControlGroup])
            {
                motionBase.PlayAnimation(MotionName.hit, false);
                OnPlayHitAnimation();
            }
        }
    }
@@ -780,4 +430,9 @@
    {
        return battleField.MapID == 30020 && battleField.FindBoss() == this;
    }

    /// <summary>
    /// 播放受击动画（只有 Hero 有实现，Mingge 留空）
    /// </summary>
    protected abstract void OnPlayHitAnimation();
}

 Main/System/Battle/BattleObject/BattleObjectFactory.cs

@@ -47,7 +47,7 @@
        GameObject battleGO = ResManager.Instance.LoadAsset<GameObject>("Hero/SpineRes", "Hero_001"/*skinCfg.SpineRes*/);

        GameObject goParent = posNodeList[teamHero.positionNum];
        BattleObject battleObject = new BattleObject(_battleField);
        BattleObject battleObject = Produce(teamHero.positionNum, _battleField);
        battleObject.ObjID = teamHero.ObjID;

        GameObject realGO = GameObject.Instantiate(battleGO, goParent.transform);
@@ -73,7 +73,16 @@
        realGO.transform.localScale = new Vector3(finalScaleRate, finalScaleRate, finalScaleRate);
        RectTransform rectTrans = realGO.GetComponent<RectTransform>();
        rectTrans.anchoredPosition = Vector2.zero;
        battleObject.Init(realGO, teamHero, _Camp);
        
        // HeroBattleObject 才有 GameObject 参数的 Init 方法
        if (battleObject is HeroBattleObject heroBattleObject)
        {
            heroBattleObject.Init(realGO, teamHero, _Camp);
        }
        else
        {
            battleObject.Init(teamHero, _Camp);
        }

#if UNITY_EDITOR
        BattleDebug.LogError(
@@ -87,6 +96,28 @@
        return battleObject;
    }

    public static BattleObject Produce(int positionNum, BattleField battleField)
    {
        if (positionNum >= 0)
        {
            return new HeroBattleObject(battleField);
        }
        else if (positionNum == 99)
        {
            //  命格
            return new MinggeBattleObject(battleField);
        }
        // else if (positionNum >= 101)
        // {
        //     //  灵兽
        //     return new SpiritBeastBattleObject(battleField);
        // }
        else
        {
            return new HeroBattleObject(battleField);
        }
    }

    public static void DestroyBattleObject(int key, BattleObject battleObj)
    {
        battleObj.Destroy();

 Main/System/Battle/BattleObject/BattleObjectLayerMgr.cs

@@ -22,8 +22,8 @@
    public void Init(BattleObject battleObj)
    {
        this.battleObj = battleObj;
        frontCharRendererAdjuster = battleObj.heroGo.AddMissingComponent<RendererAdjuster>();
        behindCharRendererAdjuster = battleObj.heroRectTrans.Find("Hero/Follower/BattleHeroInfoBar/BehindHero").gameObject.AddMissingComponent<RendererAdjuster>();
        frontCharRendererAdjuster = battleObj.GetGameObject()?.AddMissingComponent<RendererAdjuster>();
        behindCharRendererAdjuster = battleObj.GetRectTransform()?.Find("Hero/Follower/BattleHeroInfoBar/BehindHero")?.gameObject?.AddMissingComponent<RendererAdjuster>();


        frontCharRendererAdjuster.canvasOffset = BattleConst.BattleFrontCharUIOffset;

 Main/System/Battle/BattleObject/HeroBattleObject.cs

New file
@@ -0,0 +1,680 @@
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using Spine.Unity;
using UnityEngine.UI;
using System.Linq;

public class HeroBattleObject : BattleObject
{
    private GameObject _heroGo;
    public GameObject heroGo => _heroGo;

    public MotionBase motionBase;

    private RectTransform m_heroRectTrans;

    public RectTransform heroRectTrans
    {
        get
        {
            if (m_heroRectTrans == null && _heroGo != null)
            {
                m_heroRectTrans = _heroGo.GetComponent<RectTransform>();
            }
            return m_heroRectTrans;
        }
    }

    protected Action onDeathAnimationComplete;

    protected Renderer[] renderers;

    private List<HB405_tagMCAddExp> hB405_tagMCAddExps = new List<HB405_tagMCAddExp>();
    
    private BattleHeroInfoBar _heroInfoBar;
    public BattleHeroInfoBar heroInfoBar => _heroInfoBar;

    private bool _isReborning = false;
    public bool isReborning 
    { 
        get => _isReborning; 
        set => _isReborning = value; 
    }

    public HeroBattleObject(BattleField _battleField) : base(_battleField)
    {
    }

    public void Init(GameObject _heroGo, TeamHero _teamHero, BattleCamp _camp)
    {
        this._heroGo = _heroGo;
        Init(_teamHero, _camp);
    }

    public override void Init(TeamHero _teamHero, BattleCamp _camp)
    {
        teamHero = _teamHero;
        Camp = _camp;
        motionBase = new MotionBase();
        motionBase.Init(_heroGo.GetComponentInChildren<SkeletonAnimation>(true));
        buffMgr = new BattleObjectBuffMgr();
        buffMgr.Init(this);

        buffMgr.onIsControlChanged += OnControledChange;

        layerMgr = new BattleObjectLayerMgr();
        layerMgr.Init(this);

        renderers = _heroGo.GetComponentsInChildren<Renderer>(true);

        _heroInfoBar = _heroGo.GetComponentInChildren<BattleHeroInfoBar>(true);
        _heroInfoBar.SetBattleObject(this);

        //  根据阵营翻转血条
        var heroInfoBarScale = _heroInfoBar.transform.localScale;
        heroInfoBarScale.x *= Camp == BattleCamp.Red ? 1 : -1;
        _heroInfoBar.transform.localScale = heroInfoBarScale;
        if (battleField is StoryBattleField && (battleField as StoryBattleField).battleState == StoryBattleState.Break)
        {
            //主线关卡休息中的不显示血条
            heroInfoBar.SetActive(false);
        }
        else
        {
            heroInfoBar.SetActive(true);
        }
        SetFront();
    }

    public override void Run()
    {
        motionBase.Run();
        heroInfoBar.Run();
        buffMgr.Run();
    }

    public override void Pause()
    {
        motionBase.Pause();
    }

    public override void Resume()
    {
        motionBase.Resume();
    }

    public override void Destroy()
    {
        motionBase.Release();
        motionBase = null;
        buffMgr.onIsControlChanged -= OnControledChange;
        buffMgr.Release();
        buffMgr = null;
        teamHero = null;
        ObjID = 0;

        if (_heroGo != null)
        {
            GameObject.DestroyImmediate(_heroGo);
            _heroGo = null;
        }
    }

    // ============ 动画相关方法实现（通过 motionBase） ============
    
    public override void PlayAnimation(MotionName motionName, bool loop)
    {
        motionBase.PlayAnimation(motionName, loop);
    }
    
    public override void ShowIllusionShadow(bool show, Color? color = null)
    {
        if (color.HasValue)
        {
            motionBase.ShowIllusionShadow(show, color.Value);
        }
        else
        {
            motionBase.ShowIllusionShadow(show);
        }
    }
    
    public override Spine.TrackEntry PlaySkillAnimation(SkillConfig skillConfig, SkillBase skillBase, bool isCounter, Action onComplete)
    {
        return motionBase.PlaySkillAnimation(skillConfig, skillBase, isCounter, onComplete);
    }
    
    public override bool CanStartDeath()
    {
        return motionBase.CanStartDeath();
    }
    
    public override bool CanCastSkillAnimation(SkillConfig skillConfig)
    {
        return motionBase.CanCastSkill(skillConfig);
    }
    
    public override SkeletonAnimation GetSkeletonAnimation()
    {
        return motionBase.skeletonAnim;
    }
    
    public override void SetSkeletonAlpha(float alpha)
    {
        if (motionBase.skeletonAnim != null)
        {
            motionBase.skeletonAnim.skeleton.A = alpha;
        }
    }
    
    public override RectTransform GetRectTransform() => heroRectTrans;
    
    public override GameObject GetGameObject() => _heroGo;
    
    public override Transform GetTransform() => _heroGo?.transform;
    
    public override Vector3 GetPosition() => heroRectTrans != null ? heroRectTrans.position : Vector3.zero;
    
    public override BattleHeroInfoBar GetHeroInfoBar() => _heroInfoBar;
    
    public override void RefreshBuff(List<HB428_tagSCBuffRefresh> buffList)
    {
        _heroInfoBar?.RefreshBuff(buffList);
    }
    
    public override void UpdateHP(float percentage)
    {
        _heroInfoBar?.UpdateHP(percentage);
    }
    public override bool IsReborning() => _isReborning;
    
    public override void SetReborning(bool value) => _isReborning = value;
    
    public override void SetActive(bool active)
    {
        if (_heroGo != null)
        {
            _heroGo.SetActive(active);
        }
    }
    
    public override void ResetPosition()
    {
        if (heroRectTrans != null)
        {
            heroRectTrans.anchoredPosition = Vector2.zero;
        }
    }
    
    public override void SetFacing(float direction)
    {
        if (_heroGo != null)
        {
            Vector3 scale = _heroGo.transform.localScale;
            scale.x = Mathf.Abs(scale.x) * direction;
            _heroGo.transform.localScale = scale;
        }
    }
    
    public override void ResetFacing() => SetFacing(1f);
    
    public override void StopMoveAnimation()
    {
        if (heroRectTrans != null)
        {
            DG.Tweening.DOTween.Kill(heroRectTrans);
        }
    }
    
    public override void ShowTips(string message, bool useArtText = false, bool followCharacter = true, float scaleRatio = 1f)
    {
        _heroInfoBar?.ShowTips(message, useArtText, followCharacter, scaleRatio);
    }
    
    public override void ShowTips(BattleHeroInfoBar.TipsInfo tipsInfo)
    {
        _heroInfoBar?.ShowTips(tipsInfo);
    }

    //  有变化了才会调用这个函数
    private void OnControledChange(int groupType, bool value)
    {
        //  这里是受到硬控时候 需要表现的动画
        if (groupType == BattleConst.HardControlGroup)
        {
            //  从没被硬控到被硬控
            if (value)
            {
                motionBase.SetControledAnimation();
            }
            else
            {
                motionBase.CancelControledAnimation();
            }
        }
    }

    public override void OnObjInfoRefresh(H0418_tagObjInfoRefresh _refreshInfo)
    {
        // 天子的挑战拦截血条,不拦截怒气
        BattleObject boss = battleField.FindBoss();
        if (boss != null && battleField.MapID == 30020 && boss.ObjID == _refreshInfo.ObjID && _refreshInfo.RefreshType != (ushort)PlayerDataType.XP)
            return;
        switch ((PlayerDataType)_refreshInfo.RefreshType)
        {
            case PlayerDataType.HP:
                long toHp = GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                if (!IsTianziBoss())
                {
                    heroInfoBar.UpdateHP(teamHero.curHp, toHp, teamHero.maxHp, false);
                }
                teamHero.curHp = GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                // Debug.LogError("OnObjInfoRefresh " + teamHero.curHp);
                break;
            case PlayerDataType.MaxHP:
                teamHero.maxHp = GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                if (!IsTianziBoss())
                {
                    heroInfoBar.UpdateHP(teamHero.curHp, teamHero.curHp, teamHero.maxHp, false);
                }
                break;
            case PlayerDataType.XP:
                long toXp = GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                heroInfoBar.UpdateXP(teamHero.rage, toXp, 100);
                teamHero.rage = (int)GeneralDefine.GetFactValue(_refreshInfo.Value, _refreshInfo.ValueEx);
                break;
            default:
                Debug.LogError("BattleObject.ObjInfoRefresh 出现意外类型 " + _refreshInfo.RefreshType.ToString());
                break;
        }
    }

    public override DeathRecordAction Hurt(BattleHurtParam battleHurtParam, SkillRecordAction _parentSkillAction = null)
    {
        DeathRecordAction recordAction = null;
        bool isLastHit = battleHurtParam.hitIndex >= battleHurtParam.skillConfig.DamageDivide.Length - 1;
        bool firstHit = battleHurtParam.hitIndex == 0;
        
        // 添加调试日志
        bool isHealing = BattleUtility.IsHealing(battleHurtParam.hurt);
    
        BattleDmgInfo dmgInfo = PopDamage(battleHurtParam);

        // ============ 应用目标的血量和护盾变化 ============
        ApplyHurtToTarget(battleHurtParam, isLastHit);

        //  这里
        if (dmgInfo.IsType(DamageType.Dodge) /*&& !buffMgr.isControled[BattleConst.HardControlGroup]*/)//如果被控制了还闪避了 要看看服务器怎么处理了
        {
            if (isLastHit)
            {
                DodgeFinishAction dodgeFinish = new DodgeFinishAction(battleField, this);
                // 【使用 BattleField.recordPlayer】
                // 原因：闪避完成动作是目标角色的独立行为，不是技能内部产生的
                // 虽然是在Hurt过程中触发，但是闪避动作本身是目标的反应，应该由主RecordPlayer管理
                // 使用InsertRecord可以插到队列最前面，保证闪避表现的优先级
                battleField.recordPlayer.InsertRecord(dodgeFinish);
            }

            if (firstHit)
            {
                OnDodgeBegin();
            }
        }

        bool isFatalAttack = (null != battleHurtParam.deadPack) && isLastHit;

        if (isFatalAttack)
        {
            if (null != battleHurtParam.battleDrops)
            {
                PushDropItems(battleHurtParam.battleDrops);
            }
            recordAction = battleField.OnObjsDead(new List<BattleDeadPack>() { battleHurtParam.deadPack }, _parentSkillAction, _parentSkillAction);
        }
        else
        {
            if (dmgInfo.IsType(DamageType.Block))
            {
                battleField.battleEffectMgr.PlayEffect(this, BattleConst.BlockEffectID, heroRectTrans, Camp, teamHero.modelScale);
            }
            // else
            // {
            if ((dmgInfo.IsType(DamageType.Damage) || dmgInfo.IsRealdamage()))
            {
                if (!buffMgr.isControled[BattleConst.HardControlGroup])
                {
                    battleField.soundManager.PlayEffectSound(teamHero.heroConfig.HitSFX, false);
                    motionBase.PlayAnimation(MotionName.hit, false);
                }
            }
            // }
        }

        return recordAction;
    }

    /// <summary>
    /// 应用目标的血量和护盾变化
    /// </summary>
    private void ApplyHurtToTarget(BattleHurtParam battleHurtParam, bool isLastHit)
    {
        BattleHurtObj hurter = battleHurtParam.hurter;
        
        // 应用血量变化
        teamHero.curHp = hurter.toHp;

#if UNITY_EDITOR
        // 最后一击时验证血量是否与服务器一致
        if (isLastHit)
        {
            BattleUtility.ValidateHpConsistency(battleHurtParam, "目标受伤");
        }
#endif
    }

    const float pingpongTime = 0.4f;
    //  闪避开始
    public override void OnDodgeBegin()
    {
        RectTransform rectTrans = heroRectTrans;
        var tween = rectTrans.DOAnchorPos(new Vector3(-30, 0, 0), pingpongTime)
            .SetEase(Ease.OutCubic);

        motionBase.ShowIllusionShadow(true);

        DamageNumConfig damageNumConfig = DamageNumConfig.Get((int)DamageType.Dodge);

        string dodgeStr = ((char)damageNumConfig.prefix).ToString();

        heroInfoBar.ShowTips(dodgeStr, true, false);

        tween.onComplete += () =>
        {
            motionBase.ShowIllusionShadow(false);
        };

        battleField.soundManager.PlayEffectSound(BattleConst.DodgeSoundID);

        battleField.battleTweenMgr.OnPlayTween(tween);
    }

    //  闪避结束
    public override void OnDodgeEnd(Action _complete = null)
    {
        RectTransform rectTrans = heroRectTrans;

        var tween = rectTrans.DOAnchorPos(Vector3.zero, pingpongTime)
                            .SetEase(Ease.OutCubic);

        tween.onComplete += () =>
        {
            _complete?.Invoke();
        };

        battleField.battleTweenMgr.OnPlayTween(tween);
    }

    public override void OnDeath(Action _onDeathAnimationComplete, bool withoutAnime = false)
    {
        buffMgr.RemoveAllBuff();
        battleField.soundManager.PlayEffectSound(teamHero.heroConfig.DeathSFX, false);
        if (withoutAnime)
        {
            SetDeath();
            _onDeathAnimationComplete?.Invoke();
        }
        else
        {
            motionBase.PlayDeadAnimation(() =>
            {
                SetDeath();
                _onDeathAnimationComplete?.Invoke();
            });
        }
    }

    public override void SetDeath()
    {
        teamHero.isDead = true;
        OnDeadAnimationComplete();
    }

    protected virtual void OnDeadAnimationComplete()
    {
        //  或许看看溶解特效？ YYL TODO
        heroGo.SetActive(false);

        //  防止给死亡对象又上buff
        buffMgr.RemoveAllBuff();
    }

    //  释放者就是复活者时调用
    public override void PreReborn(bool reviveSelf = false)
    {
        heroGo.SetActive(true);
        motionBase.skeletonAnim.skeleton.A = 0f;
        motionBase.skeletonAnim.LateUpdate();
        heroRectTrans.anchoredPosition = Vector2.zero;
        motionBase.ResetForReborn(reviveSelf);
    }

    //  复活action
    public override void OnReborn(HB427_tagSCUseSkill.tagSCUseSkillHurt vNetData, bool reviveSelf = false, RecordAction parentAction = null)
    {
        isReborning = true;
        heroGo.SetActive(true);
        motionBase.ResetForReborn(reviveSelf);
        heroRectTrans.anchoredPosition = Vector2.zero;
        motionBase.skeletonAnim.skeleton.A = 0f;
        motionBase.skeletonAnim.LateUpdate();
    }

    public override void AfterReborn()
    {
        //  清空所有
        motionBase.ResetForReborn(false);
        isReborning = false;
    }

    // 伤害还要看 是否闪避 暴击 and so on 需要有一个DamageType 服务器应该会给
    protected override BattleDmgInfo PopDamage(BattleHurtParam battleHurtParam)
    {
        BattleDmgInfo battleDmgInfo = new BattleDmgInfo(battleField.guid, battleHurtParam);
        // 天子的挑战拦截血条逻辑
        BattleObject boss = battleField.FindBoss();
        // 修复：battleHurtParam.hurtObj.ObjID -> battleHurtParam.hurter.hurtObj.ObjID
        if (boss != null && battleField.MapID == 30020 && boss.ObjID == battleHurtParam.hurter.hurtObj.ObjID)
        {
            EventBroadcast.Instance.Broadcast(EventName.BATTLE_DAMAGE_TAKEN, battleDmgInfo);
            return battleDmgInfo;
        }
        else
        {
            heroInfoBar.UpdateDamage(battleDmgInfo);

            // YYL TODO 是否需要挂在在自身的follow点上
            EventBroadcast.Instance.Broadcast(EventName.BATTLE_DAMAGE_TAKEN, battleDmgInfo);
            return battleDmgInfo;
        }
    }

    /// <summary>
    /// 为施法者创建伤害信息（吸血/反伤）
    /// </summary>
    protected override BattleDmgInfo PopDamageForCaster(BattleHurtParam battleHurtParam)
    {
        // 传入 isCasterView=true 表示这是施法者视角
        BattleDmgInfo battleDmgInfo = new BattleDmgInfo(battleField.guid, battleHurtParam, _isCasterView: true);
        
        BattleObject boss = battleField.FindBoss();
        if (boss != null && battleField.MapID == 30020 && boss.ObjID == this.ObjID)
        {
            EventBroadcast.Instance.Broadcast(EventName.BATTLE_DAMAGE_TAKEN, battleDmgInfo);
            return battleDmgInfo;
        }
        else
        {
            heroInfoBar.UpdateDamage(battleDmgInfo);
            EventBroadcast.Instance.Broadcast(EventName.BATTLE_DAMAGE_TAKEN, battleDmgInfo);
            return battleDmgInfo;
        }
    }

    public override void HaveRest()
    {
        // YYL TODO
        //  休息状态
        //  多一个zzz的一个特效
        heroGo.SetActive(true);
        motionBase.HaveRest();
        heroRectTrans.anchoredPosition = Vector2.zero;
        heroInfoBar.HaveRest();
        isReborning = false;

        SetFront();
    }
    public override void SetSpeedRatio(float ratio)
    {
        motionBase.SetSpeedRatio(ratio);
        heroInfoBar.SetSpeedRatio(ratio);
    }
    public override void PushDropItems(BattleDrops _battleDrops)
    {
        m_battleDrops = _battleDrops;
    }

    public override void PerformDrop()
    {
        if (null == m_battleDrops)
            return;

        EventBroadcast.Instance.Broadcast<string, BattleDrops, Action>(
            EventName.BATTLE_DROP_ITEMS, battleField.guid, m_battleDrops, OnPerformDropFinish);
    }

    protected override void OnPerformDropFinish()
    {
        m_battleDrops = null;
    }

    public override void OnObjPropertyRefreshView(HB418_tagSCObjPropertyRefreshView vNetData)
    {
        // 天子的挑战拦截血条,不拦截怒气
        BattleObject boss = battleField.FindBoss();
        if (boss != null && battleField.MapID == 30020 && boss.ObjID == vNetData.ObjID && vNetData.RefreshType != (ushort)PlayerDataType.XP)
            return;

        long diffValue = GeneralDefine.GetFactValue(vNetData.DiffValue, vNetData.DiffValueEx);
        diffValue *= vNetData.DiffType == 0 ? -1 : 1;

        long newValue = GeneralDefine.GetFactValue(vNetData.Value, vNetData.ValueEx);

        switch ((PlayerDataType)vNetData.RefreshType)
        {
            case PlayerDataType.HP:
                long toHp = GeneralDefine.GetFactValue(vNetData.Value, vNetData.ValueEx);
                bool isMinus = teamHero.curHp > toHp;
                if (!IsTianziBoss())
                {
                    heroInfoBar.UpdateHP(teamHero.curHp, toHp, teamHero.maxHp, false);
                }
                teamHero.curHp = newValue;
                // Debug.LogError("OnObjPropertyRefreshView " + teamHero.curHp);
                break;
            case PlayerDataType.MaxHP:
                teamHero.maxHp = newValue;
                if (!IsTianziBoss())
                {
                    heroInfoBar.UpdateHP(teamHero.curHp, teamHero.curHp, teamHero.maxHp, false);
                }
                break;
            case PlayerDataType.XP:
                long toXp = newValue;
                heroInfoBar.UpdateXP(teamHero.rage, toXp, 100);
                teamHero.rage = (int)newValue;

                DamageNumConfig damageNumConfig = DamageNumConfig.Get((int)DamageType.RageUp);
                string message = BattleUtility.ConvertToArtFont(damageNumConfig, diffValue);
                heroInfoBar.ShowTips(new BattleHeroInfoBar.TipsInfo()
                {
                    message = message,
                    useArtText = true,
                    followCharacter = true,
                    scaleRatio = 1f,
                    isRage = true
                });
                break;
            default:
                Debug.LogError("BattleObject.ObjPropertyRefreshView 出现意外类型 " + vNetData.RefreshType.ToString());
                break;
        }
    }

    public override void OnHurtTarget(BattleHurtParam battleHurtParam)
    {
        // 检查是否有吸血或反伤
        bool hasSuckHp = battleHurtParam.caster.suckHpList != null && battleHurtParam.caster.suckHpList.Count > 0;
        bool hasReflectHp = battleHurtParam.caster.reflectHpList != null && battleHurtParam.caster.reflectHpList.Count > 0;
        
        if (!hasSuckHp && !hasReflectHp)
        {
            return;
        }

        // ============ 应用施法者的血量和护盾变化 ============
        bool isLastHit = battleHurtParam.hitIndex >= battleHurtParam.skillConfig.DamageDivide.Length - 1;
        ApplyHurtToCaster(battleHurtParam, isLastHit);

        // 和Hurt一样，调用PopDamage处理吸血/反伤的显示
        BattleDmgInfo casterDmgInfo = PopDamageForCaster(battleHurtParam);
        
        // 如果有反伤，施法者播放受击动画
        if (hasReflectHp && casterDmgInfo.casterDamageList != null && casterDmgInfo.casterDamageList.Count > 0)
        {
            long totalReflect = casterDmgInfo.casterDamageList.Sum(d => d.damage);
            if (totalReflect > 0 && !buffMgr.isControled[BattleConst.HardControlGroup])
            {
                motionBase.PlayAnimation(MotionName.hit, false);
            }
        }
    }

    /// <summary>
    /// 应用施法者的血量和护盾变化（吸血和反伤）
    /// </summary>
    private void ApplyHurtToCaster(BattleHurtParam battleHurtParam, bool isLastHit)
    {
        BattleCastObj caster = battleHurtParam.caster;
        
        // 应用血量变化
        teamHero.curHp = caster.toHp;
        
#if UNITY_EDITOR
        // 最后一击时验证血量是否与服务器一致
        if (isLastHit)
        {
            BattleUtility.ValidateHpConsistencyForCaster(battleHurtParam, "施法者吸血/反伤");
        }
#endif
    }

#if UNITY_EDITOR_STOP_USING
    public override void EditorRevive()
    {
        teamHero.curHp = 100;
        heroGo.SetActive(true);
        motionBase.PlayAnimation(MotionName.idle, true);
    }
#endif

    protected override void OnPlayHitAnimation()
    {
        motionBase.PlayAnimation(MotionName.hit, false);
    }
}

 Main/System/Battle/BattleObject/HeroBattleObject.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 358b6cdb61b081c4b9e766c10ae885af
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Main/System/Battle/BattleObject/MinggeBattleObject.cs

New file
@@ -0,0 +1,157 @@

using System;
using UnityEngine;
using Spine.Unity;

/// <summary>
/// 命格战斗对象 - 没有血量、没有实体，不会被攻击和选中，唯一作用是释放技能
/// </summary>
public class MinggeBattleObject : BattleObject
{
    public MinggeBattleObject(BattleField _battleField) : base(_battleField)
    {
    }

    public override void Init(TeamHero _teamHero, BattleCamp _camp)
    {
        teamHero = _teamHero;
        Camp = _camp;
        
        // 命格只需要 buff 管理器用于技能效果
        buffMgr = new BattleObjectBuffMgr();
        buffMgr.Init(this);
        
        layerMgr = new BattleObjectLayerMgr();
        layerMgr.Init(this);
    }

    public override void Run()
    {
        // 命格运行逻辑（如果需要）
    }

    public override void Pause()
    {
        // 命格暂停
    }

    public override void Resume()
    {
        // 命格恢复
    }

    public override void Destroy()
    {
        if (buffMgr != null)
        {
            buffMgr.Release();
        }
    }

    // ============ 动画相关方法实现（命格没有动画） ============
    
    public override void PlayAnimation(MotionName motionName, bool loop)
    {
        // 命格没有动画
    }
    
    public override void ShowIllusionShadow(bool show, Color? color = null)
    {
        // 命格没有幻影
    }
    
    public override Spine.TrackEntry PlaySkillAnimation(SkillConfig skillConfig, SkillBase skillBase, bool isCounter, Action onComplete)
    {
        // 命格没有技能动画，直接完成
        onComplete?.Invoke();
        return null;
    }
    
    public override bool CanStartDeath()
    {
        // 命格不会死亡
        return false;
    }
    
    public override bool CanCastSkillAnimation(SkillConfig skillConfig)
    {
        // 命格总是可以释放技能（从动画角度）
        return true;
    }
    
    public override SkeletonAnimation GetSkeletonAnimation()
    {
        // 命格没有骨骼动画
        return null;
    }
    
    public override void SetSkeletonAlpha(float alpha)
    {
        // 命格没有骨骼动画
    }

    // ============ 以下方法命格不需要，但必须实现接口 ============

    public override DeathRecordAction Hurt(BattleHurtParam battleHurtParam, SkillRecordAction _parentSkillAction = null)
    {
        // 命格不会被攻击
        Debug.LogWarning("命格不应该被攻击");
        return null;
    }

    public override void OnDodgeBegin()
    {
        // 命格不需要闪避
    }

    public override void OnDodgeEnd(Action _complete = null)
    {
        // 命格不需要闪避
        _complete?.Invoke();
    }

    public override void OnDeath(Action _onDeathAnimationComplete, bool withoutAnime = false)
    {
        // 命格没有死亡
        _onDeathAnimationComplete?.Invoke();
    }

    protected override BattleDmgInfo PopDamage(BattleHurtParam battleHurtParam)
    {
        // 命格不显示伤害
        return null;
    }

    protected override BattleDmgInfo PopDamageForCaster(BattleHurtParam battleHurtParam)
    {
        // 命格不显示伤害
        return null;
    }

    public override void HaveRest()
    {
        // 命格不需要休息状态
    }

    public override void SetSpeedRatio(float ratio)
    {
        // 命格不需要速度控制
    }

    public override void OnObjPropertyRefreshView(HB418_tagSCObjPropertyRefreshView vNetData)
    {
        // 命格没有血量，不需要属性刷新
    }

#if UNITY_EDITOR_STOP_USING
    public override void EditorRevive()
    {
        // 命格不需要复活
    }
#endif

    protected override void OnPlayHitAnimation()
    {
        // 命格不需要受击动画
    }
}

 Main/System/Battle/BattleObject/MinggeBattleObject.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: a8a19a09ccd7bc445af39c15aa3e343f
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Main/System/Battle/Buff/BattleObjectBuffMgr.cs

@@ -61,7 +61,7 @@
                    return;
                }
                int[] effectPos = effectPlayer.effectConfig.effectPos;
                effectPlayer.transform.position = battleObject.heroRectTrans.position;
                effectPlayer.transform.position = battleObject.GetPosition();
                if (null != effectPos && effectPos.Length >= 2)
                {
                    effectPlayer.rectTrans.anchoredPosition += new Vector2(effectPos[0], effectPos[1]);
@@ -297,7 +297,7 @@
            else
            {
                BattleEffectPlayer effect = battleObject.battleField.battleEffectMgr
                    .PlayEffect(battleObject, skillConfig.BuffEffect, battleObject.heroRectTrans, battleObject.Camp, battleObject.teamHero.modelScale);
                    .PlayEffect(battleObject, skillConfig.BuffEffect, battleObject.GetRectTransform(), battleObject.Camp, battleObject.teamHero.modelScale);

                effect.BindBone(battleObject, effect.effectConfig.nodeName);

@@ -321,7 +321,7 @@

        UpdateControlState();

        battleObject.heroInfoBar.RefreshBuff(buffDataDict.Values.ToList());
        battleObject.RefreshBuff(buffDataDict.Values.ToList());
        onBuffChanged?.Invoke();

        // bool isUnderControl = false;

 Main/System/Battle/Skill/SkillBase.cs

@@ -225,13 +225,13 @@
            if (change)
            {
                MoveSpeed = 1125f;
                caster.motionBase.ShowIllusionShadow(true, color);
                caster.ShowIllusionShadow(true, color);
            }
        }
        else
        {
            MoveSpeed = 750f;
            caster.motionBase.ShowIllusionShadow(false);
            caster.ShowIllusionShadow(false);
        }
    }

@@ -303,7 +303,7 @@
    {
        if (hintConfig != null)
        {
            battleObject.heroInfoBar.ShowTips(((char)hintConfig.prefix).ToString(), true, false, 1.25f);
            battleObject.ShowTips(((char)hintConfig.prefix).ToString(), true, false, 1.25f);
        }
    }

@@ -427,10 +427,10 @@
            return;
        }

        caster.motionBase.PlayAnimation(MotionName.run, true);
        var tweener = BattleUtility.MoveToTarget(caster.heroRectTrans, target, offset, () =>
        caster.PlayAnimation(MotionName.run, true);
        var tweener = BattleUtility.MoveToTarget(caster.GetRectTransform(), target, offset, () =>
        {
            caster.motionBase.PlayAnimation(MotionName.idle, true);
            caster.PlayAnimation(MotionName.idle, true);
            _onComplete?.Invoke();
        }, speed);
        battleField.battleTweenMgr.OnPlayTween(tweener);
@@ -441,9 +441,7 @@
    {
        if (skillConfig.CastDistance < 0)
        {
            Vector3 scale = caster.heroGo.transform.localScale;
            scale.x = Mathf.Abs(scale.x) * forward;
            caster.heroGo.transform.localScale = scale;
            caster.SetFacing(forward);
        }
        _onComplete?.Invoke();
    }
@@ -453,7 +451,7 @@
    {
        TurnBack(null, 1f);
        OnAllAttackMoveFinished();
        caster.motionBase.PlayAnimation(MotionName.idle, true);
        caster.PlayAnimation(MotionName.idle, true);
    }

    // 所有攻击移动完成后的处理：恢复UI显示状态
@@ -464,7 +462,7 @@
        foreach (BattleObject bo in allList)
        {
            bo.layerMgr.SetFront();
            bo.heroInfoBar.SetActive(true);
            bo.GetHeroInfoBar()?.SetActive(true);
        }
        battleField.battleRootNode.skillMaskNode.SetActive(false);
    }
@@ -472,7 +470,7 @@
    // 执行技能释放动画和逻辑：播放施法动作并提供回调
    protected TrackEntry CastImpl(Action onComplete = null)
    {
        return caster.motionBase.PlaySkillAnimation(skillConfig, this, tagUseSkillAttack.BattleType == 4, onComplete);
        return caster.PlaySkillAnimation(skillConfig, this, tagUseSkillAttack.BattleType == 4, onComplete);
    }

    // 技能开始回调：处理死亡、子技能、技能效果初始化
@@ -656,7 +654,7 @@
        var highlightSet = new HashSet<BattleObject>(highlightList);

        // 先把施法者的 InfoBar 隐藏（原逻辑保留）
        caster.heroInfoBar.SetActive(false);
        caster.GetHeroInfoBar()?.SetActive(false);

        foreach (BattleObject bo in allList)
        {
@@ -673,7 +671,7 @@
            }

            // 目标（含 HurtListEx）都应显示 InfoBar
            bo.heroInfoBar.SetActive(isTarget);
            bo.GetHeroInfoBar()?.SetActive(isTarget);
        }

        battleField.battleRootNode.skillMaskNode.SetActive(true);
@@ -790,7 +788,7 @@
                        DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.BreakArmor);
                        Hint(battleObject, hintConfig);
                        battleField.battleEffectMgr.PlayEffect(battleObject, 
                            BattleConst.BreakArmorEffectID, battleObject.heroRectTrans, battleObject.Camp, 
                            BattleConst.BreakArmorEffectID, battleObject.GetRectTransform(), battleObject.Camp, 
                            battleObject.teamHero.modelScale);
                    }
                }
@@ -802,7 +800,7 @@
                        DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.Parry);
                        Hint(battleObject, hintConfig);
                        battleField.battleEffectMgr.PlayEffect(battleObject, 
                            BattleConst.ParryEffectID, battleObject.heroRectTrans, battleObject.Camp, 
                            BattleConst.ParryEffectID, battleObject.GetRectTransform(), battleObject.Camp, 
                            battleObject.teamHero.modelScale);
                    }
                }
@@ -1022,7 +1020,7 @@
            
            BattleDrops battleDrops = new BattleDrops()
            {
                rectTransform = deadTarget.heroRectTrans,
                rectTransform = deadTarget.GetRectTransform(),
                dropItemPackIndex = itemIndexList,
                expDrops = expAssign[i]
            };
@@ -1323,30 +1321,22 @@
        }

        // 3. 清理 DOTween 动画（防止移动回调在战斗结束后执行）
        if (caster != null && caster.heroRectTrans != null)
        if (caster != null)
        {
            DG.Tweening.DOTween.Kill(caster.heroRectTrans);
            caster.StopMoveAnimation();
        }

        // 4. 重置施法者状态
        if (caster != null)
        {
            // 重置位置到原点
            if (caster.heroRectTrans != null)
            {
                caster.heroRectTrans.anchoredPosition = Vector2.zero;
            }
            caster.ResetPosition();
            
            // 重置朝向
            if (caster.heroGo != null)
            {
                Vector3 scale = caster.heroGo.transform.localScale;
                scale.x = Mathf.Abs(scale.x);
                caster.heroGo.transform.localScale = scale;
            }
            caster.ResetFacing();

            // 取消幻影效果
            caster.motionBase?.ShowIllusionShadow(false);
            caster.ShowIllusionShadow(false);
        }

        // 5. 恢复 UI 状态
@@ -1359,7 +1349,7 @@
                foreach (BattleObject bo in allList)
                {
                    bo.layerMgr?.SetFront();
                    bo.heroInfoBar?.SetActive(true);
                    bo.GetHeroInfoBar()?.SetActive(true);
                }
            }
            

 Main/System/Battle/SkillEffect/BulletCurve/BounceBulletCurve.cs

@@ -64,7 +64,16 @@
            var nextTargetObj = caster.battleField.battleObjMgr.GetBattleObject((int)hurtList[curIndex].ObjID);
            if (nextTargetObj != null && !nextTargetObj.IsDead())
            {
                end = WorldToLocalAnchoredPosition(nextTargetObj.heroRectTrans.position);
                RectTransform targetRect = nextTargetObj.GetRectTransform();
                if (targetRect != null)
                {
                    end = WorldToLocalAnchoredPosition(targetRect.position);
                }
                else
                {
                    BattleDebug.LogError("弹射目标没有RectTransform");
                    end = start;
                }
            }
            else
            {

 Main/System/Battle/SkillEffect/BulletCurve/BulletCurve.cs

@@ -34,14 +34,15 @@
        this.hurts = hurtList;
        this.mBulletIndex = bulletIndex;

        // 设置bulletTrans坐标为caster.heroRectTrans的世界坐标转换到bulletTrans父节点下的本地坐标
        if (bulletTrans != null && caster.heroRectTrans != null)
        // 设置bulletTrans坐标为caster的世界坐标转换到bulletTrans父节点下的本地坐标
        RectTransform casterRect = caster.GetRectTransform();
        if (bulletTrans != null && casterRect != null)
        {
            var parent = bulletTrans.parent as RectTransform;
            Vector2 localPoint;
            RectTransformUtility.ScreenPointToLocalPointInRectangle(
                parent,
                RectTransformUtility.WorldToScreenPoint(null, caster.heroRectTrans.position),
                RectTransformUtility.WorldToScreenPoint(null, casterRect.position),
                null,
                out localPoint);
            bulletTrans.anchoredPosition = localPoint;

 Main/System/Battle/SkillEffect/BulletSkillEffect.cs

@@ -172,7 +172,7 @@
    private void ShotToIndex(BattleCamp camp, int targetIndex, int bulletIndex)
    {
        RectTransform targetTransform = caster.battleField.GetTeamNode(camp, targetIndex);
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.BulletEffectId, caster.heroRectTrans, caster.Camp, caster.teamHero.modelScale);
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.BulletEffectId, caster.GetRectTransform(), caster.Camp, caster.teamHero.modelScale);

        RectTransform effectTrans = effectPlayer.transform as RectTransform;

@@ -198,8 +198,8 @@
                    continue;
                }

                PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffect4, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffect4, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
            }

            // 表现子弹飞行到目标位置
@@ -328,7 +328,7 @@

    private void ScatterShot(BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurt hurt, int bulletIndex, int order)
    {
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.BulletEffectId, caster.heroRectTrans, caster.Camp, caster.teamHero.modelScale);
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.BulletEffectId, caster.GetRectTransform(), caster.Camp, caster.teamHero.modelScale);

        bool shotToSelf = target.ObjID == caster.ObjID;

@@ -336,7 +336,7 @@

        var tempOrder = order;

        var bulletCurve = BulletCurveFactory.CreateBulletCurve(caster, skillConfig, effectPlayer, target.heroRectTrans,
        var bulletCurve = BulletCurveFactory.CreateBulletCurve(caster, skillConfig, effectPlayer, target.GetRectTransform(),
            new List<HB427_tagSCUseSkill.tagSCUseSkillHurt> { hurt }, bulletIndex, (index, hitList) =>
        {
            foreach (var hurt in hitList)
@@ -348,10 +348,10 @@
                    continue;
                }

                PlayExplosionEffect(skillConfig.ExplosionEffectId, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffect2, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffect4, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffectId, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffect2, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                PlayExplosionEffect(skillConfig.ExplosionEffect4, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
            }

            // 表现子弹飞行到目标位置
@@ -374,7 +374,7 @@

    protected void ShotToTarget(BattleObject target, int bulletIndex)
    {
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.BulletEffectId, caster.heroRectTrans, caster.Camp, caster.teamHero.modelScale);
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.BulletEffectId, caster.GetRectTransform(), caster.Camp, caster.teamHero.modelScale);

        bool shotToSelf = target.ObjID == caster.ObjID;

@@ -384,7 +384,7 @@

        int tempBulletIndex = bulletIndex;

        var bulletCurve = BulletCurveFactory.CreateBulletCurve(caster, skillConfig, effectPlayer, target.heroRectTrans, tagUseSkillAttack.HurtList.ToList(), bulletIndex, (index, hitList) =>
        var bulletCurve = BulletCurveFactory.CreateBulletCurve(caster, skillConfig, effectPlayer, target.GetRectTransform(), tagUseSkillAttack.HurtList.ToList(), bulletIndex, (index, hitList) =>
        {
            if (skillConfig.BulletPath == 4)
            {
@@ -396,10 +396,10 @@
                BattleObject targetObj = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                if (targetObj != null)
                {
                    PlayExplosionEffect(skillConfig.ExplosionEffectId, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect2, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect4, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffectId, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect2, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect4, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                }
                else
                {
@@ -433,10 +433,10 @@
                        continue;
                    }

                    PlayExplosionEffect(skillConfig.ExplosionEffectId, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect2, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect4, targetObj.heroGo.transform, caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffectId, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect2, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                    PlayExplosionEffect(skillConfig.ExplosionEffect4, targetObj.GetTransform(), caster.Camp, targetObj.teamHero.modelScale);
                }

                // 表现子弹飞行到目标位置

 Main/System/Battle/SkillEffect/DotSkillEffect.cs

@@ -31,7 +31,7 @@
                Debug.LogError($"DotSkillEffect 找不到目标，GUID={hurtInfo.ObjID}");
                continue;
            }
            target.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.TriggerEffect, target.heroRectTrans, caster.Camp, target.teamHero.modelScale);
            target.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.TriggerEffect, target.GetRectTransform(), caster.Camp, target.teamHero.modelScale);
        }

        onHit?.Invoke(0, tagUseSkillAttack.HurtList.ToList());

 Main/System/Battle/SkillEffect/NoEffect.cs

@@ -50,11 +50,11 @@

            if (skillConfig.ExplosionEffect3 > 0)
            {
                caster.battleField.battleEffectMgr.PlayEffect(target, skillConfig.ExplosionEffect3, target.heroGo.transform, caster.Camp, target.teamHero.modelScale);
                caster.battleField.battleEffectMgr.PlayEffect(target, skillConfig.ExplosionEffect3, target.GetTransform(), caster.Camp, target.teamHero.modelScale);
            }
            if (skillConfig.ExplosionEffect4 > 0)
            {
                caster.battleField.battleEffectMgr.PlayEffect(target, skillConfig.ExplosionEffect4, target.heroGo.transform, caster.Camp, target.teamHero.modelScale);
                caster.battleField.battleEffectMgr.PlayEffect(target, skillConfig.ExplosionEffect4, target.GetTransform(), caster.Camp, target.teamHero.modelScale);
            }
        }


 Main/System/Battle/SkillEffect/NormalSkillEffect.cs

@@ -49,11 +49,11 @@

            if (skillConfig.ExplosionEffect3 > 0)
            {
                caster.battleField.battleEffectMgr.PlayEffect(target, skillConfig.ExplosionEffect3, target.heroGo.transform, caster.Camp, target.teamHero.modelScale);
                caster.battleField.battleEffectMgr.PlayEffect(target, skillConfig.ExplosionEffect3, target.GetTransform(), caster.Camp, target.teamHero.modelScale);
            }
            if (skillConfig.ExplosionEffect4 > 0)
            {
                caster.battleField.battleEffectMgr.PlayEffect(target, skillConfig.ExplosionEffect4, target.heroGo.transform, caster.Camp, target.teamHero.modelScale);
                caster.battleField.battleEffectMgr.PlayEffect(target, skillConfig.ExplosionEffect4, target.GetTransform(), caster.Camp, target.teamHero.modelScale);
            }
        }


 Main/System/Battle/SkillEffect/SkillEffect.cs

@@ -29,11 +29,11 @@
        onHit = _onHit;
        if (skillConfig.EffectId > 0)
        {
            caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.EffectId, caster.heroRectTrans, caster.Camp, caster.teamHero.modelScale);
            caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.EffectId, caster.GetRectTransform(), caster.Camp, caster.teamHero.modelScale);
        }
        if (skillConfig.EffectId2 > 0)
        {
            caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.EffectId2, caster.heroRectTrans, caster.Camp, caster.teamHero.modelScale);
            caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.EffectId2, caster.GetRectTransform(), caster.Camp, caster.teamHero.modelScale);
        }
    }

@@ -52,7 +52,7 @@
        if (skillConfig.MStartEffectId <= 0)
            return;
        //  中摇固定特效
        caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.MStartEffectId, caster.heroGo.transform, caster.Camp, caster.teamHero.modelScale);
        caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.MStartEffectId, caster.GetTransform(), caster.Camp, caster.teamHero.modelScale);
    }
    
    /// <summary>

 Main/System/Battle/TianziBillboradBattleWin.cs

@@ -132,7 +132,7 @@

    private void OnStageUp(int stage)
    {
        GameObject hero = bossBattleObject.heroGo;
        GameObject hero = bossBattleObject.GetGameObject();
        if (hero == null || stage <= 1)
            return;

@@ -244,20 +244,20 @@

    private void OnValueChangeAction(float nowValue, int CurrentStage)
    {
        if (bossBattleObject == null || bossBattleObject.heroInfoBar == null)
        if (bossBattleObject == null)
            return;
        bossBattleObject.heroInfoBar.UpdateHP(nowValue);
        bossBattleObject.UpdateHP(nowValue);
        //Debug.Log($"TianziDamageBar nowValue {nowValue} 时间: {DateTime.Now:HH:mm:ss}");
    }

    private void OnChangeEndAction(ulong nowHunt, ulong nowHpMax)
    {
        if (bossBattleObject == null || bossBattleObject.heroInfoBar == null)
        if (bossBattleObject == null)
            return;
        if (nowHpMax > 0)
        {
            float percentage = Mathf.Clamp(nowHunt, 0, nowHpMax) / (float)nowHpMax;
            bossBattleObject.heroInfoBar.UpdateHP(percentage);
            bossBattleObject.UpdateHP(percentage);
            //Debug.Log($"TianziDamageBar nowValue {percentage} 时间: {DateTime.Now:HH:mm:ss}");
        }
    }