diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs | 937 |
1 files changed, 937 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs new file mode 100644 index 00000000..798f1385 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs @@ -0,0 +1,937 @@ +using System;
+using System.Collections.Generic;
+using UnityEngine;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XSkillEffectMgr : XSingleton<XSkillEffectMgr>
+ {
+ private XTableAsyncLoader _async_loader = null;
+
+ private SkillList _skillTable = new SkillList();
+
+ public Dictionary<uint, uint> PreSkillDict = new Dictionary<uint, uint>(200);
+
+ private Dictionary<ulong, uint> _specialEnemyPreSkillDict = new Dictionary<ulong, uint>();
+
+ public uint EmptySkillHash = XSingleton<XCommon>.singleton.XHash("E");
+
+ private static CVSReader.RowDataCompare<SkillList.RowData, uint> comp = new CVSReader.RowDataCompare<SkillList.RowData, uint>(XSkillEffectMgr.SkillDataCompare);
+
+ private SkillLevelupRequest req = null;
+
+ private SkillEffect m_SkillEffect = new SkillEffect();
+
+ private List<uint> ret = null;
+
+ private HashSet<uint> repeatHash = null;
+
+ public void TestSkillTable()
+ {
+ for (int i = 0; i < this._skillTable.Table.Length; i++)
+ {
+ SkillList.RowData rowData = this._skillTable.Table[i];
+ bool flag = this.GetSkillConfig(XSingleton<XCommon>.singleton.XHash(rowData.SkillScript), 0u, rowData.XEntityStatisticsID) == null;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog2("skill not found:{0}", new object[]
+ {
+ rowData.SkillScript
+ });
+ }
+ }
+ }
+
+ public override bool Init()
+ {
+ bool flag = this._async_loader == null;
+ if (flag)
+ {
+ this._async_loader = new XTableAsyncLoader();
+ this._async_loader.AddTask("Table/SkillList", this._skillTable, false);
+ this._async_loader.Execute(null);
+ }
+ bool flag2 = !this._async_loader.IsDone;
+ bool result;
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ for (int i = 0; i < this._skillTable.Table.Length; i++)
+ {
+ SkillList.RowData rowData = this._skillTable.Table[i];
+ bool flag3 = !string.IsNullOrEmpty(rowData.SkillScript) && !string.IsNullOrEmpty(rowData.ExSkillScript);
+ if (flag3)
+ {
+ bool flag4 = rowData.XEntityStatisticsID > 0u;
+ if (flag4)
+ {
+ ulong key = (ulong)XSingleton<XCommon>.singleton.XHash(rowData.ExSkillScript) << 32 | (ulong)rowData.XEntityStatisticsID;
+ this._specialEnemyPreSkillDict[key] = rowData.SkillScriptHash;
+ }
+ else
+ {
+ this.PreSkillDict[XSingleton<XCommon>.singleton.XHash(rowData.ExSkillScript)] = rowData.SkillScriptHash;
+ }
+ }
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ public override void Uninit()
+ {
+ this._async_loader = null;
+ }
+
+ public SkillList.RowData GetSkillConfig(uint skillHash, uint skillLevel, uint entityTempID)
+ {
+ bool flag = entityTempID == 0u;
+ SkillList.RowData result;
+ if (flag)
+ {
+ result = this.GetSkillConfig(skillHash, skillLevel);
+ }
+ else
+ {
+ result = this.GetEnemySpecialSkillConfig(skillHash, skillLevel, entityTempID);
+ }
+ return result;
+ }
+
+ public SkillList.RowData GetEnemySpecialSkillConfig(uint skillHash, uint skillLevel, uint entityTempID)
+ {
+ bool flag = this.EmptySkillHash == skillHash;
+ SkillList.RowData result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ int num = -1;
+ int num2 = -1;
+ CVSReader.GetRowDataListByField<SkillList.RowData, uint>(this._skillTable.Table, skillHash, out num, out num2, XSkillEffectMgr.comp);
+ bool flag2 = num >= 0 && num <= num2;
+ if (flag2)
+ {
+ for (int i = num; i <= num2; i++)
+ {
+ SkillList.RowData rowData = this._skillTable.Table[i];
+ bool flag3 = rowData.XEntityStatisticsID == entityTempID && skillLevel <= (uint)rowData.SkillLevel;
+ if (flag3)
+ {
+ return rowData;
+ }
+ }
+ bool flag4 = num == num2;
+ if (flag4)
+ {
+ result = this._skillTable.Table[num];
+ }
+ else
+ {
+ for (int j = num; j <= num2; j++)
+ {
+ SkillList.RowData rowData2 = this._skillTable.Table[j];
+ bool flag5 = rowData2.XEntityStatisticsID == 0u && skillLevel <= (uint)rowData2.SkillLevel;
+ if (flag5)
+ {
+ return rowData2;
+ }
+ }
+ result = this._skillTable.Table[num2];
+ }
+ }
+ else
+ {
+ result = null;
+ }
+ }
+ return result;
+ }
+
+ private static int SkillDataCompare(SkillList.RowData rowData, uint skillHash)
+ {
+ return skillHash.CompareTo(rowData.SkillScriptHash);
+ }
+
+ public SkillList.RowData GetSkillConfig(uint skillHash, uint skillLevel)
+ {
+ bool flag = this.EmptySkillHash == skillHash;
+ SkillList.RowData result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ int num = -1;
+ int num2 = -1;
+ CVSReader.GetRowDataListByField<SkillList.RowData, uint>(this._skillTable.Table, skillHash, out num, out num2, XSkillEffectMgr.comp);
+ bool flag2 = num >= 0 && num <= num2;
+ if (flag2)
+ {
+ bool flag3 = num == num2;
+ if (flag3)
+ {
+ result = this._skillTable.Table[num];
+ }
+ else
+ {
+ for (int i = num; i <= num2; i++)
+ {
+ SkillList.RowData rowData = this._skillTable.Table[i];
+ bool flag4 = rowData.XEntityStatisticsID == 0u && skillLevel <= (uint)rowData.SkillLevel;
+ if (flag4)
+ {
+ return rowData;
+ }
+ }
+ result = this._skillTable.Table[num2];
+ }
+ }
+ else
+ {
+ result = null;
+ }
+ }
+ return result;
+ }
+
+ public int GetSkillMaxLevel(uint skillHash, uint entityTempID = 0u)
+ {
+ bool flag = this.EmptySkillHash == skillHash;
+ int result;
+ if (flag)
+ {
+ result = 0;
+ }
+ else
+ {
+ int num = -1;
+ int num2 = -1;
+ CVSReader.GetRowDataListByField<SkillList.RowData, uint>(this._skillTable.Table, skillHash, out num, out num2, XSkillEffectMgr.comp);
+ bool flag2 = num >= 0 && num <= num2;
+ if (flag2)
+ {
+ bool flag3 = entityTempID > 0u;
+ SkillList.RowData rowData;
+ if (flag3)
+ {
+ for (int i = num2; i >= num; i--)
+ {
+ rowData = this._skillTable.Table[i];
+ bool flag4 = rowData.XEntityStatisticsID == entityTempID;
+ if (flag4)
+ {
+ return (int)rowData.SkillLevel;
+ }
+ }
+ }
+ rowData = this._skillTable.Table[0];
+ uint preSkill = this.GetPreSkill(skillHash, 0u);
+ bool flag5 = preSkill > 0u;
+ if (flag5)
+ {
+ result = 1;
+ }
+ else
+ {
+ for (int j = num2; j >= num; j--)
+ {
+ rowData = this._skillTable.Table[j];
+ bool flag6 = rowData.XEntityStatisticsID == 0u;
+ if (flag6)
+ {
+ return (int)rowData.SkillLevel;
+ }
+ }
+ result = 0;
+ }
+ }
+ else
+ {
+ result = 0;
+ }
+ }
+ return result;
+ }
+
+ public int GetSkillHpMaxLimit(string skillName, uint level, uint entityTempID)
+ {
+ uint skillHash = XSingleton<XCommon>.singleton.XHash(skillName);
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID);
+ bool flag = skillConfig == null;
+ int result;
+ if (flag)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = (int)skillConfig.HpMaxLimit;
+ }
+ return result;
+ }
+
+ public int GetSkillHpMinLimit(string skillName, uint level, uint entityTempID)
+ {
+ uint skillHash = XSingleton<XCommon>.singleton.XHash(skillName);
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID);
+ bool flag = skillConfig == null;
+ int result;
+ if (flag)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = (int)skillConfig.HpMinLimit;
+ }
+ return result;
+ }
+
+ public bool GetSkillDescriptValue(uint skillhash, uint level, XBodyBag EmblemBag, out float Ratio, out float Fixed)
+ {
+ float num = 0f;
+ float num2 = 0f;
+ Ratio = 0f;
+ Fixed = 0f;
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillhash, level);
+ bool flag = skillConfig == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ for (int i = 0; i < skillConfig.TipsRatio.Count; i++)
+ {
+ Ratio += skillConfig.TipsRatio[i, 0];
+ num += skillConfig.TipsRatio[i, 1];
+ }
+ Ratio += num * level;
+ for (int i = 0; i < skillConfig.TipsFixed.Count; i++)
+ {
+ Fixed += skillConfig.TipsFixed[i, 0];
+ num2 += skillConfig.TipsFixed[i, 1];
+ }
+ Fixed += num2 * level;
+ float num3 = 0f;
+ CombatEffectHelper data = XDataPool<CombatEffectHelper>.GetData();
+ data.Set(skillhash, XSingleton<XEntityMgr>.singleton.Player);
+ data.GetSkillDamage(out num3);
+ num3 += XEmblemDocument.GetSkillDamageRatio(EmblemBag, skillhash);
+ Ratio *= 1f + num3;
+ data.Recycle();
+ result = true;
+ }
+ return result;
+ }
+
+ public SkillLevelupRequest GetLevelupRequest(uint skillHash, uint level)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level);
+ bool flag = skillConfig == null;
+ SkillLevelupRequest result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ bool flag2 = this.req == null;
+ if (flag2)
+ {
+ this.req = new SkillLevelupRequest();
+ }
+ bool flag3 = skillConfig.UpReqRoleLevel == null || skillConfig.UpReqRoleLevel.Length == 0;
+ if (flag3)
+ {
+ this.req.Level = 0;
+ }
+ else
+ {
+ bool flag4 = (ulong)level < (ulong)((long)skillConfig.UpReqRoleLevel.Length);
+ if (flag4)
+ {
+ this.req.Level = (int)skillConfig.UpReqRoleLevel[(int)level];
+ }
+ else
+ {
+ this.req.Level = (int)skillConfig.UpReqRoleLevel[skillConfig.UpReqRoleLevel.Length - 1];
+ }
+ }
+ bool flag5 = this.req.Items == null;
+ if (flag5)
+ {
+ this.req.Items = new List<ItemDesc>();
+ }
+ else
+ {
+ this.req.Items.Clear();
+ }
+ ItemDesc item = default(ItemDesc);
+ item.ItemID = 5;
+ bool flag6 = skillConfig.LevelupCost == null || skillConfig.LevelupCost.Length == 0;
+ if (flag6)
+ {
+ item.ItemCount = 0;
+ }
+ else
+ {
+ bool flag7 = (ulong)level < (ulong)((long)skillConfig.LevelupCost.Length);
+ if (flag7)
+ {
+ item.ItemCount = (int)skillConfig.LevelupCost[(int)level];
+ }
+ else
+ {
+ item.ItemCount = (int)skillConfig.LevelupCost[skillConfig.LevelupCost.Length - 1];
+ }
+ }
+ this.req.Items.Add(item);
+ result = this.req;
+ }
+ return result;
+ }
+
+ public double GetAttackSpeedRatio(XAttributes attr)
+ {
+ return (double)attr.AttackSpeed;
+ }
+
+ public float GetSkillInitCDRatio(uint skillHash, uint level, uint entityTempID, bool IsPVP, XAttributes attr)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID);
+ bool flag = skillConfig == null;
+ float result;
+ if (flag)
+ {
+ result = 0f;
+ }
+ else
+ {
+ float num = 0f;
+ CombatEffectHelper data = XDataPool<CombatEffectHelper>.GetData();
+ data.Set(skillHash, attr.Entity);
+ data.GetSkillCD(out num);
+ data.Recycle();
+ bool isPlayer = attr.Entity.IsPlayer;
+ if (isPlayer)
+ {
+ num += XEmblemDocument.GetSkillCDRatio(attr.EmblemBag, skillHash);
+ }
+ num += 1f;
+ if (IsPVP)
+ {
+ result = skillConfig.PvPInitCD * num;
+ }
+ else
+ {
+ result = skillConfig.InitCD * num;
+ }
+ }
+ return result;
+ }
+
+ public float GetSkillCDDynamicRatio(XAttributes attr)
+ {
+ return (float)(attr.GetAttr(XAttributeDefine.XATTR_SKILL_CD_Total) / XSingleton<XGlobalConfig>.singleton.GeneralCombatParam);
+ }
+
+ public float GetSkillCDDynamicRatio(XAttributes attr, uint skillHash)
+ {
+ return this.CalcDynamicRatio(this.GetSkillCDDynamicRatio(attr), this.GetSkillCDSemiDynamicRatio(attr, skillHash));
+ }
+
+ public float GetSkillCDSemiDynamicRatio(XAttributes attr, uint skillHash)
+ {
+ float num = 0f;
+ CombatEffectHelper data = XDataPool<CombatEffectHelper>.GetData();
+ data.Set(skillHash, attr.Entity);
+ data.GetSkillCD(out num);
+ data.Recycle();
+ bool isPlayer = attr.Entity.IsPlayer;
+ if (isPlayer)
+ {
+ num += XEmblemDocument.GetSkillCDRatio(attr.EmblemBag, skillHash);
+ }
+ return num;
+ }
+
+ public double GetXULIPower(XEntity entity)
+ {
+ bool flag = entity == null || entity.Attributes == null;
+ double result;
+ if (flag)
+ {
+ result = 1.0;
+ }
+ else
+ {
+ result = entity.Attributes.GetAttr(XAttributeDefine.XAttr_XULI_Total) / XSingleton<XGlobalConfig>.singleton.GeneralCombatParam;
+ }
+ return result;
+ }
+
+ public float CalcDynamicRatio(float dynamicCDRatio, float semiDynamicCDRatio)
+ {
+ float num = dynamicCDRatio + semiDynamicCDRatio;
+ return Mathf.Clamp(num, XSingleton<XGlobalConfig>.singleton.CDChangeLowerBound, XSingleton<XGlobalConfig>.singleton.CDChangeUpperBound);
+ }
+
+ public float GetSkillCDStaticRatio(uint skillHash, uint level, uint entityTempID, bool IsPVP)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID);
+ bool flag = skillConfig == null;
+ float result;
+ if (flag)
+ {
+ result = 1f;
+ }
+ else if (IsPVP)
+ {
+ bool flag2 = skillConfig.PvPCDRatio[0] == 0f && skillConfig.PvPCDRatio[1] == 0f;
+ if (flag2)
+ {
+ result = 1f;
+ }
+ else
+ {
+ result = skillConfig.PvPCDRatio[0] + skillConfig.PvPCDRatio[1] * level;
+ }
+ }
+ else
+ {
+ bool flag3 = skillConfig.CDRatio[0] == 0f && skillConfig.CDRatio[1] == 0f;
+ if (flag3)
+ {
+ result = 1f;
+ }
+ else
+ {
+ result = skillConfig.CDRatio[0] + skillConfig.CDRatio[1] * level;
+ }
+ }
+ return result;
+ }
+
+ public float GetSkillCostMP(uint skillHash, uint level, uint entityTempID)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID);
+ bool flag = skillConfig == null;
+ float result;
+ if (flag)
+ {
+ result = 0f;
+ }
+ else
+ {
+ result = skillConfig.CostMP[0] + skillConfig.CostMP[1] * level;
+ }
+ return result;
+ }
+
+ public float GetSkillCostMP(string skillName, uint level, uint entityTempID)
+ {
+ uint skillHash = XSingleton<XCommon>.singleton.XHash(skillName);
+ return this.GetSkillCostMP(skillHash, level, entityTempID);
+ }
+
+ public SkillStartEffect GetSkillStartEffect(uint skillHash, uint level, XSkillFlags skillFlags, uint entityTempID, bool IsPVP)
+ {
+ SkillStartEffect skillStartEffect = default(SkillStartEffect);
+ skillStartEffect.IncSuperArmor = 0;
+ skillStartEffect.MpCost = 0.0;
+ skillStartEffect.Buffs = null;
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID);
+ bool flag = skillConfig == null;
+ SkillStartEffect result;
+ if (flag)
+ {
+ result = skillStartEffect;
+ }
+ else
+ {
+ if (IsPVP)
+ {
+ skillStartEffect.IncSuperArmor = skillConfig.PvPIncreaseSuperArmor;
+ }
+ else
+ {
+ skillStartEffect.IncSuperArmor = skillConfig.IncreaseSuperArmor;
+ }
+ for (int i = 0; i < skillConfig.StartBuffID.Count; i++)
+ {
+ bool flag2 = skillConfig.StartBuffID[i, 0] != 0f && (skillFlags == null || skillFlags.IsFlagSet((uint)skillConfig.StartBuffID[i, 3]));
+ if (flag2)
+ {
+ BuffDesc item;
+ item.BuffID = (int)skillConfig.StartBuffID[i, 0];
+ item.BuffLevel = (int)(((int)skillConfig.StartBuffID[i, 1] == 0) ? level : ((uint)((int)skillConfig.StartBuffID[i, 1])));
+ item.DelayTime = skillConfig.StartBuffID[i, 2];
+ item.CasterID = 0UL;
+ item.EffectTime = BuffDesc.DEFAULT_TIME;
+ bool flag3 = skillStartEffect.Buffs == null;
+ if (flag3)
+ {
+ skillStartEffect.Buffs = new List<BuffDesc>();
+ }
+ item.SkillID = skillHash;
+ skillStartEffect.Buffs.Add(item);
+ }
+ }
+ skillStartEffect.MpCost = (double)(skillConfig.CostMP[0] + skillConfig.CostMP[1] * level);
+ result = skillStartEffect;
+ }
+ return result;
+ }
+
+ public SkillEffect GetSkillEffect(uint skillHash, int hitpoint, uint level, XSkillFlags skillFlags, uint entityTempID, bool IsPVP)
+ {
+ SkillEffect skillEffect = this.m_SkillEffect;
+ skillEffect.DamageElementType = DamageElement.DE_NONE;
+ skillEffect.PhyRatio = 1.0;
+ skillEffect.PhyFixed = 0.0;
+ skillEffect.MagRatio = 1.0;
+ skillEffect.MagFixed = 0.0;
+ skillEffect.DecSuperArmor = 0f;
+ bool flag = skillEffect.Buffs != null;
+ if (flag)
+ {
+ skillEffect.Buffs.Clear();
+ }
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID);
+ bool flag2 = skillConfig == null;
+ SkillEffect result;
+ if (flag2)
+ {
+ result = skillEffect;
+ }
+ else
+ {
+ skillEffect.DamageElementType = (DamageElement)skillConfig.Element;
+ if (IsPVP)
+ {
+ bool flag3 = hitpoint >= skillConfig.PvPRatio.Count || hitpoint >= skillConfig.PvPFixed.Count || hitpoint >= skillConfig.PvPMagicRatio.Count || hitpoint >= skillConfig.PvPMagicFixed.Count || hitpoint >= skillConfig.PercentDamage.Count;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Error: skill ", skillConfig.SkillScript, " hitpoint ", hitpoint.ToString(), " out of range", null);
+ return skillEffect;
+ }
+ skillEffect.PhyRatio = (double)(skillConfig.PvPRatio[hitpoint, 0] + skillConfig.PvPRatio[hitpoint, 1] * level);
+ skillEffect.PhyFixed = (double)(skillConfig.PvPFixed[hitpoint, 0] + skillConfig.PvPFixed[hitpoint, 1] * level);
+ skillEffect.MagRatio = (double)(skillConfig.PvPMagicRatio[hitpoint, 0] + skillConfig.PvPMagicRatio[hitpoint, 1] * level);
+ skillEffect.MagFixed = (double)(skillConfig.PvPMagicFixed[hitpoint, 0] + skillConfig.PvPMagicFixed[hitpoint, 1] * level);
+ skillEffect.PercentDamage = (double)(skillConfig.PercentDamage[hitpoint, 0] + skillConfig.PercentDamage[hitpoint, 1] * level);
+ bool flag4 = skillConfig.PvPDecreaseSuperArmor != null && hitpoint < skillConfig.PvPDecreaseSuperArmor.Length;
+ if (flag4)
+ {
+ skillEffect.DecSuperArmor = skillConfig.PvPDecreaseSuperArmor[hitpoint];
+ }
+ }
+ else
+ {
+ bool flag5 = hitpoint >= skillConfig.PhysicalRatio.Count || hitpoint >= skillConfig.PhysicalFixed.Count || hitpoint >= skillConfig.MagicRatio.Count || hitpoint >= skillConfig.MagicFixed.Count || hitpoint >= skillConfig.PercentDamage.Count;
+ if (flag5)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Error: skill ", skillConfig.SkillScript, " hitpoint ", hitpoint.ToString(), " out of range", null);
+ return skillEffect;
+ }
+ skillEffect.PhyRatio = (double)(skillConfig.PhysicalRatio[hitpoint, 0] + skillConfig.PhysicalRatio[hitpoint, 1] * level);
+ skillEffect.PhyFixed = (double)(skillConfig.PhysicalFixed[hitpoint, 0] + skillConfig.PhysicalFixed[hitpoint, 1] * level);
+ skillEffect.MagRatio = (double)(skillConfig.MagicRatio[hitpoint, 0] + skillConfig.MagicRatio[hitpoint, 1] * level);
+ skillEffect.MagFixed = (double)(skillConfig.MagicFixed[hitpoint, 0] + skillConfig.MagicFixed[hitpoint, 1] * level);
+ skillEffect.PercentDamage = (double)(skillConfig.PercentDamage[hitpoint, 0] + skillConfig.PercentDamage[hitpoint, 1] * level);
+ bool flag6 = skillConfig.DecreaseSuperArmor != null && hitpoint < skillConfig.DecreaseSuperArmor.Length;
+ if (flag6)
+ {
+ skillEffect.DecSuperArmor = (float)skillConfig.DecreaseSuperArmor[hitpoint];
+ }
+ }
+ bool flag7 = skillConfig.AddBuffPoint != null;
+ if (flag7)
+ {
+ for (int i = 0; i < skillConfig.AddBuffPoint.Length; i++)
+ {
+ bool flag8 = (int)skillConfig.AddBuffPoint[i] == hitpoint;
+ if (flag8)
+ {
+ bool flag9 = i < skillConfig.BuffID.Count && (skillFlags == null || skillFlags.IsFlagSet((uint)skillConfig.BuffID[i, 2]));
+ if (flag9)
+ {
+ bool flag10 = skillEffect.Buffs == null;
+ if (flag10)
+ {
+ skillEffect.Buffs = new List<BuffDesc>();
+ }
+ BuffDesc item;
+ item.BuffID = skillConfig.BuffID[i, 0];
+ item.BuffLevel = (int)((skillConfig.BuffID[i, 1] == 0) ? level : ((uint)skillConfig.BuffID[i, 1]));
+ item.CasterID = 0UL;
+ item.DelayTime = 0f;
+ item.EffectTime = BuffDesc.DEFAULT_TIME;
+ item.SkillID = skillHash;
+ skillEffect.Buffs.Add(item);
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddLog("Error: skill ", skillConfig.SkillScript, " index ", i.ToString(), " buff out of range ", skillConfig.BuffID.Count.ToString(), XDebugColor.XDebug_None);
+ }
+ }
+ }
+ }
+ skillEffect.ExclusiveMask = 0u;
+ bool flag11 = skillConfig.ExclusiveMask != null;
+ if (flag11)
+ {
+ for (int j = 0; j < skillConfig.ExclusiveMask.Length; j++)
+ {
+ skillEffect.ExclusiveMask |= 1u << (int)skillConfig.ExclusiveMask[j];
+ }
+ }
+ result = skillEffect;
+ }
+ return result;
+ }
+
+ public List<uint> GetProfSkillID(int profID)
+ {
+ bool flag = this.ret == null;
+ if (flag)
+ {
+ this.ret = new List<uint>();
+ }
+ bool flag2 = this.repeatHash == null;
+ if (flag2)
+ {
+ this.repeatHash = new HashSet<uint>();
+ }
+ this.ret.Clear();
+ this.repeatHash.Clear();
+ for (int i = 0; i < this._skillTable.Table.Length; i++)
+ {
+ SkillList.RowData rowData = this._skillTable.Table[i];
+ bool flag3 = rowData != null && rowData.Profession == profID && rowData.IsBasicSkill == 0;
+ if (flag3)
+ {
+ bool flag4 = !this.repeatHash.Contains(rowData.SkillScriptHash);
+ if (flag4)
+ {
+ this.ret.Add(rowData.SkillScriptHash);
+ this.repeatHash.Add(rowData.SkillScriptHash);
+ }
+ }
+ }
+ return this.ret;
+ }
+
+ public int GetSkillType(uint skillID)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillID, 0u);
+ bool flag = skillConfig != null;
+ int result;
+ if (flag)
+ {
+ result = (int)skillConfig.SkillType;
+ }
+ else
+ {
+ result = 0;
+ }
+ return result;
+ }
+
+ public uint GetSkillID(string skillName, uint statisticsID = 0u)
+ {
+ uint num = XSingleton<XCommon>.singleton.XHash(skillName);
+ SkillList.RowData skillConfig = this.GetSkillConfig(num, 0u, statisticsID);
+ bool flag = skillConfig == null;
+ uint result;
+ if (flag)
+ {
+ result = 0u;
+ }
+ else
+ {
+ result = num;
+ }
+ return result;
+ }
+
+ public void SetMobProperty(XEntity mobEntity, XEntity caster, uint skillID)
+ {
+ bool flag = mobEntity == null || caster == null || mobEntity.Attributes == null || caster.Attributes == null;
+ if (!flag)
+ {
+ XAttributes attributes = mobEntity.Attributes;
+ XAttributes attributes2 = caster.Attributes;
+ attributes.Level = attributes2.Level;
+ attributes.SetAttr(XAttributeDefine.XAttr_MaxHP_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MaxHP_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_CurrentHP_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MaxHP_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_PhysicalAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_PhysicalAtk_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_MagicAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MagicAtk_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_PhysicalAtkMod_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_PhysicalAtkMod_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_MagicAtkMod_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MagicAtkMod_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_PhysicalDefMod_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_PhysicalDefMod_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_MagicDefMod_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MagicDefMod_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_Critical_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Critical_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_CritDamage_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_CritDamage_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_CritResist_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_CritResist_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_FireAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_FireAtk_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_WaterAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_WaterAtk_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_LightAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_LightAtk_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_DarkAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_DarkAtk_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_FireDef_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_FireDef_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_WaterDef_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_WaterDef_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_LightDef_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_LightDef_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_DarkDef_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_DarkDef_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_Strength_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Strength_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_Agility_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Agility_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_Intelligence_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Intelligence_Basic));
+ attributes.SetAttr(XAttributeDefine.XAttr_Vitality_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Vitality_Basic));
+ attributes.SetHost(caster);
+ uint skillLevel = attributes2.SkillLevelInfo.GetSkillLevel(skillID);
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillID, skillLevel, caster.SkillCasterTypeID);
+ bool flag2 = skillConfig == null;
+ if (!flag2)
+ {
+ CombatEffectHelper data = XDataPool<CombatEffectHelper>.GetData();
+ data.Set(skillID, caster);
+ bool flag3 = (skillConfig == null || skillConfig.MobBuffs == null) && !data.bHasEffect(CombatEffectType.CET_Skill_AddMobBuff);
+ if (flag3)
+ {
+ data.Recycle();
+ }
+ else
+ {
+ List<BuffDesc> list = ListPool<BuffDesc>.Get();
+ bool flag4 = data != null;
+ if (flag4)
+ {
+ data.GetSkillAddMobBuff((int)skillLevel, list);
+ }
+ bool flag5 = skillConfig.MobBuffs != null;
+ if (flag5)
+ {
+ for (int i = 0; i < skillConfig.MobBuffs.Length; i++)
+ {
+ list.Add(new BuffDesc
+ {
+ BuffID = (int)skillConfig.MobBuffs[i],
+ BuffLevel = (int)skillLevel,
+ EffectTime = BuffDesc.DEFAULT_TIME
+ });
+ }
+ }
+ for (int j = 0; j < list.Count; j++)
+ {
+ XBuffAddEventArgs @event = XEventPool<XBuffAddEventArgs>.GetEvent();
+ @event.xBuffDesc = list[j];
+ @event.xBuffDesc.CasterID = mobEntity.ID;
+ @event.Firer = mobEntity;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ ListPool<BuffDesc>.Release(list);
+ data.Recycle();
+ }
+ }
+ }
+ }
+
+ public uint GetPreSkill(uint skillID, uint entityTempID)
+ {
+ uint num = 0u;
+ bool flag = entityTempID > 0u;
+ if (flag)
+ {
+ ulong key = (ulong)skillID << 32 | (ulong)entityTempID;
+ bool flag2 = this._specialEnemyPreSkillDict.TryGetValue(key, out num);
+ if (flag2)
+ {
+ return num;
+ }
+ }
+ bool flag3 = this.PreSkillDict.TryGetValue(skillID, out num);
+ uint result;
+ if (flag3)
+ {
+ result = num;
+ }
+ else
+ {
+ result = 0u;
+ }
+ return result;
+ }
+
+ public bool CanChangeCD(uint skillHash, uint skillLevel, uint entityTempID)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID);
+ bool flag = skillConfig == null;
+ return !flag && skillConfig.UnchangableCD == 0;
+ }
+
+ public bool AICantCast(uint skillHash, uint skillLevel, uint entityTempID)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID);
+ bool flag = skillConfig == null;
+ return !flag && skillConfig.LinkType == 1;
+ }
+
+ public float GetRemainingCDNotify(uint skillHash, uint skillLevel, uint entityTempID)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID);
+ bool flag = skillConfig == null;
+ float result;
+ if (flag)
+ {
+ result = 0f;
+ }
+ else
+ {
+ result = skillConfig.RemainingCDNotify;
+ }
+ return result;
+ }
+
+ public int GetStrengthValue(uint skillHash, uint skillLevel, uint entityTempID)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID);
+ bool flag = skillConfig == null;
+ int result;
+ if (flag)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = skillConfig.StrengthValue;
+ }
+ return result;
+ }
+
+ public int GetUsageCount(uint skillHash, uint skillLevel, uint entityTempID)
+ {
+ SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID);
+ bool flag = skillConfig == null;
+ int result;
+ if (flag)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = (int)skillConfig.UsageCount;
+ }
+ return result;
+ }
+ }
+}
|