public static BattleCalculator.DamageResult CalculateDamage(BattleBaseAttrs caster, BattleBaseAttrs target, bool isCasterPlayer, bool isTargetPlayer, XDict <GameData.AttrType, long> casterTempAttrs, XDict <GameData.AttrType, long> targetTempAttrs)
{
FileStream fileStream = null;
StreamWriter streamWriter = null;
StringBuilder stringBuilder = null;
if (ClientApp.Instance.isShowFightLog)
{
string text = Application.get_dataPath() + "/../BattleLog.txt";
try
{
fileStream = new FileStream(text, 4, 3);
streamWriter = new StreamWriter(fileStream, Encoding.get_UTF8());
stringBuilder = new StringBuilder();
}
catch (Exception ex)
{
Debug.LogError("Can't Write Log File!\n" + ex.get_Message());
return(null);
}
stringBuilder.Append("Caster: \n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.Atk, caster.Atk) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.Defence, caster.Defence) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PveAtk, caster.PveAtk) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PvpAtk, caster.PvpAtk) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HitRatio, caster.HitRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.CritRatio, caster.CritRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.CritHurtAddRatio, caster.CritHurtAddRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.DeparryRatio, caster.DeparryRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.SuckBloodScale, caster.SuckBloodScale) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HurtAddRatio, caster.HurtAddRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PveHurtAddRatio, caster.PveHurtAddRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PvpHurtAddRatio, caster.PvpHurtAddRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.AtkMulAmend, caster.AtkMulAmend) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PveAtkMulAmend, caster.PveAtkMulAmend) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PvpAtkMulAmend, caster.PvpAtkMulAmend) + "\n");
stringBuilder.Append("Target: \n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.Defence, target.Defence) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HpLmt, target.HpLmt) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.DodgeRatio, target.DodgeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.DecritRatio, target.DecritRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.ParryRatio, target.ParryRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.ParryHurtDeRatio, target.ParryHurtDeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HurtDeRatio, target.ParryHurtDeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PveHurtDeRatio, target.PveHurtDeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PvpHurtDeRatio, target.PvpHurtDeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.DefMulAmend, target.DefMulAmend) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HpLmtMulAmend, target.HpLmtMulAmend) + "\n");
stringBuilder.Append("Calculate: \n");
}
BattleCalculator.DamageResult damageResult = new BattleCalculator.DamageResult();
if (BattleCalculator.CheckHit(caster, target, stringBuilder))
{
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("IsHit: " + true + "\n");
}
bool flag = BattleCalculator.CheckParry(caster, target, out damageResult.parryRandomIndex, stringBuilder);
double finalParryAddRatio = BattleCalculator.GetFinalParryAddRatio(target, flag);
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("IsParry: " + flag + "\n");
}
bool flag2 = BattleCalculator.CheckCrit(caster, target, out damageResult.critRandomIndex, stringBuilder);
double finalCritAddRatio = BattleCalculator.GetFinalCritAddRatio(caster, flag2);
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("IsCrit: " + flag2 + "\n");
}
double tempDamage = BattleCalculator.GetTempDamage(caster, target, isTargetPlayer);
double holyDamage = BattleCalculator.GetHolyDamage(caster, target, casterTempAttrs);
double ignoreTargetDamage = BattleCalculator.GetIgnoreTargetDamage(caster, isTargetPlayer, casterTempAttrs);
double num = (double)BattleCalculator.GetCritAddDamage(caster, flag2);
List <double> list = new List <double>();
list.Add(tempDamage * (double)caster.TryAddValue(GameData.AttrType.SkillNmlDmgScale, casterTempAttrs) * 0.001 + (double)caster.TryAddValue(GameData.AttrType.SkillNmlDmgAddAmend, casterTempAttrs));
list.Add(finalCritAddRatio);
list.Add(finalParryAddRatio);
list.Add((!isCasterPlayer || !isTargetPlayer) ? Math.Max(0.0, (1000.0 + (double)caster.PveHurtAddRatio - (double)target.PveHurtDeRatio) * 0.001) : Math.Max(0.0, (1000.0 + (double)caster.PvpHurtAddRatio - (double)target.PvpHurtDeRatio) * 0.001));
list.Add(Math.Max(0.0, (double)(1000 + caster.HurtAddRatio - target.HurtDeRatio) * 0.001));
double num2 = BattleCalculator.GetMultipleResult(list) + holyDamage + ignoreTargetDamage + num;
double num3 = Math.Max(1.0, num2 * (double)BattleCalculator.serverRandom.Next(9500, 10500, out damageResult.damageRandomIndex) * 9.9999997473787516E-05);
double num4 = BattleCalculator.CalculateLifeSteal(caster, (int)num3);
damageResult.IsMiss = false;
damageResult.IsCrit = flag2;
damageResult.IsParry = flag;
damageResult.Damage = (long)num3;
damageResult.Lifesteal = (long)num4;
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("TempDamage: " + tempDamage + "\n");
stringBuilder.Append("HolyDamage: " + holyDamage + "\n");
stringBuilder.Append("SkillNmlDmgScale: " + caster.TryAddValue(GameData.AttrType.SkillNmlDmgScale, casterTempAttrs) + "\n");
stringBuilder.Append("SkillNmlDmgAddAmend: " + caster.TryAddValue(GameData.AttrType.SkillNmlDmgAddAmend, casterTempAttrs) + "\n");
stringBuilder.Append("FixFinalDamage: " + num3 + "\n");
stringBuilder.Append("Lifesteal: " + num4 + "\n");
}
}
else
{
damageResult.parryRandomIndex = 0;
damageResult.critRandomIndex = 0;
damageResult.damageRandomIndex = 0;
damageResult.IsMiss = true;
damageResult.IsParry = false;
damageResult.IsCrit = false;
damageResult.Damage = 0L;
damageResult.Lifesteal = 0L;
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("IsHit: " + false + "\n");
}
}
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("================================================================\n\n");
Debug.LogError(stringBuilder.ToString());
streamWriter.Write(stringBuilder.ToString());
streamWriter.Close();
fileStream.Close();
}
return(damageResult);
}
protected static void AppDamage(Buff buffData, EntityParent caster, EntityParent target, int fromSkillID, int fromSkillLevel, XDict <GameData.AttrType, BattleSkillAttrAdd> fromSkillAttrChange, bool isCommunicateMix)
{
if (!LocalAgent.GetEntityCalculatable(caster, isCommunicateMix))
{
return;
}
if (!LocalAgent.GetEntityCalculatable(target, isCommunicateMix))
{
return;
}
if (target.IsUnconspicuous && buffData.forceHandle == 0)
{
return;
}
if (target.IsIgnoreFormula)
{
return;
}
XDict <GameData.AttrType, long> buffCasterTempAttr = LocalBattleBuffCalculatorHandler.GetBuffCasterTempAttr(buffData, caster, fromSkillLevel, fromSkillAttrChange);
XDict <GameData.AttrType, long> buffTargetTempAttr = LocalBattleBuffCalculatorHandler.GetBuffTargetTempAttr(buffData, caster, fromSkillLevel, fromSkillAttrChange);
BattleCalculator.DamageResult damageResult = BattleCalculator.CalculateDamage(caster.BattleBaseAttrs, target.BattleBaseAttrs, caster.IsEntitySelfType || caster.IsEntityPlayerType || caster.IsEntityPetType, target.IsEntitySelfType || target.IsEntityPlayerType, buffCasterTempAttr, buffTargetTempAttr);
List <ClientDrvBuffInfo> casterBuffInfo = null;
List <ClientDrvBuffInfo> targetBuffInfo = null;
if (isCommunicateMix)
{
casterBuffInfo = LocalAgent.MakeClientDrvBuffInfo(caster.ID);
targetBuffInfo = LocalAgent.MakeClientDrvBuffInfo(target.ID);
}
if (damageResult.Lifesteal > 0L && !damageResult.IsMiss && LocalAgent.GetEntityIsCurable(caster, isCommunicateMix))
{
long num = LocalAgent.GetSpiritCurHp(caster, isCommunicateMix) + damageResult.Lifesteal;
if (num > caster.RealHpLmt)
{
num = caster.RealHpLmt;
}
Pos pos = null;
if (caster.Actor)
{
pos = new Pos();
pos.x = caster.Actor.FixTransform.get_position().x * 100f;
pos.y = caster.Actor.FixTransform.get_position().z * 100f;
}
LocalAgent.SetSpiritCurHp(caster, num, isCommunicateMix);
LocalBattleProtocolSimulator.SendTreat(caster.ID, (GameObjectType.ENUM)caster.WrapType, caster.ID, (GameObjectType.ENUM)caster.WrapType, BattleAction_Treat.TreatSrcType.SuckBlood, damageResult.Lifesteal, num, pos);
}
long num2 = LocalAgent.GetSpiritCurHp(target, isCommunicateMix) - damageResult.Damage;
if (damageResult.IsMiss)
{
CauseMissAnnouncer.Announce(caster, target);
UnderMissAnnouncer.Announce(target, caster);
}
else if (num2 <= 0L)
{
num2 = 0L;
LocalBattleHitHandler.AppDead(target.ID);
GlobalBattleNetwork.Instance.SendClientDrvBattleDeathNty(target.ID);
}
else
{
if (damageResult.IsCrit)
{
CauseCritAnnouncer.Announce(caster, target);
UnderCritAnnouncer.Announce(target, caster);
}
if (damageResult.IsParry)
{
CauseParryAnnouncer.Announce(caster, target);
UnderParryAnnouncer.Announce(target, caster);
}
LocalBattleHitHandler.AppWeakCalculate(caster, target, buffCasterTempAttr);
}
LocalAgent.SetSpiritCurHp(target, num2, isCommunicateMix);
List <long> list = new List <long>();
if (isCommunicateMix && !damageResult.IsMiss)
{
list.Add((long)damageResult.parryRandomIndex);
list.Add((long)damageResult.critRandomIndex);
list.Add((long)damageResult.damageRandomIndex);
GlobalBattleNetwork.Instance.SendClientDriveBattleBuffDamage(caster.ID, target.ID, caster.Hp, num2, damageResult.Damage, buffData.id, true, casterBuffInfo, targetBuffInfo, list, string.Concat(new object[]
{
caster.TryAddValue(GameData.AttrType.SkillNmlDmgScale, buffCasterTempAttr),
"_",
caster.TryAddValue(GameData.AttrType.SkillNmlDmgAddAmend, buffCasterTempAttr),
"_",
target.DefMulAmend,
"_",
caster.TryAddValue(GameData.AttrType.SkillIgnoreDefenceHurt, buffCasterTempAttr)
}));
}
if (list.get_Count() == 3)
{
}
LocalBattleProtocolSimulator.SendBleed(target.ID, (GameObjectType.ENUM)target.WrapType, caster.ID, (GameObjectType.ENUM)caster.WrapType, BattleAction_Bleed.DmgSrcType.Attack, ElemType.ENUM.Normal, damageResult.Damage, num2, damageResult.IsCrit, damageResult.IsParry, damageResult.IsMiss);
}
public static void AppDamage(Effect effectData, EntityParent caster, List <long> effectTargetIDs, XPoint basePoint, int skillID, bool isAddEffect, bool isCommunicateMix)
{
if (!LocalAgent.GetEntityCalculatable(caster, isCommunicateMix))
{
return;
}
XDict <GameData.AttrType, long> effectCasterTempAttr = LocalBattleEffectCalculatorHandler.GetEffectCasterTempAttr(effectData, caster, skillID);
bool flag = isAddEffect && isCommunicateMix;
for (int i = 0; i < effectTargetIDs.get_Count(); i++)
{
if (LocalAgent.GetEntityCalculatable(caster, isCommunicateMix))
{
EntityParent entityByID = LocalAgent.GetEntityByID(effectTargetIDs.get_Item(i));
if (LocalAgent.GetEntityCalculatable(entityByID, isCommunicateMix))
{
if (!entityByID.IsUnconspicuous || effectData.forcePickup != 0)
{
if (!entityByID.IsIgnoreFormula)
{
CauseDamageEffectAnnouncer.Announce(caster, entityByID, effectData.id);
UnderDamageEffectAnnouncer.Announce(entityByID, caster, effectData.id);
BattleCalculator.DamageResult damageResult = BattleCalculator.CalculateDamage(caster.BattleBaseAttrs, entityByID.BattleBaseAttrs, caster.IsEntitySelfType || caster.IsEntityPlayerType || caster.IsEntityPetType, entityByID.IsEntitySelfType || entityByID.IsEntityPlayerType, effectCasterTempAttr, null);
List <ClientDrvBuffInfo> casterBuffInfo = null;
List <ClientDrvBuffInfo> targetBuffInfo = null;
if (isCommunicateMix)
{
casterBuffInfo = LocalAgent.MakeClientDrvBuffInfo(caster.ID);
targetBuffInfo = LocalAgent.MakeClientDrvBuffInfo(effectTargetIDs.get_Item(i));
}
if (damageResult.Lifesteal > 0L && !damageResult.IsMiss && LocalAgent.GetEntityIsCurable(caster, isCommunicateMix))
{
long num = LocalAgent.GetSpiritCurHp(caster, isCommunicateMix) + damageResult.Lifesteal;
if (num > caster.RealHpLmt)
{
num = caster.RealHpLmt;
}
Pos pos = null;
if (caster.Actor)
{
pos = new Pos();
pos.x = caster.Actor.FixTransform.get_position().x * 100f;
pos.y = caster.Actor.FixTransform.get_position().z * 100f;
}
LocalAgent.SetSpiritCurHp(caster, num, isCommunicateMix);
LocalBattleProtocolSimulator.SendTreat(caster.ID, (GameObjectType.ENUM)caster.WrapType, caster.ID, (GameObjectType.ENUM)caster.WrapType, BattleAction_Treat.TreatSrcType.SuckBlood, damageResult.Lifesteal, num, pos);
}
long num2 = LocalAgent.GetSpiritCurHp(entityByID, isCommunicateMix) - damageResult.Damage;
if (damageResult.IsMiss)
{
CauseMissAnnouncer.Announce(caster, entityByID);
UnderMissAnnouncer.Announce(entityByID, caster);
}
else if (num2 <= 0L)
{
num2 = 0L;
LocalBattleHitHandler.AppDead(effectTargetIDs.get_Item(i));
GlobalBattleNetwork.Instance.SendClientDrvBattleDeathNty(effectTargetIDs.get_Item(i));
}
else
{
if (damageResult.IsCrit)
{
CauseCritAnnouncer.Announce(caster, entityByID);
UnderCritAnnouncer.Announce(entityByID, caster);
}
if (damageResult.IsParry)
{
CauseParryAnnouncer.Announce(caster, entityByID);
UnderParryAnnouncer.Announce(entityByID, caster);
LocalBattleHitHandler.AppParryFx(entityByID);
}
else
{
LocalBattleHitHandler.AppHit(effectData, caster, entityByID, basePoint, isAddEffect);
}
LocalBattleHitHandler.AppHitAudio(effectData, entityByID);
LocalBattleHitHandler.AppWeakCalculate(caster, entityByID, effectCasterTempAttr);
}
LocalAgent.SetSpiritCurHp(entityByID, num2, isCommunicateMix);
List <long> list = new List <long>();
if (isCommunicateMix && !damageResult.IsMiss)
{
list.Add((long)damageResult.parryRandomIndex);
list.Add((long)damageResult.critRandomIndex);
list.Add((long)damageResult.damageRandomIndex);
GlobalBattleNetwork.Instance.SendClientDriveBattleEffectDamage(caster.ID, effectTargetIDs.get_Item(i), caster.Hp, num2, damageResult.Damage, skillID, effectData.id, flag, true, casterBuffInfo, targetBuffInfo, basePoint, list, string.Concat(new object[]
{
caster.TryAddValue(GameData.AttrType.SkillNmlDmgScale, effectCasterTempAttr),
"_",
caster.TryAddValue(GameData.AttrType.SkillNmlDmgAddAmend, effectCasterTempAttr),
"_",
entityByID.DefMulAmend,
"_",
caster.TryAddValue(GameData.AttrType.SkillIgnoreDefenceHurt, effectCasterTempAttr)
}), false);
}
if (list.get_Count() == 3)
{
}
LocalBattleProtocolSimulator.SendBleed(effectTargetIDs.get_Item(i), (GameObjectType.ENUM)entityByID.WrapType, caster.ID, (GameObjectType.ENUM)caster.WrapType, BattleAction_Bleed.DmgSrcType.Attack, ElemType.ENUM.Normal, damageResult.Damage, num2, damageResult.IsCrit, damageResult.IsParry, damageResult.IsMiss);
if (flag)
{
flag = false;
}
}
}
}
}
}
}
