using System.Collections.Generic;
|
using UnityEngine;
|
using DG.Tweening;
|
using Spine;
|
using System.Linq;
|
using System;
|
|
public class SkillBase
|
{
|
const float moveTime = 0.5f;
|
|
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 SkillEffect skillEffect;
|
public HB427_tagSCUseSkill tagUseSkillAttack;
|
public SkillConfig skillConfig;
|
protected bool isFinished = false;
|
protected BattleField battleField = null; // 战场
|
protected RectTransform targetNode = null; // 目标节点
|
public BattleObject caster = null; // 施法者
|
protected List<GameNetPackBasic> packList;
|
|
protected List<RecordAction> currentWaitingSkill = new List<RecordAction>();
|
|
protected List<H0704_tagRolePackRefresh> dropPackList = new List<H0704_tagRolePackRefresh>();
|
protected List<HB405_tagMCAddExp> expPackList = new List<HB405_tagMCAddExp>();
|
|
protected bool moveFinished = false;
|
public SkillBase fromSkill;
|
public bool isPlay = false;
|
|
// 父RecordAction（SkillRecordAction），用于子技能建立父子关系
|
protected RecordAction parentRecordAction;
|
|
// 技能动画是否播放完成（针对有动画的技能）
|
protected bool isMotionCompleted = false;
|
|
private float MoveSpeed = 750f;
|
|
private Dictionary<int, BattleDrops> tempDropList = new Dictionary<int, BattleDrops>();
|
private Dictionary<int, BattleDeadPack> tempDeadPackList = new Dictionary<int, BattleDeadPack>();
|
|
// Buff相关包集合，支持 HB428(刷新) 和 HB429(删除)
|
protected List<GameNetPackBasic> buffPackCollections = new List<GameNetPackBasic>();
|
|
|
// 构造函数：初始化技能基础数据
|
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 (battleField != null && caster != null)
|
{
|
battleField.AddCastingSkill(caster.ObjID, this);
|
}
|
|
SafetyCheck();
|
}
|
|
public virtual void AfterAddToQueue()
|
{
|
|
}
|
|
// 设置父RecordAction
|
public void SetParentRecordAction(RecordAction recordAction)
|
{
|
parentRecordAction = recordAction;
|
}
|
|
#if UNITY_EDITOR
|
public static Dictionary<string, string> changeListDict = new Dictionary<string, string>();
|
#endif
|
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.teamHero.name : "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.teamHero.name : "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();
|
}
|
|
|
}
|
|
// 技能运行主逻辑：处理技能效果和其他技能动作
|
public virtual void Run()
|
{
|
if (skillEffect != null)
|
{
|
if (skillEffect.IsFinished())
|
{
|
skillEffect = null;
|
OnSkillFinished();
|
}
|
else
|
{
|
skillEffect.Run();
|
}
|
return;
|
}
|
|
|
}
|
|
protected void ShadowIllutionCreate(bool create)
|
{
|
if (create)
|
{
|
Color color = Color.white;
|
//1-连击；2-反击；3-追击
|
// 反击蓝色
|
// 追击连击绿色
|
bool change = false;
|
if (tagUseSkillAttack.BattleType == 1)
|
{
|
color = colorGreen;
|
change = true;
|
}
|
else if (tagUseSkillAttack.BattleType == 2)
|
{
|
color = colorBlue;
|
change = true;
|
}
|
else if (tagUseSkillAttack.BattleType == 3)
|
{
|
color = colorGreen;
|
change = true;
|
}
|
|
if (change)
|
{
|
MoveSpeed = 1125f;
|
caster.motionBase.ShowIllusionShadow(true, color);
|
}
|
}
|
else
|
{
|
MoveSpeed = 750f;
|
caster.motionBase.ShowIllusionShadow(false);
|
}
|
}
|
|
// 技能释放主逻辑：广播事件、高亮目标、执行释放
|
public virtual void Cast()
|
{
|
// 广播技能释放事件
|
string guid = battleField.guid;
|
TeamHero teamHero = caster.teamHero;
|
EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, guid, skillConfig, teamHero);
|
|
if (skillConfig.SkinllSFX1 != 0)
|
{
|
battleField.soundManager.PlayEffectSound(skillConfig.SkinllSFX1, false);
|
}
|
|
if (caster != null)
|
{
|
// 战斗类型 0-常规；1-连击；2-反击；3-追击；4-子技能；5-被动触发的
|
DamageNumConfig hintConfig = null;
|
if (tagUseSkillAttack.BattleType == 1)
|
{
|
hintConfig = DamageNumConfig.Get(BattleConst.BattleComboAttack);
|
}
|
else if (tagUseSkillAttack.BattleType == 2)
|
{
|
hintConfig = DamageNumConfig.Get(BattleConst.BattleCounterAttack);
|
}
|
else if (tagUseSkillAttack.BattleType == 3)
|
{
|
hintConfig = DamageNumConfig.Get(BattleConst.BattleChaseAttack);
|
}
|
|
Hint(caster, hintConfig);
|
|
|
}
|
|
// 高亮所有本次技能相关的目标
|
HighLightAllTargets();
|
|
// 根据释放模式执行相应逻辑
|
switch (skillConfig.castMode)
|
{
|
case SkillCastMode.None:
|
case SkillCastMode.Self:
|
CastImpl(OnAttackFinish);
|
break;
|
case SkillCastMode.Enemy:
|
CastToEnemy();
|
break;
|
case SkillCastMode.Target:
|
CastToTarget();
|
break;
|
case SkillCastMode.Allies:
|
CastToAllies();
|
break;
|
case SkillCastMode.DashCast:
|
DashCast(OnAttackFinish);
|
break;
|
default:
|
Debug.LogError("强制结束技能 暂时不支持其他的方式释放 有需求please联系策划 技能id:" + skillConfig.SkillID + " cast position " + skillConfig.CastPosition);
|
ForceFinished();
|
break;
|
}
|
}
|
|
protected void Hint(BattleObject battleObject, DamageNumConfig hintConfig)
|
{
|
if (hintConfig != null)
|
{
|
battleObject.heroInfoBar.ShowTips(((char)hintConfig.prefix).ToString(), true, false, 1.25f);
|
}
|
}
|
|
// 冲撞攻击模式（待实现）
|
protected void DashCast(Action _onComplete)
|
{
|
Debug.LogError("DashCast 还没实现");
|
ForceFinished();
|
}
|
|
// 对敌方释放技能：移动到敌方区域进行攻击
|
protected void CastToEnemy()
|
{
|
RectTransform target = battleField.GetTeamNode(caster.GetEnemyCamp(), skillConfig);
|
ExecuteMoveAndCastSequence(target, () =>
|
{
|
if (skillConfig.ClientTriggerTiming == 1)
|
{
|
OnAttackFinish();
|
}
|
else
|
{
|
// ShadowIllutionCreate(true);
|
MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero, () =>
|
{
|
// ShadowIllutionCreate(false);
|
OnAttackFinish();
|
}, MoveSpeed);
|
}
|
});
|
}
|
|
// 对指定目标释放技能：移动到主要目标位置进行攻击
|
protected void CastToTarget()
|
{
|
if (tagUseSkillAttack.HurtCount <= 0)
|
{
|
Debug.LogError("技能攻击包没有目标 HurtCount <= 0");
|
OnSkillFinished();
|
return;
|
}
|
|
int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(this, caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);
|
BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();
|
RectTransform targetTrans = battleField.GetTeamNode(battleCamp, mainTargetPosNum);
|
|
ExecuteMoveAndCastSequence(targetTrans, () =>
|
{
|
RectTransform rectTransform = battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum);
|
// ShadowIllutionCreate(true);
|
MoveToTarget(rectTransform, Vector2.zero, () =>
|
{
|
// ShadowIllutionCreate(false);
|
OnAttackFinish();
|
}, MoveSpeed);
|
});
|
}
|
|
// 对友方释放技能：移动到友方区域进行治疗或增益
|
protected void CastToAllies()
|
{
|
RectTransform target = battleField.GetTeamNode(caster.Camp, skillConfig);
|
ExecuteMoveAndCastSequence(target, () =>
|
{
|
if (skillConfig.ClientTriggerTiming == 1)
|
{
|
OnAttackFinish();
|
}
|
else
|
{
|
// ShadowIllutionCreate(true);
|
MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero, () =>
|
{
|
// ShadowIllutionCreate(false);
|
OnAttackFinish();
|
}, MoveSpeed);
|
}
|
});
|
}
|
|
// 执行移动-施法-返回序列：通用的移动攻击流程
|
private void ExecuteMoveAndCastSequence(RectTransform target, Action onReturnComplete)
|
{
|
ShadowIllutionCreate(true);
|
MoveToTarget(target, new Vector2(skillConfig.CastDistance, 0), () =>
|
{
|
if (skillConfig.CastDistance < 9999 && skillConfig.SkinllSFX2 != 0)
|
{
|
battleField.soundManager.PlayEffectSound(skillConfig.SkinllSFX2, false);
|
}
|
|
TurnBack(() =>
|
{
|
ShadowIllutionCreate(false);
|
|
CastImpl(() =>
|
{
|
TurnBack(() =>
|
{
|
try
|
{
|
onReturnComplete?.Invoke(); // 添加异常处理防止回调异常导致状态不完整
|
}
|
catch (Exception ex)
|
{
|
Debug.LogError($"ExecuteMoveAndCastSequence回调异常: {ex.Message}");
|
throw;
|
}
|
}, -1f);
|
});
|
}, -1f);
|
});
|
}
|
|
// 移动到目标位置：处理角色的移动动画和逻辑
|
protected void MoveToTarget(RectTransform target, Vector2 offset, Action _onComplete = null, float speed = 750f)
|
{
|
if (skillConfig.CastDistance >= 9999)
|
{
|
_onComplete?.Invoke();
|
return;
|
}
|
|
caster.motionBase.PlayAnimation(MotionName.run, true);
|
var tweener = BattleUtility.MoveToTarget(caster.heroRectTrans, target, offset, () =>
|
{
|
caster.motionBase.PlayAnimation(MotionName.idle, true);
|
_onComplete?.Invoke();
|
}, speed);
|
battleField.battleTweenMgr.OnPlayTween(tweener);
|
}
|
|
// 转身逻辑：根据技能配置处理角色转向
|
protected void TurnBack(Action _onComplete, float forward)
|
{
|
if (skillConfig.CastDistance < 0)
|
{
|
Vector3 scale = caster.heroGo.transform.localScale;
|
scale.x = Mathf.Abs(scale.x) * forward;
|
caster.heroGo.transform.localScale = scale;
|
}
|
_onComplete?.Invoke();
|
}
|
|
// 攻击完成后的处理：转身、恢复状态、播放待机动画
|
protected void OnAttackFinish()
|
{
|
TurnBack(null, 1f);
|
OnAllAttackMoveFinished();
|
caster.motionBase.PlayAnimation(MotionName.idle, true);
|
}
|
|
// 所有攻击移动完成后的处理：恢复UI显示状态
|
protected virtual void OnAllAttackMoveFinished()
|
{
|
moveFinished = true;
|
List<BattleObject> allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList<BattleObject>();
|
foreach (BattleObject bo in allList)
|
{
|
bo.layerMgr.SetFront();
|
bo.heroInfoBar.SetActive(true);
|
}
|
battleField.battleRootNode.skillMaskNode.SetActive(false);
|
}
|
|
// 执行技能释放动画和逻辑：播放施法动作并提供回调
|
protected TrackEntry CastImpl(Action onComplete = null)
|
{
|
return caster.motionBase.PlaySkillAnimation(skillConfig, this, tagUseSkillAttack.BattleType == 4, onComplete);
|
}
|
|
// 技能开始回调：处理死亡、子技能、技能效果初始化
|
public void OnSkillStart()
|
{
|
if (isPlay)
|
{
|
Debug.LogError(" play twice OnSkillStart skillId :" + skillConfig.SkillID);
|
return;
|
}
|
|
// 先把死亡包收集了
|
HandleDead();
|
|
// 再处理 内嵌技能
|
ProcessSubSkill();
|
|
skillEffect = SkillEffectFactory.CreateSkillEffect(this, caster, skillConfig, tagUseSkillAttack);
|
skillEffect.Play(OnHitTargets);
|
|
|
isPlay = true;
|
}
|
|
protected void ProcessSubSkill()
|
{
|
// 按packUID排序所有子技能
|
var allSubSkills = new List<(ulong packUID, SkillRecordAction action)>();
|
|
List<GameNetPackBasic> removePackList = new List<GameNetPackBasic>();
|
|
foreach (var pack in packList)
|
{
|
if (pack is HB427_tagSCUseSkill skillPack)
|
{
|
SkillConfig ssc = SkillConfig.Get((int)skillPack.SkillID);
|
if (!string.IsNullOrEmpty(ssc.SkillMotionName))
|
{
|
break;
|
}
|
SkillRecordAction skillRecordAction = CustomHB426CombinePack.CreateSkillAction(battleField.guid, new List<GameNetPackBasic> { skillPack });
|
allSubSkills.Add((skillPack.packUID, skillRecordAction));
|
removePackList.Add(pack);
|
}
|
else if (pack is HB422_tagMCTurnFightObjDead dead)
|
{
|
break;
|
}
|
else if (pack is CustomHB426CombinePack combinePack)
|
{
|
HB427_tagSCUseSkill sp = combinePack.GetMainHB427SkillPack();
|
SkillConfig ssc = SkillConfig.Get((int)sp.SkillID);
|
|
if (!string.IsNullOrEmpty(ssc.SkillMotionName))
|
{
|
break;
|
}
|
SkillRecordAction skillRecordAction = combinePack.CreateSkillAction();
|
allSubSkills.Add((sp.packUID, skillRecordAction));
|
removePackList.Add(pack);
|
}
|
}
|
|
for (int i = 0; i < removePackList.Count; i++)
|
{
|
packList.Remove(removePackList[i]);
|
}
|
|
// 按packUID排序
|
allSubSkills.Sort((a, b) => a.packUID.CompareTo(b.packUID));
|
|
foreach (var (packUID, recordAction) in allSubSkills)
|
{
|
battleField.recordPlayer.ImmediatelyPlay(recordAction);
|
|
if (recordAction.IsNeedWaiting())
|
{
|
currentWaitingSkill.Add(recordAction);
|
}
|
}
|
}
|
|
// 技能前摇结束回调
|
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(); // 修复：添加空值检查
|
}
|
|
// 高亮所有相关目标：设置施法者和目标的显示层级
|
protected void HighLightAllTargets()
|
{
|
caster.layerMgr.SetSortingOrder(BattleConst.SkillMaskOrder + BattleConst.BattleActiveHeroOffset);
|
|
if (skillConfig.FuncType != 2)
|
return;
|
|
// 收集所有目标（包含 HurtList、每个 Hurt 的 HurtListEx、以及顶层 HurtListEx）
|
var targetSet = new HashSet<BattleObject>();
|
if (tagUseSkillAttack != null)
|
{
|
// 主目标列表
|
if (tagUseSkillAttack.HurtList != null)
|
{
|
foreach (var hurt in tagUseSkillAttack.HurtList)
|
{
|
var bo = battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
|
if (bo != null) targetSet.Add(bo);
|
|
// 主目标的额外目标（弹射/平摊）
|
if (hurt.HurtListEx != null)
|
{
|
foreach (var hurtEx in hurt.HurtListEx)
|
{
|
var exBo = battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
|
if (exBo != null) targetSet.Add(exBo);
|
}
|
}
|
}
|
}
|
|
// 技能包顶层的 HurtListEx（如溅射、顶层平摊）
|
if (tagUseSkillAttack.HurtListEx != null)
|
{
|
foreach (var hurtEx in tagUseSkillAttack.HurtListEx)
|
{
|
var exBo = battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
|
if (exBo != null) targetSet.Add(exBo);
|
}
|
}
|
}
|
|
// 确保施法者也被高亮（原逻辑）
|
var highlightList = new List<BattleObject>(targetSet) { caster };
|
|
var allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList();
|
|
// 构造集合便于判断
|
var targetSetLookup = new HashSet<BattleObject>(targetSet);
|
var highlightSet = new HashSet<BattleObject>(highlightList);
|
|
// 先把施法者的 InfoBar 隐藏（原逻辑保留）
|
caster.heroInfoBar.SetActive(false);
|
|
foreach (BattleObject bo in allList)
|
{
|
bool isHighlight = highlightSet.Contains(bo);
|
bool isTarget = targetSetLookup.Contains(bo);
|
|
if (isHighlight)
|
{
|
bo.layerMgr.SetFront();
|
}
|
else
|
{
|
bo.layerMgr.SetBack();
|
}
|
|
// 目标（含 HurtListEx）都应显示 InfoBar
|
bo.heroInfoBar.SetActive(isTarget);
|
}
|
|
battleField.battleRootNode.skillMaskNode.SetActive(true);
|
}
|
|
|
// 命中目标回调：处理所有被命中的目标（包括主目标、弹射目标、溅射目标）
|
protected virtual void OnHitTargets(int _hitIndex, List<HB427_tagSCUseSkill.tagSCUseSkillHurt> hitList)
|
{
|
// Debug.LogError($"Skill {skillConfig.SkillID} hit targets _hitIndex: {_hitIndex} hit {string.Join(", ", hitList.Select(h => h.ObjID + ":" + battleField.battleObjMgr.GetBattleObject((int)h.ObjID)?.teamHero.name))}");
|
|
// 造成伤害前先处理血量刷新包
|
HandleRefreshHP();
|
|
bool suckHp = true;
|
|
// 处理主目标列表
|
foreach (var hurt in hitList)
|
{
|
BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
|
if (target == null)
|
{
|
Debug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
|
continue;
|
}
|
|
OnHitEachTarget(_hitIndex, target, hurt, suckHp);
|
|
suckHp = false;
|
|
// 处理该目标的额外目标列表（如弹射伤害的平摊目标）
|
if (hurt.HurtListEx != null && hurt.HurtListEx.Length > 0)
|
{
|
foreach (var hurtEx in hurt.HurtListEx)
|
{
|
BattleObject exTarget = caster.battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
|
if (exTarget == null)
|
{
|
Debug.LogError($"额外目标为空 HurtListEx target == null ObjId : {hurtEx.ObjID}");
|
continue;
|
}
|
|
OnHitEachTargetEx(_hitIndex, exTarget, hurtEx);
|
}
|
}
|
}
|
|
// 处理技能包顶层的额外目标列表（如溅射伤害、平摊伤害）
|
if (tagUseSkillAttack.HurtListEx != null && tagUseSkillAttack.HurtListEx.Length > 0)
|
{
|
foreach (var hurtEx in tagUseSkillAttack.HurtListEx)
|
{
|
BattleObject exTarget = caster.battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
|
if (exTarget == null)
|
{
|
Debug.LogError($"顶层额外目标为空 tagUseSkillAttack.HurtListEx target == null ObjId : {hurtEx.ObjID}");
|
continue;
|
}
|
|
OnHitEachTargetEx(_hitIndex, exTarget, hurtEx);
|
}
|
}
|
|
HandleHint(_hitIndex, hitList);
|
}
|
|
protected void HandleHint(int _hitIndex, List<HB427_tagSCUseSkill.tagSCUseSkillHurt> hitList)
|
{
|
if (0 == _hitIndex)
|
{
|
bool needhint = false;
|
|
for (int i = 0; i < hitList.Count; i++)
|
{
|
var hurt = hitList[i];
|
|
//8-击晕
|
if ((hurt.AttackTypes & (int)DamageType.Stunned) == (int)DamageType.Stunned)
|
{
|
needhint = true;
|
break;
|
}
|
|
for (int j = 0; j < hurt.HurtListEx?.Length; j++)
|
{
|
var hurtex = hurt.HurtListEx[j];
|
//8-击晕
|
if ((hurtex.AttackTypes & (int)ServerDamageType.Stunned) == (int)ServerDamageType.Stunned)
|
{
|
needhint = true;
|
break;
|
}
|
}
|
|
if (needhint)
|
break;
|
}
|
|
if (needhint)
|
{
|
DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.BattleStun);
|
Hint(caster, hintConfig);
|
}
|
|
for (int i = 0; i < hitList.Count; i++)
|
{
|
var hurt = hitList[i];
|
|
if ((hurt.AttackTypes & (int)DamageType.BreakArmor) == (int)DamageType.BreakArmor)
|
{
|
BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
|
if (battleObject != null)
|
{
|
DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.BreakArmor);
|
Hint(battleObject, hintConfig);
|
battleField.battleEffectMgr.PlayEffect(battleObject,
|
BattleConst.BreakArmorEffectID, battleObject.heroRectTrans, battleObject.Camp,
|
battleObject.teamHero.modelScale);
|
}
|
}
|
else if ((hurt.AttackTypes & (int)DamageType.Parry) == (int)DamageType.Parry)
|
{
|
BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
|
if (battleObject != null)
|
{
|
DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.Parry);
|
Hint(battleObject, hintConfig);
|
battleField.battleEffectMgr.PlayEffect(battleObject,
|
BattleConst.ParryEffectID, battleObject.heroRectTrans, battleObject.Camp,
|
battleObject.teamHero.modelScale);
|
}
|
}
|
}
|
}
|
}
|
|
// 处理单个目标被命中:应用伤害和施法者效果
|
protected virtual void OnHitEachTarget(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurt hurt, bool suckHp)
|
{
|
// ============ 获取临时数据(掉落、死亡等) ============
|
int objID = (int)target.ObjID;
|
tempDropList.TryGetValue(objID, out BattleDrops battleDrops);
|
tempDeadPackList.TryGetValue(objID, out BattleDeadPack deadPack);
|
|
// 如果目标正在释放技能，跳过死亡处理（延迟到技能结束）
|
if (battleField != null && battleField.IsCastingSkill(target.ObjID))
|
{
|
deadPack = null;
|
}
|
|
// ============ 参数打包 ============
|
BattleHurtParam hurtParam = BattleUtility.CalcBattleHurtParam(this, _hitIndex, target, hurt, battleDrops, deadPack, suckHp);
|
#if UNITY_EDITOR
|
PrintHurtParamDebugInfo(hurtParam);
|
#endif
|
|
// 先调用目标受伤
|
DeathRecordAction recordAc = target.Hurt(hurtParam, parentRecordAction);
|
|
if (null != recordAc)
|
{
|
tempDeadPackList.Remove(hurtParam.hurter.hurtObj.ObjID);
|
battleField.recordPlayer.ImmediatelyPlay(recordAc, parentRecordAction, true);
|
currentWaitingSkill.Add(recordAc);
|
}
|
|
// 再调用施法者吸血/反伤
|
caster.OnHurtTarget(hurtParam);
|
}
|
|
// 处理额外目标被命中（HurtListEx）：溅射、弹射、平摊伤害等
|
protected virtual void OnHitEachTargetEx(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurtEx hurtEx)
|
{
|
// ============ 获取临时数据(掉落、死亡等) ============
|
int objID = (int)target.ObjID;
|
tempDropList.TryGetValue(objID, out BattleDrops battleDrops);
|
|
tempDeadPackList.TryGetValue(objID, out BattleDeadPack deadPack);
|
|
// 如果目标正在释放技能，跳过死亡处理（延迟到技能结束）
|
if (battleField != null && battleField.IsCastingSkill(target.ObjID))
|
{
|
deadPack = null;
|
}
|
// ============ 参数打包（将 tagSCUseSkillHurtEx 转换为 tagSCUseSkillHurt）============
|
HB427_tagSCUseSkill.tagSCUseSkillHurt hurt = new HB427_tagSCUseSkill.tagSCUseSkillHurt
|
{
|
ObjID = hurtEx.ObjID,
|
AttackTypes = hurtEx.AttackTypes,
|
HurtHP = hurtEx.HurtHP,
|
HurtHPEx = hurtEx.HurtHPEx,
|
CurHP = hurtEx.CurHP,
|
CurHPEx = hurtEx.CurHPEx,
|
SuckHP = 0,//hurtEx.SuckHP, 获取全部吸血时已经计算过 这里就不再计算
|
BounceHP = 0, // HurtEx 没有反伤字段
|
HurtCountEx = 0,
|
HurtListEx = null
|
};
|
|
OnHitEachTarget(_hitIndex, target, hurt, false);//获取全部吸血时已经计算过 这里就不再计算
|
}
|
|
#if UNITY_EDITOR
|
private void PrintHurtParamDebugInfo(BattleHurtParam hurtParam)
|
{
|
bool isLastHit = hurtParam.hitIndex >= hurtParam.skillConfig.DamageDivide.Length - 1;
|
|
long currentHitDamage = hurtParam.hurter.damageList != null ? hurtParam.hurter.damageList.Sum() : 0;
|
long currentHitSuckHp = hurtParam.caster.suckHpList != null ? hurtParam.caster.suckHpList.Sum() : 0;
|
long currentHitReflectHp = hurtParam.caster.reflectHpList != null ? hurtParam.caster.reflectHpList.Sum() : 0;
|
|
long totalDamage = GeneralDefine.GetFactValue(hurtParam.hurt.HurtHP, hurtParam.hurt.HurtHPEx);
|
long totalSuckHp = BattleUtility.GetSuckHp(tagUseSkillAttack);
|
long totalReflectHp = hurtParam.hurt.BounceHP;
|
|
BattleDebug.LogError(
|
(hurtParam.caster.casterObj.Camp == BattleCamp.Red ? "【红方行动】" : "【蓝方行动】 ") +
|
$"攻击者: {hurtParam.caster.casterObj.teamHero.name} (ObjID:{hurtParam.caster.casterObj.ObjID})\n" +
|
$"目标: {hurtParam.hurter.hurtObj.teamHero.name} (ObjID:{hurtParam.hurter.hurtObj.ObjID})\n" +
|
$"技能: {hurtParam.skillConfig.SkillName} (ID:{hurtParam.skillConfig.SkillID})\n" +
|
$"击数: 第{hurtParam.hitIndex + 1}击 / 共{hurtParam.skillConfig.DamageDivide.Length}击" + (isLastHit ? " [最后一击]" : " [中间击]") + "\n" +
|
$"\n" +
|
$"========== 目标受伤数据 ==========\n" +
|
$"伤害: {currentHitDamage} / 总伤害: {totalDamage}\n" +
|
$"伤害分段: [{string.Join(", ", hurtParam.hurter.damageList ?? new List<long>())}]\n" +
|
$"目标血量: {hurtParam.hurter.fromHp} -> {hurtParam.hurter.toHp} (最大:{hurtParam.hurter.maxHp})\n" +
|
$"目标护盾: {hurtParam.hurter.fromShieldValue} -> {hurtParam.hurter.toShieldValue}\n" +
|
$"攻击类型: {hurtParam.hurt.AttackTypes}\n" +
|
$"\n" +
|
$"========== 施法者数据 ==========\n" +
|
$"吸血: {currentHitSuckHp} / 总吸血: {totalSuckHp}\n" +
|
$"吸血分段: [{string.Join(", ", hurtParam.caster.suckHpList ?? new List<long>())}]\n" +
|
$"反伤: {currentHitReflectHp} / 总反伤: {totalReflectHp}\n" +
|
$"反伤分段: [{string.Join(", ", hurtParam.caster.reflectHpList ?? new List<long>())}]\n" +
|
$"施法者血量: {hurtParam.caster.fromHp} -> {hurtParam.caster.toHp} (最大:{hurtParam.caster.maxHp})\n" +
|
$"施法者护盾: {hurtParam.caster.fromShieldValue} -> {hurtParam.caster.toShieldValue}\n"
|
);
|
}
|
#endif
|
|
// 处理HP刷新包（简化逻辑）
|
private void HandleRefreshHP()
|
{
|
// 查找HP刷新包
|
HB419_tagSCObjHPRefresh refreshPack = BattleUtility.FindObjHPRefreshPack(packList);
|
|
if (refreshPack != null)
|
{
|
// 分发HP刷新包
|
// 【使用 parentRecordAction.innerRecordPlayer】
|
// 原因：HP刷新包是技能内部产生的，应该由当前SkillRecordAction的innerRecordPlayer管理
|
// 这样可以确保HP刷新与技能的生命周期绑定，ForceFinish时一并处理
|
PackageRegeditEx.DistributeToRecordAction(refreshPack, parentRecordAction);
|
packList.Remove(refreshPack);
|
}
|
}
|
|
// 处理死亡相关逻辑：分配掉落和经验
|
protected void HandleDead()
|
{
|
List<BattleDeadPack> deadPackList = BattleUtility.FindDeadPack(packList);
|
if (deadPackList.Count <= 0) return;
|
|
foreach (var deadPack in deadPackList)
|
{
|
packList.Remove(deadPack.deadPack);
|
packList.Remove(deadPack.deadTriggerSkill);
|
}
|
|
// 找到最大的死亡包 packUID
|
BattleDeadPack lastBattleDeadPack = null;
|
ulong maxDeathPackUID = 0;
|
foreach (var deadPack in deadPackList)
|
{
|
if (deadPack.deadPack != null && deadPack.deadPack.packUID > maxDeathPackUID)
|
{
|
maxDeathPackUID = deadPack.deadPack.packUID;
|
lastBattleDeadPack = deadPack;
|
}
|
}
|
|
// 如果找到了死亡包，收集所有 packUID > maxDeathPackUID 的包
|
if (maxDeathPackUID > 0 && lastBattleDeadPack != null)
|
{
|
BattleDebug.LogError($"SkillBase.HandleDead: 找到死亡包，maxDeathPackUID = {maxDeathPackUID}，开始收集死亡后的包");
|
|
// 1. 收集 packList 中 packUID 大于死亡包的包（排除经验包和掉落包，它们需要在当前技能中处理）
|
List<GameNetPackBasic> packsToRemove = new List<GameNetPackBasic>();
|
foreach (var pack in packList)
|
{
|
ulong packUID = GetPackUID(pack);
|
if (packUID > maxDeathPackUID)
|
{
|
// 排除经验包和掉落包，它们属于当前死亡事件的一部分，不是"死亡后"的包
|
if (pack is HB405_tagMCAddExp expPack && expPack.Source == 2 ||
|
(pack is H0704_tagRolePackRefresh h0704 && h0704.PackType == (byte)PackType.DropItem && h0704.IsBind == 1))
|
{
|
continue; // 跳过经验包和掉落包，让 CheckAfterDeadhPack() 处理它们
|
}
|
|
BattleDebug.LogError($"SkillBase.HandleDead: 从packList收集死亡后的包 - Type: {pack.GetType().Name}, UID: {packUID}");
|
lastBattleDeadPack.packListAfterDeath.Add(pack);
|
packsToRemove.Add(pack);
|
}
|
}
|
|
packList.RemoveAll(p => packsToRemove.Contains(p));
|
}
|
|
CheckAfterDeadhPack();
|
|
// 修复：先收集要删除的包，避免在foreach中修改集合
|
var dropPacksToRemove = new List<H0704_tagRolePackRefresh>(dropPackList);
|
foreach (var _dropPack in dropPacksToRemove)
|
{
|
// 【使用 parentRecordAction.innerRecordPlayer】
|
// 原因：掉落包是技能效果的一部分，应该由当前SkillRecordAction管理
|
// 掉落包的分发与技能完成绑定，确保在技能ForceFinish时正确处理
|
PackageRegeditEx.DistributeToRecordAction(_dropPack, parentRecordAction);
|
packList.Remove(_dropPack);
|
}
|
|
// 获取并分配掉落物品和经验
|
var dropPack = PackManager.Instance.GetSinglePack(PackType.DropItem);
|
var itemDict = dropPack.GetAllItems();
|
List<ItemModel> itemList = new List<ItemModel>(itemDict.Values.Where(item => item != null && item.isAuction));
|
|
var dropAssign = AssignDrops(itemList, deadPackList.Count);
|
var expAssign = AssignExp(expPackList, deadPackList.Count);
|
|
// 构造BattleDrops并缓存
|
for (int i = 0; i < deadPackList.Count; i++)
|
{
|
BattleDeadPack bdp = deadPackList[i];
|
int objID = (int)bdp.deadPack.ObjID;
|
BattleObject deadTarget = battleField.battleObjMgr.GetBattleObject(objID);
|
|
// 修复：添加空值检查
|
if (deadTarget == null)
|
{
|
Debug.LogError($"找不到死亡目标，ObjID: {objID}");
|
continue;
|
}
|
|
List<int> itemIndexList = dropAssign[i].Select(item => item.gridIndex).ToList();
|
|
BattleDrops battleDrops = new BattleDrops()
|
{
|
rectTransform = deadTarget.heroRectTrans,
|
dropItemPackIndex = itemIndexList,
|
expDrops = expAssign[i]
|
};
|
|
// 修复：避免字典键冲突，使用安全的添加方式
|
if (!tempDropList.ContainsKey(objID))
|
{
|
tempDropList.Add(objID, battleDrops);
|
}
|
else
|
{
|
Debug.LogWarning($"tempDropList中已存在ObjID={objID}的记录，将覆盖原值");
|
tempDropList[objID] = battleDrops; // 覆盖现有值
|
}
|
|
if (!tempDeadPackList.ContainsKey(objID))
|
{
|
tempDeadPackList.Add(objID, deadPackList[i]);
|
}
|
else
|
{
|
Debug.LogWarning($"tempDeadPackList中已存在ObjID={objID}的记录，将覆盖原值");
|
tempDeadPackList[objID] = deadPackList[i]; // 覆盖现有值
|
}
|
}
|
|
// 修复：避免在遍历时修改集合，先收集后删除
|
var deadPacksToRemove = new List<GameNetPackBasic>(deadPackList.Select(d => d.deadPack));
|
deadPacksToRemove.AddRange(deadPackList.Where(d => d.deadTriggerSkill != null).Select(d => d.deadTriggerSkill));
|
foreach (var deadPack in deadPacksToRemove)
|
{
|
packList.Remove(deadPack);
|
}
|
}
|
|
// 分配掉落物品：将掉落物品平均分配给死亡对象
|
protected List<List<ItemModel>> AssignDrops(List<ItemModel> itemList, int deadCount)
|
{
|
var dropAssign = new List<List<ItemModel>>();
|
for (int i = 0; i < deadCount; i++)
|
dropAssign.Add(new List<ItemModel>());
|
for (int i = 0; i < itemList.Count; i++)
|
dropAssign[i % deadCount].Add(itemList[i]);
|
return dropAssign;
|
}
|
|
// 获取包的 packUID
|
protected ulong GetPackUID(GameNetPackBasic pack)
|
{
|
if (pack == null) return 0;
|
|
if (pack is HB422_tagMCTurnFightObjDead deadPack)
|
return deadPack.packUID;
|
|
if (pack is CustomHB426CombinePack combinePack)
|
{
|
var mainSkillPack = combinePack.GetMainHB427SkillPack();
|
return mainSkillPack?.packUID ?? 0;
|
}
|
|
if (pack is HB427_tagSCUseSkill skillPack)
|
return skillPack.packUID;
|
|
if (pack is HB428_tagSCBuffRefresh buffRefresh)
|
return buffRefresh.packUID;
|
|
if (pack is HB429_tagSCBuffDel buffDel)
|
return buffDel.packUID;
|
|
if (pack is HB419_tagSCObjHPRefresh hpRefresh)
|
return hpRefresh.packUID;
|
|
if (pack is HB405_tagMCAddExp expPack)
|
return expPack.packUID;
|
|
if (pack is H0704_tagRolePackRefresh dropPack)
|
return dropPack.packUID;
|
|
// 尝试通过反射获取 packUID
|
var packUIDField = pack.GetType().GetField("packUID");
|
if (packUIDField != null)
|
{
|
return (ulong)packUIDField.GetValue(pack);
|
}
|
|
return 0;
|
}
|
|
// 分配经验值：将经验包平均分配给每个死亡对象
|
protected List<List<HB405_tagMCAddExp>> AssignExp(List<HB405_tagMCAddExp> expList, int deadCount)
|
{
|
var expAssign = new List<List<HB405_tagMCAddExp>>();
|
for (int i = 0; i < deadCount; i++)
|
expAssign.Add(new List<HB405_tagMCAddExp>());
|
|
// 修复：检查除零风险
|
if (deadCount == 0)
|
{
|
Debug.LogWarning("AssignExp: deadCount为0，无法分配经验");
|
return expAssign;
|
}
|
|
// 修复：先收集要删除的包，避免在foreach中修改packList
|
var expPacksToRemove = new List<HB405_tagMCAddExp>();
|
|
foreach (var expPack in expList)
|
{
|
long totalExp = GeneralDefine.GetFactValue(expPack.Exp, expPack.ExpPoint);
|
long avgExp = totalExp / deadCount;
|
long remain = totalExp % deadCount;
|
|
for (int i = 0; i < deadCount; i++)
|
{
|
long assignExp = avgExp + (i < remain ? 1 : 0);
|
var newPack = new HB405_tagMCAddExp
|
{
|
Exp = (uint)(assignExp % Constants.ExpPointValue),
|
ExpPoint = (uint)(assignExp / Constants.ExpPointValue),
|
Source = expPack.Source
|
};
|
expAssign[i].Add(newPack);
|
}
|
expPacksToRemove.Add(expPack);
|
}
|
|
// 统一删除收集的包
|
foreach (var pack in expPacksToRemove)
|
{
|
packList.Remove(pack);
|
}
|
|
return expAssign;
|
}
|
|
// 检查死亡后的包处理：处理技能包、掉落包、经验包
|
protected void CheckAfterDeadhPack()
|
{
|
List<int> removeIndexList = new List<int>();
|
|
for (int i = 0; i < packList.Count; i++)
|
{
|
var pack = packList[i];
|
|
// 复活基本都靠技能包
|
if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
|
break;
|
|
if (pack is H0704_tagRolePackRefresh h0704Pack && h0704Pack.PackType == (byte)PackType.DropItem && h0704Pack.IsBind == 1)
|
{
|
dropPackList.Add(h0704Pack);
|
removeIndexList.Add(i);
|
}
|
|
if (pack is HB405_tagMCAddExp h405Pack && h405Pack.Source == 2)
|
{
|
expPackList.Add(h405Pack);
|
removeIndexList.Add(i);
|
}
|
}
|
|
for (int i = removeIndexList.Count - 1; i >= 0; i--)
|
packList.RemoveAt(removeIndexList[i]);
|
}
|
|
|
public virtual bool IsActionCompleted()
|
{
|
if (!isPlay) return false;
|
|
if (skillEffect != null)
|
{
|
if (!skillEffect.IsFinished()) return false;
|
}
|
|
if (moveFinished)
|
{
|
// 如果技能有动画（SkillMotionName不为空），需要等待动画播放完成
|
if (skillConfig != null && !string.IsNullOrEmpty(skillConfig.SkillMotionName))
|
{
|
if (!isMotionCompleted)
|
{
|
BattleDebug.LogError($"SkillBase.IsActionCompleted: 技能 {skillConfig.SkillID} 等待动画播放完成");
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
return false;
|
}
|
|
// 检查技能是否完成：综合检查所有完成条件
|
public virtual bool IsFinished()
|
{
|
if (!isPlay) return false;
|
|
bool tempRetValue = true;
|
|
// 检查技能效果是否完成
|
if (skillEffect != null)
|
{
|
if (!skillEffect.IsFinished()) return false;
|
skillEffect = null;
|
OnSkillFinished();
|
tempRetValue = false;
|
}
|
|
// 检查其他技能动作是否完成
|
if (currentWaitingSkill.Count > 0)
|
{
|
if (currentWaitingSkill.Any(s => s.IsFinished()))
|
{
|
currentWaitingSkill.RemoveAll(s => s.IsFinished());
|
OnSkillFinished();
|
}
|
else
|
{
|
tempRetValue = false;
|
}
|
}
|
|
if (!tempRetValue)
|
{
|
return false;
|
}
|
|
// 检查最终完成状态
|
if (isFinished && moveFinished)
|
{
|
if (packList.Count > 0)
|
{
|
OnSkillFinished();
|
return false;
|
}
|
|
// 如果自己内部的recora action的 inner record player还有没执行完的包 也是返回false
|
if (parentRecordAction != null && parentRecordAction.GetInnerRecordPlayer().IsPlaying())
|
{
|
return false;
|
}
|
|
// 技能完全结束，移除技能注册并触发延迟的死亡判定
|
if (battleField != null && caster != null)
|
{
|
battleField.RemoveCastingSkill(caster.ObjID, this);
|
|
// 传递parentRecordAction，让死亡技能等待当前技能完成
|
DeathRecordAction recordAction = battleField.OnObjsDead(new List<BattleDeadPack>(tempDeadPackList.Values));
|
if (null != recordAction)
|
{
|
parentRecordAction.GetInnerRecordPlayer().ImmediatelyPlay(recordAction);
|
tempDeadPackList.Clear();
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
return false;
|
}
|
|
|
// 强制结束技能：立即结束所有技能相关的处理
|
public virtual void ForceFinished()
|
{
|
if (isFinished)
|
return;
|
|
// 移除技能注册
|
if (battleField != null && caster != null)
|
{
|
battleField.RemoveCastingSkill(caster.ObjID, this);
|
}
|
|
// 传递parentRecordAction，让死亡技能等待当前技能完成
|
RecordAction rc = battleField.OnObjsDead(new List<BattleDeadPack>(tempDeadPackList.Values));
|
if (null != rc)
|
{
|
parentRecordAction.GetInnerRecordPlayer().ImmediatelyPlay(rc);
|
}
|
tempDeadPackList.Clear();
|
|
// 1. 强制结束技能效果
|
skillEffect?.ForceFinished();
|
skillEffect = null;
|
|
// 2. 强制结束所有子技能动作
|
if (currentWaitingSkill.Count > 0)
|
{
|
foreach (var skill in currentWaitingSkill)
|
{
|
skill.ForceFinish();
|
}
|
currentWaitingSkill.Clear();
|
}
|
|
// 3. 清理 DOTween 动画（防止移动回调在战斗结束后执行）
|
if (caster != null && caster.heroRectTrans != null)
|
{
|
DG.Tweening.DOTween.Kill(caster.heroRectTrans);
|
}
|
|
// 4. 重置施法者状态
|
if (caster != null)
|
{
|
// 重置位置到原点
|
if (caster.heroRectTrans != null)
|
{
|
caster.heroRectTrans.anchoredPosition = Vector2.zero;
|
}
|
|
// 重置朝向
|
if (caster.heroGo != null)
|
{
|
Vector3 scale = caster.heroGo.transform.localScale;
|
scale.x = Mathf.Abs(scale.x);
|
caster.heroGo.transform.localScale = scale;
|
}
|
|
// 取消幻影效果
|
caster.motionBase?.ShowIllusionShadow(false);
|
}
|
|
// 5. 恢复 UI 状态
|
if (battleField != null)
|
{
|
// 恢复所有角色的显示层级和血条
|
var allList = battleField.battleObjMgr?.allBattleObjDict?.Values;
|
if (allList != null)
|
{
|
foreach (BattleObject bo in allList)
|
{
|
bo.layerMgr?.SetFront();
|
bo.heroInfoBar?.SetActive(true);
|
}
|
}
|
|
// 关闭技能遮罩
|
if (battleField.battleRootNode != null && battleField.battleRootNode.skillMaskNode != null)
|
{
|
battleField.battleRootNode.skillMaskNode.SetActive(false);
|
}
|
}
|
|
isFinished = true;
|
moveFinished = true;
|
isPlay = true;
|
|
// 强制结束时，无论是否有动画，都标记动画完成
|
isMotionCompleted = true;
|
|
// 6. 处理所有剩余包（包括 buff 包）
|
// 先处理 buffPackCollections
|
DistributeBuffPacks(buffPackCollections);
|
buffPackCollections.Clear();
|
|
// 处理剩余的 packList
|
while (packList.Count > 0)
|
{
|
var pack = packList[0];
|
packList.RemoveAt(0);
|
|
if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
|
{
|
var otherSkillAction = combinePack.CreateSkillAction();
|
otherSkillAction.fromSkill = this;
|
otherSkillAction.ForceFinish();
|
}
|
else
|
{
|
// 【使用 parentRecordAction.innerRecordPlayer】
|
// 原因：ForceFinished时剩余的包也是技能内部产生的，应该由innerRecordPlayer管理
|
// 这样可以确保即使强制结束，包的处理也在正确的上下文中
|
PackageRegedit.Distribute(pack);
|
}
|
}
|
}
|
|
// 技能完成处理：正常完成时的清理工作
|
public void OnSkillFinished()
|
{
|
// 修复：使用循环代替递归，避免栈溢出风险
|
// try
|
// {
|
while (true)
|
{
|
// 验证技能效果是否完成
|
if (skillEffect != null && !skillEffect.IsFinished())
|
return;
|
|
if (skillEffect != null)
|
{
|
skillEffect = null;
|
continue; // 使用continue代替递归调用
|
}
|
|
// 验证其他技能动作是否完成
|
if (currentWaitingSkill.Count > 0)
|
{
|
bool hasFinishedAction = currentWaitingSkill.All(s => s.IsFinished());
|
|
if (hasFinishedAction)
|
{
|
// 修复死循环：完成后需要清空 currentWaitingSkill
|
currentWaitingSkill.Clear();
|
continue; // 使用continue代替递归调用
|
}
|
return;
|
}
|
|
break; // 没有更多需要处理的，退出循环
|
}
|
|
// 处理剩余包
|
if (!ResolvePackList())
|
{
|
return;
|
}
|
// }
|
// catch (Exception ex)
|
// {
|
// Debug.LogError($"OnSkillFinished异常: {ex.Message}，技能ID={skillConfig.SkillID}");
|
// // 确保状态一致性，即使出现异常也要标记完成
|
// isFinished = true;
|
// throw; // 重新抛出异常供上层处理
|
// }
|
|
isFinished = true;
|
}
|
|
protected virtual bool ResolvePackList()
|
{
|
if (currentWaitingSkill.Count > 0)
|
{
|
return false;
|
}
|
|
while (packList.Count > 0)
|
{
|
var pack = packList[0];
|
packList.RemoveAt(0);
|
|
|
if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
|
{
|
BattleDebug.LogError("other skill casting " + combinePack.startTag.Tag);
|
var skillRecordAction = combinePack.CreateSkillAction();
|
skillRecordAction.fromSkill = this;
|
currentWaitingSkill.Add(skillRecordAction);
|
parentRecordAction.GetInnerRecordPlayer().PlayRecord(skillRecordAction);
|
return false;
|
}
|
else if (IsBuffPack(pack))
|
{
|
// 从找到第一个 Buff 包开始，收集连续的 HB428/HB429 包
|
buffPackCollections.Add(pack);
|
while (packList.Count > 0)
|
{
|
var nextPack = packList[0];
|
if (IsBuffPack(nextPack))
|
{
|
buffPackCollections.Add(nextPack);
|
packList.RemoveAt(0);
|
}
|
else
|
{
|
break;
|
}
|
}
|
|
// 处理所有收集到的 buff 包
|
ProcessBuffPacks(buffPackCollections);
|
|
// 清空已处理的 buff 集合
|
buffPackCollections.Clear();
|
continue;
|
}
|
else
|
{
|
// 【使用 parentRecordAction.innerRecordPlayer】
|
// 原因：技能执行过程中的包（Buff、属性刷新等）是技能效果的一部分
|
// 应该由SkillRecordAction的innerRecordPlayer管理，确保与技能生命周期一致
|
PackageRegeditEx.DistributeToRecordAction(pack, parentRecordAction);
|
}
|
}
|
|
return true;
|
}
|
|
// 添加清理方法：防止内存泄漏
|
public virtual void Cleanup()
|
{
|
tempDropList?.Clear();
|
tempDeadPackList?.Clear();
|
currentWaitingSkill?.Clear();
|
dropPackList?.Clear();
|
expPackList?.Clear();
|
buffPackCollections?.Clear();
|
|
skillEffect = null;
|
packList = null;
|
}
|
|
#region Buff包处理
|
|
/// <summary>
|
/// 判断是否为 Buff 相关的包（HB428 或 HB429）
|
/// </summary>
|
protected bool IsBuffPack(GameNetPackBasic pack)
|
{
|
return pack is HB428_tagSCBuffRefresh || pack is HB429_tagSCBuffDel;
|
}
|
|
/// <summary>
|
/// 处理收集到的 Buff 包列表（HB428 刷新 和 HB429 删除）
|
/// </summary>
|
protected void ProcessBuffPacks(List<GameNetPackBasic> buffPacks)
|
{
|
if (buffPacks == null || buffPacks.Count == 0) return;
|
|
foreach (var pack in buffPacks)
|
{
|
if (pack is HB428_tagSCBuffRefresh buffRefresh)
|
{
|
BattleObject battleObj = battleField.battleObjMgr.GetBattleObject((int)buffRefresh.ObjID);
|
if (battleObj != null)
|
{
|
battleObj.buffMgr.RefreshBuff(buffRefresh, true);
|
}
|
}
|
else if (pack is HB429_tagSCBuffDel buffDel)
|
{
|
BattleObject battleObj = battleField.battleObjMgr.GetBattleObject((int)buffDel.ObjID);
|
if (battleObj != null)
|
{
|
battleObj.buffMgr.RemoveBuff(buffDel, false);
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// 强制分发 Buff 包（用于 ForceFinished 场景）
|
/// </summary>
|
protected void DistributeBuffPacks(List<GameNetPackBasic> buffPacks)
|
{
|
if (buffPacks == null || buffPacks.Count == 0) return;
|
|
foreach (var pack in buffPacks)
|
{
|
// 【使用 parentRecordAction.innerRecordPlayer】
|
// 原因：Buff包是技能效果的核心组成部分，应该由SkillRecordAction管理
|
// 即使是强制分发的情况，也要保持在正确的RecordAction上下文中
|
PackageRegeditEx.DistributeToRecordAction(pack, parentRecordAction);
|
}
|
}
|
|
public virtual bool CanStartExecution()
|
{
|
if (null == caster)
|
{
|
return false;
|
}
|
|
if (null == skillConfig)
|
{
|
return false;
|
}
|
|
if (string.IsNullOrEmpty(skillConfig.SkillMotionName))
|
{
|
return true;
|
}
|
|
return !battleField.IsCastingSkill(caster.ObjID);
|
}
|
|
#endregion
|
|
}
|
