diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs | 1063 |
1 files changed, 1063 insertions, 0 deletions
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<XSkillTreeView, XSkillTreeBehaviour>
+ {
+ 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<GameObject> _TabRedPointList = new List<GameObject>();
+
+ private bool _SwitchFrameState = true;
+
+ public bool IsPromoteHandlerShow = false;
+
+ public int LastSelectPromote;
+
+ private XSkillTreeDocument _doc = null;
+
+ private List<IXUICheckBox> _icbList = new List<IXUICheckBox>();
+
+ 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>(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<XGlobalConfig>.singleton.GetInt("FreeResetSkillLevel")));
+ this._skillDlgPromoteHandler = DlgHandlerBase.EnsureCreate<SkillDlgPromoteHandler>(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<XAttributeMgr>.singleton.XPlayerData.TypeID;
+ uint level = XSingleton<XAttributeMgr>.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<XAttributeMgr>.singleton.XPlayerData.TypeID % (uint)this.MI[i + 1]);
+ inputText = XSingleton<XProfessionSkillMgr>.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<BoxCollider>().enabled = true;
+ ixuicheckBox.RegisterOnCheckEventHandler(new CheckBoxOnCheckEventHandler(this.OnTabClick));
+ ixuisprite.RegisterSpriteClickEventHandler(null);
+ }
+ else
+ {
+ gameObject.GetComponent<BoxCollider>().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<XCombatEffectManager>.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<XSkillPreViewMgr>.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<SkillDlgPromoteHandler>(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<XAttributeMgr>.singleton.XPlayerData.TypeID / (uint)this.MI[Promote] == 0u;
+ if (flag)
+ {
+ this._TabRedPointList[Promote].SetActive(false);
+ }
+ else
+ {
+ int profID = (int)(XSingleton<XAttributeMgr>.singleton.XPlayerData.TypeID % (uint)this.MI[Promote + 1]);
+ List<uint> profSkillID = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(profID);
+ for (int i = 0; i < profSkillID.Count; i++)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.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<XAttributeMgr>.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<XSkillPreViewMgr>.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<XAttributeMgr>.singleton.XPlayerData.TypeID % (uint)this.MI[Promote + 1]);
+ base.uiBehaviour.m_SkillPool.ReturnAll(false);
+ base.uiBehaviour.m_ArrowPool.ReturnAll(false);
+ List<uint> profSkillID = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(profID);
+ List<SkillTreeSortItem> list = new List<SkillTreeSortItem>();
+ for (int i = 0; i < profSkillID.Count; i++)
+ {
+ SkillTreeSortItem skillTreeSortItem = new SkillTreeSortItem();
+ skillTreeSortItem.skillID = profSkillID[i];
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(profSkillID[i], 0u);
+ skillTreeSortItem.x = (int)skillConfig.XPostion;
+ skillTreeSortItem.y = (int)skillConfig.YPostion;
+ list.Add(skillTreeSortItem);
+ }
+ list.Sort(new Comparison<SkillTreeSortItem>(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<XAttributeMgr>.singleton.XPlayerData.Level < (ulong)((long)XSingleton<XGlobalConfig>.singleton.GetInt("FreeResetSkillLevel")));
+ int num = (int)XSingleton<XGame>.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<XGame>.singleton.Doc.XBagDoc.GetSkillPointCount(true), this._doc.TotalAwakeSkillPoint));
+ base.uiBehaviour.m_LeftSkillPoint.SetText(num.ToString());
+ base.uiBehaviour.m_ResetProBtn.SetEnabled(XSingleton<XAttributeMgr>.singleton.XPlayerData.TypeID > 10u);
+ base.uiBehaviour.m_ResetSkillBtn.SetEnabled((isAwake ? this._doc.TotalAwakeSkillPoint : this._doc.TotalSkillPoint) - (int)XSingleton<XGame>.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake) != 1);
+ base.uiBehaviour.m_SwitchSkillPageBtn.SetGrey((ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level >= (ulong)((long)this._doc.SkillPageOpenLevel));
+ base.uiBehaviour.m_SkillPageText.SetEnabled((ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level >= (ulong)((long)this._doc.SkillPageOpenLevel));
+ base.uiBehaviour.m_SkillPageText.SetText(XStringDefineProxy.GetString(string.Format("SkillPage{0}", 1u - XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillPageIndex)));
+ }
+
+ protected void SetupSkill(GameObject go, uint skillID)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, skillOriginalLevel);
+ SkillList.RowData rowData = null;
+ bool flag = skillConfig.PreSkill != null && skillConfig.PreSkill != "";
+ if (flag)
+ {
+ uint skillID2 = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(skillConfig.PreSkill, 0u);
+ rowData = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID2, 0u);
+ }
+ int skillMaxLevel = XSingleton<XSkillEffectMgr>.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<XAttributeMgr>.singleton.XPlayerData.Level;
+ if (flag)
+ {
+ XSingleton<UiUtility>.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<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(this._doc.CurrentSkillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(this._doc.CurrentSkillID, skillOriginalLevel);
+ bool flag = skillConfig == null;
+ if (flag)
+ {
+ XSingleton<XDebug>.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<XSkillEffectMgr>.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<XSkillPreViewMgr>.singleton.SkillShowEnd(this._doc.Dummy);
+ XSingleton<XSkillPreViewMgr>.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<ItemEnum>.ToInt(ItemEnum.AWAKE_SKILL_POINT) : XFastEnumIntEqualityComparer<ItemEnum>.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<XSkillEffectMgr>.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<XAttributeMgr>.singleton.XPlayerData.skillSlot.Length;
+ if (flag3)
+ {
+ num = XSingleton<XAttributeMgr>.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<XSkillEffectMgr>.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<XAttributeMgr>.singleton.XPlayerData.Level) ? 1f : 0f);
+ bool flag6 = skillSlotType == SkillTypeEnum.Skill_Buff && this._doc.GetSkillSlotUnLockLevel(XFastEnumIntEqualityComparer<XSkillSlot>.ToInt(XSkillSlot.Skill_1_Buff)) > XSingleton<XAttributeMgr>.singleton.XPlayerData.Level;
+ if (flag6)
+ {
+ base.uiBehaviour.m_SkillSlotList[i].SetAlpha(0f);
+ }
+ bool flag7 = num > 0u;
+ if (flag7)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(num);
+ SkillList.RowData skillConfig2 = XSingleton<XSkillEffectMgr>.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<XSkillEffectMgr>.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<XSkillEffectMgr>.singleton.GetPreSkill(skillID, 0u);
+ uint num = 0u;
+ bool flag2 = preSkill > 0u;
+ if (flag2)
+ {
+ num = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(preSkill);
+ }
+ float num2;
+ float num3;
+ XSingleton<XSkillEffectMgr>.singleton.GetSkillDescriptValue(skillID, (preSkill == 0u) ? skillLevel : num, XSingleton<XGame>.singleton.Doc.XBagDoc.EmblemBag, out num2, out num3);
+ base.uiBehaviour.m_SkillCurrDesc.SetText(string.Format(XSingleton<UiUtility>.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<XSkillEffectMgr>.singleton.GetSkillDescriptValue(skillID, (preSkill == 0u) ? (skillLevel + 1u) : num, XSingleton<XGame>.singleton.Doc.XBagDoc.EmblemBag, out num2, out num3);
+ base.uiBehaviour.m_SkillNextDesc.SetText(string.Format(XSingleton<UiUtility>.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<XSkillEffectMgr>.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<XAttributeMgr>.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<XGame>.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<XSkillEffectMgr>.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<ModalDlg, ModalDlgBehaviour>.singleton._bHasGrey = false;
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetSingleButtonMode(false);
+ int num = XSingleton<XGlobalConfig>.singleton.GetInt("SkillResetCost");
+ bool flag = (ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level < (ulong)((long)XSingleton<XGlobalConfig>.singleton.GetInt("FreeResetSkillLevel"));
+ if (flag)
+ {
+ num = 0;
+ }
+ bool flag2 = num != 0;
+ if (flag2)
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(string.Format(XSingleton<UiUtility>.singleton.ReplaceReturn(XStringDefineProxy.GetString(XStringDefine.SKILL_RESET_SP)), num, XLabelSymbolHelper.FormatSmallIcon(7)), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL));
+ }
+ else
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(string.Format(XStringDefineProxy.GetString("FREE_RESET_SKILL_POINT"), XSingleton<XGlobalConfig>.singleton.GetInt("FreeResetSkillLevel")), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL));
+ }
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnResetSpConfirmed), null);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetTweenTargetAndPlay(DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.uiBehaviour.gameObject);
+ }
+
+ private bool OnResetSpConfirmed(IXUIButton go)
+ {
+ this._doc.SendResetSkill();
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ return true;
+ }
+
+ private void OnResetProfClicked(IXUISprite sp)
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton._bHasGrey = false;
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetSingleButtonMode(false);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(string.Format("{0}{1}", string.Format(XStringDefineProxy.GetString(XStringDefine.SKILL_RESET_PROF), XSingleton<XGlobalConfig>.singleton.GetInt("SkillResetProfession")), XLabelSymbolHelper.FormatSmallIcon(7)), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL));
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnResetProfConfirmed), null);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetTweenTargetAndPlay(DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.uiBehaviour.gameObject);
+ }
+
+ private bool OnResetProfConfirmed(IXUIButton go)
+ {
+ this._doc.SendResetProf();
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ return true;
+ }
+
+ private void OnSwitchSkillPageBtnClick(IXUISprite iSp)
+ {
+ bool flag = (ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level < (ulong)((long)this._doc.SkillPageOpenLevel);
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("SkillPageOpenTips"), "fece00");
+ }
+ else
+ {
+ bool flag2 = Time.time - this._skillPageSwitchSignTime < 2f;
+ if (flag2)
+ {
+ XSingleton<UiUtility>.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<XSkillTreeView, XSkillTreeBehaviour>.singleton.IsVisible();
+ if (!flag)
+ {
+ base.uiBehaviour.m_LearnBtn.SetEnable(state, false);
+ }
+ }
+
+ public void CreateAndPlayFxFxFirework()
+ {
+ XSingleton<XAudioMgr>.singleton.PlayUISound("Audio/UI/zhuanzhi", true, AudioChannel.Action);
+ this.DestroyFx(this._FxFirework);
+ this._FxFirework = null;
+ this._FxFirework = XSingleton<XFxMgr>.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<XFxMgr>.singleton.DestroyFx(fx, true);
+ }
+ }
+
+ private void OnUnableCheckBoxClick(IXUISprite iSp)
+ {
+ XSingleton<UiUtility>.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);
+ }
+ }
+}
|