Merge branch 'master' into h5version

yyl

2026-05-11 51b0f6ed9f4e1d3bb6f8144470b46908c7699a96

 Main/System/Battle/Skill/SkillBase.cs

@@ -1,237 +1,350 @@
using System.Collections.Generic;
using System.Collections.Generic;
using UnityEngine;
using System;
using DG.Tweening;
using Spine;
using System.Linq;
using System;
using Cysharp.Threading.Tasks;


public class SkillBase
// SkillBase：技能运行时基类。
// 本类使用 partial 拆分为多个文件，按职责分组：
//   SkillBase.cs             字段、构造、公共入口（Cast/Run/OnSkillStart/各 Frame 回调 等）
//   SkillBase.Cast.cs        施法阶段：移动、动画、残影、高亮、攻击回合结束
//   SkillBase.Hit.cs         命中阶段：OnHit 分发到主目标 / 溅射目标 / 命中提示
//   SkillBase.SubSkill.cs    前置内嵌子技能的收集与投递
//   SkillBase.Death.cs       死亡包与掉落/经验分配
//   SkillBase.Buff.cs        Buff 包（HB428/HB429）的收集与分发
//   SkillBase.Finish.cs      完成判定与强制结束
public partial class SkillBase
{
   protected H0604_tagUseSkillAttack tagUseSkillAttack;
    // ===== 常量 =====
    const float moveTime = 0.5f;

   protected SkillConfig skillConfig;
    private static readonly Color colorGreen = new Color(33f / 255f,
                                                        133f / 255f,
                                                        6f / 255f);
    private static readonly Color colorBlue = new Color(40f / 255f,
                                                        87f / 255f,
                                                        189f / 255f);

   protected bool isFinished = false;
    // ===== 核心引用 =====
    public HB427_tagSCUseSkill tagUseSkillAttack;
    public SkillConfig skillConfig;
    public SkillSkinConfig skillSkinConfig;
    public BattleObject caster = null; // 施法者
    protected BattleField battleField = null; // 战场
    protected RectTransform targetNode = null; // 目标节点
    protected List<GameNetPackBasic> packList;

   protected BattleField battleField = null; // 战场
    // ===== 命中效果 =====
    protected SkillEffect skillEffect;

   protected RectTransform targetNode = null; // 目标节点
    // ===== 子技能/子动作等待列表 =====
    protected List<RecordAction> currentWaitingSkill = new List<RecordAction>();

   protected BattleObject caster = null; // 施法者
    // ===== 死亡相关临时数据 =====
    protected List<H0704_tagRolePackRefresh> dropPackList = new List<H0704_tagRolePackRefresh>();
    protected List<HB405_tagMCAddExp> expPackList = new List<HB405_tagMCAddExp>();
    private Dictionary<int, BattleDrops> tempDropList = new Dictionary<int, BattleDrops>();
    private Dictionary<int, BattleDeadPack> tempDeadPackList = new Dictionary<int, BattleDeadPack>();

   protected bool startCounting = false;
    // ===== Buff 相关包集合，支持 HB428(刷新) 和 HB429(删除) =====
    protected List<GameNetPackBasic> buffPackCollections = new List<GameNetPackBasic>();

   protected bool pauseState = false;
    // ===== 生命周期状态（4 个并行里程碑位，合并到同一 Flags 字段） =====
    //   Started        : 已进入施法阶段（OnSkillStart 调用后）
    //   MoveCompleted  : 位移已收尾（OnAllAttackMoveFinished）
    //   MotionCompleted: 技能动画已播放完（OnFinalFrameEnd）
    //   Finished       : 包列表已处理完（OnSkillFinished / ForceFinished 结尾）
    //   4 个里程碑相互独立，非线性阶段，不能用单一 state 表达。
    [System.Flags]
    protected enum SkillStateFlags
    {
        None            = 0,
        Started         = 1 << 0,
        MoveCompleted   = 1 << 1,
        MotionCompleted = 1 << 2,
        Finished        = 1 << 3,
    }

   protected int curFrame = 0;
    private SkillStateFlags _stateFlags = SkillStateFlags.None;

   protected List<int> triggerFrames = new List<int>();
    /// <summary>当前技能状态位（只读，调试用）。</summary>
    protected SkillStateFlags StateFlags => _stateFlags;

