using System.Collections.Generic;
|
using UnityEngine;
|
|
public class BattleDmg
|
{
|
public long damage;
|
public int attackType;
|
|
public bool IsType(DamageType damageType)
|
{
|
return (attackType & (int)damageType) == (int)damageType;
|
}
|
}
|
|
public class BattleDmgInfo
|
{
|
public string battleFieldGuid { get; private set; }
|
public BattleHurtParam battleHurtParam { get; private set; }
|
|
public List<long> damageList { get { return battleHurtParam.damageList; } }
|
public BattleObject hurtObj { get { return battleHurtParam.hurtObj; } }
|
public BattleObject casterObj { get { return battleHurtParam.casterObj; } }
|
public HB427_tagSCUseSkill.tagSCUseSkillHurt hurt { get { return battleHurtParam.hurt; } }
|
public SkillConfig skillConfig { get { return battleHurtParam.skillConfig; } }
|
|
public bool isBlocked = false;
|
public bool isLastHit = false;
|
|
public List<BattleDmg> targetDamageList = new List<BattleDmg>();
|
public List<BattleDmg> casterDamageList = new List<BattleDmg>();
|
|
#region Initialization
|
|
public BattleDmgInfo(string battleFieldGuid, BattleHurtParam battleHurtParam)
|
{
|
this.battleFieldGuid = battleFieldGuid;
|
this.battleHurtParam = battleHurtParam;
|
this.isLastHit = battleHurtParam.hitIndex >= battleHurtParam.skillConfig.DamageDivide.Length - 1;
|
|
HandleDamageType();
|
HandleAttackTypeAndDamage();
|
}
|
|
#endregion
|
|
#region Damage Type Processing
|
|
private void HandleDamageType()
|
{
|
if (hurt == null) return;
|
|
int attackTypes = 0;
|
foreach (ServerDamageType serverDamageType in System.Enum.GetValues(typeof(ServerDamageType)))
|
{
|
int nsdt = (int)serverDamageType;
|
if ((hurt.AttackTypes & nsdt) == nsdt)
|
{
|
attackTypes += nsdt;
|
}
|
}
|
hurt.AttackTypes = (uint)attackTypes;
|
}
|
|
#endregion
|
|
#region Damage List Generation
|
|
private void HandleAttackTypeAndDamage()
|
{
|
isBlocked = HaveBlockDamage();
|
int rawAttackType = hurt == null ? 0 : (int)hurt.AttackTypes;
|
|
int maxCount = CalculateMaxDamageSegmentCount();
|
|
for (int i = 0; i < maxCount; i++)
|
{
|
ProcessReflectDamage(i);
|
ProcessSuckHpDamage(i);
|
ProcessMainDamage(i, rawAttackType);
|
}
|
}
|
|
/// <summary>
|
/// 计算最大伤害段数
|
/// </summary>
|
private int CalculateMaxDamageSegmentCount()
|
{
|
int maxCount = damageList != null ? damageList.Count : 0;
|
maxCount = Mathf.Max(maxCount, battleHurtParam.suckHpList != null ? battleHurtParam.suckHpList.Count : 0);
|
maxCount = Mathf.Max(maxCount, battleHurtParam.reflectHpList != null ? battleHurtParam.reflectHpList.Count : 0);
|
return maxCount;
|
}
|
|
/// <summary>
|
/// 处理反伤伤害
|
/// </summary>
|
private void ProcessReflectDamage(int segmentIndex)
|
{
|
if (battleHurtParam.reflectHpList == null || segmentIndex >= battleHurtParam.reflectHpList.Count)
|
return;
|
|
long reflectHp = battleHurtParam.reflectHpList[segmentIndex];
|
if (reflectHp > 0)
|
{
|
casterDamageList.Add(new BattleDmg
|
{
|
damage = reflectHp,
|
attackType = (int)DamageType.Reflect
|
});
|
}
|
}
|
|
/// <summary>
|
/// 处理吸血伤害
|
/// </summary>
|
private void ProcessSuckHpDamage(int segmentIndex)
|
{
|
if (battleHurtParam.suckHpList == null || segmentIndex >= battleHurtParam.suckHpList.Count)
|
return;
|
|
long suckHp = battleHurtParam.suckHpList[segmentIndex];
|
if (suckHp > 0)
|
{
|
casterDamageList.Add(new BattleDmg
|
{
|
damage = suckHp,
|
attackType = (int)DamageType.SuckHP
|
});
|
}
|
}
|
|
/// <summary>
|
/// 处理主要伤害
|
/// </summary>
|
private void ProcessMainDamage(int segmentIndex, int rawAttackType)
|
{
|
if (damageList == null || segmentIndex >= damageList.Count)
|
return;
|
|
long actualDamage = damageList[segmentIndex];
|
|
if (isBlocked)
|
{
|
ProcessBlockedDamage(actualDamage, rawAttackType);
|
}
|
else
|
{
|
ProcessNormalDamage(actualDamage, rawAttackType);
|
}
|
}
|
|
/// <summary>
|
/// 处理被格挡的伤害
|
/// </summary>
|
private void ProcessBlockedDamage(long actualDamage, int rawAttackType)
|
{
|
float blockRatio = GeneralDefine.blockRatio;
|
int attackType = rawAttackType & (~(int)DamageType.Block);
|
|
// 添加格挡伤害显示
|
long totalDamage = (long)(actualDamage / (1 - blockRatio));
|
long blockDmg = totalDamage - actualDamage;
|
targetDamageList.Add(new BattleDmg { damage = blockDmg, attackType = (int)DamageType.Block });
|
|
// 添加实际伤害显示
|
if (IsRealdamage())
|
{
|
AddRealdamageToList(actualDamage);
|
}
|
else
|
{
|
AddNormalDamageToList(actualDamage, attackType);
|
}
|
}
|
|
/// <summary>
|
/// 处理正常伤害（未被格挡）
|
/// </summary>
|
private void ProcessNormalDamage(long actualDamage, int rawAttackType)
|
{
|
if (IsRealdamage())
|
{
|
AddRealdamageToList(actualDamage);
|
}
|
else
|
{
|
AddNormalDamageToList(actualDamage, rawAttackType);
|
}
|
}
|
|
/// <summary>
|
/// 添加真实伤害到列表
|
/// </summary>
|
private void AddRealdamageToList(long damage)
|
{
|
int showAttackType = (int)DamageType.Realdamage + (IsCrit() ? (int)DamageType.Crit : 0);
|
targetDamageList.Add(new BattleDmg { damage = damage, attackType = showAttackType });
|
}
|
|
/// <summary>
|
/// 添加普通伤害/治疗到列表
|
/// </summary>
|
private void AddNormalDamageToList(long damage, int attackType)
|
{
|
attackType = ValidateAndFixAttackType(attackType);
|
targetDamageList.Add(new BattleDmg { damage = damage, attackType = attackType });
|
}
|
|
/// <summary>
|
/// 验证并修复攻击类型
|
/// </summary>
|
private int ValidateAndFixAttackType(int attackType)
|
{
|
if (DamageNumConfig.Get(attackType) != null)
|
return attackType;
|
|
UnityEngine.Debug.LogError($"服务器给的伤害类型不对，强制转换为普通伤害/治疗, attackType: {attackType}");
|
|
if ((attackType & (int)DamageType.Damage) != 0)
|
return (int)DamageType.Damage;
|
|
if ((attackType & (int)DamageType.Recovery) != 0)
|
return (int)DamageType.Recovery;
|
|
UnityEngine.Debug.LogError($"强制转换失败，该类型不是治疗也不是伤害 {attackType}");
|
return attackType;
|
}
|
|
#endregion
|
|
#region Type Checking
|
|
public bool IsType(DamageType damageType)
|
{
|
return hurt != null && (hurt.AttackTypes & (int)damageType) == (int)damageType;
|
}
|
|
public bool IsCrit()
|
{
|
return IsType(DamageType.Crit);
|
}
|
|
public bool HaveBlockDamage()
|
{
|
return IsType(DamageType.Block);
|
}
|
|
public bool IsRealdamage()
|
{
|
return skillConfig.HurtType / 10 == 1;
|
}
|
|
public bool IsDamage()
|
{
|
return IsType(DamageType.Damage) || IsRealdamage() || IsType((DamageType)11) || IsType((DamageType)12);
|
}
|
|
#endregion
|
}
|
|
public class BattleHurtParam
|
{
|
public BattleObject casterObj;
|
public BattleObject hurtObj;
|
public List<long> damageList;
|
public List<long> suckHpList;
|
public List<long> reflectHpList;
|
|
public long fromShieldValue;
|
public long toShieldValue;
|
public long fromHp;
|
public long toHp;
|
|
public BattleDrops battleDrops;
|
public HB427_tagSCUseSkill.tagSCUseSkillHurt hurt;
|
public int hitIndex;
|
public HB422_tagMCTurnFightObjDead deadPack;
|
public SkillConfig skillConfig;
|
public long maxHp;
|
|
#region Shield Value Calculations
|
|
public long MaxSheildValue
|
{
|
get
|
{
|
return hurtObj == null ? 0 : hurtObj.teamHero.maxHp;
|
}
|
}
|
|
public long phase1FromShieldValue
|
{
|
get
|
{
|
if (fromShieldValue > 0)
|
{
|
return Mathf.Min((int)fromShieldValue, (int)MaxSheildValue);
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
}
|
|
public long phase1ToShieldValue
|
{
|
get
|
{
|
if (toShieldValue > 0)
|
{
|
return Mathf.Min((int)toShieldValue, (int)MaxSheildValue);
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
}
|
|
public long phase2FromShieldValue
|
{
|
get
|
{
|
if (fromShieldValue > MaxSheildValue)
|
{
|
return fromShieldValue - MaxSheildValue;
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
}
|
|
public long phase2ToShieldValue
|
{
|
get
|
{
|
if (toShieldValue > MaxSheildValue)
|
{
|
return toShieldValue - MaxSheildValue;
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
}
|
|
#endregion
|
}
|
