From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Scripts/XMainClient/Skill/XSkillComponent.cs | 1070 ++++++++++++++++++++ 1 file changed, 1070 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs (limited to 'Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs') diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs new file mode 100644 index 00000000..8553d0d4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs @@ -0,0 +1,1070 @@ +using System; +using System.Collections.Generic; +using KKSG; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillComponent : XComponent + { + public override uint ID + { + get + { + return XSkillComponent.uuID; + } + } + + public bool IsSkillReplaced + { + get + { + return this._skill_replaced_by_typeid > 0u; + } + } + + public uint ReplacedByTypeID + { + get + { + return this._skill_replaced_by_typeid; + } + } + + public XSkillMgr SkillMgr + { + get + { + return this._skill_mgr; + } + } + + public uint[] ReplacedSlot + { + get + { + return this._replaced_skill_slot; + } + } + + public List SkillMobs + { + get + { + return this._skill_mobs; + } + } + + public bool HasSkillReplaced + { + get + { + return this._skills_replace_dic != null && this._skills_replace_dic.Count != 0; + } + } + + public XSkill CurrentSkill + { + get + { + return this._skill; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("Skill"); + + public static readonly string TriggerTag = ""; + + private XSkill _skill = null; + + private XSkillMgr _skill_mgr = null; + + private uint _timer_token = 0u; + + private uint _skill_replaced_by_typeid = 0u; + + private XLocateTargetComponent _locate = null; + + private XQuickTimeEventComponent _qte = null; + + private string _trigger = null; + + private uint[] _replaced_skill_slot = null; + + private List _skill_mobs = null; + + private Dictionary _skills_replace_dic = null; + + public XSkillCore TryGetSkillReplace(uint skillID, XSkillCore soul) + { + bool flag = this._skills_replace_dic == null; + XSkillCore result; + if (flag) + { + result = soul; + } + else + { + uint id; + bool flag2 = this._skills_replace_dic.TryGetValue(skillID, out id); + if (flag2) + { + XSkillCore skill = this._entity.SkillMgr.GetSkill(id); + bool flag3 = skill != null; + if (flag3) + { + return skill; + } + } + result = soul; + } + return result; + } + + public void SetSkillReplace(uint from, uint to) + { + bool flag = to == 0u; + if (flag) + { + bool flag2 = this._skills_replace_dic != null; + if (flag2) + { + this._skills_replace_dic.Remove(from); + } + } + else + { + bool flag3 = this._skills_replace_dic == null; + if (flag3) + { + this._skills_replace_dic = DictionaryPool.Get(); + } + this._skills_replace_dic[from] = to; + } + } + + public bool AddSkillMob(XEntity e) + { + bool result = false; + bool flag = this._skill_mobs == null; + if (flag) + { + this._skill_mobs = ListPool.Get(); + } + bool flag2 = e != null && !this._skill_mobs.Contains(e); + if (flag2) + { + this._skill_mobs.Add(e); + bool syncMode = XSingleton.singleton.SyncMode; + if (syncMode) + { + result = true; + } + else + { + XOthersAttributes xothersAttributes = e.Attributes as XOthersAttributes; + bool flag3 = xothersAttributes != null && xothersAttributes.SummonGroup > 0 && xothersAttributes.SummonGroup < XSingleton.singleton.EntitySummonGroupLimit.Length; + if (flag3) + { + int num = XSingleton.singleton.EntitySummonGroupLimit[xothersAttributes.SummonGroup]; + int num2 = 0; + XEntity xentity = null; + for (int i = 0; i < this._skill_mobs.Count; i++) + { + bool flag4 = !XEntity.ValideEntity(this._skill_mobs[i]); + if (!flag4) + { + XOthersAttributes xothersAttributes2 = this._skill_mobs[i].Attributes as XOthersAttributes; + bool flag5 = xothersAttributes2 != null && xothersAttributes2.SummonGroup == xothersAttributes.SummonGroup; + if (flag5) + { + bool flag6 = num2 == 0; + if (flag6) + { + xentity = this._skill_mobs[i]; + } + num2++; + } + } + } + bool flag7 = num2 > num; + if (flag7) + { + result = (e != xentity); + XSingleton.singleton.DestroyEntity(xentity); + } + else + { + result = true; + } + } + else + { + result = true; + } + } + } + return result; + } + + public void RemoveSkillMob(XEntity e) + { + bool flag = this._skill_mobs != null; + if (flag) + { + this._skill_mobs.Remove(e); + } + } + + public override void Update(float fDeltaT) + { + bool flag = this._skill == null; + if (!flag) + { + bool flag2 = !this._skill.Update(fDeltaT); + if (flag2) + { + this.EndSkill(false, false); + } + } + } + + public override void PostUpdate(float fDeltaT) + { + bool flag = this._trigger != null; + if (flag) + { + bool flag2 = this._trigger != "EndSkill"; + if (flag2) + { + bool flag3 = this.IsCasting(); + if (flag3) + { + this._skill.AnimInit = true; + bool flag4 = this._entity.Ator != null; + if (flag4) + { + this._entity.Ator.speed = 1f; + } + this._skill.TriggerAnim(); + } + } + else + { + bool flag5 = this._entity.Ator != null; + if (flag5) + { + this._entity.Ator.SetTrigger(this._trigger); + } + } + this._trigger = null; + } + } + + public void TagTrigger() + { + this._trigger = XSkillComponent.TriggerTag; + } + + public bool CanPerformAction(XStateDefine state, XActionArgs e) + { + bool flag = this.CurrentSkill == null; + return flag || this.CurrentSkill.CanPerformAction(state, e.Token); + } + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_Attack, new XComponent.XEventHandler(this.OnAttack)); + base.RegisterEvent(XEventDefine.XEvent_StrengthPresevedOff, new XComponent.XEventHandler(this.OnPresevedStrengthStop)); + base.RegisterEvent(XEventDefine.XEvent_RealDead, new XComponent.XEventHandler(this.OnRealDead)); + base.RegisterEvent(XEventDefine.XEvent_Move_Mob, new XComponent.XEventHandler(this.OnMoveMob)); + } + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._skill_mgr = XSingleton.singleton.CreateSkillMgr(this._entity); + } + + public override void Attached() + { + bool flag = XSingleton.singleton.CurrentStage.Stage != EXStage.Hall; + if (flag) + { + this._qte = (this._entity.GetXComponent(XQuickTimeEventComponent.uuID) as XQuickTimeEventComponent); + bool flag2 = !XSingleton.singleton.IsMustTransform || (this._entity.IsEnemy && this._entity.Transformee == null); + if (flag2) + { + this._locate = (this._entity.IsPlayer ? (this._entity.GetXComponent(XLocateTargetComponent.uuID) as XLocateTargetComponent) : null); + bool flag3 = XEntity.ValideEntity(this._entity.MobbedBy) && this._entity.Attributes.SkillLevelInfo != null; + if (flag3) + { + this._entity.Attributes.SkillLevelInfo.RefreshMobLinkedLevels(this._entity, this._entity.MobbedBy); + } + this.AttachSkill(); + } + } + } + + public override void OnDetachFromHost() + { + this.EndSkill(true, true); + bool flag = this._skill_mgr != null; + if (flag) + { + XSingleton.singleton.ReturnSkillMgr(this._skill_mgr); + this._skill_mgr = null; + } + this._skill = null; + XSingleton.singleton.KillTimer(this._timer_token); + this._timer_token = 0u; + this._locate = null; + this._qte = null; + this._trigger = null; + bool flag2 = this._skill_mobs != null; + if (flag2) + { + ListPool.Release(this._skill_mobs); + this._skill_mobs = null; + } + bool flag3 = this._skills_replace_dic != null; + if (flag3) + { + DictionaryPool.Release(this._skills_replace_dic); + this._skills_replace_dic = null; + } + base.OnDetachFromHost(); + } + + public bool IsCasting() + { + return this._skill != null && this._skill.Casting; + } + + public bool IsOverResults() + { + bool flag = this.IsCasting(); + bool result2; + if (flag) + { + List result = this._skill.Core.Soul.Result; + result2 = (result != null && result.Count > 0 && result[result.Count - 1].At < this.CurrentSkill.TimeElapsed); + } + else + { + result2 = true; + } + return result2; + } + + protected bool OnPresevedStrengthStop(XEventArgs e) + { + bool flag = this.IsCasting() && this.CurrentSkill.MainCore.PreservedStrength > 0 && this.CurrentSkill.TimeElapsed < this.CurrentSkill.MainCore.Soul.Logical.PreservedEndAt; + if (flag) + { + this.EndSkill(true, false); + XStrengthPresevationOffArgs @event = XEventPool.GetEvent(); + @event.Host = this._entity; + @event.Firer = XSingleton.singleton.Doc; + XSingleton.singleton.FireEvent(@event); + } + return true; + } + + protected virtual bool OnAttack(XEventArgs e) + { + XAttackEventArgs xattackEventArgs = e as XAttackEventArgs; + uint identify = xattackEventArgs.Identify; + XSkillCore xskillCore = this._entity.SkillMgr.GetSkill(identify); + bool flag = xskillCore == null; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = !XSingleton.singleton.SyncMode; + if (flag2) + { + xskillCore = this.PhysicalAttackAdaptor(xskillCore); + } + bool flag3 = xskillCore == null; + if (flag3) + { + XSingleton.singleton.AddErrorLog("Skill ", identify.ToString(), " Physical-Adapter error.", null, null, null); + result = false; + } + else + { + bool flag4 = !XSingleton.singleton.SyncMode; + if (flag4) + { + xskillCore = this.TryGetSkillReplace(xskillCore.ID, xskillCore); + } + XEntity target = this.SelectedTarget(xattackEventArgs, xskillCore); + bool flag5 = this._entity.QTE != null && this._entity.QTE.QTEList.Contains(xskillCore.ID); + bool flag6 = false; + bool flag7 = xskillCore != null && (xattackEventArgs.Demonstration || XSingleton.singleton.SyncMode || (xskillCore.CooledDown && (flag5 || (xskillCore.CanCast(e.Token) && (this._skill == null || !this._skill.Casting || this._skill.MainCore.CanReplacedBy(xskillCore)))))); + if (flag7) + { + XSkill carrier = this._entity.SkillMgr.GetCarrier(xskillCore.CarrierID); + bool flag8 = this.FireSkill(carrier, target, xskillCore, xattackEventArgs); + if (flag8) + { + flag6 = true; + } + } + bool flag9 = flag5 || xskillCore.Soul.TypeToken == 0; + if (flag9) + { + bool flag10 = this._qte != null; + if (flag10) + { + this._qte.OnSkillCasted(xskillCore.ID, xattackEventArgs.Slot, flag6); + } + } + result = flag6; + } + } + return result; + } + + protected virtual bool OnRealDead(XEventArgs e) + { + this.EndSkill(false, true); + return true; + } + + protected virtual bool FireSkill(XSkill newOne, XEntity target, XSkillCore core, XAttackEventArgs args) + { + bool flag = this._skill != null; + if (flag) + { + this.EndSkill(false, false); + } + this._skill = newOne; + bool flag2 = this._skill != null && this._skill.Fire(target, core, args); + bool result; + if (flag2) + { + this.TagTrigger(); + bool multipleAttackSupported = this._skill.MainCore.Soul.MultipleAttackSupported; + if (multipleAttackSupported) + { + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[0], this._skill.MainCore.Soul.ClipName, false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[1], this._skill.MainCore.Soul.ClipName + "_right_forward", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[2], this._skill.MainCore.Soul.ClipName + "_right", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[3], this._skill.MainCore.Soul.ClipName + "_right_back", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[4], this._skill.MainCore.Soul.ClipName + "_left_forward", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[5], this._skill.MainCore.Soul.ClipName + "_left", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[6], this._skill.MainCore.Soul.ClipName + "_left_back", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[7], this._skill.MainCore.Soul.ClipName + "_back", false, false); + } + else + { + switch (this._skill.MainCore.Soul.TypeToken) + { + case 0: + this._entity.OverrideAnimClip(XSkillData.JaOverrideMap[core.Soul.SkillPosition], this._skill.MainCore.Soul.ClipName, false, false); + break; + case 1: + this._entity.OverrideAnimClip("Art", this._skill.AnimClipName, false, false); + break; + case 3: + for (int i = 0; i < this._skill.MainCore.Soul.Combined.Count; i++) + { + XSkillCore skill = this._entity.SkillMgr.GetSkill(XSingleton.singleton.XHash(this._skill.MainCore.Soul.Combined[i].Name)); + this._entity.OverrideAnimClip(XSkillData.CombinedOverrideMap[i], skill.Soul.ClipName, false, false); + } + break; + } + } + result = true; + } + else + { + bool flag3 = this._skill != null && this._skill.Casting; + if (!flag3) + { + this._skill = null; + } + result = false; + } + return result; + } + + private bool OnMoveMob(XEventArgs e) + { + bool flag = this._skill_mobs != null && this._host.EngineObject != null; + if (flag) + { + for (int i = 0; i < this._skill_mobs.Count; i++) + { + bool flag2 = this._skill_mobs[i].Skill != null; + if (flag2) + { + this._skill_mobs[i].Skill.EndSkill(false, false); + } + Vector3 vector = this._host.EngineObject.Rotation * ((XSingleton.singleton.MobMovePos.Length > i) ? XSingleton.singleton.MobMovePos[i] : Vector3.zero); + bool flag3 = this._skill_mobs[i].Net != null && this._skill_mobs[i].Machine != null && this._skill_mobs[i].Machine.Current == XStateDefine.XState_Move; + if (flag3) + { + this._skill_mobs[i].Net.ReportMoveAction(Vector3.zero, 0.0); + } + this._skill_mobs[i].CorrectMe(this._host.EngineObject.Position + vector, this._host.EngineObject.Forward, false, false); + } + } + return true; + } + + public void ReAttachSkill(XEntityPresentation.RowData template, uint typeid) + { + XSingleton.singleton.ClearBullets(this._entity.ID); + bool flag = this._skill_mgr != null; + if (flag) + { + this._skill_mgr.Uninitialize(); + } + this._skill_mgr.Initialize(this._entity); + bool flag2 = template == null; + if (flag2) + { + bool isSkillReplaced = this.IsSkillReplaced; + if (isSkillReplaced) + { + bool flag3 = !XSingleton.singleton.IsMustTransform; + if (flag3) + { + this.AttachSkill(); + } + } + } + else + { + this._skill_replaced_by_typeid = typeid; + string skillprefix = "SkillPackage/" + template.SkillLocation; + bool flag4 = !string.IsNullOrEmpty(template.A); + if (flag4) + { + this._entity.SkillMgr.AttachPhysicalSkill(XSingleton.singleton.Build(skillprefix, template.A, this._entity)); + } + bool flag5 = !string.IsNullOrEmpty(template.AA); + if (flag5) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.AA, this._entity), false); + } + bool flag6 = !string.IsNullOrEmpty(template.AAA); + if (flag6) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.AAA, this._entity), false); + } + bool flag7 = !string.IsNullOrEmpty(template.AAAA); + if (flag7) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.AAAA, this._entity), false); + } + bool flag8 = !string.IsNullOrEmpty(template.AAAAA); + if (flag8) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.AAAAA, this._entity), false); + } + bool flag9 = !string.IsNullOrEmpty(template.Ultra); + if (flag9) + { + this._entity.SkillMgr.AttachUltraSkill(XSingleton.singleton.Build(skillprefix, template.Ultra, this._entity)); + } + bool flag10 = !string.IsNullOrEmpty(template.Appear); + if (flag10) + { + this._entity.SkillMgr.AttachAppearSkill(XSingleton.singleton.Build(skillprefix, template.Appear, this._entity)); + } + bool flag11 = !string.IsNullOrEmpty(template.Disappear); + if (flag11) + { + this._entity.SkillMgr.AttachDisappearSkill(XSingleton.singleton.Build(skillprefix, template.Disappear, this._entity)); + } + bool flag12 = !string.IsNullOrEmpty(template.Dash); + if (flag12) + { + this._entity.SkillMgr.AttachDashSkill(XSingleton.singleton.Build(skillprefix, template.Dash, this._entity)); + } + bool flag13 = !string.IsNullOrEmpty(template.SuperArmorRecoverySkill); + if (flag13) + { + this._entity.SkillMgr.AttachRecoverySkill(XSingleton.singleton.Build(skillprefix, template.SuperArmorRecoverySkill, this._entity)); + } + bool flag14 = !string.IsNullOrEmpty(template.ArmorBroken); + if (flag14) + { + this._entity.SkillMgr.AttachBrokenSkill(XSingleton.singleton.Build(skillprefix, template.ArmorBroken, this._entity)); + } + bool flag15 = template.OtherSkills != null && template.OtherSkills.Length != 0; + if (flag15) + { + int i = 0; + int num = template.OtherSkills.Length; + while (i < num) + { + bool flag16 = !string.IsNullOrEmpty(template.OtherSkills[i]) && template.OtherSkills[i] != "E"; + if (flag16) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.OtherSkills[i], this._entity), true); + } + i++; + } + } + else + { + bool isRole = this._entity.IsRole; + if (isRole) + { + for (int j = 0; j < this._entity.Attributes.skillSlot.Length; j++) + { + bool flag17 = this._entity.Attributes.skillSlot[j] == 0u; + if (!flag17) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(this._entity.Attributes.skillSlot[j], 0u); + bool flag18 = skillConfig == null; + if (flag18) + { + XSingleton.singleton.AddErrorLog("Skill: ", this._entity.Attributes.skillSlot[j].ToString(), " is not found in SkillList", null, null, null); + } + else + { + this.OtherAttachFilter(skillConfig, this._entity.Attributes.skillSlot[j]); + } + } + } + Dictionary.Enumerator enumerator = this._entity.Attributes.SkillLevelInfo.LearnedSkills.GetEnumerator(); + while (enumerator.MoveNext()) + { + XSkillEffectMgr singleton = XSingleton.singleton; + KeyValuePair keyValuePair = enumerator.Current; + SkillList.RowData skillConfig2 = singleton.GetSkillConfig(keyValuePair.Key, 0u); + bool flag19 = skillConfig2 == null; + if (flag19) + { + XDebug singleton2 = XSingleton.singleton; + string log = "Skill: "; + keyValuePair = enumerator.Current; + singleton2.AddErrorLog(log, keyValuePair.Key.ToString(), " is not found in SkillList", null, null, null); + } + else + { + bool flag20 = (int)skillConfig2.SkillType == XFastEnumIntEqualityComparer.ToInt(SkillTypeEnum.Skill_Help) || skillConfig2.IsBasicSkill > 0; + if (flag20) + { + SkillList.RowData data = skillConfig2; + keyValuePair = enumerator.Current; + this.OtherAttachFilter(data, keyValuePair.Key); + } + } + } + } + } + this._entity.SkillMgr.StatisticsPhysicalSkill(); + bool isPlayer = this._entity.IsPlayer; + if (isPlayer) + { + List list = ListPool.Get(); + list.Add(this._entity.SkillMgr.GetPhysicalIdentity()); + list.Add(this._entity.SkillMgr.GetDashIdentity()); + bool flag21 = template.OtherSkills != null && template.OtherSkills.Length != 0; + if (flag21) + { + int num2 = template.OtherSkills.Length; + int num3 = 2; + while ((long)num3 < (long)((ulong)XBattleSkillDocument.Total_skill_slot)) + { + bool flag22 = num3 - 2 < num2 && !string.IsNullOrEmpty(template.OtherSkills[num3 - 2]) && template.OtherSkills[num3 - 2] != "E"; + if (flag22) + { + list.Add(XSingleton.singleton.XHash(template.OtherSkills[num3 - 2])); + } + else + { + list.Add(0u); + } + num3++; + } + } + else + { + int num4 = 2; + while ((long)num4 < (long)((ulong)XBattleSkillDocument.Total_skill_slot)) + { + list.Add(this._entity.Attributes.skillSlot[num4]); + num4++; + } + } + this._replaced_skill_slot = list.ToArray(); + ListPool.Release(list); + bool flag23 = DlgBase.singleton.SkillHandler != null; + if (flag23) + { + DlgBase.singleton.SkillHandler.SetButtonNum((int)template.SkillNum); + } + } + } + } + + public void AttachSkill() + { + this._skill_replaced_by_typeid = 0u; + this._replaced_skill_slot = null; + bool isRole = this._entity.IsRole; + if (isRole) + { + for (int i = 0; i < this._entity.Attributes.skillSlot.Length; i++) + { + bool flag = this._entity.Attributes.skillSlot[i] == 0u; + if (!flag) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(this._entity.Attributes.skillSlot[i], 0u); + bool flag2 = skillConfig == null; + if (flag2) + { + XSingleton.singleton.AddErrorLog("Skill: ", this._entity.Attributes.skillSlot[i].ToString(), " is not found in SkillList", null, null, null); + } + else + { + this.AttachFilter(skillConfig, this._entity.Attributes.skillSlot[i]); + } + } + } + Dictionary.Enumerator enumerator = this._entity.Attributes.SkillLevelInfo.LearnedSkills.GetEnumerator(); + while (enumerator.MoveNext()) + { + XSkillEffectMgr singleton = XSingleton.singleton; + KeyValuePair keyValuePair = enumerator.Current; + SkillList.RowData skillConfig2 = singleton.GetSkillConfig(keyValuePair.Key, 0u); + bool flag3 = skillConfig2 == null; + if (flag3) + { + XDebug singleton2 = XSingleton.singleton; + string log = "Skill: "; + keyValuePair = enumerator.Current; + singleton2.AddErrorLog(log, keyValuePair.Key.ToString(), " is not found in SkillList", null, null, null); + } + else + { + bool flag4 = (int)skillConfig2.SkillType == XFastEnumIntEqualityComparer.ToInt(SkillTypeEnum.Skill_Help) || skillConfig2.IsBasicSkill > 0; + if (flag4) + { + SkillList.RowData data = skillConfig2; + keyValuePair = enumerator.Current; + this.AttachFilter(data, keyValuePair.Key); + } + } + } + } + else + { + bool flag5 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.A); + if (flag5) + { + this._entity.SkillMgr.AttachPhysicalSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.A, this._entity)); + } + bool flag6 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.AA); + if (flag6) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.AA, this._entity), false); + } + bool flag7 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.AAA); + if (flag7) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.AAA, this._entity), false); + } + bool flag8 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.AAAA); + if (flag8) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.AAAA, this._entity), false); + } + bool flag9 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.AAAAA); + if (flag9) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.AAAAA, this._entity), false); + } + bool flag10 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.Ultra); + if (flag10) + { + this._entity.SkillMgr.AttachUltraSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.Ultra, this._entity)); + } + bool flag11 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.Appear); + if (flag11) + { + this._entity.SkillMgr.AttachAppearSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.Appear, this._entity)); + } + bool flag12 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.Disappear); + if (flag12) + { + this._entity.SkillMgr.AttachDisappearSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.Disappear, this._entity)); + } + bool flag13 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.Dash); + if (flag13) + { + this._entity.SkillMgr.AttachDashSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.Dash, this._entity)); + } + bool flag14 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.SuperArmorRecoverySkill); + if (flag14) + { + this._entity.SkillMgr.AttachRecoverySkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.SuperArmorRecoverySkill, this._entity)); + } + bool flag15 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.ArmorBroken); + if (flag15) + { + this._entity.SkillMgr.AttachBrokenSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.ArmorBroken, this._entity)); + } + bool flag16 = this._entity.Present.PresentLib.OtherSkills != null; + if (flag16) + { + int j = 0; + int num = this._entity.Present.PresentLib.OtherSkills.Length; + while (j < num) + { + bool flag17 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.OtherSkills[j]) && this._entity.Present.PresentLib.OtherSkills[j] != "E"; + if (flag17) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.OtherSkills[j], this._entity), true); + } + j++; + } + } + } + this._entity.SkillMgr.StatisticsPhysicalSkill(); + bool isPlayer = this._entity.IsPlayer; + if (isPlayer) + { + } + } + + public void EndSkill(bool cleanUp = false, bool force = false) + { + bool syncMode = XSingleton.singleton.SyncMode; + if (syncMode) + { + bool isPlayer = this._entity.IsPlayer; + if (isPlayer) + { + this._entity.Net.LastReqSkill = 0u; + } + bool flag = !force && this._skill != null && !this._skill.DemonstrationMode; + if (flag) + { + return; + } + } + this.InnerEnd(cleanUp); + } + + private void InnerEnd(bool cleanUp) + { + bool flag = this._skill != null; + if (flag) + { + this._skill.Cease(cleanUp); + this._skill = null; + this._trigger = "EndSkill"; + } + } + + private XEntity SelectedTarget(XAttackEventArgs args, XSkillCore soul) + { + bool syncMode = XSingleton.singleton.SyncMode; + XEntity result; + if (syncMode) + { + result = args.Target; + } + else + { + bool flag = args.Target == null; + if (flag) + { + result = ((this._locate == null) ? null : this._locate.Locate(this._entity.EngineObject.Forward, this._entity.EngineObject.Position, false)); + } + else + { + result = args.Target; + } + } + return result; + } + + private XSkillCore PhysicalAttackAdaptor(XSkillCore soul) + { + bool flag = this._entity.IsPlayer && soul.Soul.Logical.Association; + if (flag) + { + bool feeding = XSingleton.singleton.Feeding; + if (feeding) + { + bool flag2 = !soul.Soul.Logical.MoveType; + if (flag2) + { + soul = this._entity.SkillMgr.GetSkill(XSingleton.singleton.XHash(soul.Soul.Logical.Association_Skill)); + } + } + else + { + bool moveType = soul.Soul.Logical.MoveType; + if (moveType) + { + soul = this._entity.SkillMgr.GetSkill(XSingleton.singleton.XHash(soul.Soul.Logical.Association_Skill)); + } + } + } + return soul; + } + + private void AttachFilter(SkillList.RowData data, uint id) + { + XSkillCore core = XSingleton.singleton.Build(this._entity.Present.SkillPrefix, data.SkillScript, this._entity); + XSkillData.PreLoad = (this._entity.IsPlayer && !XSingleton.singleton.IsMustTransform); + bool flag = this._entity.SkillMgr.GetPhysicalIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.A) == id; + if (flag) + { + this._entity.SkillMgr.AttachPhysicalSkill(core); + } + else + { + bool flag2 = this._entity.SkillMgr.GetUltraIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.Ultra) == id; + if (flag2) + { + this._entity.SkillMgr.AttachUltraSkill(core); + } + else + { + bool flag3 = this._entity.SkillMgr.GetAppearIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.Appear) == id; + if (flag3) + { + this._entity.SkillMgr.AttachAppearSkill(core); + } + else + { + bool flag4 = this._entity.SkillMgr.GetDisappearIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.Disappear) == id; + if (flag4) + { + this._entity.SkillMgr.AttachDisappearSkill(core); + } + else + { + bool flag5 = this._entity.SkillMgr.GetDashIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.Dash) == id; + if (flag5) + { + this._entity.SkillMgr.AttachDashSkill(core); + } + else + { + bool flag6 = this._entity.SkillMgr.GetRecoveryIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.SuperArmorRecoverySkill) == id; + if (flag6) + { + this._entity.SkillMgr.AttachRecoverySkill(core); + } + else + { + bool flag7 = this._entity.SkillMgr.GetBrokenIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.ArmorBroken) == id; + if (flag7) + { + this._entity.SkillMgr.AttachRecoverySkill(core); + } + else + { + bool flag8 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AA) == id; + if (flag8) + { + this._entity.SkillMgr.AttachSkill(core, false); + } + else + { + bool flag9 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAA) == id; + if (flag9) + { + this._entity.SkillMgr.AttachSkill(core, false); + } + else + { + bool flag10 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAAA) == id; + if (flag10) + { + this._entity.SkillMgr.AttachSkill(core, false); + } + else + { + bool flag11 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAAAA) == id; + if (flag11) + { + this._entity.SkillMgr.AttachSkill(core, false); + } + else + { + this._entity.SkillMgr.AttachSkill(core, true); + } + } + } + } + } + } + } + } + } + } + } + XSkillData.PreLoad = false; + } + + private void OtherAttachFilter(SkillList.RowData data, uint id) + { + bool flag = XSingleton.singleton.XHash(this._entity.Present.PresentLib.A) == id; + if (!flag) + { + bool flag2 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.Ultra) == id; + if (!flag2) + { + bool flag3 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.Appear) == id; + if (!flag3) + { + bool flag4 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.Disappear) == id; + if (!flag4) + { + bool flag5 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.Dash) == id; + if (!flag5) + { + bool flag6 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.SuperArmorRecoverySkill) == id; + if (!flag6) + { + bool flag7 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.ArmorBroken) == id; + if (!flag7) + { + bool flag8 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AA) == id; + if (!flag8) + { + bool flag9 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAA) == id; + if (!flag9) + { + bool flag10 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAAA) == id; + if (!flag10) + { + bool flag11 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAAAA) == id; + if (!flag11) + { + XSkillCore core = XSingleton.singleton.Build(this._entity.Present.SkillPrefix, data.SkillScript, this._entity); + this._entity.SkillMgr.AttachSkill(core, true); + } + } + } + } + } + } + } + } + } + } + } + } + } +} -- cgit v1.1-26-g67d0