   public SkillBase(BattleObject _caster, SkillConfig _skillCfg, H0604_tagUseSkillAttack vNetData, BattleField _battleField = null)
   {
      caster = _caster;
      skillConfig = _skillCfg;
      tagUseSkillAttack = vNetData;
      battleField = _battleField;

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

   public virtual void Run()
   {
      if (startCounting)
      {
         curFrame++;

         if (triggerFrames.Contains(curFrame))
         {
            OnTriggerEvent(triggerFrames.IndexOf(curFrame), curFrame);
         }
      }
   }

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

   }

   public void Pause()
   {
      pauseState = startCounting;
      startCounting = false;
   }

   public void Resume()
   {
      startCounting = pauseState;
   }

   // 0·移动到距离目标n码，的距离释放（可配置，9999即原地释放，负数则是移动到人物背面，人物要转身）
   // 1·移动到距离阵容位置n码的距离（如2号位，5号位）释放（即战场中央此类）
   public virtual void Cast()
   {
      //   高亮所有本次技能相关的目标
      HighLightAllTargets();

      switch (skillConfig.castMode)
      {
         case SkillCastMode.StandCast:
            PlayCastAnimation(() => DoSkillLogic(OnSkillFinished));
            break;
         case SkillCastMode.MoveToTarget:
            MoveToTarget(_onComplete: () => TurnBack(() => PlayCastAnimation(() => DoSkillLogic(() => { BackToOrigin(OnSkillFinished); }))));
            break;
         case SkillCastMode.DashCast:
            DashToTarget(() => BackToOrigin(OnSkillFinished));
            break;
         default:
            Debug.LogError("暂时不支持其他的方式释放 有需求请联系策划");
            break;
      }
   }

   //   冲刺的技能 动作 跟移动 是同时进行的 移动到目标的一瞬间就要进行技能逻辑
   protected void DashToTarget(Action _onComplete)
   {
      TrackEntry entry = PlayCastAnimation();
      //   做一个微微的提前
      MoveToTarget(entry.TrackTime - 0.05f, () => DoSkillLogic(_onComplete));
   }

   protected void GetTargetNode()
   {
      targetNode = null;

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

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

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

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

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

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

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

      var tweener = BattleUtility.MoveToTarget(selfRect, targetRect, offset, duration, _onComplete);
      battleField.battleTweenMgr.OnPlayTween(tweener);
   }

   public void TurnBack(Action _onComplete)
   {
      if (skillConfig.CastDistance < 0)
      {
         caster.heroGo.transform.localScale = new Vector3(-1, 1, 1);
      }
      _onComplete?.Invoke();
   }

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

      battleField.battleTweenMgr.OnPlayTween(tween);
   }

   protected void HighLightAllTargets()
   {
      // 高亮所有目标
      HashSet<BattleObject> highlightList = new HashSet<BattleObject>(battleField.battleObjMgr.GetBattleObjList(tagUseSkillAttack));
      highlightList.Add(caster);

		

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

   public virtual bool IsFinished()
   {
      return isFinished;
   }

   public virtual void ForceFinished()
   {
      isFinished = true;
   }

   public void OnSkillFinished()
   {
      isFinished = true;
   }

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

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

   public virtual List<Dictionary<int, List<int>>> GetDamageList(BattleField _battleField)
   {
      Debug.LogError("SkillBase GetDamageList should be overridden by derived class");
      return null;
   }
#if UNITY_EDITOR
    /// <summary>供外部调试/诊断打印用，非编辑器下不编译。</summary>
    public string StateFlagsForDebug => _stateFlags.ToString();
#endif
}

    /// <summary>是否已进入施法阶段（OnSkillStart 调用后为 true）。</summary>
    public bool isPlay
    {
        get => (_stateFlags & SkillStateFlags.Started) != 0;
        set => SetFlag(SkillStateFlags.Started, value);
    }

    /// <summary>包列表是否已全部处理完。</summary>
    protected bool isFinished
    {
        get => (_stateFlags & SkillStateFlags.Finished) != 0;
        set => SetFlag(SkillStateFlags.Finished, value);
    }

    /// <summary>位移是否已收尾。</summary>
    protected bool moveFinished
    {
        get => (_stateFlags & SkillStateFlags.MoveCompleted) != 0;
        set => SetFlag(SkillStateFlags.MoveCompleted, value);
    }

    /// <summary>技能动画是否已播放完。</summary>
    protected bool isMotionCompleted
    {
        get => (_stateFlags & SkillStateFlags.MotionCompleted) != 0;
        set => SetFlag(SkillStateFlags.MotionCompleted, value);
    }

    private void SetFlag(SkillStateFlags flag, bool value)
    {
#if UNITY_EDITOR
        //  记录状态变更：卡死/卡活的排查利器。
        //  编辑器下只在值真正发生改变时打印，避免刷屏。
        bool oldValue = (_stateFlags & flag) != 0;
        if (oldValue != value)
        {
            int skillId = skillConfig != null ? skillConfig.SkillID : 0;
            ulong casterId = tagUseSkillAttack != null ? tagUseSkillAttack.ObjID : 0UL;
            BattleDebug.LogError(
                $"SkillBase.StateFlags 变更:skillId={skillId} caster={casterId} " +
                $"{flag}: {oldValue} -> {value}  (before={_stateFlags})");
        }
#endif

        if (value) _stateFlags |= flag;
        else       _stateFlags &= ~flag;
    }

    // ===== 父子关系 =====
    public SkillBase fromSkill;
    //  父RecordAction（SkillRecordAction），用于子技能建立父子关系
    protected SkillRecordAction ownRecordAction;

    // ===== 移动速度（残影加速时会改变） =====
    private float MoveSpeed = 750f;

