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/XSkillFactory.cs | 294 +++++++++++++++++++++ 1 file changed, 294 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs (limited to 'Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs') diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs new file mode 100644 index 00000000..071f6616 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs @@ -0,0 +1,294 @@ +using System; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillFactory : XSingleton + { + private SmallBuffer _skillData; + + private SmallBuffer _skillCache; + + private SmallBuffer _skillMgrCache; + + public void OnSceneLoaded() + { + this._skillData.debugName = "XSkillCorePool._skillData"; + this._skillCache.debugName = "XSkillCorePool._skillCache"; + XSingleton.singleton.GetSmallBuffer(ref this._skillData, 256, 0); + XSingleton.singleton.GetSmallBuffer(ref this._skillCache, 256, 0); + XSingleton.singleton.GetSmallBuffer(ref this._skillMgrCache, 256, 0); + XSingleton.singleton.OnEnterScene(); + } + + public void OnLeaveScene() + { + bool isInit = this._skillData.IsInit; + if (isInit) + { + int i = 0; + int count = this._skillData.Count; + while (i < count) + { + XSkillCore xskillCore = this._skillData[i] as XSkillCore; + bool flag = xskillCore != null; + if (flag) + { + xskillCore.Clear(); + } + i++; + } + } + XSingleton.singleton.ReturnSmallBuffer(ref this._skillData); + XSingleton.singleton.ReturnSmallBuffer(ref this._skillCache); + XSingleton.singleton.ReturnSmallBuffer(ref this._skillMgrCache); + XSingleton.singleton.OnLeaveScene(); + } + + public XSkillCore Build(string skillprefix, string name, XEntity firer) + { + string text = skillprefix + name; + uint num = XSingleton.singleton.XHash(text); + XSkillCore xskillCore = firer.SkillMgr.GetSkill(XSingleton.singleton.XHash(name)); + bool flag = xskillCore != null; + XSkillCore result; + if (flag) + { + result = xskillCore; + } + else + { + int i = 0; + int count = this._skillData.Count; + while (i < count) + { + XSkillCore xskillCore2 = this._skillData[i] as XSkillCore; + bool flag2 = xskillCore2 != null && num == xskillCore2.LongID; + if (flag2) + { + xskillCore2.Recycle(firer); + this._skillData[i] = null; + bool flag3 = XSingleton.singleton.IsPVPScene && !xskillCore2.IsPvPVersion; + if (flag3) + { + bool flag4 = !string.IsNullOrEmpty(xskillCore2.Soul.PVP_Script_Name); + if (flag4) + { + XSkillData data = XSingleton.singleton.GetData(skillprefix + xskillCore2.Soul.PVP_Script_Name, ".txt"); + data.Prefix = skillprefix; + data.Name = xskillCore2.Soul.Name; + xskillCore2.SoulRefine(data, true); + } + } + else + { + bool flag5 = !XSingleton.singleton.IsPVPScene && xskillCore2.IsPvPVersion; + if (flag5) + { + XSkillData data2 = XSingleton.singleton.GetData(skillprefix + xskillCore2.Soul.Name, ".txt"); + data2.Prefix = skillprefix; + xskillCore2.SoulRefine(data2, false); + } + } + return xskillCore2; + } + i++; + } + XSkillData data3 = XSingleton.singleton.GetData(text, ".txt"); + data3.Prefix = skillprefix; + xskillCore = new XSkillCore(firer, data3, num); + bool flag6 = XSingleton.singleton.IsPVPScene && !string.IsNullOrEmpty(xskillCore.Soul.PVP_Script_Name); + if (flag6) + { + XSkillData data4 = XSingleton.singleton.GetData(skillprefix + xskillCore.Soul.PVP_Script_Name, ".txt"); + data4.Prefix = skillprefix; + data4.Name = xskillCore.Soul.Name; + xskillCore.SoulRefine(data4, true); + } + switch (xskillCore.Soul.TypeToken) + { + case 0: + xskillCore.TriggerToken = XSkillData.JA_Command[xskillCore.Soul.SkillPosition]; + break; + case 1: + xskillCore.TriggerToken = "ToArtSkill"; + xskillCore.Soul.Ja = null; + break; + case 2: + xskillCore.TriggerToken = "ToUltraShow"; + xskillCore.Soul.Ja = null; + break; + case 3: + xskillCore.TriggerToken = "ToPhase"; + xskillCore.Soul.Ja = null; + break; + } + bool multipleAttackSupported = xskillCore.Soul.MultipleAttackSupported; + if (multipleAttackSupported) + { + xskillCore.TriggerToken = "ToMultipleDirAttack"; + } + result = xskillCore; + } + return result; + } + + public void Release(XSkillCore core) + { + core.CoolDown(); + core.Uninit(); + int i = 0; + int count = this._skillData.Count; + while (i < count) + { + bool flag = this._skillData[i] == null; + if (flag) + { + this._skillData[i] = core; + return; + } + i++; + } + this._skillData.Add(core); + } + + public void Print() + { + XSingleton.singleton.AddLog("skill core count:", this._skillData.Count.ToString(), null, null, null, null, XDebugColor.XDebug_None); + } + + public string GetTypeName(int token) + { + bool flag = token < XSkillData.Skills.Length; + string result; + if (flag) + { + result = XSkillData.Skills[token]; + } + else + { + result = null; + } + return result; + } + + public int GetTypeHash(int token) + { + int result; + switch (token) + { + case 0: + result = XSkill.XJAComboSkillHash; + break; + case 1: + result = XSkill.XArtsSkillHash; + break; + case 2: + result = XSkill.XUltraSkillHash; + break; + case 3: + result = XSkill.XCombinedSkillHash; + break; + default: + throw new ArgumentException(); + } + return result; + } + + public XSkill CreateSkill(XEntity firer, int token) + { + int i = 0; + int count = this._skillCache.Count; + while (i < count) + { + XSkill xskill = this._skillCache[i] as XSkill; + bool flag = xskill != null && xskill.SkillType == token; + if (flag) + { + this._skillCache[i] = null; + xskill.Initialize(firer); + return xskill; + } + i++; + } + XSkill xskill2; + switch (token) + { + case 0: + xskill2 = new XJAComboSkill(); + break; + case 1: + xskill2 = new XArtsSkill(); + break; + case 2: + xskill2 = new XUltraSkill(); + break; + case 3: + xskill2 = new XCombinedSkill(); + break; + default: + return null; + } + xskill2.Initialize(firer); + return xskill2; + } + + public void ReturnSkill(XSkill skill) + { + int i = 0; + int count = this._skillCache.Count; + while (i < count) + { + bool flag = this._skillCache[i] == null; + if (flag) + { + this._skillCache[i] = skill; + return; + } + i++; + } + this._skillCache.Add(skill); + } + + public XSkillMgr CreateSkillMgr(XEntity entity) + { + int i = 0; + int count = this._skillMgrCache.Count; + while (i < count) + { + XSkillMgr xskillMgr = this._skillMgrCache[i] as XSkillMgr; + bool flag = xskillMgr != null; + if (flag) + { + this._skillMgrCache[i] = null; + xskillMgr.Initialize(entity); + return xskillMgr; + } + i++; + } + return new XSkillMgr(entity); + } + + public void ReturnSkillMgr(XSkillMgr skillMgr) + { + bool flag = skillMgr != null; + if (flag) + { + skillMgr.Uninitialize(); + int i = 0; + int count = this._skillMgrCache.Count; + while (i < count) + { + bool flag2 = this._skillMgrCache[i] == null; + if (flag2) + { + this._skillCache[i] = skillMgr; + return; + } + i++; + } + this._skillMgrCache.Add(skillMgr); + } + } + } +} -- cgit v1.1-26-g67d0