path: root/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs

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);
		}
	}
}