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 static void AppBlink(Effect effectData, EntityParent caster, XPoint basePoint, bool isCommunicateMix)
{
Pos pos = new Pos();
Vector2 vector = new Vector2();
Vector3 vector2 = Vector3.get_zero();
Vector3 vector3 = caster.Actor.FixTransform.get_forward();
EffectBasePointType @base = (EffectBasePointType)effectData.@base;
if (@base != EffectBasePointType.SpawnPoint)
{
vector2 = basePoint.ApplyOffset(effectData.offset).position;
}
else
{
vector2 = LocalAgent.GetSpawnPosition(effectData.summonId);
}
if (effectData.blinkPoint != 0)
{
vector3 = LocalAgent.GetSpawnPosition(effectData.blinkPoint) - vector2;
}
pos.x = (float)((int)vector2.x * 100);
pos.y = (float)((int)vector2.z * 100);
vector.x = vector3.x;
vector.y = vector3.z;
LocalBattleProtocolSimulator.SendTeleport(caster.ID, pos);
}
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);
}
protected static void AppTreat(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.GetEntityIsCurable(target, isCommunicateMix))
{
return;
}
if (target.IsUnconspicuous && buffData.forceHandle == 0)
{
return;
}
XDict <GameData.AttrType, long> buffCasterTempAttr = LocalBattleBuffCalculatorHandler.GetBuffCasterTempAttr(buffData, caster, fromSkillLevel, fromSkillAttrChange);
XDict <GameData.AttrType, long> buffTargetTempAttr = LocalBattleBuffCalculatorHandler.GetBuffTargetTempAttr(buffData, caster, fromSkillLevel, fromSkillAttrChange);
long num = BattleCalculator.CalculateTreatment(caster.BattleBaseAttrs, target.BattleBaseAttrs, target.IsEntitySelfType || target.IsEntityPlayerType, buffCasterTempAttr, buffTargetTempAttr);
if (num != 0L)
{
List <ClientDrvBuffInfo> casterBuffInfo = null;
List <ClientDrvBuffInfo> targetBuffInfo = null;
if (isCommunicateMix)
{
casterBuffInfo = LocalAgent.MakeClientDrvBuffInfo(caster.ID);
targetBuffInfo = LocalAgent.MakeClientDrvBuffInfo(target.ID);
}
long num2 = LocalAgent.GetSpiritCurHp(target, isCommunicateMix) + num;
if (num2 > target.RealHpLmt)
{
num2 = target.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(target, num2, isCommunicateMix);
if (isCommunicateMix)
{
GlobalBattleNetwork.Instance.SendClientDriveBattleBuffDamage(caster.ID, target.ID, caster.Hp, num2, num, buffData.id, true, casterBuffInfo, targetBuffInfo, new List <long>(), string.Concat(new object[]
{
caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOAtk, buffCasterTempAttr),
"_",
caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOHpLmt, buffCasterTempAttr),
"_",
caster.TryAddValue(GameData.AttrType.SkillIgnoreDefenceHurt, buffCasterTempAttr)
}));
}
LocalBattleProtocolSimulator.SendTreat(target.ID, (GameObjectType.ENUM)target.WrapType, caster.ID, (GameObjectType.ENUM)caster.WrapType, BattleAction_Treat.TreatSrcType.Treat, num, num2, pos);
}
}
protected void OnLeaveBuff(int buffID, long targetID)
{
XDict <int, BuffState> buffListByEntityID = this.GetBuffListByEntityID(targetID);
if (!buffListByEntityID.ContainsKey(buffID))
{
return;
}
this.KillBuff(buffID, buffListByEntityID[buffID].casterID, targetID, buffListByEntityID[buffID].fromSkillLevel, buffListByEntityID[buffID].isCommunicateMix);
this.buffStateTable[targetID].Remove(buffID);
LocalBattleProtocolSimulator.SendRemoveBuff(targetID, buffID);
}
public static void KillBuff(Buff buffData, EntityParent caster, EntityParent target, int fromSkillLevel, bool isCommunicateMix)
{
LocalBattleBuffPropHandler.KillBuff(buffData, caster, target, fromSkillLevel);
if (target == null)
{
return;
}
if (LocalAgent.GetSpiritIsDead(target, isCommunicateMix))
{
return;
}
if (!LocalAgent.CheckBuffTypeContainOther(buffData, target.ID))
{
LocalBattleProtocolSimulator.SendEndWeak(target.ID);
}
}
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);
}
public static void HandleBuff(Buff buffData, EntityParent caster, EntityParent target, int fromSkillLevel)
{
LocalBattleBuffPropHandler.HandleBuff(buffData, caster, target, fromSkillLevel);
LocalBattleProtocolSimulator.SendWeak(target.ID);
}
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 AppSendPetLeaveBattleField(long petID)
{
LocalBattleProtocolSimulator.SendPetLeaveBattleField(petID);
}
public static void AppSendPetEnterBattleField(long petID, Pos pos, Vector2 dir, float existTime)
{
LocalBattleProtocolSimulator.SendPetEnterBattleField(petID, pos, dir, existTime);
}
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);
}
}
public void AddSkill(long targetID, int skillIndex, int skillID, int skillLevel = 1)
{
LocalBattleProtocolSimulator.SendAddSkill(targetID, skillIndex, skillID, skillLevel);
}
public void AppFuse(EntityParent caster, int skillID, bool isCommunicateMix)
{
if (caster == null)
{
return;
}
if (caster.BattleBaseAttrs == null)
{
return;
}
XDict <int, LocalDimensionPetSpirit> petSpiritByOwnerID = LocalAgent.GetPetSpiritByOwnerID(caster.ID);
if (petSpiritByOwnerID == null)
{
return;
}
if (petSpiritByOwnerID.Count == 0)
{
return;
}
int num = -1;
for (int i = 0; i < petSpiritByOwnerID.Count; i++)
{
if (petSpiritByOwnerID.ElementValueAt(i).fuseRitualSkillInfo != null)
{
if (petSpiritByOwnerID.ElementValueAt(i).fuseRitualSkillInfo.skillId == skillID)
{
num = petSpiritByOwnerID.ElementKeyAt(i);
LocalAgent.RemovePetSummonRitualSkill(caster.ID, petSpiritByOwnerID.ElementValueAt(i));
break;
}
}
}
List <EntityParent> values = EntityWorld.Instance.GetEntities <EntityPet>().Values;
EntityPet entityPet = null;
for (int j = 0; j < values.get_Count(); j++)
{
if (values.get_Item(j).IsFighting&& values.get_Item(j).OwnerListIdx == num && values.get_Item(j).OwnerID == caster.ID)
{
entityPet = (values.get_Item(j) as EntityPet);
break;
}
}
if (entityPet == null)
{
return;
}
FuseState fuseState = new FuseState();
fuseState.modelID = caster.ModelID;
fuseState.skill.Clear();
using (Dictionary <int, int> .Enumerator enumerator = caster.GetSkillPairPart().GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <int, int> current = enumerator.get_Current();
fuseState.skill.Add(current.get_Key(), current.get_Value());
}
}
using (List <int> .Enumerator enumerator2 = caster.GetSkillSinglePart().GetEnumerator())
{
while (enumerator2.MoveNext())
{
int current2 = enumerator2.get_Current();
fuseState.skill.AddValue(current2);
}
}
fuseState.petID = entityPet.ID;
LocalAgent.AppClearBuff(caster.ID);
LocalAgent.AppClearBuff(entityPet.ID);
this.SetFuseAttrs(caster, entityPet, fuseState);
Pet pet = DataReader <Pet> .Get(entityPet.TypeID);
for (int k = 0; k < pet.fuseSkill.get_Count(); k++)
{
if (pet.fuseSkill.get_Item(k).key == caster.TypeID)
{
List <KeyValuePair <int, int> > list = new List <KeyValuePair <int, int> >();
list.Add(new KeyValuePair <int, int>(1, pet.fuseNormalSkill));
list.Add(new KeyValuePair <int, int>(11, pet.fuseSkill.get_Item(k).value));
LocalBattleProtocolSimulator.SendFit(caster.ID, entityPet.ID, pet.fuseModle, list, 1000 * (int)(entityPet.FuseTime + (caster as EntitySelf).TotalFuseTimePlus));
caster.SetValue(GameData.AttrType.MoveSpeed, DataReader <AvatarModel> .Get(pet.fuseModle).speed, true);
break;
}
}
fuseState.timerID = TimerHeap.AddTimer((uint)(1000f * (entityPet.FuseTime + (caster as EntitySelf).TotalFuseTimePlus)), 0, delegate
{
this.AppDeFuse(caster.ID);
});
this.fuseStateTable.Add(caster.ID, fuseState);
}
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;
}
}
}
}
}
}
}