#if UNITY_EDITOR
    public static Dictionary<string, string> changeListDict = new Dictionary<string, string>();
#endif

    // 构造函数：初始化技能基础数据
    public SkillBase(BattleObject _caster, SkillConfig _skillCfg, HB427_tagSCUseSkill vNetData, List<GameNetPackBasic> _packList, BattleField _battleField = null)
    {
        caster = _caster;
        skillConfig = _skillCfg;
        tagUseSkillAttack = vNetData;
        battleField = _battleField;
        packList = _packList;

        if (_caster is HeroBattleObject heroBattleObject)
        {
            skillSkinConfig = skillConfig.GetSkillSkinConfig(heroBattleObject.teamHero.SkinID);

            if (null == skillSkinConfig)
            {
                Debug.LogError("找不到技能皮肤表 " + "skillId: " + skillConfig.SkillID + " skinId: " + heroBattleObject.teamHero.SkinID);
            }
        }
        else
        {
            skillSkinConfig = skillConfig.GetOriginSkinConfig();
        }


        // 注册正在释放的技能
        if (battleField != null && caster != null)
        {
            battleField.AddCastingSkill(caster.ObjID, this);
        }

        SafetyCheck();
    }

    public virtual void AfterAddToQueue()
    {

    }

    //  设置父RecordAction
    public void SetOwnRecordAction(SkillRecordAction recordAction)
    {
        ownRecordAction = recordAction;
    }

    private void PinrtHB427Hp()
    {
#if UNITY_EDITOR
        string skillDetail = "SkillCaster : " + tagUseSkillAttack.ObjID + " -> cast SkillID: " + skillConfig.SkillID + "\n";

        skillDetail += "------------------ HurtList ------------------\n";
        for (int i = 0; i < tagUseSkillAttack.HurtCount; i++)
        {
            var Hurt = tagUseSkillAttack.HurtList[i];
            BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)Hurt.ObjID);

            string targetName = battleObject != null ? battleObject.GetName() : "Unknown";
            long hurtHp = GeneralDefine.GetFactValue(Hurt.HurtHP, Hurt.HurtHPEx);
            long curHp = GeneralDefine.GetFactValue(Hurt.CurHP, Hurt.CurHPEx);

            skillDetail += $"  [{i}] Target: {targetName} (ObjID:{Hurt.ObjID})\n";
            skillDetail += $"      HurtHP: {hurtHp}\n";
            skillDetail += $"      CurHP: {curHp}\n";
            skillDetail += $"      SuckHP: {Hurt.SuckHP}\n";
            skillDetail += $"      BounceHP: {Hurt.BounceHP}\n";
            skillDetail += $"      AttackTypes: {Hurt.AttackTypes}\n";

            if (Hurt.HurtListEx != null && Hurt.HurtListEx.Length > 0)
            {
                skillDetail += $"      HurtListEx ({Hurt.HurtListEx.Length}):\n";
                for (int j = 0; j < Hurt.HurtListEx.Length; j++)
                {
                    var hurtEx = Hurt.HurtListEx[j];
                    long hurtExHp = GeneralDefine.GetFactValue(hurtEx.HurtHP, hurtEx.HurtHPEx);
                    long curExHp = GeneralDefine.GetFactValue(hurtEx.CurHP, hurtEx.CurHPEx);

                    skillDetail += $"        [{j}] ObjID:{hurtEx.ObjID} HurtHP:{hurtExHp} CurHP:{curExHp} SuckHP:{hurtEx.SuckHP} AttackTypes:{hurtEx.AttackTypes}\n";
                }
            }
        }

        skillDetail += "------------------ HurtListEx ------------------\n";
        if (tagUseSkillAttack.HurtListEx != null)
        {
            for (int i = 0; i < tagUseSkillAttack.HurtListEx.Length; i++)
            {
                var HurtEx = tagUseSkillAttack.HurtListEx[i];
                BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)HurtEx.ObjID);

                string targetName = battleObject != null ? battleObject.GetName() : "Unknown";
                long hurtHp = GeneralDefine.GetFactValue(HurtEx.HurtHP, HurtEx.HurtHPEx);
                long curHp = GeneralDefine.GetFactValue(HurtEx.CurHP, HurtEx.CurHPEx);

                skillDetail += $"  [{i}] Target: {targetName} (ObjID:{HurtEx.ObjID})\n";
                skillDetail += $"      HurtHP: {hurtHp}\n";
                skillDetail += $"      CurHP: {curHp}\n";
                skillDetail += $"      SuckHP: {HurtEx.SuckHP}\n";
                skillDetail += $"      AttackTypes: {HurtEx.AttackTypes}\n";
            }
        }

        skillDetail += "------------------ END ------------------\n";

        if (changeListDict.ContainsKey(caster.battleField.guid))
        {
            string origin = changeListDict[caster.battleField.guid];
            origin += skillDetail;
            changeListDict[caster.battleField.guid] = origin;

        }
        else
            changeListDict.Add(caster.battleField.guid, skillDetail);

        Debug.LogError("skillDetail : " + skillDetail);
