From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../XMainClient/Skill/XSkillTreeDocument.cs | 1295 ++++++++++++++++++++ 1 file changed, 1295 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs') diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs new file mode 100644 index 00000000..cf51d34f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs @@ -0,0 +1,1295 @@ +using System; +using System.Collections.Generic; +using KKSG; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillTreeDocument : XDocComponent + { + public override uint ID + { + get + { + return XSkillTreeDocument.uuID; + } + } + + public XDummy Dummy { get; set; } + + public static int SkillSlotCount + { + get + { + return 11; + } + } + + public XPlayer Player { get; set; } + + public uint CurrentSkillID { get; set; } + + public int TotalSkillPoint { get; set; } + + public int TotalAwakeSkillPoint { get; set; } + + public bool RedPoint { get; set; } + + public bool IsAwakeSkillSlotOpen + { + get + { + return 1 == XSingleton.singleton.GetInt("AwakeSkillSlotOpen"); + } + } + + public bool IsSelfAwaked + { + get + { + return XSingleton.singleton.XPlayerData.TypeID / 1000u > 0u; + } + } + + public static int AwakeSkillSlot + { + get + { + return XFastEnumIntEqualityComparer.ToInt(XSkillSlot.Awake_Attack); + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("SkillTreeDocument"); + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + private static SkillTreeConfigTable _skillTreeConfig = new SkillTreeConfigTable(); + + public Camera BlackHouseCamera; + + public GameObject BlackHouse; + + public readonly uint UNSELECT = 0u; + + public Dictionary NewSkillDic = new Dictionary(); + + private List _slot_unlock_level = new List(); + + public List TransferLimit = new List(); + + public readonly int TRANSFERNUM = 4; + + private RenderTexture skillPreView; + + public List TurnProTaskIDList = new List(); + + public List NpcID = new List(); + + public int SkillPageOpenLevel; + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this.NewSkillDic.Clear(); + this.GetSlotUnLockLevel(); + this.GetSkillInfo(); + } + + public static void Execute(OnLoadedCallback callback = null) + { + XSkillTreeDocument.AsyncLoader.AddTask("Table/SkillTreeConfig", XSkillTreeDocument._skillTreeConfig, false); + XSkillTreeDocument.AsyncLoader.Execute(callback); + } + + protected override void EventSubscribe() + { + base.EventSubscribe(); + base.RegisterEvent(XEventDefine.XEvent_AttackShowEnd, new XComponent.XEventHandler(this.SkillPlayFinished)); + base.RegisterEvent(XEventDefine.XEvent_VirtualItemChanged, new XComponent.XEventHandler(this.SkillPointChanged)); + base.RegisterEvent(XEventDefine.XEvent_TaskStateChange, new XComponent.XEventHandler(this.IsTurnProTaskFinish)); + base.RegisterEvent(XEventDefine.XEvent_PlayerLevelChange, new XComponent.XEventHandler(this.OnPlayerLevelChange)); + } + + public override void OnEnterSceneFinally() + { + base.OnEnterScene(); + this.Player = XSingleton.singleton.Player; + uint sceneID = XSingleton.singleton.SceneID; + this.Dummy = null; + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag) + { + this.CalSkillPointTotalCount(); + this.RefreshRedPoint(); + } + } + + private void GetSlotUnLockLevel() + { + string[] array = XSingleton.singleton.GetValue("SkillSlotUnlockLevel").Split(XGlobalConfig.ListSeparator); + for (int i = 0; i < array.Length; i++) + { + this._slot_unlock_level.Add(uint.Parse(array[i])); + } + } + + private void GetSkillInfo() + { + this.TransferLimit.Add(0u); + for (int i = 1; i < this.TRANSFERNUM; i++) + { + this.TransferLimit.Add((uint)XSingleton.singleton.GetInt(string.Format("Promote{0}", i))); + } + this.TurnProTaskIDList = XSingleton.singleton.GetIntList("ChangeProTaskIds"); + this.NpcID = XSingleton.singleton.GetIntList("ChangeProNpc"); + this.SkillPageOpenLevel = XSingleton.singleton.GetInt("SkillPageNewOpen"); + } + + public uint GetSkillSlotUnLockLevel(int slotid) + { + bool flag = slotid >= this._slot_unlock_level.Count; + uint result; + if (flag) + { + result = 0u; + } + else + { + result = this._slot_unlock_level[slotid]; + } + return result; + } + + public SkillTypeEnum GetSkillSlotType(int slotid) + { + bool flag = (2 <= slotid && 6 >= slotid) || 10 == slotid; + SkillTypeEnum result; + if (flag) + { + result = SkillTypeEnum.Skill_Normal; + } + else + { + bool flag2 = 9 == slotid; + if (flag2) + { + result = SkillTypeEnum.Skill_Big; + } + else + { + bool flag3 = 7 <= slotid && 8 >= slotid; + if (flag3) + { + result = SkillTypeEnum.Skill_Buff; + } + else + { + result = SkillTypeEnum.Skill_None; + } + } + } + return result; + } + + public void SetNewSkillDic() + { + int num = XFastEnumIntEqualityComparer.ToInt(XSingleton.singleton.XPlayerData.Profession); + int num2 = num % 10; + int num3 = (num > 10) ? (num % 100) : 0; + int num4 = (num > 100) ? (num % 1000) : 0; + bool flag = num2 > 0; + if (flag) + { + List profSkillID = XSingleton.singleton.GetProfSkillID(num2); + for (int i = 0; i < profSkillID.Count; i++) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], skillOriginalLevel); + bool flag2 = this.CheckRedPoint(profSkillID[i]); + if (flag2) + { + bool flag3 = !this.NewSkillDic.ContainsKey(profSkillID[i]); + if (flag3) + { + this.NewSkillDic.Add(profSkillID[i], false); + } + } + bool flag4 = this.CheckNew(profSkillID[i]); + if (flag4) + { + bool flag5 = !this.NewSkillDic.ContainsKey(profSkillID[i]); + if (flag5) + { + this.NewSkillDic.Add(profSkillID[i], false); + } + } + } + } + bool flag6 = num3 > 0; + if (flag6) + { + List profSkillID2 = XSingleton.singleton.GetProfSkillID(num3); + for (int j = 0; j < profSkillID2.Count; j++) + { + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID2[j]); + SkillList.RowData skillConfig2 = XSingleton.singleton.GetSkillConfig(profSkillID2[j], skillOriginalLevel2); + bool flag7 = this.CheckRedPoint(profSkillID2[j]); + if (flag7) + { + bool flag8 = !this.NewSkillDic.ContainsKey(profSkillID2[j]); + if (flag8) + { + this.NewSkillDic.Add(profSkillID2[j], false); + } + } + bool flag9 = this.CheckNew(profSkillID2[j]); + if (flag9) + { + bool flag10 = !this.NewSkillDic.ContainsKey(profSkillID2[j]); + if (flag10) + { + this.NewSkillDic.Add(profSkillID2[j], false); + } + } + } + } + bool flag11 = num4 > 0; + if (flag11) + { + List profSkillID3 = XSingleton.singleton.GetProfSkillID(num4); + for (int k = 0; k < profSkillID3.Count; k++) + { + uint skillOriginalLevel3 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID3[k]); + SkillList.RowData skillConfig3 = XSingleton.singleton.GetSkillConfig(profSkillID3[k], skillOriginalLevel3); + bool flag12 = this.CheckRedPoint(profSkillID3[k]); + if (flag12) + { + bool flag13 = !this.NewSkillDic.ContainsKey(profSkillID3[k]); + if (flag13) + { + this.NewSkillDic.Add(profSkillID3[k], false); + } + } + bool flag14 = this.CheckNew(profSkillID3[k]); + if (flag14) + { + bool flag15 = !this.NewSkillDic.ContainsKey(profSkillID3[k]); + if (flag15) + { + this.NewSkillDic.Add(profSkillID3[k], false); + } + } + } + } + } + + public bool CanSkillLevelUp(uint skillID, uint skillLevel, int addLevel = 0) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, 0u); + bool flag = skillLevel != 0u && XSingleton.singleton.GetPreSkill(skillID, 0u) > 0u; + bool result; + if (flag) + { + result = false; + } + else + { + SkillLevelupRequest levelupRequest = XSingleton.singleton.GetLevelupRequest(skillID, skillLevel + (uint)addLevel); + bool flag2 = (ulong)skillLevel >= (ulong)((long)XSingleton.singleton.GetSkillMaxLevel(skillID, 0u)); + if (flag2) + { + result = false; + } + else + { + bool flag3 = (ulong)XSingleton.singleton.XPlayerData.Level < (ulong)((long)levelupRequest.Level); + result = !flag3; + } + } + return result; + } + + public bool SkillIsEquip(uint skillID) + { + uint num = skillID; + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, 0u); + bool flag = skillConfig.ExSkillScript != "" && XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID) > 0u; + if (flag) + { + num = XSingleton.singleton.GetSkillID(skillConfig.ExSkillScript, 0u); + } + for (int i = 0; i < XSingleton.singleton.XPlayerData.skillSlot.Length; i++) + { + bool flag2 = XSingleton.singleton.XPlayerData.skillSlot[i] == skillID || XSingleton.singleton.XPlayerData.skillSlot[i] == num; + if (flag2) + { + return true; + } + } + return false; + } + + public void SendResetSkill() + { + RpcC2G_ResetSkill rpcC2G_ResetSkill = new RpcC2G_ResetSkill(); + rpcC2G_ResetSkill.oArg.resetType = ResetType.RESET_SKILL; + XSingleton.singleton.Send(rpcC2G_ResetSkill); + } + + public void SendSkillLevelup() + { + RpcC2G_SkillLevelup rpcC2G_SkillLevelup = new RpcC2G_SkillLevelup(); + rpcC2G_SkillLevelup.oArg.skillHash = this.CurrentSkillID; + XSingleton.singleton.Send(rpcC2G_SkillLevelup); + } + + public void SendResetProf() + { + RpcC2G_ResetSkill rpcC2G_ResetSkill = new RpcC2G_ResetSkill(); + rpcC2G_ResetSkill.oArg.resetType = ResetType.RESET_PROFESSION; + XSingleton.singleton.Send(rpcC2G_ResetSkill); + } + + public void SendBindSkill(uint skillID, uint slot) + { + RpcC2G_BindSkill rpcC2G_BindSkill = new RpcC2G_BindSkill(); + rpcC2G_BindSkill.oArg.skillhash = skillID; + rpcC2G_BindSkill.oArg.slot = (int)slot; + XSingleton.singleton.Send(rpcC2G_BindSkill); + } + + public void QuerySwitchSkillPage() + { + RpcC2G_ChangeSkillSet rpcC2G_ChangeSkillSet = new RpcC2G_ChangeSkillSet(); + rpcC2G_ChangeSkillSet.oArg.index = 1u - XSingleton.singleton.XPlayerData.SkillPageIndex; + XSingleton.singleton.Send(rpcC2G_ChangeSkillSet); + } + + public void OnSwitchSkillPageSuccess(uint index, SkillRecord data) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("SwitchSkillPageSuccess"), "fece00"); + XSingleton.singleton.XPlayerData.SkillPageIndex = index; + XSingleton.singleton.XPlayerData.skillSlot = ((index == 0u) ? data.SkillSlot.ToArray() : data.SkillSlotTwo.ToArray()); + XSingleton.singleton.XPlayerData.SkillLevelInfo.Init((index == 0u) ? data.Skills : data.SkillsTwo); + this.CalSkillPointTotalCount(); + this.SkillRefresh(false, true); + } + + public bool SkillPlayFinished(XEventArgs args) + { + bool flag = !DlgBase.singleton.IsVisible(); + bool result; + if (flag) + { + result = false; + } + else + { + DlgBase.singleton.uiBehaviour.m_SkillPlayBtn.SetVisible(true); + bool flag2 = DlgBase.singleton._skillDlgPromoteHandler.IsVisible(); + if (flag2) + { + DlgBase.singleton._skillDlgPromoteHandler.m_PlayBtn.SetVisible(true); + } + result = true; + } + return result; + } + + public bool SkillPointChanged(XEventArgs args) + { + bool flag = XSingleton.singleton.XPlayerData == null; + bool result; + if (flag) + { + result = false; + } + else + { + XVirtualItemChangedEventArgs xvirtualItemChangedEventArgs = args as XVirtualItemChangedEventArgs; + ItemEnum itemID = (ItemEnum)xvirtualItemChangedEventArgs.itemID; + bool flag2 = XSingleton.singleton.XPlayerData.SkillPageIndex == 0u; + if (flag2) + { + bool flag3 = itemID != ItemEnum.SKILL_POINT && itemID != ItemEnum.AWAKE_SKILL_POINT; + if (flag3) + { + return true; + } + } + else + { + bool flag4 = itemID != ItemEnum.SKILL_POINT_TWO && itemID != ItemEnum.AWAKE_SKILL_POINT_TWO; + if (flag4) + { + return true; + } + } + this.RefreshRedPoint(); + this.CalSkillPointTotalCount(); + bool flag5 = DlgBase.singleton.IsVisible(); + if (flag5) + { + DlgBase.singleton.CalAllTabRedPoint(); + } + result = true; + } + return result; + } + + public bool IsTurnProTaskFinish(XEventArgs args) + { + bool flag = XSingleton.singleton.CurrentStage.Stage != EXStage.Hall; + bool result; + if (flag) + { + result = false; + } + else + { + XTaskStatusChangeArgs xtaskStatusChangeArgs = args as XTaskStatusChangeArgs; + bool flag2 = xtaskStatusChangeArgs.status != TaskStatus.TaskStatus_Over; + if (flag2) + { + result = false; + } + else + { + for (int i = 0; i < this.TurnProTaskIDList.Count; i++) + { + bool flag3 = xtaskStatusChangeArgs.id == (uint)this.TurnProTaskIDList[i]; + if (flag3) + { + uint num = XSingleton.singleton.XPlayerData.TypeID; + for (int j = 0; j < 5; j++) + { + num /= 10u; + bool flag4 = num == 0u; + if (flag4) + { + DlgBase.singleton.LastSelectPromote = j + 1; + bool flag5 = j + 1 == XSkillTreeView.AwakeIndex; + if (flag5) + { + this.AwakeTaskFinish(); + } + else + { + DlgBase.singleton.SetVisibleWithAnimation(true, null); + } + return true; + } + } + } + } + result = false; + } + } + return result; + } + + private void AwakeTaskFinish() + { + XSingleton.singleton.CreateAndPlay("Effects/FX_Particle/Roles/Lzg_Ty/Ty_juexing", XSingleton.singleton.Player.EngineObject, Vector3.zero, Vector3.one, 1f, false, 3f, true); + uint num = 1u; + for (int i = 0; i < XSkillTreeView.AwakeIndex; i++) + { + num *= 10u; + } + uint key = num + XSingleton.singleton.XPlayerData.TypeID; + ProfessionTable.RowData byProfID = XSingleton.singleton.RoleInfo.GetByProfID(key); + bool flag = byProfID == null; + if (flag) + { + XSingleton.singleton.AddErrorLog("ProfessionTable config not found: profID = ", key.ToString(), null, null, null, null); + } + else + { + uint awakeHair = byProfID.AwakeHair; + XFashionStorageDocument specificDocument = XDocuments.GetSpecificDocument(XFashionStorageDocument.uuID); + bool flag2 = XFashionDocument.IsTargetPart((int)awakeHair, FashionPosition.Hair); + if (flag2) + { + specificDocument.CheckMutuexHair((int)awakeHair); + RpcC2G_UseItem rpcC2G_UseItem = new RpcC2G_UseItem(); + rpcC2G_UseItem.oArg.OpType = ItemUseMgr.GetItemUseValue(ItemUse.FashionDisplayWear); + rpcC2G_UseItem.oArg.itemID = awakeHair; + XSingleton.singleton.Send(rpcC2G_UseItem); + } + } + } + + public static bool IsAvengerTaskDone(int prof) + { + XTaskDocument specificDocument = XDocuments.GetSpecificDocument(XTaskDocument.uuID); + uint avengerTaskID = XSkillTreeDocument.GetAvengerTaskID(prof); + return specificDocument.TaskRecord.IsTaskFinished(avengerTaskID); + } + + private static uint GetAvengerTaskID(int prof) + { + List intList = XSingleton.singleton.GetIntList("AvengerProTaskIds"); + bool flag = intList != null && intList.Count > 0; + uint result; + if (flag) + { + int num = 0; + bool flag2 = prof / 100 > 0; + if (flag2) + { + num = 1; + } + bool flag3 = prof / 1000 > 0; + if (flag3) + { + num = 2; + } + uint num2 = (uint)((num < intList.Count) ? intList[num] : 0); + result = num2; + } + else + { + result = 0u; + } + return result; + } + + private bool OnPlayerLevelChange(XEventArgs args) + { + this.RefreshRedPoint(); + return true; + } + + public void SkillRefresh(bool resetTabs = false, bool resetPosition = true) + { + this.RefreshRedPoint(); + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + bool isPromoteHandlerShow = DlgBase.singleton.IsPromoteHandlerShow; + if (isPromoteHandlerShow) + { + DlgBase.singleton._skillDlgPromoteHandler.SetVisible(false); + DlgBase.singleton.IsPromoteHandlerShow = false; + } + if (resetTabs) + { + DlgBase.singleton.SetupTabs(); + } + DlgBase.singleton.Refresh(DlgBase.singleton.LastSelectPromote, resetTabs, resetPosition); + DlgBase.singleton.CalAllTabRedPoint(); + } + } + + public void OnSkillLevelUp(uint skillID) + { + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, 0u); + DlgBase.singleton.OnSkillLevelUp((int)skillConfig.XPostion, (int)skillConfig.YPostion); + bool flag2 = skillOriginalLevel == 1u && skillConfig.SkillType == 2; + if (flag2) + { + int num = XFastEnumIntEqualityComparer.ToInt(XSkillSlot.Ultra_Attack); + bool flag3 = XSingleton.singleton.XPlayerData.skillSlot[num] == 0u; + if (flag3) + { + this.SendBindSkill(this.CurrentSkillID, (uint)num); + } + } + } + } + + public int CheckPreSkillLevel(uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag = skillID2 == 0u; + int result; + if (flag) + { + result = -1; + } + else + { + result = (int)skillOriginalLevel2; + } + return result; + } + + public bool CheckFx(uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag = skillOriginalLevel >= (uint)skillConfig.SkillLevel; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = !this.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + if (flag2) + { + result = false; + } + else + { + bool isAwake = skillConfig.IsAwake; + int num = (int)skillConfig.LevelupCost[(int)Math.Min((long)((ulong)skillOriginalLevel), (long)(skillConfig.LevelupCost.Length - 1))]; + bool flag3 = num > (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + if (flag3) + { + result = false; + } + else + { + bool flag4 = skillID2 != 0u && skillOriginalLevel2 == 0u; + if (flag4) + { + result = false; + } + else + { + int num2 = (isAwake ? this.TotalAwakeSkillPoint : this.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag5 = num2 < (int)skillConfig.PreSkillPoint; + result = !flag5; + } + } + } + } + return result; + } + + public bool CheckNew(uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag = skillOriginalLevel > 0u; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = this.NewSkillDic.ContainsKey(skillID); + if (flag2) + { + result = this.NewSkillDic[skillID]; + } + else + { + bool flag3 = !this.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + if (flag3) + { + result = false; + } + else + { + bool flag4 = skillID2 != 0u && skillOriginalLevel2 == 0u; + if (flag4) + { + result = false; + } + else + { + bool isAwake = skillConfig.IsAwake; + int num = (isAwake ? this.TotalAwakeSkillPoint : this.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag5 = num < (int)skillConfig.PreSkillPoint; + result = !flag5; + } + } + } + } + return result; + } + + public bool CheckLevelUpButton() + { + return this.CheckLevelUpButton(this.CurrentSkillID); + } + + public bool CheckLevelUpButton(uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag = !this.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + bool result; + if (flag) + { + result = false; + } + else + { + bool isAwake = skillConfig.IsAwake; + int num = (int)skillConfig.LevelupCost[(int)Math.Min((long)((ulong)skillOriginalLevel), (long)(skillConfig.LevelupCost.Length - 1))]; + bool flag2 = num > (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + if (flag2) + { + result = false; + } + else + { + bool flag3 = skillID2 != 0u && skillOriginalLevel2 == 0u; + if (flag3) + { + result = false; + } + else + { + int num2 = (isAwake ? this.TotalAwakeSkillPoint : this.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag4 = num2 < (int)skillConfig.PreSkillPoint; + result = !flag4; + } + } + } + return result; + } + + public bool CheckRedPoint(uint skillID) + { + SkillTreeConfigTable.RowData byLevel = XSkillTreeDocument._skillTreeConfig.GetByLevel(XSingleton.singleton.XPlayerData.Level); + bool flag = byLevel == null; + bool result; + if (flag) + { + XSingleton.singleton.AddErrorLog("Can't find skill tree show redpoint num level config from SkillTreeConfigTable, level = ", XSingleton.singleton.XPlayerData.Level.ToString(), null, null, null, null); + result = false; + } + else + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + bool isAwake = skillConfig.IsAwake; + bool flag2 = XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake) < (ulong)byLevel.RedPointShowNum; + if (flag2) + { + result = false; + } + else + { + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag3 = skillOriginalLevel >= (uint)skillConfig.SkillLevel; + if (flag3) + { + result = false; + } + else + { + SkillTypeEnum skillType = (SkillTypeEnum)skillConfig.SkillType; + bool flag4 = !this.IsExSkill(skillConfig); + if (flag4) + { + bool flag5 = skillOriginalLevel != 0u && (skillType == SkillTypeEnum.Skill_Normal || skillType == SkillTypeEnum.Skill_Big || skillType == SkillTypeEnum.Skill_Buff) && !this.SkillIsEquip(skillID); + if (flag5) + { + return false; + } + } + bool flag6 = !this.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + if (flag6) + { + result = false; + } + else + { + int num = (int)skillConfig.LevelupCost[(int)Math.Min((long)((ulong)skillOriginalLevel), (long)(skillConfig.LevelupCost.Length - 1))]; + bool flag7 = num > (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + if (flag7) + { + result = false; + } + else + { + bool flag8 = skillID2 != 0u && skillOriginalLevel2 == 0u; + if (flag8) + { + result = false; + } + else + { + int num2 = (isAwake ? this.TotalAwakeSkillPoint : this.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag9 = num2 < (int)skillConfig.PreSkillPoint; + result = !flag9; + } + } + } + } + } + } + return result; + } + + public void RefreshRedPoint() + { + int num = XFastEnumIntEqualityComparer.ToInt(XSingleton.singleton.XPlayerData.Profession); + int num2 = num % 10; + int num3 = (num > 10) ? (num % 100) : 0; + int num4 = (num > 100) ? (num % 1000) : 0; + int num5 = (num > 1000) ? (num % 10000) : 0; + this.RedPoint = false; + bool flag = num2 > 0; + if (flag) + { + List profSkillID = XSingleton.singleton.GetProfSkillID(num2); + for (int i = 0; i < profSkillID.Count; i++) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], skillOriginalLevel); + bool flag2 = this.CheckRedPoint(profSkillID[i]); + if (flag2) + { + this.RedPoint = true; + break; + } + } + } + bool flag3 = num3 > 0 && !this.RedPoint; + if (flag3) + { + List profSkillID2 = XSingleton.singleton.GetProfSkillID(num3); + for (int j = 0; j < profSkillID2.Count; j++) + { + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID2[j]); + SkillList.RowData skillConfig2 = XSingleton.singleton.GetSkillConfig(profSkillID2[j], skillOriginalLevel2); + bool flag4 = this.CheckRedPoint(profSkillID2[j]); + if (flag4) + { + this.RedPoint = true; + break; + } + } + } + bool flag5 = num4 > 0 && !this.RedPoint; + if (flag5) + { + List profSkillID3 = XSingleton.singleton.GetProfSkillID(num4); + for (int k = 0; k < profSkillID3.Count; k++) + { + uint skillOriginalLevel3 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID3[k]); + SkillList.RowData skillConfig3 = XSingleton.singleton.GetSkillConfig(profSkillID3[k], skillOriginalLevel3); + bool flag6 = this.CheckRedPoint(profSkillID3[k]); + if (flag6) + { + this.RedPoint = true; + break; + } + } + } + bool flag7 = num5 > 0 && !this.RedPoint; + if (flag7) + { + List profSkillID4 = XSingleton.singleton.GetProfSkillID(num5); + for (int l = 0; l < profSkillID4.Count; l++) + { + uint skillOriginalLevel4 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID4[l]); + SkillList.RowData skillConfig4 = XSingleton.singleton.GetSkillConfig(profSkillID4[l], skillOriginalLevel4); + bool flag8 = this.CheckRedPoint(profSkillID4[l]); + if (flag8) + { + this.RedPoint = true; + break; + } + } + } + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_Skill, true); + } + + public void CalSkillPointTotalCount() + { + int num = XFastEnumIntEqualityComparer.ToInt(XSingleton.singleton.XPlayerData.Profession); + int num2 = num % 10; + int num3 = (num > 10) ? (num % 100) : 0; + int num4 = (num > 100) ? (num % 1000) : 0; + int num5 = (num > 1000) ? (num % 10000) : 0; + this.TotalSkillPoint = (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(false); + this.TotalAwakeSkillPoint = (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(true); + bool flag = num2 > 0; + if (flag) + { + List profSkillID = XSingleton.singleton.GetProfSkillID(num2); + for (int i = 0; i < profSkillID.Count; i++) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], skillOriginalLevel); + int num6 = 0; + while ((long)num6 < (long)((ulong)skillOriginalLevel)) + { + this.TotalSkillPoint += (int)skillConfig.LevelupCost[Math.Min(num6, skillConfig.LevelupCost.Length - 1)]; + num6++; + } + } + } + bool flag2 = num3 > 0; + if (flag2) + { + List profSkillID2 = XSingleton.singleton.GetProfSkillID(num3); + for (int j = 0; j < profSkillID2.Count; j++) + { + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID2[j]); + SkillList.RowData skillConfig2 = XSingleton.singleton.GetSkillConfig(profSkillID2[j], skillOriginalLevel2); + int num7 = 0; + while ((long)num7 < (long)((ulong)skillOriginalLevel2)) + { + this.TotalSkillPoint += (int)skillConfig2.LevelupCost[Math.Min(num7, skillConfig2.LevelupCost.Length - 1)]; + num7++; + } + } + } + bool flag3 = num4 > 0; + if (flag3) + { + List profSkillID3 = XSingleton.singleton.GetProfSkillID(num4); + for (int k = 0; k < profSkillID3.Count; k++) + { + uint skillOriginalLevel3 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID3[k]); + SkillList.RowData skillConfig3 = XSingleton.singleton.GetSkillConfig(profSkillID3[k], skillOriginalLevel3); + int num8 = 0; + while ((long)num8 < (long)((ulong)skillOriginalLevel3)) + { + this.TotalSkillPoint += (int)skillConfig3.LevelupCost[Math.Min(num8, skillConfig3.LevelupCost.Length - 1)]; + num8++; + } + } + } + bool flag4 = num5 > 0; + if (flag4) + { + List profSkillID4 = XSingleton.singleton.GetProfSkillID(num5); + for (int l = 0; l < profSkillID4.Count; l++) + { + uint skillOriginalLevel4 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID4[l]); + SkillList.RowData skillConfig4 = XSingleton.singleton.GetSkillConfig(profSkillID4[l], skillOriginalLevel4); + int num9 = 0; + while ((long)num9 < (long)((ulong)skillOriginalLevel4)) + { + bool isAwake = skillConfig4.IsAwake; + if (isAwake) + { + this.TotalAwakeSkillPoint += (int)skillConfig4.LevelupCost[Math.Min(num9, skillConfig4.LevelupCost.Length - 1)]; + } + else + { + this.TotalSkillPoint += (int)skillConfig4.LevelupCost[Math.Min(num9, skillConfig4.LevelupCost.Length - 1)]; + } + num9++; + } + } + } + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + this.SkillRefresh(false, true); + } + + public void CreateSkillBlackHouse() + { + bool flag = this.BlackHouse == null; + if (flag) + { + XSingleton.singleton.GetSkillBlackHouse(ref this.BlackHouse, ref this.BlackHouseCamera); + this.BlackHouseCamera.enabled = false; + } + bool flag2 = this.Dummy == null || this.Dummy.Deprecated; + if (flag2) + { + this.CreateDummy(); + } + } + + private void CreateDummy() + { + XOutlookData outlook = XSingleton.singleton.XPlayerData.Outlook; + this.Dummy = XSingleton.singleton.CreateDummy(XSingleton.singleton.XPlayerData.PresentID, XSingleton.singleton.XPlayerData.TypeID, outlook, true, true, true); + bool flag = this.Dummy == null; + if (flag) + { + XSingleton.singleton.AddErrorLog("Dummy Creat Fail.", null, null, null, null, null); + } + else + { + this.Dummy.OverrideAnimClip("Idle", XSingleton.singleton.Player.Present.PresentLib.AttackIdle, true, false); + XSingleton.singleton.ResetDummyPos(this.Dummy); + } + } + + public void DelDummy() + { + bool flag = this.Dummy != null; + if (flag) + { + XSingleton.singleton.SkillShowEnd(this.Dummy); + XSingleton.singleton.DestroyEntity(this.Dummy); + } + } + + public void SetSkillPreviewTexture(RenderTexture rt) + { + this.skillPreView = rt; + bool flag = this.BlackHouseCamera != null; + if (flag) + { + this.BlackHouseCamera.targetTexture = rt; + } + } + + public void CreateAndPlayFxFxFirework() + { + bool flag = DlgBase.singleton.IsVisible(); + if (flag) + { + DlgBase.singleton.CreateAndPlayFxFxFirework(); + } + } + + public bool IsExSkill(SkillList.RowData data) + { + return XSingleton.singleton.GetPreSkill(XSingleton.singleton.XHash(data.SkillScript), 0u) > 0u; + } + + public bool isTutorialNeed(int promote, int index) + { + int[] array = new int[] + { + 1, + 10, + 100, + 1000 + }; + int profID = (int)(XSingleton.singleton.XPlayerData.TypeID % (uint)array[promote + 1]); + List profSkillID = XSingleton.singleton.GetProfSkillID(profID); + List list = new List(); + for (int i = 0; i < profSkillID.Count; i++) + { + SkillTreeSortItem skillTreeSortItem = new SkillTreeSortItem(); + skillTreeSortItem.skillID = profSkillID[i]; + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], 0u); + skillTreeSortItem.x = (int)skillConfig.XPostion; + skillTreeSortItem.y = (int)skillConfig.YPostion; + list.Add(skillTreeSortItem); + } + list.Sort(new Comparison(this.Compare)); + return XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(list[index - 1].skillID) == 0u; + } + + private int Compare(SkillTreeSortItem x, SkillTreeSortItem y) + { + bool flag = x.skillID == y.skillID; + int result; + if (flag) + { + result = 0; + } + else + { + bool flag2 = x.y != y.y; + if (flag2) + { + result = y.y - x.y; + } + else + { + result = x.x - y.x; + } + } + return result; + } + + public static string GetSkillAttrStr(int element) + { + string @string; + switch (element) + { + case 0: + @string = XStringDefineProxy.GetString("Void"); + break; + case 1: + @string = XStringDefineProxy.GetString("Fire"); + break; + case 2: + @string = XStringDefineProxy.GetString("Water"); + break; + case 3: + @string = XStringDefineProxy.GetString("Light"); + break; + case 4: + @string = XStringDefineProxy.GetString("Dark"); + break; + default: + @string = XStringDefineProxy.GetString("Void"); + break; + } + return @string; + } + + public bool IsEquipThisSkill(List skillNames) + { + for (int i = 0; i < skillNames.Count; i++) + { + bool flag = skillNames[i] == string.Empty; + if (!flag) + { + uint skillID = XSingleton.singleton.GetSkillID(skillNames[i], 0u); + bool flag2 = skillID > 0u; + if (flag2) + { + bool flag3 = this.IsEquipThisSkill(skillID); + if (flag3) + { + return true; + } + } + } + } + return false; + } + + public void ShowEmblemTips(List hashList) + { + bool flag = hashList.Count == 0; + if (!flag) + { + List skillRow = new List(); + XEmblemDocument specificDocument = XDocuments.GetSpecificDocument(XEmblemDocument.uuID); + for (int i = 0; i < hashList.Count; i++) + { + uint num = XSingleton.singleton.XPlayerData.skillSlot[hashList[i]]; + bool flag2 = num > 0u; + if (flag2) + { + bool flag3 = specificDocument.IsEquipThisSkillEmblem(num, ref skillRow); + bool flag4 = flag3; + if (flag4) + { + this.ShowTips(skillRow, false); + } + } + } + } + } + + public void ShowEmblemTips(ulong skillHash, int slot) + { + bool flag = skillHash == 0UL; + if (!flag) + { + uint num = XSingleton.singleton.XPlayerData.skillSlot[slot]; + bool flag2 = (ulong)num == skillHash; + if (!flag2) + { + List skillRow = new List(); + XEmblemDocument specificDocument = XDocuments.GetSpecificDocument(XEmblemDocument.uuID); + bool flag3 = this.IsEquipThisSkill((uint)skillHash); + bool flag4 = num == 0u && skillHash > 0UL; + if (flag4) + { + bool flag5 = !flag3; + if (flag5) + { + bool flag6 = specificDocument.IsEquipThisSkillEmblem((uint)skillHash, ref skillRow); + bool flag7 = flag6; + if (flag7) + { + this.ShowTips(skillRow, true); + } + } + } + else + { + bool flag8 = !flag3; + if (flag8) + { + bool flag6 = specificDocument.IsEquipThisSkillEmblem((uint)skillHash, ref skillRow); + bool flag9 = flag6; + if (flag9) + { + this.ShowTips(skillRow, true); + } + flag6 = specificDocument.IsEquipThisSkillEmblem(num, ref skillRow); + bool flag10 = flag6; + if (flag10) + { + this.ShowTips(skillRow, false); + } + } + } + } + } + } + + public void ShowTips(List skillRow, bool isUp) + { + bool flag = skillRow.Count == 0; + if (!flag) + { + for (int i = 0; i < skillRow.Count; i++) + { + ItemList.RowData itemConf = XBagDocument.GetItemConf((int)skillRow[i].EmblemID); + bool flag2 = itemConf == null; + if (flag2) + { + break; + } + if (isUp) + { + XSingleton.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("Active_Emblem"), itemConf.ItemName[0], skillRow[i].SkillPPT), "fece00"); + } + else + { + XSingleton.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("Deactive_Emblem"), itemConf.ItemName[0], skillRow[i].SkillPPT), "fece00"); + } + } + } + } + + private bool IsEquipThisSkill(uint skillHash) + { + bool flag = this.IsPassiveSkill(skillHash); + bool flag2 = !flag; + bool result; + if (flag2) + { + for (int i = 0; i < XSingleton.singleton.XPlayerData.skillSlot.Length; i++) + { + uint num = XSingleton.singleton.XPlayerData.skillSlot[i]; + bool flag3 = num > 0u && skillHash == num; + if (flag3) + { + return true; + } + } + result = false; + } + else + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillHash); + bool flag4 = skillOriginalLevel > 0u; + result = flag4; + } + return result; + } + + public bool IsPassiveSkill(uint skillHash) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillHash, 0u); + return skillConfig != null && skillConfig.SkillType == 5; + } + } +} -- cgit v1.1-26-g67d0