From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../XMainClient/Skill/XSkillLevelInfoMgr.cs | 284 +++++++++++++++++++++ 1 file changed, 284 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs (limited to 'Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs') diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs new file mode 100644 index 00000000..bb8aa2e4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs @@ -0,0 +1,284 @@ +using System; +using System.Collections.Generic; +using KKSG; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillLevelInfoMgr + { + public XSkillFlags Flags + { + get + { + return this._Flags; + } + } + + public Dictionary LearnedSkills + { + get + { + return this._SkillDicts; + } + } + + public static int AuraSkillType = 4; + + private Dictionary _SkillDicts = new Dictionary(); + + private Dictionary _LinkedLevels = new Dictionary(); + + private uint _DefaultLevel = 1u; + + private XEntity _entity = null; + + private XSkillFlags _Flags = new XSkillFlags(); + + private static List g_SkillsHavingEx = new List(); + + public void SetDefaultLevel(uint level) + { + this._DefaultLevel = level; + } + + public void RemoveSkill(uint skillHash) + { + this._SkillDicts.Remove(skillHash); + } + + public uint GetSkillLevel(uint skillHash) + { + uint num = 0u; + bool flag = XEntity.ValideEntity(this._entity) && this._entity.IsTransform; + uint result; + if (flag) + { + bool canlevelrans = XBattleSkillDocument.m_canlevelrans; + if (canlevelrans) + { + bool flag2 = XBattleSkillDocument.SkillLevelDict.TryGetValue(skillHash, out num); + if (flag2) + { + result = num; + } + else + { + result = 1u; + } + } + else + { + result = 1u; + } + } + else + { + bool flag3 = this._LinkedLevels.TryGetValue(skillHash, out num); + if (flag3) + { + result = num; + } + else + { + result = this.GetSkillOriginalLevel(skillHash); + } + } + return result; + } + + public uint GetSkillOriginalLevel(uint skillHash) + { + uint defaultLevel = this._DefaultLevel; + bool flag = this._SkillDicts.TryGetValue(skillHash, out defaultLevel); + uint result; + if (flag) + { + result = defaultLevel; + } + else + { + result = this._DefaultLevel; + } + return result; + } + + public void SetSkillLevel(uint skillHash, uint skillLevel) + { + bool flag = this._SkillDicts.ContainsKey(skillHash); + if (flag) + { + this._SkillDicts[skillHash] = skillLevel; + } + else + { + this._SkillDicts.Add(skillHash, skillLevel); + } + } + + public void RefreshSkillFlags() + { + this._Flags.Reset(); + foreach (KeyValuePair keyValuePair in this._SkillDicts) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(keyValuePair.Key, keyValuePair.Value); + bool flag = skillConfig != null; + if (flag) + { + this._Flags.SetFlag(skillConfig.Flag); + } + } + } + + public void Init(List skills) + { + this._SkillDicts.Clear(); + for (int i = 0; i < skills.Count; i++) + { + this.SetSkillLevel(skills[i].skillHash, skills[i].skillLevel); + } + this.RefreshSkillFlags(); + } + + public void CaskAuraSkills(XEntity entity) + { + Dictionary.Enumerator enumerator = this._SkillDicts.GetEnumerator(); + while (enumerator.MoveNext()) + { + XSkillEffectMgr singleton = XSingleton.singleton; + KeyValuePair keyValuePair = enumerator.Current; + uint key = keyValuePair.Key; + keyValuePair = enumerator.Current; + SkillList.RowData skillConfig = singleton.GetSkillConfig(key, keyValuePair.Value, entity.SkillCasterTypeID); + bool flag = skillConfig != null && (int)skillConfig.SkillType == XSkillLevelInfoMgr.AuraSkillType; + if (flag) + { + XBuffAddEventArgs @event = XEventPool.GetEvent(); + @event.xBuffDesc.BuffID = skillConfig.AuraBuffID[0]; + XBuffAddEventArgs xbuffAddEventArgs = @event; + int buffLevel; + if (skillConfig.AuraBuffID[1] != 0) + { + buffLevel = skillConfig.AuraBuffID[1]; + } + else + { + keyValuePair = enumerator.Current; + buffLevel = (int)keyValuePair.Value; + } + xbuffAddEventArgs.xBuffDesc.BuffLevel = buffLevel; + @event.Firer = entity; + @event.xBuffDesc.CasterID = entity.ID; + XBuffAddEventArgs xbuffAddEventArgs2 = @event; + keyValuePair = enumerator.Current; + xbuffAddEventArgs2.xBuffDesc.SkillID = keyValuePair.Key; + XSingleton.singleton.FireEvent(@event); + } + } + } + + public void RefreshSelfLinkedLevels(XEntity entity) + { + this._entity = entity; + this._LinkedLevels.Clear(); + bool flag = entity == null || entity.Attributes == null || this._entity.Attributes.skillSlot == null; + if (!flag) + { + foreach (uint num in this._SkillDicts.Keys) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(num, 1u, entity.SkillCasterTypeID); + bool flag2 = skillConfig != null && !string.IsNullOrEmpty(skillConfig.LinkedSkill); + if (flag2) + { + uint skillOriginalLevel = this.GetSkillOriginalLevel(XSingleton.singleton.XHash(skillConfig.LinkedSkill)); + bool flag3 = skillOriginalLevel > 0u; + if (flag3) + { + this._LinkedLevels[num] = skillOriginalLevel; + } + } + } + } + } + + public void RefreshMobLinkedLevels(XEntity entity, XEntity hoster) + { + this._entity = entity; + this._LinkedLevels.Clear(); + bool flag = entity == null || entity.SkillMgr == null || hoster == null || hoster.Attributes == null || hoster.Attributes.SkillLevelInfo == null; + if (!flag) + { + XSkillMgr skillMgr = entity.SkillMgr; + XSkillLevelInfoMgr skillLevelInfo = hoster.Attributes.SkillLevelInfo; + XEntityPresentation.RowData byPresentID = XSingleton.singleton.EntityInfo.GetByPresentID(entity.PresentID); + bool flag2 = byPresentID == null || byPresentID.OtherSkills == null; + if (!flag2) + { + XSkillLevelInfoMgr.g_SkillsHavingEx.Clear(); + for (int i = 0; i < byPresentID.OtherSkills.Length; i++) + { + bool flag3 = string.IsNullOrEmpty(byPresentID.OtherSkills[i]) || byPresentID.OtherSkills[i] == "E"; + if (!flag3) + { + uint num = XSingleton.singleton.XHash(byPresentID.OtherSkills[i]); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(num, 1u, entity.SkillCasterTypeID); + bool flag4 = skillConfig == null; + if (!flag4) + { + bool flag5 = !string.IsNullOrEmpty(skillConfig.ExSkillScript); + if (flag5) + { + XSkillLevelInfoMgr.g_SkillsHavingEx.Add(skillConfig); + } + else + { + this.SetLinkedLevel(num, skillConfig, skillLevelInfo, entity.SkillCasterTypeID); + } + } + } + } + for (int j = 0; j < XSkillLevelInfoMgr.g_SkillsHavingEx.Count; j++) + { + SkillList.RowData rowData = XSkillLevelInfoMgr.g_SkillsHavingEx[j]; + uint num2 = XSingleton.singleton.XHash(rowData.SkillScript); + bool flag6 = this.GetSkillLevel(XSingleton.singleton.XHash(rowData.ExSkillScript)) > 0u; + if (flag6) + { + this._LinkedLevels[num2] = 0u; + } + else + { + this.SetLinkedLevel(num2, rowData, skillLevelInfo, entity.SkillCasterTypeID); + } + } + } + } + } + + private void SetLinkedLevel(uint skillID, SkillList.RowData rowData, XSkillLevelInfoMgr hosterSkillLevelMgr, uint enemyTempID) + { + bool flag = rowData == null || hosterSkillLevelMgr == null || string.IsNullOrEmpty(rowData.LinkedSkill); + if (!flag) + { + uint skillHash = XSingleton.singleton.XHash(rowData.LinkedSkill); + uint skillLevel = hosterSkillLevelMgr.GetSkillLevel(skillHash); + bool flag2 = skillLevel == 0u; + if (flag2) + { + this._LinkedLevels[skillID] = 0u; + } + else + { + uint val = skillLevel; + uint preSkill = XSingleton.singleton.GetPreSkill(XSingleton.singleton.XHash(rowData.LinkedSkill), enemyTempID); + bool flag3 = preSkill > 0u; + if (flag3) + { + val = hosterSkillLevelMgr.GetSkillLevel(preSkill); + } + this._LinkedLevels[skillID] = Math.Min((uint)rowData.SkillLevel, val); + } + } + } + } +} -- cgit v1.1-26-g67d0