diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XCombat.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XCombat.cs | 771 |
1 files changed, 771 insertions, 0 deletions
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<XCombat>
+ {
+ private XTableAsyncLoader _async_loader = null;
+
+ private static CombatParamTable oTable = new CombatParamTable();
+
+ private static List<AttackApplyState> 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<AttackApplyState>();
+ XCombat.oAttackApplyStateHandlers.Add(new AttackApplyCritical());
+ XCombat.oAttackApplyStateHandlers.Add(new AttackApplyStun());
+ this.PhysicalAvoidenceLimit = double.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("PhycialAvoidenceLimit"));
+ this.MagicAvoidenceLimit = double.Parse(XSingleton<XGlobalConfig>.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<XCombat>.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<BuffDesc> Buffs)
+ {
+ for (int i = 0; i < Buffs.Count; i++)
+ {
+ int buffTargetType = XSingleton<XBuffTemplateManager>.singleton.GetBuffTargetType(Buffs[i].BuffID);
+ bool flag = buffTargetType == -1;
+ if (!flag)
+ {
+ XSkillExternalBuffArgs @event = XEventPool<XSkillExternalBuffArgs>.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<XBuffAddEventArgs>.GetEvent();
+ @event.xBuffDesc = xskillExternalBuffArgs.xBuffDesc;
+ @event.Firer = xskillExternalBuffArgs.xTarget;
+ XSingleton<XEventMgr>.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<XGlobalConfig>.singleton.ElemAtkLimit;
+ if (flag4)
+ {
+ num7 = XSingleton<XGlobalConfig>.singleton.ElemAtkLimit;
+ }
+ bool flag5 = num8 > XSingleton<XGlobalConfig>.singleton.ElemDefLimit;
+ if (flag5)
+ {
+ num8 = XSingleton<XGlobalConfig>.singleton.ElemDefLimit;
+ }
+ double num9 = this.GetCombatValue(combatParam2.FinalDamageBase, casterAttr.GetAttr(XAttributeDefine.XAttr_FinalDamage_Total));
+ bool flag6 = num9 > XSingleton<XGlobalConfig>.singleton.FinalDamageLimit;
+ if (flag6)
+ {
+ num9 = XSingleton<XGlobalConfig>.singleton.FinalDamageLimit;
+ }
+ double num10 = targetAttr.GetAttr(XAttributeDefine.XAttr_HurtInc_Total) / XSingleton<XGlobalConfig>.singleton.GeneralCombatParam + 1.0;
+ bool flag7 = num10 > XSingleton<XGlobalConfig>.singleton.AttrChangeDamageLimit;
+ if (flag7)
+ {
+ num10 = XSingleton<XGlobalConfig>.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<XGlobalConfig>.singleton.CritDamageBase;
+ bool flag = num > XSingleton<XGlobalConfig>.singleton.CritDamageUpperBound;
+ if (flag)
+ {
+ num = XSingleton<XGlobalConfig>.singleton.CritDamageUpperBound;
+ }
+ bool flag2 = num < XSingleton<XGlobalConfig>.singleton.CritDamageLowerBound;
+ if (flag2)
+ {
+ num = XSingleton<XGlobalConfig>.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<XCommon>.singleton.RandomFloat(XSingleton<XGlobalConfig>.singleton.DamageRandomLowerBound, XSingleton<XGlobalConfig>.singleton.DamageRandomUpperBound);
+ result.Value *= num5;
+ SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(XSingleton<XScene>.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<XAttrChangeEventArgs>.GetEvent();
+ @event.AttrKey = XAttributeDefine.XAttr_CurrentSuperArmor_Basic;
+ @event.DeltaValue = -num;
+ @event.Firer = rawInput.Target;
+ XSingleton<XEventMgr>.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<XSkillEffectMgr>.singleton.GetSkillStartEffect(rawInput.SkillID, 1u, null, 0u, XSingleton<XScene>.singleton.IsPVPScene);
+ bool flag = skillStartEffect.Buffs != null;
+ if (flag)
+ {
+ this.ApplySkillBuff(rawInput, skillStartEffect.Buffs);
+ }
+ }
+
+ public void ProjectStart(HurtInfo rawInput)
+ {
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ if (!syncMode)
+ {
+ uint skillLevel = rawInput.Caster.Attributes.SkillLevelInfo.GetSkillLevel(rawInput.SkillID);
+ SkillStartEffect skillStartEffect = XSingleton<XSkillEffectMgr>.singleton.GetSkillStartEffect(rawInput.SkillID, skillLevel, rawInput.Caster.Attributes.SkillLevelInfo.Flags, rawInput.Caster.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene);
+ CombatEffectHelper data = XDataPool<CombatEffectHelper>.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<XAttrChangeEventArgs>.GetEvent();
+ @event.AttrKey = XAttributeDefine.XAttr_CurrentSuperArmor_Basic;
+ @event.DeltaValue = (double)skillStartEffect.IncSuperArmor;
+ @event.Firer = rawInput.Caster;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ XAttrChangeEventArgs event2 = XEventPool<XAttrChangeEventArgs>.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<XEventMgr>.singleton.FireEvent(event2);
+ XAIStartSkillEventArgs event3 = XEventPool<XAIStartSkillEventArgs>.GetEvent();
+ event3.Firer = rawInput.Caster;
+ event3.SkillId = rawInput.SkillID;
+ event3.IsCaster = true;
+ XSingleton<XEventMgr>.singleton.FireEvent(event3);
+ XAIStartSkillEventArgs event4 = XEventPool<XAIStartSkillEventArgs>.GetEvent();
+ event4.Firer = rawInput.Target;
+ event4.SkillId = rawInput.SkillID;
+ event4.IsCaster = false;
+ XSingleton<XEventMgr>.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<XGame>.singleton.SyncMode;
+ if (!syncMode)
+ {
+ uint skillLevel = rawInput.Caster.Attributes.SkillLevelInfo.GetSkillLevel(rawInput.SkillID);
+ SkillStartEffect skillStartEffect = XSingleton<XSkillEffectMgr>.singleton.GetSkillStartEffect(rawInput.SkillID, skillLevel, rawInput.Caster.Attributes.SkillLevelInfo.Flags, rawInput.Caster.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene);
+ bool flag = skillStartEffect.IncSuperArmor > 0 && rawInput.Caster is XPlayer;
+ if (flag)
+ {
+ XAttrChangeEventArgs @event = XEventPool<XAttrChangeEventArgs>.GetEvent();
+ @event.AttrKey = XAttributeDefine.XAttr_CurrentSuperArmor_Basic;
+ @event.DeltaValue = (double)(-(double)skillStartEffect.IncSuperArmor);
+ @event.Firer = rawInput.Caster;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ XAIEndSkillEventArgs event2 = XEventPool<XAIEndSkillEventArgs>.GetEvent();
+ event2.Firer = rawInput.Caster;
+ event2.SkillId = rawInput.SkillID;
+ event2.IsCaster = true;
+ XSingleton<XEventMgr>.singleton.FireEvent(event2);
+ XAIEndSkillEventArgs event3 = XEventPool<XAIEndSkillEventArgs>.GetEvent();
+ event3.Firer = rawInput.Target;
+ event3.SkillId = rawInput.SkillID;
+ event3.IsCaster = false;
+ XSingleton<XEventMgr>.singleton.FireEvent(event3);
+ }
+ }
+
+ public ProjectDamageResult ProjectDamage(HurtInfo rawInput)
+ {
+ ProjectDamageResult data = XDataPool<ProjectDamageResult>.GetData();
+ bool flag = rawInput.Caster == null;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("caster is null!", null, null, null, null, null);
+ }
+ else
+ {
+ data.Caster = rawInput.Caster.ID;
+ }
+ bool flag2 = rawInput.Target == null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("target is null!", null, null, null, null, null);
+ }
+ else
+ {
+ XAISkillHurtEventArgs @event = XEventPool<XAISkillHurtEventArgs>.GetEvent();
+ @event.Firer = rawInput.Target;
+ @event.IsCaster = false;
+ @event.SkillId = rawInput.SkillID;
+ XSingleton<XEventMgr>.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<XSkillEffectMgr>.singleton.GetSkillEffect(rawInput.SkillID, rawInput.HitPoint, rawInput.Caster.Attributes.SkillLevelInfo.GetSkillLevel(rawInput.SkillID), rawInput.Caster.Attributes.SkillLevelInfo.Flags, rawInput.Caster.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene);
+ bool flag4 = (rawInput.Target.Attributes.Tag & skillEffect.ExclusiveMask) > 0u;
+ if (flag4)
+ {
+ data.Accept = false;
+ result = data;
+ }
+ else
+ {
+ XAISkillHurtEventArgs event2 = XEventPool<XAISkillHurtEventArgs>.GetEvent();
+ event2.Firer = rawInput.Caster;
+ event2.IsCaster = true;
+ event2.SkillId = rawInput.SkillID;
+ XSingleton<XEventMgr>.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<XDebug>.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<XAttrChangeEventArgs>.GetEvent();
+ @event.AttrKey = XAttributeDefine.XAttr_CurrentXULI_Basic;
+ @event.DeltaValue = -result.Value;
+ @event.Firer = target;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ bool flag4 = target.Attributes.GetAttr(XAttributeDefine.XAttr_CurrentXULI_Basic) <= 0.0;
+ if (flag4)
+ {
+ XStrengthPresevationOffArgs event2 = XEventPool<XStrengthPresevationOffArgs>.GetEvent();
+ event2.Firer = target;
+ XSingleton<XEventMgr>.singleton.FireEvent(event2);
+ }
+ }
+ bool flag5 = result.Value != 0.0;
+ if (flag5)
+ {
+ XAttrChangeEventArgs event3 = XEventPool<XAttrChangeEventArgs>.GetEvent();
+ event3.AttrKey = XAttributeDefine.XAttr_CurrentHP_Basic;
+ event3.DeltaValue = -result.Value;
+ event3.CasterID = result.Caster;
+ event3.bShowHUD = bShowHUD;
+ event3.Firer = target;
+ XSingleton<XEventMgr>.singleton.FireEvent(event3);
+ }
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("target.Attributes == null, typeID: ", target.TypeID.ToString(), " name: ", target.Name, null, null);
+ }
+ result.IsTargetDead = target.IsDead;
+ XEnmityEventArgs event4 = XEventPool<XEnmityEventArgs>.GetEvent();
+ event4.AttrKey = XAttributeDefine.XAttr_CurrentHP_Basic;
+ event4.Firer = target;
+ event4.Starter = caster;
+ event4.DeltaValue = result.Value;
+ event4.SkillId = rawInput.SkillID;
+ XSingleton<XEventMgr>.singleton.FireEvent(event4);
+ XProjectDamageEventArgs event5 = XEventPool<XProjectDamageEventArgs>.GetEvent();
+ event5.Damage = result;
+ event5.Hurt = rawInput;
+ event5.Firer = rawInput.Caster;
+ XSingleton<XEventMgr>.singleton.FireEvent(event5);
+ event5 = XEventPool<XProjectDamageEventArgs>.GetEvent();
+ event5.Damage = result;
+ event5.Hurt = rawInput;
+ event5.Firer = rawInput.Target;
+ XSingleton<XEventMgr>.singleton.FireEvent(event5);
+ }
+ }
+
+ public void ChangeHPAndFireEventByQTE(double Value, XEntity target)
+ {
+ Value = XCombat.CheckChangeHPLimit(Value, target, false, false);
+ XAttrChangeEventArgs @event = XEventPool<XAttrChangeEventArgs>.GetEvent();
+ @event.AttrKey = XAttributeDefine.XAttr_CurrentHP_Basic;
+ @event.DeltaValue = -Value;
+ @event.Firer = target;
+ XSingleton<XEventMgr>.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<HurtInfo>.GetData();
+ data.Caster = XSingleton<XEntityMgr>.singleton.GetEntity(CasterID);
+ data.Target = target;
+ ProjectDamageResult data2 = XDataPool<ProjectDamageResult>.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<XProjectDamageEventArgs>.GetEvent();
+ @event = XEventPool<XProjectDamageEventArgs>.GetEvent();
+ @event.Damage = data2;
+ @event.Hurt = data;
+ @event.Firer = data.Caster;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ @event = XEventPool<XProjectDamageEventArgs>.GetEvent();
+ @event.Damage = data2;
+ @event.Hurt = data;
+ @event.Firer = data.Target;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ data.Recycle();
+ data2.Recycle();
+ }
+ }
+ }
+}
|