diff options
| author | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
|---|---|---|
| committer | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
| commit | 6eb915c129fc90c6f4c82ae097dd6ffad5239efc (patch) | |
| tree | 7dd2be50edf41f36b60fac84696e731c13afe617 /Client/Assets/Scripts/XMainClient/XSecurityBuffInfo.cs | |
+scripts
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XSecurityBuffInfo.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XSecurityBuffInfo.cs | 292 |
1 files changed, 292 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XSecurityBuffInfo.cs b/Client/Assets/Scripts/XMainClient/XSecurityBuffInfo.cs new file mode 100644 index 00000000..6daca1dd --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XSecurityBuffInfo.cs @@ -0,0 +1,292 @@ +using System;
+using System.Collections.Generic;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XSecurityBuffInfo
+ {
+ private static HashSet<XAttributeDefine> _UsefulAttrs = new HashSet<XAttributeDefine>(default(XFastEnumIntEqualityComparer<XAttributeDefine>))
+ {
+ XAttributeDefine.XATTR_ATTACK_SPEED_Basic,
+ XAttributeDefine.XATTR_ATTACK_SPEED_Percent,
+ XAttributeDefine.XAttr_Critical_Basic,
+ XAttributeDefine.XAttr_Critical_Percent,
+ XAttributeDefine.XAttr_RUN_SPEED_Basic,
+ XAttributeDefine.XAttr_RUN_SPEED_Percent,
+ XAttributeDefine.XAttr_PhysicalDefMod_Basic,
+ XAttributeDefine.XAttr_PhysicalDefMod_Percent,
+ XAttributeDefine.XAttr_PhysicalAtkMod_Basic,
+ XAttributeDefine.XAttr_PhysicalAtkMod_Percent,
+ XAttributeDefine.XAttr_MagicAtkMod_Basic,
+ XAttributeDefine.XAttr_MagicAtkMod_Percent
+ };
+
+ public XSecurityBuffInfo.BuffInfo _AttackSpeed = default(XSecurityBuffInfo.BuffInfo);
+
+ public XSecurityBuffInfo.BuffInfo _RunSpeed = default(XSecurityBuffInfo.BuffInfo);
+
+ public XSecurityBuffInfo.BuffInfo _Critical = default(XSecurityBuffInfo.BuffInfo);
+
+ public XSecurityBuffInfo.BuffInfo _PhysicalDef = default(XSecurityBuffInfo.BuffInfo);
+
+ public XSecurityBuffInfo.BuffInfo _Attack = default(XSecurityBuffInfo.BuffInfo);
+
+ public XSecurityBuffInfo.BuffInfo _Immortal = default(XSecurityBuffInfo.BuffInfo);
+
+ public XSecurityBuffInfo.BuffInfo _ReduceDamage = default(XSecurityBuffInfo.BuffInfo);
+
+ public XSecurityBuffInfo.BuffInfo _Freeze = default(XSecurityBuffInfo.BuffInfo);
+
+ private static XSecurityBuffInfo.AttributeParam s_AttrParam = new XSecurityBuffInfo.AttributeParam();
+
+ public struct BuffInfo
+ {
+ public int _CountTotal;
+
+ public float _EffectMin;
+
+ public float _EffectMax;
+
+ public float _TimeMin;
+
+ public float _TimeMax;
+
+ public float _TimeTotal;
+
+ public void Reset()
+ {
+ this._CountTotal = 0;
+ this._EffectMax = 0f;
+ this._EffectMin = float.MaxValue;
+ this._TimeMax = 0f;
+ this._TimeMin = float.MaxValue;
+ this._TimeTotal = 0f;
+ }
+
+ public void OnChanged(XBuff buff, double value)
+ {
+ this._CountTotal++;
+ this._EffectMax = Math.Max(this._EffectMax, (float)value);
+ this._EffectMin = Math.Min(this._EffectMin, (float)value);
+ float num = buff.ActualDuration * 1000f;
+ this._TimeMax = Math.Max(this._TimeMax, num);
+ this._TimeMin = Math.Min(this._TimeMin, num);
+ this._TimeTotal += num;
+ }
+
+ public void Merge(ref XSecurityBuffInfo.BuffInfo other)
+ {
+ this._CountTotal += other._CountTotal;
+ this._EffectMax = Math.Max(this._EffectMax, other._EffectMax);
+ this._EffectMin = Math.Min(this._EffectMin, other._EffectMin);
+ this._TimeMax = Math.Max(this._TimeMax, other._TimeMax);
+ this._TimeMin = Math.Min(this._TimeMin, other._TimeMin);
+ this._TimeTotal += other._TimeTotal;
+ }
+ }
+
+ public class AttributeParam
+ {
+ public XAttributes attributes = null;
+
+ public XAttributeDefine attr = XAttributeDefine.XAttr_PhysicalDefMod_Percent;
+
+ public double value = 0.0;
+
+ public float initValue = 0f;
+
+ public XBuff buff = null;
+ }
+
+ public bool IsUsefulAttr(XAttributeDefine attr)
+ {
+ return XSecurityBuffInfo._UsefulAttrs.Contains(attr);
+ }
+
+ public void Reset()
+ {
+ this._AttackSpeed.Reset();
+ this._RunSpeed.Reset();
+ this._Critical.Reset();
+ this._PhysicalDef.Reset();
+ this._Immortal.Reset();
+ this._ReduceDamage.Reset();
+ this._Freeze.Reset();
+ }
+
+ public void OnAttributeChanged(XAttributes attributes, XBuff buff, XAttributeDefine attr, double value)
+ {
+ bool flag = attributes == null || buff == null || buff.SkillID == 0u || value <= 0.0;
+ if (!flag)
+ {
+ if (attr <= XAttributeDefine.XATTR_ATTACK_SPEED_Basic)
+ {
+ if (attr <= XAttributeDefine.XAttr_MagicAtkMod_Basic)
+ {
+ if (attr == XAttributeDefine.XAttr_PhysicalAtkMod_Basic)
+ {
+ goto IL_101;
+ }
+ if (attr == XAttributeDefine.XAttr_PhysicalDefMod_Basic)
+ {
+ goto IL_F0;
+ }
+ if (attr != XAttributeDefine.XAttr_MagicAtkMod_Basic)
+ {
+ return;
+ }
+ goto IL_101;
+ }
+ else
+ {
+ if (attr == XAttributeDefine.XAttr_Critical_Basic)
+ {
+ goto IL_CE;
+ }
+ if (attr == XAttributeDefine.XAttr_RUN_SPEED_Basic)
+ {
+ goto IL_DF;
+ }
+ if (attr != XAttributeDefine.XATTR_ATTACK_SPEED_Basic)
+ {
+ return;
+ }
+ }
+ }
+ else if (attr <= XAttributeDefine.XAttr_MagicAtkMod_Percent)
+ {
+ if (attr == XAttributeDefine.XAttr_PhysicalAtkMod_Percent)
+ {
+ goto IL_101;
+ }
+ if (attr == XAttributeDefine.XAttr_PhysicalDefMod_Percent)
+ {
+ goto IL_F0;
+ }
+ if (attr != XAttributeDefine.XAttr_MagicAtkMod_Percent)
+ {
+ return;
+ }
+ goto IL_101;
+ }
+ else
+ {
+ if (attr == XAttributeDefine.XAttr_Critical_Percent)
+ {
+ goto IL_CE;
+ }
+ if (attr == XAttributeDefine.XAttr_RUN_SPEED_Percent)
+ {
+ goto IL_DF;
+ }
+ if (attr != XAttributeDefine.XATTR_ATTACK_SPEED_Percent)
+ {
+ return;
+ }
+ }
+ this._AttackSpeed.OnChanged(buff, value);
+ return;
+ IL_CE:
+ this._Critical.OnChanged(buff, value);
+ return;
+ IL_DF:
+ this._RunSpeed.OnChanged(buff, value);
+ return;
+ IL_F0:
+ this._PhysicalDef.OnChanged(buff, value);
+ return;
+ IL_101:
+ this._Attack.OnChanged(buff, value);
+ }
+ }
+
+ public void OnReduceDamage(XBuff buff, double value)
+ {
+ bool flag = buff == null || buff.SkillID == 0u;
+ if (!flag)
+ {
+ this._ReduceDamage.OnChanged(buff, value * 100.0);
+ }
+ }
+
+ public void OnFreeze(XBuff buff)
+ {
+ bool flag = buff == null || buff.SkillID == 0u;
+ if (!flag)
+ {
+ this._Freeze.OnChanged(buff, 0.0);
+ }
+ }
+
+ public void OnImmortal(XBuff buff)
+ {
+ bool flag = buff == null || buff.SkillID == 0u;
+ if (!flag)
+ {
+ this._Immortal.OnChanged(buff, 0.0);
+ }
+ }
+
+ public static XSecurityBuffInfo TryGetStatistics(XEntity entity)
+ {
+ XSecurityStatistics xsecurityStatistics = XSecurityStatistics.TryGetStatistics(entity);
+ bool flag = xsecurityStatistics == null;
+ XSecurityBuffInfo result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ result = xsecurityStatistics.BuffStatistics;
+ }
+ return result;
+ }
+
+ public static double GetValue(XSecurityBuffInfo.AttributeParam param, double finalValue)
+ {
+ bool flag = XAttributeCommon.IsBasicRange(XFastEnumIntEqualityComparer<XAttributeDefine>.ToInt(param.attr));
+ if (flag)
+ {
+ bool flag2 = param.initValue != 0f;
+ if (flag2)
+ {
+ finalValue = (finalValue - (double)param.initValue) / (double)param.initValue;
+ }
+ }
+ else
+ {
+ finalValue *= 0.01;
+ }
+ return finalValue;
+ }
+
+ public static void ProcessNormal(ref XSecurityBuffInfo.BuffInfo buffInfo, XSecurityBuffInfo.AttributeParam param)
+ {
+ buffInfo.OnChanged(param.buff, XSecurityBuffInfo.GetValue(param, param.value));
+ }
+
+ public static void SendPlayerData(XSecurityBuffInfo buffInfos)
+ {
+ XSecurityBuffInfo._SendData(buffInfos._PhysicalDef, "1");
+ XSecurityBuffInfo._SendData(buffInfos._Attack, "2");
+ XSecurityBuffInfo._SendData(buffInfos._Critical, "3");
+ XSecurityBuffInfo._SendData(buffInfos._RunSpeed, "4");
+ XSecurityBuffInfo._SendData(buffInfos._AttackSpeed, "5");
+ XSecurityBuffInfo._SendData(buffInfos._ReduceDamage, "6");
+ XSecurityBuffInfo._SendData(buffInfos._Immortal, "7");
+ XSecurityBuffInfo._SendData(buffInfos._Freeze, "8");
+ }
+
+ private static void _SendData(XSecurityBuffInfo.BuffInfo buffInfo, string keywords)
+ {
+ XStaticSecurityStatistics.Append(string.Format("Skill{0}Count", keywords), (float)buffInfo._CountTotal);
+ XStaticSecurityStatistics.Append(string.Format("Skill{0}EffectMin", keywords), buffInfo._EffectMin);
+ XStaticSecurityStatistics.Append(string.Format("Skill{0}EffectMax", keywords), buffInfo._EffectMax);
+ XStaticSecurityStatistics.Append(string.Format("Skill{0}TimeMin", keywords), buffInfo._TimeMin);
+ XStaticSecurityStatistics.Append(string.Format("Skill{0}TimeMax", keywords), buffInfo._TimeMax);
+ XStaticSecurityStatistics.Append(string.Format("Skill{0}TimeTotal", keywords), buffInfo._TimeTotal);
+ }
+ }
+}
|