From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- Client/Assets/Scripts/XMainClient/XCombat.cs | 771 +++++++++++++++++++++++++++ 1 file changed, 771 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/XCombat.cs (limited to 'Client/Assets/Scripts/XMainClient/XCombat.cs') diff --git a/Client/Assets/Scripts/XMainClient/XCombat.cs b/Client/Assets/Scripts/XMainClient/XCombat.cs new file mode 100644 index 00000000..0116a7a7 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XCombat.cs @@ -0,0 +1,771 @@ +using System; +using System.Collections.Generic; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XCombat : XSingleton + { + private XTableAsyncLoader _async_loader = null; + + private static CombatParamTable oTable = new CombatParamTable(); + + private static List oAttackApplyStateHandlers; + + private double PhysicalAvoidenceLimit; + + private double MagicAvoidenceLimit; + + public override bool Init() + { + bool flag = this._async_loader == null; + if (flag) + { + this._async_loader = new XTableAsyncLoader(); + this._async_loader.AddTask("Table/CombatParamList", XCombat.oTable, false); + this._async_loader.Execute(null); + } + bool flag2 = !this._async_loader.IsDone; + bool result; + if (flag2) + { + result = false; + } + else + { + XCombat.oAttackApplyStateHandlers = new List(); + XCombat.oAttackApplyStateHandlers.Add(new AttackApplyCritical()); + XCombat.oAttackApplyStateHandlers.Add(new AttackApplyStun()); + this.PhysicalAvoidenceLimit = double.Parse(XSingleton.singleton.GetValue("PhycialAvoidenceLimit")); + this.MagicAvoidenceLimit = double.Parse(XSingleton.singleton.GetValue("MagicAvoidenceLimit")); + result = true; + } + return result; + } + + public override void Uninit() + { + XCombat.oAttackApplyStateHandlers.Clear(); + this._async_loader = null; + } + + public double GetBaseCriticalProb(XAttributes attributes, double value) + { + bool flag = attributes == null; + double result; + if (flag) + { + result = 0.0; + } + else + { + CombatParamTable.RowData combatParam = XSingleton.singleton.GetCombatParam(attributes.Level); + result = value / (value + (double)combatParam.CriticalBase); + } + return result; + } + + public double GetCombatValue(int combatParam, double value) + { + return value / (value + (double)combatParam); + } + + public CombatParamTable.RowData GetCombatParam(uint Level) + { + bool flag = Level == 0u || (ulong)Level >= (ulong)((long)XCombat.oTable.Table.Length); + CombatParamTable.RowData result; + if (flag) + { + result = XCombat.oTable.Table[0]; + } + else + { + result = XCombat.oTable.Table[(int)(Level - 1u)]; + } + return result; + } + + public XAttributeDefine MapElementToAttrAttack(DamageElement de) + { + XAttributeDefine result; + switch (de) + { + case DamageElement.DE_NONE: + result = XAttributeDefine.XAttr_VoidAtk_Total; + break; + case DamageElement.DE_FIRE: + result = XAttributeDefine.XAttr_FireAtk_Total; + break; + case DamageElement.DE_WATER: + result = XAttributeDefine.XAttr_WaterAtk_Total; + break; + case DamageElement.DE_LIGHT: + result = XAttributeDefine.XAttr_LightAtk_Total; + break; + case DamageElement.DE_DARK: + result = XAttributeDefine.XAttr_DarkAtk_Total; + break; + default: + result = XAttributeDefine.XAttr_VoidAtk_Total; + break; + } + return result; + } + + public XAttributeDefine MapElementToAttrDefense(DamageElement de) + { + XAttributeDefine result; + switch (de) + { + case DamageElement.DE_NONE: + result = XAttributeDefine.XAttr_VoidDef_Total; + break; + case DamageElement.DE_FIRE: + result = XAttributeDefine.XAttr_FireDef_Total; + break; + case DamageElement.DE_WATER: + result = XAttributeDefine.XAttr_WaterDef_Total; + break; + case DamageElement.DE_LIGHT: + result = XAttributeDefine.XAttr_LightDef_Total; + break; + case DamageElement.DE_DARK: + result = XAttributeDefine.XAttr_DarkDef_Total; + break; + default: + result = XAttributeDefine.XAttr_VoidDef_Total; + break; + } + return result; + } + + private void ApplySkillBuff(HurtInfo rawInput, List Buffs) + { + for (int i = 0; i < Buffs.Count; i++) + { + int buffTargetType = XSingleton.singleton.GetBuffTargetType(Buffs[i].BuffID); + bool flag = buffTargetType == -1; + if (!flag) + { + XSkillExternalBuffArgs @event = XEventPool.GetEvent(); + @event.xBuffDesc = Buffs[i]; + @event.xBuffDesc.CasterID = rawInput.Caster.ID; + bool flag2 = buffTargetType == 1; + if (flag2) + { + @event.xTarget = rawInput.Target; + } + else + { + bool flag3 = buffTargetType == 0; + if (flag3) + { + @event.xTarget = rawInput.Caster; + } + } + bool flag4 = Buffs[i].DelayTime == 0f; + if (flag4) + { + this._OnApplyBuff(@event); + @event.Recycle(); + } + else + { + @event.delay = Buffs[i].DelayTime; + @event.callback = new SkillExternalCallback(this._OnApplyBuff); + rawInput.Callback(@event); + } + } + } + } + + private bool _OnApplyBuff(XSkillExternalArgs arg) + { + XSkillExternalBuffArgs xskillExternalBuffArgs = arg as XSkillExternalBuffArgs; + bool flag = xskillExternalBuffArgs.xTarget != null && !xskillExternalBuffArgs.xTarget.Deprecated; + if (flag) + { + XBuffAddEventArgs @event = XEventPool.GetEvent(); + @event.xBuffDesc = xskillExternalBuffArgs.xBuffDesc; + @event.Firer = xskillExternalBuffArgs.xTarget; + XSingleton.singleton.FireEvent(@event); + } + return true; + } + + private void GetBaseDamage(XAttributes casterAttr, XAttributes targetAttr, SkillEffect eff, ref ProjectDamageResult result) + { + CombatParamTable.RowData combatParam = this.GetCombatParam(targetAttr.Level); + double num = this.GetCombatValue(combatParam.PhysicalDef, targetAttr.GetAttr(XAttributeDefine.XAttr_PhysicalDefMod_Total)); + num = Math.Min(num, this.PhysicalAvoidenceLimit); + double num2 = casterAttr.GetAttr(XAttributeDefine.XAttr_PhysicalAtkMod_Total) * (1.0 - num); + double num3 = this.GetCombatValue(combatParam.MagicDef, targetAttr.GetAttr(XAttributeDefine.XAttr_MagicDefMod_Total)); + num3 = Math.Min(num3, this.MagicAvoidenceLimit); + double num4 = casterAttr.GetAttr(XAttributeDefine.XAttr_MagicAtkMod_Total) * (1.0 - num3); + bool flag = num2 < 0.0; + if (flag) + { + num2 = 0.0; + } + bool flag2 = num4 < 0.0; + if (flag2) + { + num4 = 0.0; + } + double num5 = 0.0; + num5 += eff.PhyRatio * num2 + eff.PhyFixed; + num5 += eff.MagRatio * num4 + eff.MagFixed; + bool flag3 = num5 > 0.0; + if (flag3) + { + double num6 = 0.0; + num6 += eff.PhyRatio * num2 / (1.0 - num) + eff.PhyFixed; + num6 += eff.MagRatio * num4 / (1.0 - num3) + eff.MagFixed; + result.DefOriginalRatio = num6 / num5; + CombatParamTable.RowData combatParam2 = this.GetCombatParam(casterAttr.Level); + double num7 = this.GetCombatValue(combatParam2.ElementAtk, casterAttr.GetAttr(this.MapElementToAttrAttack(eff.DamageElementType))); + double num8 = this.GetCombatValue(combatParam.ElementDef, targetAttr.GetAttr(this.MapElementToAttrDefense(eff.DamageElementType))); + bool flag4 = num7 > XSingleton.singleton.ElemAtkLimit; + if (flag4) + { + num7 = XSingleton.singleton.ElemAtkLimit; + } + bool flag5 = num8 > XSingleton.singleton.ElemDefLimit; + if (flag5) + { + num8 = XSingleton.singleton.ElemDefLimit; + } + double num9 = this.GetCombatValue(combatParam2.FinalDamageBase, casterAttr.GetAttr(XAttributeDefine.XAttr_FinalDamage_Total)); + bool flag6 = num9 > XSingleton.singleton.FinalDamageLimit; + if (flag6) + { + num9 = XSingleton.singleton.FinalDamageLimit; + } + double num10 = targetAttr.GetAttr(XAttributeDefine.XAttr_HurtInc_Total) / XSingleton.singleton.GeneralCombatParam + 1.0; + bool flag7 = num10 > XSingleton.singleton.AttrChangeDamageLimit; + if (flag7) + { + num10 = XSingleton.singleton.AttrChangeDamageLimit; + } + result.Value = num10 * num5 * (1.0 + num9) * (1.0 + num7) * (1.0 - num8); + } + else + { + result.Value = 0.0; + result.DefOriginalRatio = 1.0; + } + } + + public double GetCritialRatio(XAttributes casterAttr) + { + double attr = casterAttr.GetAttr(XAttributeDefine.XAttr_CritDamage_Total); + CombatParamTable.RowData combatParam = this.GetCombatParam(casterAttr.Level); + double num = attr / (attr + (double)combatParam.CritDamageBase) + XSingleton.singleton.CritDamageBase; + bool flag = num > XSingleton.singleton.CritDamageUpperBound; + if (flag) + { + num = XSingleton.singleton.CritDamageUpperBound; + } + bool flag2 = num < XSingleton.singleton.CritDamageLowerBound; + if (flag2) + { + num = XSingleton.singleton.CritDamageLowerBound; + } + return num; + } + + public void CaculateSkillDamage(HurtInfo rawInput, ProjectDamageResult result, SkillEffect eff) + { + XAttributes attributes = rawInput.Caster.Attributes; + XAttributes attributes2 = rawInput.Target.Attributes; + float num; + result.EffectHelper.GetSkillDamage(out num); + num += XEmblemDocument.GetSkillDamageRatio(attributes.EmblemBag, rawInput.SkillID); + eff.PhyRatio *= 1.0 + (double)num; + eff.MagRatio *= 1.0 + (double)num; + this.GetBaseDamage(attributes, attributes2, eff, ref result); + for (int i = 0; i < XCombat.oAttackApplyStateHandlers.Count; i++) + { + bool flag = XCombat.oAttackApplyStateHandlers[i].GetStateMask() != 0; + if (flag) + { + bool flag2 = XCombat.oAttackApplyStateHandlers[i].IsApplyState(rawInput.Caster) && !XCombat.oAttackApplyStateHandlers[i].IsDefenseState(rawInput.Target); + if (flag2) + { + XCombat.oAttackApplyStateHandlers[i].ApplyState(rawInput.Caster, result); + } + } + } + bool flag3 = eff.Buffs != null && eff.Buffs.Count > 0; + if (flag3) + { + this.ApplySkillBuff(rawInput, eff.Buffs); + } + result.ElementType = eff.DamageElementType; + double num2 = 1.0; + double num3 = 1.0; + double num4 = 1.0; + bool flag4 = rawInput.Caster.Buffs != null; + if (flag4) + { + num2 += rawInput.Caster.Buffs.ModifySkillDamage(); + num4 += rawInput.Caster.Buffs.ChangeSkillDamage(rawInput.SkillID); + } + bool flag5 = rawInput.Target.Buffs != null; + if (flag5) + { + num2 += rawInput.Target.Buffs.IncReceivedDamage(); + num3 += rawInput.Target.Buffs.DecReceivedDamage(); + } + result.Value *= num2 * num3 * num4; + double num5 = (double)XSingleton.singleton.RandomFloat(XSingleton.singleton.DamageRandomLowerBound, XSingleton.singleton.DamageRandomUpperBound); + result.Value *= num5; + SceneTable.RowData sceneData = XSingleton.singleton.GetSceneData(XSingleton.singleton.SceneID); + bool flag6 = sceneData != null; + if (flag6) + { + result.Value *= (double)sceneData.HurtCoef; + } + double num6 = attributes.GetAttr(XAttributeDefine.XAttr_TrueDamage_Total); + bool flag7 = eff.PercentDamage > 1E-05; + if (flag7) + { + num6 += attributes2.GetAttr(XAttributeDefine.XAttr_MaxHP_Total) * eff.PercentDamage; + } + result.TrueDamage += num6; + bool flag8 = result.Value < 1.0; + if (flag8) + { + result.Value = 1.0; + } + } + + public static void CaculateSuperArmorChange(HurtInfo rawInput, ProjectDamageResult result, SkillEffect eff) + { + XWoozyComponent xwoozyComponent = rawInput.Target.GetXComponent(XWoozyComponent.uuID) as XWoozyComponent; + bool flag = xwoozyComponent != null && xwoozyComponent.InTransfer; + if (flag) + { + result.SetResult(ProjectResultType.PJRES_BATI); + } + else + { + bool flag2 = rawInput.Target.Attributes.GetAttr(XAttributeDefine.XAttr_MaxSuperArmor_Basic) > 0.0 && rawInput.Target.Attributes.IsSuperArmorBroken; + if (!flag2) + { + double attr = rawInput.Caster.Attributes.GetAttr(XAttributeDefine.XAttr_SuperArmorAtk_Total); + double attr2 = rawInput.Target.Attributes.GetAttr(XAttributeDefine.XAttr_SuperArmorDef_Total); + double num = attr * (double)eff.DecSuperArmor - attr2; + bool flag3 = num <= 0.0; + if (flag3) + { + result.SetResult(ProjectResultType.PJRES_BATI); + } + else + { + bool flag4 = rawInput.Target.Attributes.GetAttr(XAttributeDefine.XAttr_MaxSuperArmor_Basic) <= 0.0; + if (!flag4) + { + bool flag5 = !rawInput.Target.Attributes.IsSuperArmorBroken; + if (flag5) + { + double attr3 = rawInput.Target.Attributes.GetAttr(XAttributeDefine.XAttr_CurrentSuperArmor_Basic); + XAttrChangeEventArgs @event = XEventPool.GetEvent(); + @event.AttrKey = XAttributeDefine.XAttr_CurrentSuperArmor_Basic; + @event.DeltaValue = -num; + @event.Firer = rawInput.Target; + XSingleton.singleton.FireEvent(@event); + bool flag6 = rawInput.Target.Attributes.GetAttr(XAttributeDefine.XAttr_CurrentSuperArmor_Basic) > 0.0; + if (flag6) + { + result.SetResult(ProjectResultType.PJRES_BATI); + } + else + { + bool flag7 = rawInput.Target.Attributes.HasWoozyStatus && attr3 > 0.0; + if (flag7) + { + result.SetResult(ProjectResultType.PJRES_BATI); + } + } + } + } + } + } + } + } + + public void ProjectDemonstrationStart(HurtInfo rawInput) + { + SkillStartEffect skillStartEffect = XSingleton.singleton.GetSkillStartEffect(rawInput.SkillID, 1u, null, 0u, XSingleton.singleton.IsPVPScene); + bool flag = skillStartEffect.Buffs != null; + if (flag) + { + this.ApplySkillBuff(rawInput, skillStartEffect.Buffs); + } + } + + public void ProjectStart(HurtInfo rawInput) + { + bool syncMode = XSingleton.singleton.SyncMode; + if (!syncMode) + { + uint skillLevel = rawInput.Caster.Attributes.SkillLevelInfo.GetSkillLevel(rawInput.SkillID); + SkillStartEffect skillStartEffect = XSingleton.singleton.GetSkillStartEffect(rawInput.SkillID, skillLevel, rawInput.Caster.Attributes.SkillLevelInfo.Flags, rawInput.Caster.SkillCasterTypeID, XSingleton.singleton.IsPVPScene); + CombatEffectHelper data = XDataPool.GetData(); + data.Set(rawInput.SkillID, rawInput.Caster); + data.GetSkillAddBuff(ref skillStartEffect.Buffs, rawInput.Caster.Attributes.SkillLevelInfo.Flags); + data.Recycle(); + bool flag = skillStartEffect.IncSuperArmor > 0; + if (flag) + { + XAttrChangeEventArgs @event = XEventPool.GetEvent(); + @event.AttrKey = XAttributeDefine.XAttr_CurrentSuperArmor_Basic; + @event.DeltaValue = (double)skillStartEffect.IncSuperArmor; + @event.Firer = rawInput.Caster; + XSingleton.singleton.FireEvent(@event); + } + XAttrChangeEventArgs event2 = XEventPool.GetEvent(); + event2.AttrKey = XAttributeDefine.XAttr_CurrentMP_Basic; + bool flag2 = skillStartEffect.MpCost > 0.0; + if (flag2) + { + event2.DeltaValue = -skillStartEffect.MpCost * (1.0 + rawInput.Caster.Buffs.ModifySkillCost()); + } + else + { + event2.DeltaValue = -skillStartEffect.MpCost; + } + event2.Firer = rawInput.Caster; + XSingleton.singleton.FireEvent(event2); + XAIStartSkillEventArgs event3 = XEventPool.GetEvent(); + event3.Firer = rawInput.Caster; + event3.SkillId = rawInput.SkillID; + event3.IsCaster = true; + XSingleton.singleton.FireEvent(event3); + XAIStartSkillEventArgs event4 = XEventPool.GetEvent(); + event4.Firer = rawInput.Target; + event4.SkillId = rawInput.SkillID; + event4.IsCaster = false; + XSingleton.singleton.FireEvent(event4); + uint skillID = rawInput.SkillID; + bool flag3 = rawInput.Caster.Buffs != null; + if (flag3) + { + rawInput.Caster.Buffs.OnCastSkill(rawInput); + } + bool flag4 = skillID != rawInput.SkillID; + if (!flag4) + { + bool flag5 = skillStartEffect.Buffs != null; + if (flag5) + { + this.ApplySkillBuff(rawInput, skillStartEffect.Buffs); + } + bool flag6 = rawInput.SkillToken != 0L; + if (flag6) + { + int num = 0; + for (int i = 0; i < XCombat.oAttackApplyStateHandlers.Count; i++) + { + num |= XCombat.oAttackApplyStateHandlers[i].GetStateMask(); + } + } + } + } + } + + public void ProjectEnd(HurtInfo rawInput) + { + bool syncMode = XSingleton.singleton.SyncMode; + if (!syncMode) + { + uint skillLevel = rawInput.Caster.Attributes.SkillLevelInfo.GetSkillLevel(rawInput.SkillID); + SkillStartEffect skillStartEffect = XSingleton.singleton.GetSkillStartEffect(rawInput.SkillID, skillLevel, rawInput.Caster.Attributes.SkillLevelInfo.Flags, rawInput.Caster.SkillCasterTypeID, XSingleton.singleton.IsPVPScene); + bool flag = skillStartEffect.IncSuperArmor > 0 && rawInput.Caster is XPlayer; + if (flag) + { + XAttrChangeEventArgs @event = XEventPool.GetEvent(); + @event.AttrKey = XAttributeDefine.XAttr_CurrentSuperArmor_Basic; + @event.DeltaValue = (double)(-(double)skillStartEffect.IncSuperArmor); + @event.Firer = rawInput.Caster; + XSingleton.singleton.FireEvent(@event); + } + XAIEndSkillEventArgs event2 = XEventPool.GetEvent(); + event2.Firer = rawInput.Caster; + event2.SkillId = rawInput.SkillID; + event2.IsCaster = true; + XSingleton.singleton.FireEvent(event2); + XAIEndSkillEventArgs event3 = XEventPool.GetEvent(); + event3.Firer = rawInput.Target; + event3.SkillId = rawInput.SkillID; + event3.IsCaster = false; + XSingleton.singleton.FireEvent(event3); + } + } + + public ProjectDamageResult ProjectDamage(HurtInfo rawInput) + { + ProjectDamageResult data = XDataPool.GetData(); + bool flag = rawInput.Caster == null; + if (flag) + { + XSingleton.singleton.AddErrorLog("caster is null!", null, null, null, null, null); + } + else + { + data.Caster = rawInput.Caster.ID; + } + bool flag2 = rawInput.Target == null; + if (flag2) + { + XSingleton.singleton.AddErrorLog("target is null!", null, null, null, null, null); + } + else + { + XAISkillHurtEventArgs @event = XEventPool.GetEvent(); + @event.Firer = rawInput.Target; + @event.IsCaster = false; + @event.SkillId = rawInput.SkillID; + XSingleton.singleton.FireEvent(@event); + } + data.EffectHelper.Set(rawInput.SkillID, rawInput.Caster); + bool flag3 = !this.CheckState(rawInput, data); + ProjectDamageResult result; + if (flag3) + { + bool accept = data.Accept; + if (accept) + { + XCombat.BuffEffect(rawInput, data); + } + result = data; + } + else + { + SkillEffect skillEffect = XSingleton.singleton.GetSkillEffect(rawInput.SkillID, rawInput.HitPoint, rawInput.Caster.Attributes.SkillLevelInfo.GetSkillLevel(rawInput.SkillID), rawInput.Caster.Attributes.SkillLevelInfo.Flags, rawInput.Caster.SkillCasterTypeID, XSingleton.singleton.IsPVPScene); + bool flag4 = (rawInput.Target.Attributes.Tag & skillEffect.ExclusiveMask) > 0u; + if (flag4) + { + data.Accept = false; + result = data; + } + else + { + XAISkillHurtEventArgs event2 = XEventPool.GetEvent(); + event2.Firer = rawInput.Caster; + event2.IsCaster = true; + event2.SkillId = rawInput.SkillID; + XSingleton.singleton.FireEvent(event2); + this.CaculateSkillDamage(rawInput, data, skillEffect); + XCombat.CaculateSuperArmorChange(rawInput, data, skillEffect); + XCombat.BuffEffect(rawInput, data); + XCombat.ChangeHPAndFireEvent(rawInput, data, false); + result = data; + } + } + return result; + } + + public static void BuffEffect(HurtInfo rawInput, ProjectDamageResult result) + { + XBuff.EffectEnumeratorPriorityCur = XBuffEffectPrioriy.BEP_START; + XBuff.EffectEnumeratorPriorityNext = XBuffEffectPrioriy.BEP_END; + XBuffComponent xbuffComponent = null; + XBuffComponent xbuffComponent2 = null; + bool flag = rawInput.Target != null; + if (flag) + { + xbuffComponent = rawInput.Target.Buffs; + } + bool flag2 = rawInput.Caster != null; + if (flag2) + { + xbuffComponent2 = rawInput.Caster.Buffs; + } + while (XBuff.EffectEnumeratorPriorityCur != XBuffEffectPrioriy.BEP_END) + { + bool flag3 = xbuffComponent != null; + if (flag3) + { + xbuffComponent.OnHurt(rawInput, result); + } + bool flag4 = xbuffComponent2 != null; + if (flag4) + { + xbuffComponent2.OnCastDamage(rawInput, result); + } + XBuff.EffectEnumeratorPriorityCur = XBuff.EffectEnumeratorPriorityNext; + XBuff.EffectEnumeratorPriorityNext = XBuffEffectPrioriy.BEP_END; + } + } + + public static double CheckChangeHPLimit(double damage, XEntity entity, bool bIgnoreImmortal, bool bForceCantDie) + { + return XCombat._CheckChangeHPLimit(XAttributeDefine.XAttr_CurrentHP_Basic, damage, true, entity, bIgnoreImmortal, bForceCantDie); + } + + public static double CheckChangeHPLimit(XAttributeDefine attr, double value, XEntity entity, bool bIgnoreImmortal, bool bForceCantDie) + { + return XCombat._CheckChangeHPLimit(attr, value, false, entity, bIgnoreImmortal, bForceCantDie); + } + + private static double _CheckChangeHPLimit(XAttributeDefine attr, double value, bool bIsDamage, XEntity entity, bool bIgnoreImmortal, bool bForceCantDie) + { + double result; + if (bIsDamage) + { + result = -XBuffSpecialState.GetActualChangeAttr(attr, -value, entity, bIgnoreImmortal, bForceCantDie); + } + else + { + result = XBuffSpecialState.GetActualChangeAttr(attr, value, entity, bIgnoreImmortal, bForceCantDie); + } + return result; + } + + private static void ChangeHPAndFireEvent(HurtInfo rawInput, ProjectDamageResult result, bool bShowHUD) + { + bool flag = rawInput == null || result == null || rawInput.Target == null; + if (flag) + { + XSingleton.singleton.AddWarningLog("rawInput == null || result == null || rawInput.Target == null", null, null, null, null, null); + } + else + { + XEntity caster = rawInput.Caster; + XEntity target = rawInput.Target; + bool flag2 = target.Attributes != null; + if (flag2) + { + bool flag3 = target.Attributes.GetAttr(XAttributeDefine.XAttr_CurrentXULI_Basic) > 0.0; + if (flag3) + { + XAttrChangeEventArgs @event = XEventPool.GetEvent(); + @event.AttrKey = XAttributeDefine.XAttr_CurrentXULI_Basic; + @event.DeltaValue = -result.Value; + @event.Firer = target; + XSingleton.singleton.FireEvent(@event); + bool flag4 = target.Attributes.GetAttr(XAttributeDefine.XAttr_CurrentXULI_Basic) <= 0.0; + if (flag4) + { + XStrengthPresevationOffArgs event2 = XEventPool.GetEvent(); + event2.Firer = target; + XSingleton.singleton.FireEvent(event2); + } + } + bool flag5 = result.Value != 0.0; + if (flag5) + { + XAttrChangeEventArgs event3 = XEventPool.GetEvent(); + event3.AttrKey = XAttributeDefine.XAttr_CurrentHP_Basic; + event3.DeltaValue = -result.Value; + event3.CasterID = result.Caster; + event3.bShowHUD = bShowHUD; + event3.Firer = target; + XSingleton.singleton.FireEvent(event3); + } + } + else + { + XSingleton.singleton.AddErrorLog("target.Attributes == null, typeID: ", target.TypeID.ToString(), " name: ", target.Name, null, null); + } + result.IsTargetDead = target.IsDead; + XEnmityEventArgs event4 = XEventPool.GetEvent(); + event4.AttrKey = XAttributeDefine.XAttr_CurrentHP_Basic; + event4.Firer = target; + event4.Starter = caster; + event4.DeltaValue = result.Value; + event4.SkillId = rawInput.SkillID; + XSingleton.singleton.FireEvent(event4); + XProjectDamageEventArgs event5 = XEventPool.GetEvent(); + event5.Damage = result; + event5.Hurt = rawInput; + event5.Firer = rawInput.Caster; + XSingleton.singleton.FireEvent(event5); + event5 = XEventPool.GetEvent(); + event5.Damage = result; + event5.Hurt = rawInput; + event5.Firer = rawInput.Target; + XSingleton.singleton.FireEvent(event5); + } + } + + public void ChangeHPAndFireEventByQTE(double Value, XEntity target) + { + Value = XCombat.CheckChangeHPLimit(Value, target, false, false); + XAttrChangeEventArgs @event = XEventPool.GetEvent(); + @event.AttrKey = XAttributeDefine.XAttr_CurrentHP_Basic; + @event.DeltaValue = -Value; + @event.Firer = target; + XSingleton.singleton.FireEvent(@event); + } + + private bool CheckState(HurtInfo rawInput, ProjectDamageResult result) + { + bool flag = !XEntity.ValideEntity(rawInput.Target); + bool result2; + if (flag) + { + result.Accept = false; + result2 = false; + } + else + { + bool flag2 = rawInput.Target.Attributes.BuffState.IsBuffStateOn(XBuffType.XBuffType_Immortal); + if (flag2) + { + result.Accept = true; + result.SetResult(ProjectResultType.PJRES_IMMORTAL); + result2 = false; + } + else + { + bool flag3 = rawInput.Caster.Attributes.BuffState.IsBuffStateOn(XBuffType.XBuffType_Blind); + if (flag3) + { + result.Accept = true; + result.SetResult(ProjectResultType.PJRES_MISS); + result2 = false; + } + else + { + result2 = true; + } + } + } + return result2; + } + + public static void ProjectExternalDamage(double damage, ulong CasterID, XEntity target, bool bShowHUD, int flag = 0) + { + bool flag2 = target == null; + if (!flag2) + { + HurtInfo data = XDataPool.GetData(); + data.Caster = XSingleton.singleton.GetEntity(CasterID); + data.Target = target; + ProjectDamageResult data2 = XDataPool.GetData(); + data2.Value = damage; + data2.Caster = CasterID; + data2.Flag |= flag; + data2.DefOriginalRatio = 1.0; + XCombat.BuffEffect(data, data2); + XCombat.ChangeHPAndFireEvent(data, data2, bShowHUD); + XProjectDamageEventArgs @event = XEventPool.GetEvent(); + @event = XEventPool.GetEvent(); + @event.Damage = data2; + @event.Hurt = data; + @event.Firer = data.Caster; + XSingleton.singleton.FireEvent(@event); + @event = XEventPool.GetEvent(); + @event.Damage = data2; + @event.Hurt = data; + @event.Firer = data.Target; + XSingleton.singleton.FireEvent(@event); + data.Recycle(); + data2.Recycle(); + } + } + } +} -- cgit v1.1-26-g67d0