public static void AppHit(Effect effectData, EntityParent caster, List <long> effectTargetIDs, XPoint basePoint, bool isAddEffect)
{
for (int i = 0; i < effectTargetIDs.get_Count(); i++)
{
LocalBattleHitHandler.AppHit(effectData, caster, LocalAgent.GetEntityByID(effectTargetIDs.get_Item(i)), basePoint, isAddEffect);
}
}
public static void AppTheat(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++)
{
EntityParent entityByID = LocalAgent.GetEntityByID(effectTargetIDs.get_Item(i));
if (LocalAgent.GetEntityIsCurable(entityByID, isCommunicateMix))
{
if (!entityByID.IsUnconspicuous || effectData.forcePickup != 0)
{
long num = BattleCalculator.CalculateTreatment(caster.BattleBaseAttrs, entityByID.BattleBaseAttrs, entityByID.IsEntitySelfType || entityByID.IsEntityPlayerType, effectCasterTempAttr, null);
if (num != 0L)
{
List <ClientDrvBuffInfo> casterBuffInfo = null;
List <ClientDrvBuffInfo> targetBuffInfo = null;
if (isCommunicateMix)
{
casterBuffInfo = LocalAgent.MakeClientDrvBuffInfo(caster.ID);
targetBuffInfo = LocalAgent.MakeClientDrvBuffInfo(effectTargetIDs.get_Item(i));
}
long num2 = LocalAgent.GetSpiritCurHp(entityByID, isCommunicateMix) + num;
if (num2 > entityByID.RealHpLmt)
{
num2 = entityByID.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(entityByID, num2, isCommunicateMix);
if (isCommunicateMix)
{
GlobalBattleNetwork.Instance.SendClientDriveBattleEffectDamage(caster.ID, effectTargetIDs.get_Item(i), caster.Hp, num2, num, skillID, effectData.id, flag, true, casterBuffInfo, targetBuffInfo, basePoint, new List <long>(), string.Concat(new object[]
{
caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOAtk, effectCasterTempAttr),
"_",
caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOHpLmt, effectCasterTempAttr),
"_",
caster.TryAddValue(GameData.AttrType.SkillIgnoreDefenceHurt, effectCasterTempAttr)
}), false);
}
LocalBattleProtocolSimulator.SendTreat(effectTargetIDs.get_Item(i), (GameObjectType.ENUM)entityByID.WrapType, caster.ID, (GameObjectType.ENUM)caster.WrapType, BattleAction_Treat.TreatSrcType.Treat, num, num2, pos);
if (flag)
{
flag = false;
}
}
}
}
}
}
public void AppClearFuse(long targetID, bool isDeadDefuse)
{
EntityParent entityByID = LocalAgent.GetEntityByID(targetID);
if (entityByID == null)
{
return;
}
if (entityByID.BattleBaseAttrs == null)
{
return;
}
if (!this.fuseStateTable.ContainsKey(targetID))
{
return;
}
FuseState fuseState = this.fuseStateTable[targetID];
TimerHeap.DelTimer(fuseState.timerID);
if (!isDeadDefuse)
{
LocalBattleProtocolSimulator.SendExitFit(targetID, fuseState.petID, fuseState.modelID, fuseState.skill);
}
this.ResetFuseAttrs(targetID, 0L, fuseState);
entityByID.SetValue(GameData.AttrType.MoveSpeed, DataReader <AvatarModel> .Get(fuseState.modelID).speed, true);
this.fuseStateTable.Remove(targetID);
}
public void RemoveSkill(long targetID, int skillID)
{
if (LocalAgent.GetEntityByID(targetID).IsFuse&& this.fuseStateTable.ContainsKey(targetID))
{
this.fuseStateTable[targetID].skill.Remove(skillID);
}
LocalBattleProtocolSimulator.SendRemoveSkill(targetID, skillID);
}
public static void AppDead(long targetID)
{
if (LocalAgent.GetEntityByID(targetID) == null)
{
return;
}
LocalAgent.AppClearBuff(targetID);
LocalAgent.ClearFuseDataByEntityID(targetID, true);
}
public void AppAddBuff(int buffID, EntityParent caster, long targetID, int fromSkillID, int elementType = 0, bool isCommunicateMix = false)
{
Buff buffDataByID = LocalAgent.GetBuffDataByID(buffID);
EntityParent entityByID = LocalAgent.GetEntityByID(targetID);
if (this.CheckBuff(buffDataByID, caster, entityByID, fromSkillID, elementType, isCommunicateMix))
{
this.InitBuff(buffDataByID, caster, entityByID, fromSkillID, elementType, isCommunicateMix);
}
}
protected void InitBuff(Buff buffData, EntityParent caster, EntityParent target, int fromSkillID, int elementType, bool isCommunicateMix = false)
{
double num = BattleCalculator.CalculateBuffTime(caster.BattleBaseAttrs.GetBuffCtrlAttrs(elementType), target.BattleBaseAttrs.GetBuffCtrlAttrs(elementType), (double)buffData.time);
if (LocalAgent.CheckBuffByTargetIDAndBuffID(target.ID, buffData.id))
{
int overlayModeId = buffData.overlayModeId;
if (overlayModeId != 1)
{
if (overlayModeId == 2)
{
this.buffStateTable[target.ID][buffData.id].removeLeftTime = num;
}
}
else
{
this.buffStateTable[target.ID][buffData.id].removeLeftTime += num;
}
return;
}
BuffState buffState = new BuffState();
buffState.isBlock = false;
buffState.isCommunicateMix = isCommunicateMix;
buffState.isGlobalBuff = false;
buffState.casterID = caster.ID;
buffState.fromSkillID = fromSkillID;
buffState.fromSkillLevel = caster.GetSkillLevelByID(fromSkillID);
buffState.fromSkillAttrChange = caster.GetSkillAttrChangeByID(fromSkillID);
buffState.intervalDefaultTime = (float)buffData.interval;
buffState.intervalLeftTime = (float)buffData.interval;
buffState.removeLeftTime = num;
if (!this.buffStateTable.ContainsKey(target.ID))
{
this.buffStateTable.Add(target.ID, new XDict <int, BuffState>());
}
this.buffStateTable[target.ID].Add(buffData.id, buffState);
this.HandleBuff(buffData, caster, target, fromSkillID, buffState.fromSkillLevel, buffState.fromSkillAttrChange, isCommunicateMix);
AddBuffAnnouncer.Announce(LocalAgent.GetEntityByID(target.ID), buffData.id);
LocalBattleProtocolSimulator.SendAddBuff(caster.ID, target.ID, buffData.id, (int)num);
}
protected static void AppRelive(long targetID, bool isCommunicateMix)
{
EntityParent entityByID = LocalAgent.GetEntityByID(targetID);
if (entityByID == null)
{
return;
}
if (entityByID.BattleBaseAttrs == null)
{
return;
}
if (entityByID.BackUpBattleBaseAttrs == null)
{
return;
}
entityByID.BattleBaseAttrs.AssignAllAttrs(entityByID.BackUpBattleBaseAttrs);
LocalAgent.SetSpiritCurHp(entityByID, entityByID.RealHpLmt, isCommunicateMix);
entityByID.Hp = entityByID.RealHpLmt;
entityByID.IsDead = false;
}
public void HandleUseSkill(long casterID, long targetID, int skillID, bool isCommunicateMix = false)
{
Skill skillDataByID = LocalAgent.GetSkillDataByID(skillID);
if (skillDataByID == null)
{
return;
}
EntityParent entityByID = LocalAgent.GetEntityByID(casterID);
if (entityByID == null)
{
return;
}
entityByID.SetValue(GameData.AttrType.ActPoint, entityByID.TryAddValue(GameData.AttrType.ActPoint, (long)(skillDataByID.actionPoint + entityByID.GetSkillActionPointVariationByType(skillDataByID.skilltype))), true);
if (isCommunicateMix)
{
GlobalBattleNetwork.Instance.SendClientDriveBattleSkill(casterID, targetID, skillID);
}
if (!this.skillStateTable.ContainsKey(casterID))
{
this.skillStateTable.Add(casterID, new XDict <int, long>());
}
if (!this.skillStateTable[casterID].ContainsKey(skillID))
{
this.skillStateTable[casterID].Add(skillID, targetID);
}
else
{
this.skillStateTable[casterID][skillID] = targetID;
}
EntityParent entityByID2 = LocalAgent.GetEntityByID(targetID);
UseSkillAnnouncer.Announce(entityByID, entityByID2, skillID);
BacameSkillTargetAnnouncer.Announce(entityByID2, entityByID, skillID);
}
protected void HandleTriggerEffect(long casterID, int skillID, int effectID, List <EffectTargetInfo> effectTargetInfos, XPoint basePoint, int effectUniqueID, bool isAddEffect = true, bool isCommunicateMix = false)
{
Effect effectDataByID = LocalAgent.GetEffectDataByID(effectID);
EntityParent entityByID = LocalAgent.GetEntityByID(casterID);
List <long> list = new List <long>();
for (int i = 0; i < effectTargetInfos.get_Count(); i++)
{
list.Add(effectTargetInfos.get_Item(i).targetId);
}
if (isAddEffect)
{
if (list.get_Count() > 0 && LocalAgent.GetEntityUsable(entityByID, isCommunicateMix))
{
int num = BattleCalculator.CalculateEffectCasterActPoint(entityByID.BattleBaseAttrs, (double)effectDataByID.casterPoint);
entityByID.SetValue(GameData.AttrType.ActPoint, entityByID.TryAddValue(GameData.AttrType.ActPoint, (long)num), true);
}
if (isCommunicateMix && effectDataByID.type1 != 0 && effectDataByID.type1 != 1 && effectDataByID.type1 != 2)
{
GlobalBattleNetwork.Instance.SendClientDriveBattleEffectDamage(casterID, 0L, (!LocalAgent.GetEntityUsable(entityByID, isCommunicateMix)) ? 0L : entityByID.Hp, 0L, 0L, skillID, effectID, true, false, null, null, basePoint, new List <long>(), string.Empty, true);
}
}
for (int j = 0; j < list.get_Count(); j++)
{
EntityParent entityByID2 = LocalAgent.GetEntityByID(list.get_Item(j));
if (LocalAgent.GetEntityUsable(entityByID2, isCommunicateMix))
{
entityByID2.SetValue(GameData.AttrType.ActPoint, entityByID2.TryAddValue(GameData.AttrType.ActPoint, (long)effectDataByID.targetPoint), true);
}
}
switch (effectDataByID.type1)
{
case 1:
LocalBattleEffectCalculatorDamageHandler.AppDamage(effectDataByID, entityByID, list, basePoint, skillID, isAddEffect, isCommunicateMix);
break;
case 2:
LocalBattleEffectCalculatorTreatHandler.AppTheat(effectDataByID, entityByID, list, basePoint, skillID, isAddEffect, isCommunicateMix);
break;
case 3:
LocalBattleEffectSummonMonsterHandler.AppSummonMonster(effectDataByID, entityByID, basePoint, isCommunicateMix);
break;
case 4:
LocalBattleEffectReliveHandler.AppRelive(list, isCommunicateMix);
break;
case 5:
LocalBattleEffectDrainHandler.AppDrain(effectDataByID, entityByID, list, isCommunicateMix);
break;
case 7:
this.AppFuse(entityByID, skillID, isCommunicateMix);
break;
case 8:
LocalBattleEffectSummonPetHandler.AppSummonPet(effectDataByID, entityByID, skillID, isCommunicateMix);
break;
case 9:
LocalBattleEffectPetManualSkillHandler.AppManualSkill(entityByID, list, skillID, isCommunicateMix);
break;
case 10:
LocalBattleEffectBlinkHandler.AppBlink(effectDataByID, entityByID, basePoint, isCommunicateMix);
break;
case 11:
LocalBattleEffectHitHandler.AppHit(effectDataByID, entityByID, list, basePoint, isAddEffect);
break;
}
for (int k = 0; k < list.get_Count(); k++)
{
for (int l = 0; l < effectDataByID.addLoopBuff.get_Count(); l++)
{
this.AppAddBuff(effectDataByID.addLoopBuff.get_Item(l), entityByID, list.get_Item(k), skillID, effectDataByID.element, isCommunicateMix);
}
if (isAddEffect)
{
for (int m = 0; m < effectDataByID.addBuff.get_Count(); m++)
{
this.AppAddBuff(effectDataByID.addBuff.get_Item(m), entityByID, list.get_Item(k), skillID, effectDataByID.element, isCommunicateMix);
}
for (int n = 0; n < effectDataByID.removeBuff.get_Count(); n++)
{
this.AppRemoveBuff(effectDataByID.removeBuff.get_Item(n), list.get_Item(k));
}
}
if (entityByID != null)
{
int skillLevelByID = entityByID.GetSkillLevelByID(skillID);
for (int num2 = 0; num2 < effectDataByID.gradeAddLoopBuffId.get_Count(); num2++)
{
if (effectDataByID.gradeAddLoopBuffId.get_Item(num2).key == skillLevelByID)
{
this.AppAddBuff(effectDataByID.gradeAddLoopBuffId.get_Item(num2).value, entityByID, list.get_Item(k), skillID, effectDataByID.element, isCommunicateMix);
}
}
if (isAddEffect)
{
for (int num3 = 0; num3 < effectDataByID.gradeAddBuffId.get_Count(); num3++)
{
if (effectDataByID.gradeAddBuffId.get_Item(num3).key == skillLevelByID)
{
this.AppAddBuff(effectDataByID.gradeAddBuffId.get_Item(num3).value, entityByID, list.get_Item(k), skillID, effectDataByID.element, isCommunicateMix);
}
}
}
}
}
}
protected void KillBuff(int buffID, long casterID, long targetID, int fromSkillLevel, bool isCommunicateMix)
{
Buff buffDataByID = LocalAgent.GetBuffDataByID(buffID);
EntityParent entityByID = LocalAgent.GetEntityByID(casterID);
EntityParent entityByID2 = LocalAgent.GetEntityByID(targetID);
switch (buffDataByID.type)
{
case 1:
LocalBattleBuffCalculatorDamageHandler.KillBuff(buffID, casterID, targetID, fromSkillLevel, isCommunicateMix);
break;
case 2:
LocalBattleBuffCalculatorTreatHandler.KillBuff(buffID, casterID, targetID, fromSkillLevel, isCommunicateMix);
break;
case 3:
LocalBattleBuffTauntHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 4:
LocalBattleBuffFixHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 5:
LocalBattleBuffStaticHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 6:
LocalBattleBuffShiftHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 7:
LocalBattleBuffChangeAttrsHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 8:
LocalBattleBuffSuperArmorHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 9:
LocalBattleBuffDrainHandler.KillBuff(buffID, casterID, targetID, fromSkillLevel, isCommunicateMix);
break;
case 10:
LocalBattleBuffIgnoreFormulaHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 11:
LocalBattleBuffCloseRendererHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 12:
LocalBattleBuffMoveCastHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 13:
LocalBattleBuffFilterHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 14:
LocalBattleBuffDizzyHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 15:
LocalBattleBuffUnconspicuousHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 16:
LocalBattleBuffAuraHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 17:
LocalBattleBuffWeakHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 18:
LocalBattleBuffIncurableHandler.KillBuff(buffDataByID, entityByID, entityByID2, fromSkillLevel, isCommunicateMix);
break;
case 19:
LocalBattleBuffCalculatorTreat2Handler.KillBuff(buffID, casterID, targetID, fromSkillLevel, isCommunicateMix);
break;
}
if (buffDataByID.tempSkill > 0)
{
LocalBattleProtocolSimulator.SendRemoveSkill(targetID, buffDataByID.tempSkill);
}
}
protected void IntervalHandleBuff(int buffID, long targetID)
{
EntityParent entityByID = LocalAgent.GetEntityByID(targetID);
if (entityByID == null)
{
return;
}
XDict <int, BuffState> buffListByEntityID = this.GetBuffListByEntityID(targetID);
if (buffListByEntityID == null)
{
return;
}
if (buffListByEntityID.Count == 0)
{
return;
}
if (!buffListByEntityID.ContainsKey(buffID))
{
return;
}
EntityParent entityByID2 = LocalAgent.GetEntityByID(this.buffStateTable[targetID][buffID].casterID);
if (entityByID2 == null)
{
return;
}
Buff buffDataByID = LocalAgent.GetBuffDataByID(buffID);
BuffType type = (BuffType)buffDataByID.type;
switch (type)
{
case BuffType.Aura:
entityByID.GetSkillManager().ClientCastSkillByID(buffDataByID.tempSkill);
return;
case BuffType.Weak:
case BuffType.Incurable:
IL_83:
if (type == BuffType.Damage)
{
LocalBattleBuffCalculatorDamageHandler.IntervalBuff(buffDataByID, entityByID2, entityByID, this.buffStateTable[targetID][buffID].fromSkillID, this.buffStateTable[targetID][buffID].fromSkillLevel, this.buffStateTable[targetID][buffID].fromSkillAttrChange, this.buffStateTable[targetID][buffID].isCommunicateMix);
return;
}
if (type == BuffType.Theat)
{
LocalBattleBuffCalculatorTreatHandler.IntervalBuff(buffDataByID, entityByID2, entityByID, this.buffStateTable[targetID][buffID].fromSkillID, this.buffStateTable[targetID][buffID].fromSkillLevel, this.buffStateTable[targetID][buffID].fromSkillAttrChange, this.buffStateTable[targetID][buffID].isCommunicateMix);
return;
}
if (type != BuffType.Drain)
{
return;
}
LocalBattleBuffDrainHandler.IntervalBuff(buffDataByID, entityByID2, entityByID, this.buffStateTable[targetID][buffID].fromSkillID, this.buffStateTable[targetID][buffID].fromSkillLevel, this.buffStateTable[targetID][buffID].fromSkillAttrChange, this.buffStateTable[targetID][buffID].isCommunicateMix);
return;
case BuffType.Theat2:
LocalBattleBuffCalculatorTreat2Handler.IntervalBuff(buffDataByID, entityByID2, entityByID, this.buffStateTable[targetID][buffID].fromSkillID, this.buffStateTable[targetID][buffID].fromSkillLevel, this.buffStateTable[targetID][buffID].fromSkillAttrChange, this.buffStateTable[targetID][buffID].isCommunicateMix);
return;
}
goto IL_83;
}
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;
}
}
}
}
}
}
}