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/XSkillTreeView.cs | 1063 ++++++++++++++++++++ 1 file changed, 1063 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs (limited to 'Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs') diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs new file mode 100644 index 00000000..d614f958 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs @@ -0,0 +1,1063 @@ +using System; +using System.Collections.Generic; +using KKSG; +using UILib; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.GameSystem; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillTreeView : DlgBase + { + public override string fileName + { + get + { + return "GameSystem/SkillTree"; + } + } + + public override int layer + { + get + { + return 1; + } + } + + public override bool pushstack + { + get + { + return true; + } + } + + public override bool fullscreenui + { + get + { + return true; + } + } + + public override bool hideMainMenu + { + get + { + return true; + } + } + + public override bool autoload + { + get + { + return true; + } + } + + public SkillDlgPromoteHandler _skillDlgPromoteHandler; + + private GameObject _LastSelect = null; + + private GameObject _CurrentSkillSprite = null; + + private List _TabRedPointList = new List(); + + private bool _SwitchFrameState = true; + + public bool IsPromoteHandlerShow = false; + + public int LastSelectPromote; + + private XSkillTreeDocument _doc = null; + + private List _icbList = new List(); + + public RenderTexture skillPreView; + + private float _skillPageSwitchSignTime = 0f; + + private XFx _FxFirework; + + private int[] MI = new int[] + { + 1, + 10, + 100, + 1000, + 10000 + }; + + public static readonly int AwakeIndex = 3; + + protected override void Init() + { + base.Init(); + this._doc = XDocuments.GetSpecificDocument(XSkillTreeDocument.uuID); + this._doc.CurrentSkillID = this._doc.UNSELECT; + this._SwitchFrameState = true; + this.SetupTabs(); + base.uiBehaviour.m_FreeResetSkillTip.SetText(string.Format(XStringDefineProxy.GetString("SKILL_RESETFREE_TIPS"), XSingleton.singleton.GetInt("FreeResetSkillLevel"))); + this._skillDlgPromoteHandler = DlgHandlerBase.EnsureCreate(ref this._skillDlgPromoteHandler, base.uiBehaviour.m_TransferFrame, null, false); + } + + public override void RegisterEvent() + { + base.RegisterEvent(); + base.uiBehaviour.m_Close.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnCloseClicked)); + base.uiBehaviour.m_ResetSkillBtn.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnResetSkillPointClicked)); + base.uiBehaviour.m_ResetProBtn.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnResetProfClicked)); + base.uiBehaviour.m_SwitchSkillPageBtn.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnSwitchSkillPageBtnClick)); + base.uiBehaviour.m_CatchBackBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this.TurnSwitchFrameState)); + base.uiBehaviour.m_ChooseBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this.TurnSwitchFrameState)); + base.uiBehaviour.m_SkillPlayBtn.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnPlaySkillClicked)); + base.uiBehaviour.m_LearnBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnSkillLevelUpClicked)); + for (int i = 0; i < XSkillTreeDocument.SkillSlotCount; i++) + { + base.uiBehaviour.m_SkillSlotList[i].RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnSetupSkillClicked)); + } + } + + public void SetupTabs() + { + uint num = XSingleton.singleton.XPlayerData.TypeID; + uint level = XSingleton.singleton.XPlayerData.Level; + base.uiBehaviour.m_Tabs.ReturnAll(false); + Vector3 tplPos = base.uiBehaviour.m_Tabs.TplPos; + bool flag = true; + this._icbList.Clear(); + this._TabRedPointList.Clear(); + for (int i = 0; i < this._doc.TRANSFERNUM; i++) + { + uint num2 = num % 10u; + num /= 10u; + bool flag2 = num2 == 0u; + string inputText; + if (flag2) + { + bool flag3 = i == XSkillTreeView.AwakeIndex; + if (flag3) + { + inputText = XStringDefineProxy.GetString("SKILL_TREE_TAB_AWAKE"); + } + else + { + string arg = (i == 1) ? XStringDefineProxy.GetString("ONE") : XStringDefineProxy.GetString("TWO"); + string arg2 = (level >= this._doc.TransferLimit[i]) ? "" : XLabelSymbolHelper.FormatImage("common/Lcommon", "l_lock_00"); + inputText = string.Format(XStringDefineProxy.GetString("SKILL_TREE_TAB"), arg2, this._doc.TransferLimit[i], arg); + } + } + else + { + int profID = (int)(XSingleton.singleton.XPlayerData.TypeID % (uint)this.MI[i + 1]); + inputText = XSingleton.singleton.GetProfName(profID); + } + GameObject gameObject = base.uiBehaviour.m_Tabs.FetchGameObject(false); + gameObject.transform.localPosition = new Vector3(tplPos.x, tplPos.y - (float)(base.uiBehaviour.m_Tabs.TplHeight * i)); + this._TabRedPointList.Add(gameObject.transform.Find("RedPoint").gameObject); + IXUILabelSymbol ixuilabelSymbol = gameObject.transform.Find("TextLabel").GetComponent("XUILabelSymbol") as IXUILabelSymbol; + ixuilabelSymbol.InputText = inputText; + IXUILabelSymbol ixuilabelSymbol2 = gameObject.transform.Find("SelectedTextLabel").GetComponent("XUILabelSymbol") as IXUILabelSymbol; + ixuilabelSymbol2.InputText = inputText; + IXUICheckBox ixuicheckBox = gameObject.GetComponent("XUICheckBox") as IXUICheckBox; + IXUISprite ixuisprite = gameObject.transform.Find("Lock").GetComponent("XUISprite") as IXUISprite; + this._icbList.Add(ixuicheckBox); + ixuicheckBox.ID = (ulong)((long)i); + bool flag4 = flag; + if (flag4) + { + gameObject.GetComponent().enabled = true; + ixuicheckBox.RegisterOnCheckEventHandler(new CheckBoxOnCheckEventHandler(this.OnTabClick)); + ixuisprite.RegisterSpriteClickEventHandler(null); + } + else + { + gameObject.GetComponent().enabled = false; + ixuicheckBox.RegisterOnCheckEventHandler(null); + ixuisprite.ID = (ulong)this._doc.TransferLimit[i - 1]; + ixuisprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnUnableCheckBoxClick)); + } + bool flag5 = num2 == 0u; + if (flag5) + { + flag = false; + } + } + } + + protected override void OnShow() + { + base.OnShow(); + XSingleton.singleton.ArrangeEffectData(); + this._doc.CreateSkillBlackHouse(); + bool flag = this.skillPreView == null; + if (flag) + { + this.skillPreView = new RenderTexture(369, 208, 1, 0, 0); + this.skillPreView.name = "SkillPreview"; + this.skillPreView.autoGenerateMips = false; + this.skillPreView.Create(); + } + base.uiBehaviour.m_Snapshot.SetRuntimeTex(this.skillPreView, true); + this._doc.SetSkillPreviewTexture(this.skillPreView); + this.SetUVRectangle(); + this._icbList[this.LastSelectPromote].bChecked = true; + this.OnTabClick(this._icbList[this.LastSelectPromote]); + bool flag2 = !this._SwitchFrameState; + if (flag2) + { + this.TurnSwitchFrameState(null); + } + this.CalAllTabRedPoint(); + } + + protected override void OnHide() + { + this._doc.DelDummy(); + bool flag = this._doc.BlackHouseCamera != null; + if (flag) + { + this._doc.BlackHouseCamera.enabled = false; + } + this.LastSelectPromote = 0; + this._skillDlgPromoteHandler.SetVisible(false); + this._doc.SetSkillPreviewTexture(null); + bool flag2 = this.skillPreView != null; + if (flag2) + { + base.uiBehaviour.m_Snapshot.SetRuntimeTex(null, true); + this.skillPreView = null; + } + this.DestroyFx(this._FxFirework); + this._FxFirework = null; + base.uiBehaviour.m_LevelUpFx.SetActive(false); + base.OnHide(); + } + + public override void LeaveStackTop() + { + base.LeaveStackTop(); + base.uiBehaviour.m_LevelUpFx.SetActive(false); + } + + protected override void OnUnload() + { + XSingleton.singleton.SkillShowEnd(this._doc.Dummy); + bool flag = this._doc.BlackHouseCamera != null; + if (flag) + { + this._doc.BlackHouseCamera.enabled = false; + } + this._doc.SetSkillPreviewTexture(null); + bool flag2 = this.skillPreView != null; + if (flag2) + { + this.skillPreView.Release(); + this.skillPreView = null; + } + this.LastSelectPromote = 0; + this._LastSelect = null; + DlgHandlerBase.EnsureUnload(ref this._skillDlgPromoteHandler); + this.DestroyFx(this._FxFirework); + this._FxFirework = null; + base.OnUnload(); + } + + public void CalAllTabRedPoint() + { + for (int i = 0; i < this._doc.TRANSFERNUM; i++) + { + this.CalTabRedPoint(i); + } + } + + private void CalTabRedPoint(int Promote) + { + bool flag = XSingleton.singleton.XPlayerData.TypeID / (uint)this.MI[Promote] == 0u; + if (flag) + { + this._TabRedPointList[Promote].SetActive(false); + } + else + { + int profID = (int)(XSingleton.singleton.XPlayerData.TypeID % (uint)this.MI[Promote + 1]); + List profSkillID = XSingleton.singleton.GetProfSkillID(profID); + 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._doc.CheckRedPoint(profSkillID[i]); + if (flag2) + { + this._TabRedPointList[Promote].SetActive(true); + return; + } + } + this._TabRedPointList[Promote].SetActive(false); + } + } + + private bool OnTabClick(IXUICheckBox icb) + { + bool flag = !icb.bChecked; + bool result; + if (flag) + { + result = true; + } + else + { + bool flag2 = this._LastSelect != null; + if (flag2) + { + this._LastSelect.SetActive(false); + } + this.Refresh((int)icb.ID, true, true); + result = true; + } + return result; + } + + private bool OnCloseClicked(IXUIButton button) + { + this.SetVisibleWithAnimation(false, null); + return true; + } + + public void Refresh(int Promote, bool resetCurrentSkill = false, bool resetPosition = true) + { + this.LastSelectPromote = Promote; + this._icbList[Promote].bChecked = true; + int typeID = (int)XSingleton.singleton.XPlayerData.TypeID; + int num = typeID / this.MI[Promote] % 10; + bool flag = num != 0; + if (flag) + { + if (resetCurrentSkill) + { + this._doc.CurrentSkillID = this._doc.UNSELECT; + } + this.ShowSkillTreeFrame(Promote); + } + else + { + this.ShowTransferFrame(Promote); + } + this.SetOtherInfo(Promote == XSkillTreeView.AwakeIndex); + if (resetPosition) + { + base.uiBehaviour.m_SkillTreeScrollView.ResetPosition(); + } + } + + public void ShowSkillTreeFrame(int Promote) + { + this.IsPromoteHandlerShow = false; + this._skillDlgPromoteHandler.SetVisible(false); + this.SetupSkillFrame(Promote); + } + + private void ShowTransferFrame(int Promote) + { + this.IsPromoteHandlerShow = true; + this._skillDlgPromoteHandler.IsShowAwake = (Promote == XSkillTreeView.AwakeIndex); + this._skillDlgPromoteHandler.CurrStage = Promote; + this._skillDlgPromoteHandler.SetVisible(true); + } + + private void OnPlaySkillClicked(IXUISprite sp) + { + base.uiBehaviour.m_SkillPlayBtn.SetVisible(false); + XSingleton.singleton.ShowSkill(this._doc.Dummy, this._doc.CurrentSkillID, 0u); + } + + private bool OnSkillLevelUpClicked(IXUIButton button) + { + this._doc.SendSkillLevelup(); + return true; + } + + public void SetupSkillFrame(int Promote) + { + bool flag = !base.IsVisible(); + if (!flag) + { + int profID = (int)(XSingleton.singleton.XPlayerData.TypeID % (uint)this.MI[Promote + 1]); + base.uiBehaviour.m_SkillPool.ReturnAll(false); + base.uiBehaviour.m_ArrowPool.ReturnAll(false); + 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)); + int num = 0; + for (int j = 0; j < list.Count; j++) + { + GameObject gameObject = base.uiBehaviour.m_SkillPool.FetchGameObject(false); + gameObject.name = string.Format("Skill{0}", ++num); + this.SetupSkill(gameObject, list[j].skillID); + } + } + } + + private void SetOtherInfo(bool isAwake = false) + { + base.uiBehaviour.m_FreeResetSkillTip.SetVisible((ulong)XSingleton.singleton.XPlayerData.Level < (ulong)((long)XSingleton.singleton.GetInt("FreeResetSkillLevel"))); + int num = (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(false); + base.uiBehaviour.m_UseSkillPoint.SetText(string.Format("{0}/{1}", num, this._doc.TotalSkillPoint)); + base.uiBehaviour.m_UseAwakeSkillPoint.SetText(string.Format("{0}/{1}", (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(true), this._doc.TotalAwakeSkillPoint)); + base.uiBehaviour.m_LeftSkillPoint.SetText(num.ToString()); + base.uiBehaviour.m_ResetProBtn.SetEnabled(XSingleton.singleton.XPlayerData.TypeID > 10u); + base.uiBehaviour.m_ResetSkillBtn.SetEnabled((isAwake ? this._doc.TotalAwakeSkillPoint : this._doc.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake) != 1); + base.uiBehaviour.m_SwitchSkillPageBtn.SetGrey((ulong)XSingleton.singleton.XPlayerData.Level >= (ulong)((long)this._doc.SkillPageOpenLevel)); + base.uiBehaviour.m_SkillPageText.SetEnabled((ulong)XSingleton.singleton.XPlayerData.Level >= (ulong)((long)this._doc.SkillPageOpenLevel)); + base.uiBehaviour.m_SkillPageText.SetText(XStringDefineProxy.GetString(string.Format("SkillPage{0}", 1u - XSingleton.singleton.XPlayerData.SkillPageIndex))); + } + + protected void SetupSkill(GameObject go, uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + SkillList.RowData rowData = null; + bool flag = skillConfig.PreSkill != null && skillConfig.PreSkill != ""; + if (flag) + { + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + rowData = XSingleton.singleton.GetSkillConfig(skillID2, 0u); + } + int skillMaxLevel = XSingleton.singleton.GetSkillMaxLevel(skillID, 0u); + SkillTypeEnum skillType = (SkillTypeEnum)skillConfig.SkillType; + IXUISprite ixuisprite = go.GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite2 = go.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite3 = go.transform.Find("Icon/P").GetComponent("XUISprite") as IXUISprite; + IXUILabel ixuilabel = go.transform.Find("Text").GetComponent("XUILabel") as IXUILabel; + IXUISprite ixuisprite4 = go.transform.Find("Tip").GetComponent("XUISprite") as IXUISprite; + IXUILabel ixuilabel2 = go.transform.Find("LockTip").GetComponent("XUILabel") as IXUILabel; + IXUISprite ixuisprite5 = go.transform.Find("Lock").GetComponent("XUISprite") as IXUISprite; + GameObject gameObject = go.transform.Find("Select").gameObject; + ixuisprite.ID = (ulong)skillID; + ixuisprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnSkillClicked)); + bool flag2 = this._doc.CurrentSkillID == this._doc.UNSELECT || this._doc.CurrentSkillID == skillID; + if (flag2) + { + gameObject.SetActive(true); + this._doc.CurrentSkillID = skillID; + this.OnSkillClicked(ixuisprite); + this._LastSelect = gameObject; + } + else + { + gameObject.SetActive(false); + } + Transform transform = go.transform.Find("CanLearn"); + Transform transform2 = go.transform.Find("RedPoint"); + transform.gameObject.SetActive(false); + transform2.gameObject.SetActive(false); + bool flag3 = (skillType == SkillTypeEnum.Skill_Normal || skillType == SkillTypeEnum.Skill_Big || skillType == SkillTypeEnum.Skill_Buff) && this._doc.SkillIsEquip(skillID); + if (flag3) + { + ixuisprite4.SetVisible(true); + } + else + { + ixuisprite4.SetVisible(false); + } + go.transform.localPosition = new Vector3(base.uiBehaviour.m_SkillPool.TplPos.x + (float)((int)(skillConfig.XPostion - 1) * base.uiBehaviour.m_SkillPool.TplWidth), (float)skillConfig.YPostion); + ixuisprite2.SetSprite(skillConfig.Icon, skillConfig.Atlas, false); + ixuilabel2.SetVisible(this._doc.CheckPreSkillLevel(skillID) != 0 && !this._doc.CanSkillLevelUp(skillID, skillOriginalLevel, 0) && skillOriginalLevel == 0u); + ixuilabel.SetVisible((this._doc.CheckPreSkillLevel(skillID) != 0 && this._doc.CanSkillLevelUp(skillID, skillOriginalLevel, 0)) || skillOriginalLevel > 0u); + ixuilabel.SetText(skillOriginalLevel + "/" + skillMaxLevel); + bool flag4 = skillOriginalLevel == 0u && !this._doc.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + if (flag4) + { + ixuilabel2.SetText(string.Format(XStringDefineProxy.GetString(XStringDefine.SKILL_LEARN), skillConfig.UpReqRoleLevel[0])); + } + else + { + bool flag5 = this._doc.CheckFx(skillID); + bool flag6 = this._doc.CheckRedPoint(skillID); + bool flag7 = this._doc.CheckNew(skillID); + IXUISprite ixuisprite6 = transform2.transform.Find("Fx").GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite7 = transform2.transform.Find("Fx1").GetComponent("XUISprite") as IXUISprite; + ixuisprite6.SetVisible(false); + ixuisprite7.SetVisible(false); + bool flag8 = flag7; + if (flag8) + { + transform2.gameObject.SetActive(true); + ixuisprite6.SetVisible(true); + } + bool flag9 = flag5 && !flag6; + if (flag9) + { + transform.gameObject.SetActive(true); + } + bool flag10 = flag6; + if (flag10) + { + transform2.gameObject.SetActive(true); + ixuisprite7.SetVisible(true); + } + } + SkillTypeEnum skillTypeEnum = skillType; + if (skillTypeEnum != SkillTypeEnum.Skill_Big) + { + if (skillTypeEnum != SkillTypeEnum.Skill_Buff) + { + ixuisprite3.SetSprite("JN_dk"); + } + else + { + ixuisprite3.SetSprite("JN_dk_buff"); + } + } + else + { + ixuisprite3.SetSprite("JN_dk_0"); + } + bool flag11 = rowData != null; + if (flag11) + { + Vector3 localPosition = go.transform.localPosition; + Vector3 vector; + vector= new Vector3(base.uiBehaviour.m_SkillPool.TplPos.x + (float)((int)(rowData.XPostion - 1) * base.uiBehaviour.m_SkillPool.TplWidth), (float)rowData.YPostion); + Vector3 vector2 = (localPosition + vector) / 2f; + GameObject gameObject2 = base.uiBehaviour.m_ArrowPool.FetchGameObject(false); + IXUISprite ixuisprite8 = gameObject2.GetComponent("XUISprite") as IXUISprite; + bool flag12 = skillConfig.XPostion == rowData.XPostion || skillConfig.YPostion == rowData.YPostion; + if (flag12) + { + bool flag13 = skillConfig.XPostion == rowData.XPostion; + if (flag13) + { + ixuisprite8.SetSprite("SkillTree_3"); + ixuisprite8.spriteHeight = (int)((float)(rowData.YPostion - skillConfig.YPostion) - (float)ixuisprite2.spriteHeight * 1.5f); + ixuisprite8.spriteWidth = base.uiBehaviour.m_ArrowPool.TplWidth; + gameObject2.transform.localPosition = vector2; + gameObject2.transform.localScale = new Vector3(1f, 1f); + gameObject2.transform.localRotation = Quaternion.identity; + } + else + { + ixuisprite8.SetSprite("SkillTree_3"); + int num = (skillConfig.XPostion < rowData.XPostion) ? 1 : -1; + ixuisprite8.spriteHeight = (int)((float)((int)(rowData.XPostion - skillConfig.XPostion) * (num * base.uiBehaviour.m_SkillPool.TplWidth)) - (float)ixuisprite2.spriteWidth * 1.5f); + ixuisprite8.spriteWidth = base.uiBehaviour.m_ArrowPool.TplWidth; + gameObject2.transform.localPosition = vector2; + gameObject2.transform.localScale = new Vector3(1f, 1f); + gameObject2.transform.localRotation = Quaternion.Euler(0f, 0f, (float)(-(float)num * 90)); + } + } + else + { + ixuisprite8.SetSprite("SkillTree_4"); + ixuisprite8.spriteHeight = (int)Math.Abs(localPosition.y - vector.y) - ixuisprite2.spriteHeight / 2; + ixuisprite8.spriteWidth = (int)Math.Abs(localPosition.x - vector.x) - ixuisprite2.spriteWidth / 2; + int num2 = (skillConfig.XPostion < rowData.XPostion) ? 1 : -1; + gameObject2.transform.localPosition = vector2 + new Vector3((float)(ixuisprite2.spriteWidth / 2 * -(float)num2), (float)(ixuisprite2.spriteHeight / 2)); + gameObject2.transform.localScale = new Vector3((float)num2, 1f); + gameObject2.transform.localRotation = Quaternion.identity; + } + } + ixuisprite2.SetEnabled(skillOriginalLevel > 0u); + ixuisprite3.SetEnabled(skillOriginalLevel > 0u); + ixuisprite5.SetVisible(skillOriginalLevel == 0u); + ixuisprite5.SetEnabled(skillOriginalLevel > 0u); + ixuisprite2.ID = (ulong)skillID; + } + + private void OnSkillClicked(IXUISprite sp) + { + this._doc.CurrentSkillID = (uint)sp.ID; + bool flag = this._LastSelect != null; + if (flag) + { + this._LastSelect.SetActive(false); + } + this._LastSelect = sp.gameObject.transform.Find("Select").gameObject; + this._LastSelect.SetActive(true); + this._CurrentSkillSprite = sp.gameObject.transform.Find("RedPoint").gameObject; + this.SetupDetail(true); + } + + private void OnSetupSkillClicked(IXUISprite sp) + { + uint currentSkillID = this._doc.CurrentSkillID; + uint slot = (uint)sp.ID; + uint skillSlotUnLockLevel = this._doc.GetSkillSlotUnLockLevel((int)sp.ID); + bool flag = skillSlotUnLockLevel > XSingleton.singleton.XPlayerData.Level; + if (flag) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("OpenSkillAtLevel", new object[] + { + skillSlotUnLockLevel + }), "fece00"); + this.SetupBaseSkill(); + } + else + { + this._doc.SendBindSkill(currentSkillID, slot); + } + } + + private bool TurnSwitchFrameState(IXUIButton btn) + { + this._SwitchFrameState = !this._SwitchFrameState; + this.SetupDetail(true); + int num = this._SwitchFrameState ? 1 : 0; + base.uiBehaviour.m_DetailFrameTween.StopTweenByGroup(1 - num); + base.uiBehaviour.m_CatchFrameTween.StopTweenByGroup(1 - num); + base.uiBehaviour.m_DetailFrameTween.SetTweenGroup(num); + base.uiBehaviour.m_CatchFrameTween.SetTweenGroup(num); + base.uiBehaviour.m_DetailFrameTween.PlayTween(true, -1f); + base.uiBehaviour.m_CatchFrameTween.PlayTween(true, -1f); + return true; + } + + public void SetupDetail(bool resetSnap = true) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(this._doc.CurrentSkillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(this._doc.CurrentSkillID, skillOriginalLevel); + bool flag = skillConfig == null; + if (flag) + { + XSingleton.singleton.AddErrorLog("Can't find Current Skill, SkillID = ", this._doc.CurrentSkillID.ToString(), null, null, null, null); + } + else + { + SkillTypeEnum skillType = (SkillTypeEnum)skillConfig.SkillType; + bool flag2 = false; + bool flag3 = false; + bool flag4 = (ulong)skillOriginalLevel < (ulong)((long)XSingleton.singleton.GetSkillMaxLevel(this._doc.CurrentSkillID, 0u)); + bool flag5 = skillType == SkillTypeEnum.Skill_Normal || skillType == SkillTypeEnum.Skill_Big || skillType == SkillTypeEnum.Skill_Help || skillType == SkillTypeEnum.Skill_Buff; + if (flag5) + { + flag2 = true; + } + bool flag6 = skillOriginalLevel > 0u; + if (flag6) + { + bool flag7 = !this._doc.IsExSkill(skillConfig); + if (flag7) + { + bool flag8 = skillType == SkillTypeEnum.Skill_Normal || skillType == SkillTypeEnum.Skill_Big || skillType == SkillTypeEnum.Skill_Buff; + if (flag8) + { + flag3 = true; + } + } + } + bool flag9 = this._doc.CurrentSkillID != this._doc.UNSELECT; + if (flag9) + { + base.uiBehaviour.m_SkillLearnRedPoint.gameObject.SetActive(this._doc.CheckRedPoint(this._doc.CurrentSkillID)); + } + else + { + base.uiBehaviour.m_SkillLearnRedPoint.gameObject.SetActive(false); + } + if (resetSnap) + { + XSingleton.singleton.SkillShowEnd(this._doc.Dummy); + XSingleton.singleton.SkillShowBegin(this._doc.Dummy, this._doc.BlackHouseCamera); + } + base.uiBehaviour.m_NonPreView.SetActive(!flag2); + base.uiBehaviour.m_Snapshot.SetVisible(flag2); + base.uiBehaviour.m_SkillPlayBtn.SetVisible(flag2); + base.uiBehaviour.m_ChooseBtn.SetVisible(flag3); + bool flag10 = flag3; + if (flag10) + { + Vector3 localPosition = base.uiBehaviour.m_ChooseBtn.gameObject.transform.localPosition; + bool flag11 = flag4; + if (flag11) + { + base.uiBehaviour.m_ChooseBtn.gameObject.transform.localPosition = new Vector3(96f, localPosition.y); + } + else + { + base.uiBehaviour.m_ChooseBtn.gameObject.transform.localPosition = new Vector3(0f, localPosition.y); + } + } + bool flag12 = !flag3 && !this._SwitchFrameState; + if (flag12) + { + this.TurnSwitchFrameState(null); + } + base.uiBehaviour.m_LearnBtn.SetVisible(flag4); + bool flag13 = flag4; + if (flag13) + { + Vector3 localPosition2 = base.uiBehaviour.m_LearnBtn.gameObject.transform.localPosition; + bool flag14 = flag3; + if (flag14) + { + base.uiBehaviour.m_LearnBtn.gameObject.transform.localPosition = new Vector3(-96f, localPosition2.y); + } + else + { + base.uiBehaviour.m_LearnBtn.gameObject.transform.localPosition = new Vector3(0f, localPosition2.y); + } + } + IXUISprite ixuisprite = base.uiBehaviour.m_LearnBtn.gameObject.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite; + ItemList.RowData itemConf = XBagDocument.GetItemConf(skillConfig.IsAwake ? XFastEnumIntEqualityComparer.ToInt(ItemEnum.AWAKE_SKILL_POINT) : XFastEnumIntEqualityComparer.ToInt(ItemEnum.SKILL_POINT)); + bool flag15 = itemConf != null && itemConf.ItemAtlas1.Length != 0 && itemConf.ItemIcon1.Length != 0; + if (flag15) + { + ixuisprite.SetSprite(itemConf.ItemIcon1[0], itemConf.ItemAtlas1[0], false); + } + IXUILabel ixuilabel = base.uiBehaviour.m_LearnBtn.gameObject.transform.Find("Text").GetComponent("XUILabel") as IXUILabel; + ixuilabel.SetText(XStringDefineProxy.GetString((skillOriginalLevel == 0u) ? "LEARN" : "UPGRADE")); + IXUILabel ixuilabel2 = base.uiBehaviour.m_LearnBtn.gameObject.transform.Find("Cost").GetComponent("XUILabel") as IXUILabel; + bool flag16 = skillConfig.LevelupCost == null; + if (flag16) + { + ixuilabel2.SetText("0"); + } + else + { + bool flag17 = (ulong)skillOriginalLevel < (ulong)((long)skillConfig.LevelupCost.Length); + if (flag17) + { + ixuilabel2.SetText(skillConfig.LevelupCost[(int)skillOriginalLevel].ToString()); + } + else + { + ixuilabel2.SetText(skillConfig.LevelupCost[skillConfig.LevelupCost.Length - 1].ToString()); + } + } + base.uiBehaviour.m_LearnBtn.SetGrey(this._doc.CheckLevelUpButton(this._doc.CurrentSkillID)); + this.SetupDetailMsg(this._doc.CurrentSkillID, skillOriginalLevel, skillConfig); + this.SetupBaseSkill(); + } + } + + private void SetupBaseSkill() + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(this._doc.CurrentSkillID, 0u); + SkillTypeEnum skillType = (SkillTypeEnum)skillConfig.SkillType; + bool isAwake = skillConfig.IsAwake; + for (int i = 0; i < XSkillTreeDocument.SkillSlotCount; i++) + { + bool flag = i == 0 || i == 1; + if (!flag) + { + bool flag2 = i == XSkillTreeDocument.AwakeSkillSlot; + if (flag2) + { + base.uiBehaviour.m_SkillSlotList[i].gameObject.SetActive(this._doc.IsAwakeSkillSlotOpen && this._doc.IsSelfAwaked); + } + uint num = 0u; + bool flag3 = i < XSingleton.singleton.XPlayerData.skillSlot.Length; + if (flag3) + { + num = XSingleton.singleton.XPlayerData.skillSlot[i]; + } + SkillTypeEnum skillSlotType = this._doc.GetSkillSlotType(i); + IXUISprite ixuisprite = base.uiBehaviour.m_SkillSlotList[i].gameObject.transform.Find("Light").GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite2 = base.uiBehaviour.m_SkillSlotList[i].gameObject.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite3 = base.uiBehaviour.m_SkillSlotList[i].gameObject.transform.Find("Lock").GetComponent("XUISprite") as IXUISprite; + BoxCollider boxCollider = base.uiBehaviour.m_SkillSlotList[i].gameObject.GetComponent("BoxCollider") as BoxCollider; + bool flag4 = skillConfig.ExSkillScript == ""; + if (flag4) + { + ixuisprite.SetVisible(num == this._doc.CurrentSkillID); + } + else + { + uint skillID = XSingleton.singleton.GetSkillID(skillConfig.ExSkillScript, 0u); + ixuisprite.SetVisible(num == this._doc.CurrentSkillID || num == skillID); + } + bool flag5 = skillSlotType == skillType; + if (flag5) + { + base.uiBehaviour.m_SkillSlotList[i].SetAlpha(1f); + boxCollider.enabled = true; + } + else + { + base.uiBehaviour.m_SkillSlotList[i].SetAlpha(0.5f); + boxCollider.enabled = false; + } + ixuisprite3.SetAlpha((this._doc.GetSkillSlotUnLockLevel(i) > XSingleton.singleton.XPlayerData.Level) ? 1f : 0f); + bool flag6 = skillSlotType == SkillTypeEnum.Skill_Buff && this._doc.GetSkillSlotUnLockLevel(XFastEnumIntEqualityComparer.ToInt(XSkillSlot.Skill_1_Buff)) > XSingleton.singleton.XPlayerData.Level; + if (flag6) + { + base.uiBehaviour.m_SkillSlotList[i].SetAlpha(0f); + } + bool flag7 = num > 0u; + if (flag7) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(num); + SkillList.RowData skillConfig2 = XSingleton.singleton.GetSkillConfig(num, skillOriginalLevel); + ixuisprite2.SetSprite(skillConfig2.Icon, skillConfig2.Atlas, false); + } + else + { + ixuisprite2.spriteName = "EmptySkill"; + } + } + } + } + + private void SetupDetailMsg(uint skillID, uint skillLevel, SkillList.RowData data) + { + SkillTypeEnum skillType = (SkillTypeEnum)data.SkillType; + string text = string.Format("{0}({1}/{2})", data.ScriptName, skillLevel, XSingleton.singleton.GetSkillMaxLevel(skillID, 0u)); + base.uiBehaviour.m_SkillName_L.SetText(text); + base.uiBehaviour.m_SkillName_S.SetText(text); + string @string; + switch (skillType) + { + case SkillTypeEnum.Skill_Big: + @string = XStringDefineProxy.GetString("SPECIAL_SKILL"); + goto IL_CE; + case SkillTypeEnum.Skill_SceneBuff: + @string = XStringDefineProxy.GetString("SCENEBUFF_SKILL"); + goto IL_CE; + case SkillTypeEnum.Skill_Help: + @string = XStringDefineProxy.GetString("SUPPORT_SKILL"); + goto IL_CE; + case SkillTypeEnum.Skill_Buff: + @string = XStringDefineProxy.GetString("BUFF_SKILL"); + goto IL_CE; + case SkillTypeEnum.Skill_Awake: + @string = XStringDefineProxy.GetString("AWAKE_SKILL"); + goto IL_CE; + } + @string = XStringDefineProxy.GetString("NORMAL_SKILL"); + IL_CE: + base.uiBehaviour.m_SkillType_L.SetText(@string); + base.uiBehaviour.m_SkillType_S.SetText(@string); + base.uiBehaviour.m_ChooseTips.SetText(string.Format(XStringDefineProxy.GetString("SKILL_CHOOSE_TIPS"), @string)); + base.uiBehaviour.m_SkillCostText.SetText((data.CostMP[0] + data.CostMP[1] * skillLevel).ToString()); + base.uiBehaviour.m_SkillAttrText.SetText(XSkillTreeDocument.GetSkillAttrStr((int)data.Element)); + bool flag = skillType != SkillTypeEnum.Skill_SceneBuff; + if (flag) + { + base.uiBehaviour.m_SkillCDText.SetText(string.Format("{0}s", Math.Round((double)XSkillMgr.GetCD(this._doc.Player, data.SkillScript, 0u) + 0.01, 1))); + } + else + { + base.uiBehaviour.m_SkillCDText.SetText(XStringDefineProxy.GetString("NONE")); + } + base.uiBehaviour.m_SkillDetail_L.SetText(data.CurrentLevelDescription); + base.uiBehaviour.m_SkillDetail_S.SetText(data.CurrentLevelDescription); + base.uiBehaviour.m_SkillDetailScrollView_S.SetPosition(0f); + uint preSkill = XSingleton.singleton.GetPreSkill(skillID, 0u); + uint num = 0u; + bool flag2 = preSkill > 0u; + if (flag2) + { + num = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(preSkill); + } + float num2; + float num3; + XSingleton.singleton.GetSkillDescriptValue(skillID, (preSkill == 0u) ? skillLevel : num, XSingleton.singleton.Doc.XBagDoc.EmblemBag, out num2, out num3); + base.uiBehaviour.m_SkillCurrDesc.SetText(string.Format(XSingleton.singleton.ReplaceReturn(data.NextLevelDescription), Math.Round((double)(num2 * 100f) + 0.01, 1), Math.Round((double)num3 + 0.01, 1))); + base.uiBehaviour.m_SkillPreSkillPointTips.SetVisible(false); + bool flag3 = num == 0u; + if (flag3) + { + num += 1u; + } + XSingleton.singleton.GetSkillDescriptValue(skillID, (preSkill == 0u) ? (skillLevel + 1u) : num, XSingleton.singleton.Doc.XBagDoc.EmblemBag, out num2, out num3); + base.uiBehaviour.m_SkillNextDesc.SetText(string.Format(XSingleton.singleton.ReplaceReturn(data.NextLevelDescription), Math.Round((double)(num2 * 100f) + 0.01, 1), Math.Round((double)num3 + 0.01, 1))); + bool flag4 = this._doc.CanSkillLevelUp(skillID, skillLevel, 0); + if (flag4) + { + base.uiBehaviour.m_SkillNextReq.SetText(""); + } + else + { + SkillLevelupRequest levelupRequest = XSingleton.singleton.GetLevelupRequest(skillID, skillLevel); + base.uiBehaviour.m_SkillNextReq.SetText(string.Format("{0}({1})", string.Format(XStringDefineProxy.GetString(XStringDefine.ITEM_REQUIRE_LEVEL), levelupRequest.Level), string.Format(XStringDefineProxy.GetString("LEFT_LEVEL"), (long)levelupRequest.Level - (long)((ulong)XSingleton.singleton.XPlayerData.Level)))); + } + base.uiBehaviour.m_SuperIndureAttack.SetText(data.SuperIndureAttack); + base.uiBehaviour.m_SuperIndureDenfense.SetText(data.SuperIndureDefense); + bool flag5 = skillLevel == 0u; + if (flag5) + { + base.uiBehaviour.m_SkillCurrDesc.SetText(XStringDefineProxy.GetString("NOT_LEARN")); + bool isAwake = data.IsAwake; + int num4 = (isAwake ? this._doc.TotalAwakeSkillPoint : this._doc.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag6 = num4 < (int)data.PreSkillPoint; + if (flag6) + { + base.uiBehaviour.m_SkillPreSkillPointTips.SetVisible(true); + base.uiBehaviour.m_SkillPreSkillPointTips.SetText(string.Format(XStringDefineProxy.GetString("SKILLTREE_PRESKILLPOINT_TIPS"), data.PreSkillPoint)); + } + else + { + base.uiBehaviour.m_SkillPreSkillPointTips.SetVisible(false); + } + } + else + { + bool flag7 = (ulong)skillLevel == (ulong)((long)XSingleton.singleton.GetSkillMaxLevel(skillID, 0u)); + if (flag7) + { + base.uiBehaviour.m_SkillNextDesc.SetText(XStringDefineProxy.GetString("SkillLevelMaxTips")); + base.uiBehaviour.m_SkillNextReq.SetText(""); + } + } + base.uiBehaviour.m_SkillDetailScrollView.ResetPosition(); + } + + private void OnResetSkillPointClicked(IXUISprite sp) + { + DlgBase.singleton._bHasGrey = false; + DlgBase.singleton.SetVisible(false, true); + DlgBase.singleton.SetSingleButtonMode(false); + int num = XSingleton.singleton.GetInt("SkillResetCost"); + bool flag = (ulong)XSingleton.singleton.XPlayerData.Level < (ulong)((long)XSingleton.singleton.GetInt("FreeResetSkillLevel")); + if (flag) + { + num = 0; + } + bool flag2 = num != 0; + if (flag2) + { + DlgBase.singleton.SetLabelsWithSymbols(string.Format(XSingleton.singleton.ReplaceReturn(XStringDefineProxy.GetString(XStringDefine.SKILL_RESET_SP)), num, XLabelSymbolHelper.FormatSmallIcon(7)), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL)); + } + else + { + DlgBase.singleton.SetLabelsWithSymbols(string.Format(XStringDefineProxy.GetString("FREE_RESET_SKILL_POINT"), XSingleton.singleton.GetInt("FreeResetSkillLevel")), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL)); + } + DlgBase.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnResetSpConfirmed), null); + DlgBase.singleton.SetTweenTargetAndPlay(DlgBase.singleton.uiBehaviour.gameObject); + } + + private bool OnResetSpConfirmed(IXUIButton go) + { + this._doc.SendResetSkill(); + DlgBase.singleton.SetVisible(false, true); + return true; + } + + private void OnResetProfClicked(IXUISprite sp) + { + DlgBase.singleton._bHasGrey = false; + DlgBase.singleton.SetVisible(false, true); + DlgBase.singleton.SetSingleButtonMode(false); + DlgBase.singleton.SetLabelsWithSymbols(string.Format("{0}{1}", string.Format(XStringDefineProxy.GetString(XStringDefine.SKILL_RESET_PROF), XSingleton.singleton.GetInt("SkillResetProfession")), XLabelSymbolHelper.FormatSmallIcon(7)), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL)); + DlgBase.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnResetProfConfirmed), null); + DlgBase.singleton.SetTweenTargetAndPlay(DlgBase.singleton.uiBehaviour.gameObject); + } + + private bool OnResetProfConfirmed(IXUIButton go) + { + this._doc.SendResetProf(); + DlgBase.singleton.SetVisible(false, true); + return true; + } + + private void OnSwitchSkillPageBtnClick(IXUISprite iSp) + { + bool flag = (ulong)XSingleton.singleton.XPlayerData.Level < (ulong)((long)this._doc.SkillPageOpenLevel); + if (flag) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("SkillPageOpenTips"), "fece00"); + } + else + { + bool flag2 = Time.time - this._skillPageSwitchSignTime < 2f; + if (flag2) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("SkillPageSwitchTooOften"), "fece00"); + } + else + { + this._skillPageSwitchSignTime = Time.time; + this._doc.QuerySwitchSkillPage(); + } + } + } + + public void OnSkillLevelUp(int x, int y) + { + bool flag = !base.IsVisible(); + if (!flag) + { + base.uiBehaviour.m_LevelUpFx.gameObject.transform.localPosition = new Vector3(base.uiBehaviour.m_SkillPool.TplPos.x + (float)((x - 1) * base.uiBehaviour.m_SkillPool.TplWidth), (float)y); + base.uiBehaviour.m_LevelUpFx.SetActive(false); + base.uiBehaviour.m_LevelUpFx.SetActive(true); + } + } + + public void SetLearnSkillButtonState(bool state) + { + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + base.uiBehaviour.m_LearnBtn.SetEnable(state, false); + } + } + + public void CreateAndPlayFxFxFirework() + { + XSingleton.singleton.PlayUISound("Audio/UI/zhuanzhi", true, AudioChannel.Action); + this.DestroyFx(this._FxFirework); + this._FxFirework = null; + this._FxFirework = XSingleton.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_zzcg", null, true); + this._FxFirework.Play(base.uiBehaviour.m_FxFirework, Vector3.zero, Vector3.one, 1f, true, false); + } + + public void DestroyFx(XFx fx) + { + bool flag = fx == null; + if (!flag) + { + XSingleton.singleton.DestroyFx(fx, true); + } + } + + private void OnUnableCheckBoxClick(IXUISprite iSp) + { + XSingleton.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("CHANGEPROF_PRETIPS"), iSp.ID), "fece00"); + } + + 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 void SetUVRectangle() + { + Rect rect = this._doc.BlackHouseCamera.rect; + rect.y = (rect.y * 208f + 1f) / 208f; + rect.height = (rect.height * 208f - 2f) / 208f; + base.uiBehaviour.m_Snapshot.SetUVRect(rect); + } + } +} -- cgit v1.1-26-g67d0