#endif
    }

    private void SafetyCheck()
    {
#if UNITY_EDITOR
        if (Launch.Instance.isOpenSkillLogFile)
        {
            PinrtHB427Hp();
        }
#endif

        bool safety = caster != null
                        && skillConfig != null
                        && tagUseSkillAttack != null
                        && battleField != null;


        if (!safety)
        {
            Debug.LogError("SkillBase SafetyCheck failed! Caster or SkillConfig or TagUseSkillAttack or BattleField is null, or Caster is dead.");
            ForceFinished();
        }
    }

    // 技能运行主逻辑：仅驱动技能效果（skillEffect），子技能和死亡由IsFinished()推进
    public virtual void Run()
    {
        if (skillEffect != null)
        {
            if (skillEffect.IsFinished())
            {
                skillEffect = null;
                OnSkillFinished();
            }
            else
            {
                skillEffect.Run();
            }
            return;
        }
    }

    // 技能开始回调：处理死亡、子技能、技能效果初始化
    public void OnSkillStart()
    {
        if (isPlay)
        {
            Debug.LogError(" play twice OnSkillStart skillId :" + skillConfig.SkillID);
            return;
        }

        //  先把死亡包收集了
        HandleDead();

        //  再处理 内嵌技能
        ProcessSubSkill();

        skillEffect = SkillEffectFactory.CreateSkillEffect(this, caster, skillConfig, skillSkinConfig, tagUseSkillAttack);
        skillEffect.Play(OnHitTargets);


        isPlay = true;
    }

    // ===== 技能节拍回调 =====

    // 技能前摇结束回调
    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); // 修复：添加空值检查
    }

    // 技能后摇开始回调：通知技能效果处理后摇开始
    public virtual void OnFinalFrameStart()
    {
        skillEffect?.OnFinalFrameStart(); // 修复：添加空值检查
    }

    // 技能后摇结束回调：通知技能效果处理后摇结束
    public virtual void OnFinalFrameEnd()
    {
        //  标记动画播放完成
        isMotionCompleted = true;
        BattleDebug.LogError($"SkillBase.OnFinalFrameEnd: 技能 {skillConfig?.SkillID} 动画播放完成");

        skillEffect?.OnFinalFrameEnd(); // 修复：添加空值检查
    }
}