using System;
using System.Collections.Generic;
using KKSG;
using UILib;
using UnityEngine;
using XMainClient.UI;
using XMainClient.UI.UICommon;
using XUtliPoolLib;

namespace XMainClient
{
	internal class XOtherPlayerInfoView : DlgBase<XOtherPlayerInfoView, XOtherPlayerInfoBehaviour>
	{
		public override string fileName
		{
			get
			{
				return "GameSystem/OtherPlayerInfo";
			}
		}

		public override int group
		{
			get
			{
				return 1;
			}
		}

		public override bool autoload
		{
			get
			{
				return true;
			}
		}

		private XOtherPlayerInfoDocument _doc = null;

		private ArtifactBagDocument m_doc = null;

		private EquipFusionDocument m_equipfusionDoc;

		private ulong m_PlayerId;

		private string m_PlayerName;

		private uint m_PlayerProfession;

		private uint m_PowerPoint;

		private List<uint> m_setid = new List<uint>();

		private uint m_PlayerLevel;

		public const int FUNC_NUM = 8;

		public const int EQUIP_NUM = 10;

		public const int AVATAR_NUM = 10;

		public const int EMBLEM_NUM = 16;

		public const int ARTIFACT_NUM = 4;

		private XDummy _PlayerDummy = null;

		private XSpriteAvatarHandler[] _SpriteAvatarHandler = new XSpriteAvatarHandler[4];

		private ArtifactQuanlityFx[] m_fuseBreakFx = new ArtifactQuanlityFx[10];

		private XAttributes m_Attributes = null;

		private float _EclipsedTime = 0f;

		public List<IXUICheckBox> m_InfoCheck = new List<IXUICheckBox>();

		private Dictionary<Player_Info, IXUISprite> m_InfoDic = new Dictionary<Player_Info, IXUISprite>();

		private Dictionary<int, XItem> m_ItemDic = new Dictionary<int, XItem>();

		private Dictionary<uint, uint> _skillLevel = new Dictionary<uint, uint>();

		private HashSet<uint> _bindsSkills = new HashSet<uint>();

		private ArtifactQuanlityFx[] m_artifactQuanlityFx = new ArtifactQuanlityFx[XBagDocument.ArtifactMax];

		private XBodyBag m_EquipBag = new XBodyBag(XBagDocument.EquipMax);

		private XBodyBag m_artifactBag = new XBodyBag(XBagDocument.ArtifactMax);

		private List<uint> m_FashionBag = new List<uint>();

		private XPetSkillHandler m_SkillHandler;

		private XCharacterAttrView<XAttrOtherFile> m_CharacterAttrHandler;

		private XEmbleAttrView<XAttrOtherFile> m_EmbleAttrHandler;

		private XArtifactAttrView<XAttrOtherFile> m_artifactAttrHandler;

		private uint[] allParts = new uint[10];

		private uint lastPetID = 0u;

		private bool hasPetInfo = false;

		protected override void Init()
		{
			this._doc = XDocuments.GetSpecificDocument<XOtherPlayerInfoDocument>(XOtherPlayerInfoDocument.uuID);
			this._doc.OtherPlayerInfoView = this;
			this.m_doc = ArtifactBagDocument.Doc;
			this.m_equipfusionDoc = EquipFusionDocument.Doc;
			IXUIButton ixuibutton = base.uiBehaviour.transform.Find("backclick").GetComponent("XUIButton") as IXUIButton;
			ixuibutton.RegisterClickEventHandler(new ButtonClickEventHandler(this.ClickClosePanel));
			ixuibutton = (base.uiBehaviour.transform.Find("Bg/InfoPanel/backclick").GetComponent("XUIButton") as IXUIButton);
			ixuibutton.RegisterClickEventHandler(new ButtonClickEventHandler(this.ClickClosePanel));
			this.m_InfoCheck.Clear();
			base.uiBehaviour.m_FunctionBtns.ReturnAll(false);
			string[] array = new string[]
			{
				XStringDefineProxy.GetString("EQUIP"),
				XStringDefineProxy.GetString("SKILL"),
				XStringDefineProxy.GetString("FASHION"),
				XStringDefineProxy.GetString("EMBLEM"),
				XStringDefineProxy.GetString("CHAT_GUILD"),
				XStringDefineProxy.GetString("PET"),
				XStringDefineProxy.GetString("Sprite"),
				XStringDefineProxy.GetString("Artifact")
			};
			for (int i = 0; i < 8; i++)
			{
				GameObject gameObject = base.uiBehaviour.m_FunctionBtns.FetchGameObject(false);
				gameObject.transform.localPosition = new Vector3(base.uiBehaviour.m_FunctionBtns.TplPos.x, base.uiBehaviour.m_FunctionBtns.TplPos.y - (float)(i * base.uiBehaviour.m_FunctionBtns.TplHeight), base.uiBehaviour.m_FunctionBtns.TplPos.z);
				IXUICheckBox ixuicheckBox = gameObject.transform.Find("Bg").GetComponent("XUICheckBox") as IXUICheckBox;
				ixuicheckBox.RegisterOnCheckEventHandler(new CheckBoxOnCheckEventHandler(this.ShowPlayerInfo));
				ixuicheckBox.ID = (ulong)((long)(i + 1));
				this.m_InfoCheck.Add(ixuicheckBox);
				IXUILabel ixuilabel = gameObject.transform.Find("name").GetComponent("XUILabel") as IXUILabel;
				IXUILabel ixuilabel2 = gameObject.transform.Find("nameSelected").GetComponent("XUILabel") as IXUILabel;
				ixuilabel.SetText(array[i]);
				ixuilabel2.SetText(array[i]);
			}
			for (int j = 0; j < XBagDocument.ArtifactMax; j++)
			{
				this.m_artifactQuanlityFx[j] = new ArtifactQuanlityFx();
			}
			this.m_InfoDic[Player_Info.Avatar] = base.uiBehaviour.m_AvatarLayer;
			this.m_InfoDic[Player_Info.Equip] = base.uiBehaviour.m_EquipLayer;
			this.m_InfoDic[Player_Info.Emblem] = base.uiBehaviour.m_EmblemLayer;
			this.m_InfoDic[Player_Info.Guild] = base.uiBehaviour.m_GuildLayer;
			this.m_InfoDic[Player_Info.Pet] = base.uiBehaviour.m_PetLayer;
			this.m_InfoDic[Player_Info.Sprite] = base.uiBehaviour.m_SpriteLayer;
			this.m_InfoDic[Player_Info.Skill] = base.uiBehaviour.m_SkillLayer;
			this.m_InfoDic[Player_Info.Artifact] = base.uiBehaviour.m_artifactLayer;
			DlgHandlerBase.EnsureCreate<XPetSkillHandler>(ref this.m_SkillHandler, base.uiBehaviour.m_PetSkillFrame.gameObject, null, true);
			for (int k = 0; k < 4; k++)
			{
				Transform parent = base.uiBehaviour.m_SpriteLayer.gameObject.transform.Find(string.Format("Avatar{0}", k));
				DlgHandlerBase.EnsureCreate<XSpriteAvatarHandler>(ref this._SpriteAvatarHandler[k], parent, true, this);
			}
			DlgHandlerBase.EnsureCreate<XCharacterAttrView<XAttrOtherFile>>(ref this.m_CharacterAttrHandler, base.uiBehaviour.m_EquipLayer.gameObject.transform.Find("AttrFrame"), true, null);
			DlgHandlerBase.EnsureCreate<XEmbleAttrView<XAttrOtherFile>>(ref this.m_EmbleAttrHandler, base.uiBehaviour.m_EmblemLayer.gameObject.transform.Find("AttrFrame"), true, null);
			DlgHandlerBase.EnsureCreate<XArtifactAttrView<XAttrOtherFile>>(ref this.m_artifactAttrHandler, base.uiBehaviour.m_artifactLayer.gameObject.transform.Find("AttrFrame"), true, null);
		}

		public override void RegisterEvent()
		{
		}

		protected override void OnShow()
		{
			base.OnShow();
			this.InitGuildInfo();
			this.InitEquipAndAvatar();
			base.Alloc3DAvatarPool("XOtherPlayerInfoView");
			this.SetSpriteAvatarHandlerVisible(true);
		}

		protected override void OnHide()
		{
			base.OnHide();
			base.Return3DAvatarPool();
			this._PlayerDummy = null;
			this.SetSpriteAvatarHandlerVisible(false);
			this.RestQuanlityFx();
			this.hasPetInfo = false;
		}

		private void SetSpriteAvatarHandlerVisible(bool visible)
		{
			for (int i = 0; i < this._SpriteAvatarHandler.Length; i++)
			{
				this._SpriteAvatarHandler[i].SetVisible(visible);
				if (visible)
				{
					this._SpriteAvatarHandler[i].HideAvatar();
				}
			}
		}

		protected override void OnUnload()
		{
			base.Return3DAvatarPool();
			this._doc = null;
			this.hasPetInfo = false;
			for (int i = 0; i < XBagDocument.ArtifactMax; i++)
			{
				bool flag = this.m_artifactQuanlityFx[i] != null;
				if (flag)
				{
					this.m_artifactQuanlityFx[i].Reset();
				}
			}
			for (int j = 0; j < 10; j++)
			{
				bool flag2 = this.m_fuseBreakFx[j] != null;
				if (flag2)
				{
					this.m_fuseBreakFx[j].Reset();
					this.m_fuseBreakFx[j] = null;
				}
			}
			DlgHandlerBase.EnsureUnload<XPetSkillHandler>(ref this.m_SkillHandler);
			for (int k = 0; k < this._SpriteAvatarHandler.Length; k++)
			{
				DlgHandlerBase.EnsureUnload<XSpriteAvatarHandler>(ref this._SpriteAvatarHandler[k]);
			}
			DlgHandlerBase.EnsureUnload<XCharacterAttrView<XAttrOtherFile>>(ref this.m_CharacterAttrHandler);
			DlgHandlerBase.EnsureUnload<XEmbleAttrView<XAttrOtherFile>>(ref this.m_EmbleAttrHandler);
			DlgHandlerBase.EnsureUnload<XArtifactAttrView<XAttrOtherFile>>(ref this.m_artifactAttrHandler);
			base.OnUnload();
		}

		public override void StackRefresh()
		{
			base.StackRefresh();
			base.Alloc3DAvatarPool("XOtherPlayerInfoView");
		}

		public bool OnCloseClicked(IXUIButton sp)
		{
			this.SetVisible(false, true);
			return true;
		}

		public void SetPlayerInfo(ulong uid, string name, List<uint> setid, uint powerpoint = 0u, uint profession = 1u)
		{
			this.m_PlayerId = uid;
			this.m_PlayerName = name;
			this.m_setid = setid;
			this.m_PowerPoint = powerpoint;
			this.m_PlayerProfession = profession;
		}

		public void ShowMenuUI(ulong uid, string name, List<string> menuName, List<ButtonClickEventHandler> clickHandle, uint powerpoint = 0u, uint profession = 1u)
		{
			bool flag = base.IsVisible() && this.m_PlayerId == uid;
			if (!flag)
			{
				DlgBase<XOtherPlayerInfoView, XOtherPlayerInfoBehaviour>.singleton.SetVisibleWithAnimation(true, null);
				this.SetPlayerInfo(uid, name, new List<uint>(), powerpoint, profession);
				base.uiBehaviour.m_MenuPanel.SetVisible(true);
				base.uiBehaviour.m_InfoPanel.SetVisible(false);
				base.uiBehaviour.m_MenuPlayerName.SetText(name);
				base.uiBehaviour.m_MenuPool.ReturnAll(false);
				float x = base.uiBehaviour.m_MenuPool.TplPos.x;
				float num = base.uiBehaviour.m_MenuPool.TplPos.y;
				bool flag2 = menuName.Count > 0;
				if (flag2)
				{
					num += (float)((menuName.Count - 1) * base.uiBehaviour.m_MenuPool.TplHeight / 2);
				}
				float z = base.uiBehaviour.m_MenuPool.TplPos.z;
				int spriteHeight = base.uiBehaviour.m_MenuPool.TplHeight * menuName.Count + 10;
				for (int i = 0; i < menuName.Count; i++)
				{
					GameObject gameObject = base.uiBehaviour.m_MenuPool.FetchGameObject(false);
					gameObject.transform.localPosition = new Vector3(x, num - (float)(base.uiBehaviour.m_MenuPool.TplHeight * i), z);
					IXUIButton ixuibutton = gameObject.transform.Find("button").GetComponent("XUIButton") as IXUIButton;
					IXUILabel ixuilabel = gameObject.transform.Find("button/name").GetComponent("XUILabel") as IXUILabel;
					ixuibutton.RegisterClickEventHandler(clickHandle[i]);
					ixuilabel.SetText(menuName[i]);
				}
				base.uiBehaviour.m_MenuPanel.spriteHeight = spriteHeight;
			}
		}

		public void InitMenuWithBasicInfo(ulong uid, string name, uint powerpoint = 0u, uint professional = 1u)
		{
			bool flag = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsMyFriend(uid);
			bool flag2 = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsBlock(uid);
			List<string> list = new List<string>();
			list.Add(XStringDefineProxy.GetString("OTHERPLAYERINFO_MENU_VIEW"));
			bool flag3 = flag;
			if (flag3)
			{
				list.Add(XStringDefineProxy.GetString("OTHERPLAYERINFO_MENU_DELETEFRIEND"));
			}
			else
			{
				bool flag4 = !flag2;
				if (flag4)
				{
					bool flag5 = XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_Friends);
					if (flag5)
					{
						list.Add(XStringDefineProxy.GetString("OTHERPLAYERINFO_MENU_ADDFRIEND"));
					}
				}
			}
			bool flag6 = !flag2;
			if (flag6)
			{
				list.Add(XStringDefineProxy.GetString("OTHERPLAYERINFO_MENU_PRIVATECHAT"));
				list.Add(XStringDefineProxy.GetString("OTHERPLAYERINFO_MENU_BLOCK"));
				list.Add(XStringDefineProxy.GetString("OTHERPLAYERINFO_MENU_SENDFLOWER"));
			}
			else
			{
				list.Add(XStringDefineProxy.GetString("OTHERPLAYERINFO_MENU_UNBLOCK"));
			}
			List<ButtonClickEventHandler> list2 = new List<ButtonClickEventHandler>();
			list2.Add(new ButtonClickEventHandler(this.ShowDetailInfo));
			bool flag7 = flag;
			if (flag7)
			{
				list2.Add(new ButtonClickEventHandler(this.RemoveFriend));
			}
			else
			{
				bool flag8 = !flag2;
				if (flag8)
				{
					bool flag9 = XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_Friends);
					if (flag9)
					{
						list2.Add(new ButtonClickEventHandler(this.AddFriend));
					}
				}
			}
			bool flag10 = !flag2;
			if (flag10)
			{
				list2.Add(new ButtonClickEventHandler(this.PrivateChat));
				list2.Add(new ButtonClickEventHandler(this.Block));
				list2.Add(new ButtonClickEventHandler(this.SendFlower));
			}
			else
			{
				list2.Add(new ButtonClickEventHandler(this.UnBlock));
			}
			this.ShowMenuUI(uid, name, list, list2, powerpoint, professional);
		}

		public void InitGuildMenu(ulong guildid, string guildname)
		{
			this.ShowMenuUI(guildid, guildname, new List<string>
			{
				XStringDefineProxy.GetString("CHAT_LOOKUP_GUILD")
			}, new List<ButtonClickEventHandler>
			{
				new ButtonClickEventHandler(DlgBase<XRankView, XRankBehaviour>.singleton.OnShowGuildInfo)
			}, 0u, 1u);
		}

		public void InitContentArea(Player_Info option, ulong param1 = 0UL, ulong param2 = 0UL)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			bool flag = (double)Mathf.Abs(realtimeSinceStartup - this._EclipsedTime) <= 0.1;
			if (flag)
			{
				XSingleton<XDebug>.singleton.AddLog("Time too short", null, null, null, null, null, XDebugColor.XDebug_None);
			}
			else
			{
				this._EclipsedTime = realtimeSinceStartup;
				foreach (KeyValuePair<Player_Info, IXUISprite> keyValuePair in this.m_InfoDic)
				{
					bool flag2 = keyValuePair.Key == option;
					if (flag2)
					{
						keyValuePair.Value.SetVisible(true);
						this.ShowOtherHandler(keyValuePair.Key);
					}
					else
					{
						keyValuePair.Value.SetVisible(false);
					}
				}
				base.uiBehaviour.m_InfoPlayerName.SetText(string.Concat(new object[]
				{
					"Lv.",
					this.m_PlayerLevel,
					" ",
					this.m_PlayerName
				}));
				this.m_uiBehaviour.m_CurrentSnapshot = null;
				switch (option)
				{
				case Player_Info.Equip:
				case Player_Info.Avatar:
					this.m_uiBehaviour.m_CurrentSnapshot = ((option == Player_Info.Avatar) ? this.m_uiBehaviour.m_AvatarSnapshot : this.m_uiBehaviour.m_EquipSnapshot);
					this.RequirePlayerInfo();
					break;
				case Player_Info.Skill:
					this.SetupSkillFrame();
					break;
				case Player_Info.Emblem:
					this.RefreshEmblemInfo(this._doc.m_Appearance);
					break;
				case Player_Info.Guild:
				{
					this.InitGuildInfo();
					RpcC2M_GetOtherGuildBriefNew rpcC2M_GetOtherGuildBriefNew = new RpcC2M_GetOtherGuildBriefNew();
					rpcC2M_GetOtherGuildBriefNew.oArg.roleid = this.m_PlayerId;
					XSingleton<XClientNetwork>.singleton.Send(rpcC2M_GetOtherGuildBriefNew);
					break;
				}
				case Player_Info.Pet:
					this.m_uiBehaviour.m_CurrentSnapshot = this.m_uiBehaviour.m_PetSnapshot;
					this.RequirePetInfo(param1, param2);
					break;
				case Player_Info.Sprite:
					for (int i = 0; i < 4; i++)
					{
						this._SpriteAvatarHandler[i].HideAvatar();
					}
					base.uiBehaviour.m_SpriteLayer.gameObject.transform.Find("Empty").gameObject.SetActive(false);
					this.RequireSpriteInfo();
					break;
				case Player_Info.Artifact:
					this.RefreshArtifactInfo(this._doc.m_Appearance);
					break;
				}
			}
		}

		private void ShowOtherHandler(Player_Info type)
		{
			if (type != Player_Info.Emblem)
			{
				if (type == Player_Info.Artifact)
				{
					this.m_artifactAttrHandler.SetBaseData(this._doc.GetOtherArtifactInfoList());
				}
			}
			else
			{
				this.m_EmbleAttrHandler.SetBaseData(this._doc.GetOtherEmblemInfoList());
			}
		}

		private void InitEquipAndAvatar()
		{
			for (int i = 0; i < 10; i++)
			{
				GameObject gameObject = base.uiBehaviour.transform.Find("Bg/InfoPanel/EquipLayer/EquipFrame/Part" + i.ToString()).gameObject;
				XSingleton<XItemDrawerMgr>.singleton.normalItemDrawer.DrawItem(gameObject, null, 0, false);
			}
			IXUILabel ixuilabel = base.uiBehaviour.transform.Find("Bg/InfoPanel/EquipLayer/CharacterInfoFrame/CharacterFrame/PowerPoint").GetComponent("XUILabel") as IXUILabel;
			ixuilabel.SetText("0");
			base.uiBehaviour.m_InfoPlayerName.SetText("");
			for (int j = 0; j < 10; j++)
			{
				GameObject gameObject2 = base.uiBehaviour.transform.Find("Bg/InfoPanel/AvatarLayer/EquipFrame/Part" + (11 + j).ToString()).gameObject;
				XSingleton<XItemDrawerMgr>.singleton.normalItemDrawer.DrawItem(gameObject2, null, 0, false);
			}
			for (int k = 0; k < 16; k++)
			{
				GameObject gameObject3 = base.uiBehaviour.m_EmblemBg[k];
				XSingleton<XItemDrawerMgr>.singleton.normalItemDrawer.DrawItem(gameObject3, null, 0, false);
				gameObject3.SetActive(true);
			}
		}

		public XAttributes GetAttrByUnitAppearance(UnitAppearance data)
		{
			return XSingleton<XAttributeMgr>.singleton.InitAttrFromServer(data.uID, data.nickid, data.unitType, data.unitName, data.attributes, data.fightgroup, data.isServerControl, data.skills, data.bindskills, new XOutLookAttr(data.outlook), data.level, 0u);
		}

		private void _FillCharacterInfoFrame(UnitAppearance data)
		{
			bool flag = !base.IsVisible();
			if (!flag)
			{
				this._FillInitEquip(data);
				this._FillInitInfos(data);
				this._FillInitAvatar(data);
				this.RefreshEmblemInfo(data);
				this._FillRoleDummy(data);
				this._FillInitSkillData(data);
				this.RefreshArtifactInfo(data);
			}
		}

		private void _FillInitEquip(UnitAppearance data)
		{
			foreach (XItem xitem in this.m_ItemDic.Values)
			{
				xitem.Recycle();
			}
			this.m_ItemDic.Clear();
			int num = 0;
			while (num < 10 && num < data.equip.Count)
			{
				Item kksgitem = data.equip[num];
				XItem xitem2 = XBagDocument.MakeXItem(kksgitem);
				this.m_EquipBag[num] = xitem2;
				this.m_ItemDic[xitem2.itemID] = xitem2;
				GameObject gameObject = base.uiBehaviour.transform.Find("Bg/InfoPanel/EquipLayer/EquipFrame/Part" + num.ToString()).gameObject;
				IXUISprite ixuisprite = gameObject.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite;
				bool flag = xitem2 != null && xitem2.itemID > 0;
				if (flag)
				{
					ixuisprite.ID = (ulong)((long)xitem2.itemID);
					ixuisprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnClickItemBg));
					XEquipItem xequipItem = xitem2 as XEquipItem;
					this.SetEquipEffect(gameObject, xequipItem.fuseInfo.BreakNum, num);
				}
				else
				{
					this.SetEquipEffect(gameObject, 0u, num);
				}
				XItemDrawerMgr.Param.bHideBinding = true;
				XItemDrawerMgr.Param.Profession = data.unitType % 10u;
				XSingleton<XItemDrawerMgr>.singleton.DrawItem(gameObject, xitem2);
				num++;
			}
			bool flag2 = data.equip.Count > 10;
			if (flag2)
			{
				for (int i = data.equip.Count; i < 10; i++)
				{
					GameObject gameObject2 = base.uiBehaviour.transform.Find("Bg/InfoPanel/EquipLayer/EquipFrame/Part" + i.ToString()).gameObject;
					this.SetEquipEffect(gameObject2, 0u, i);
				}
			}
		}

		private void SetEquipEffect(GameObject go, uint breakLevel, int slot)
		{
			bool flag = slot >= this.m_fuseBreakFx.Length;
			if (!flag)
			{
				bool flag2 = go == null;
				if (!flag2)
				{
					ArtifactQuanlityFx artifactQuanlityFx = this.m_fuseBreakFx[slot];
					bool flag3 = artifactQuanlityFx == null;
					if (flag3)
					{
						artifactQuanlityFx = new ArtifactQuanlityFx();
						this.m_fuseBreakFx[slot] = artifactQuanlityFx;
					}
					string path;
					bool flag4 = !this.m_equipfusionDoc.GetEffectPath(breakLevel, out path);
					if (flag4)
					{
						artifactQuanlityFx.Reset();
					}
					else
					{
						bool flag5 = !artifactQuanlityFx.IsCanReuse((ulong)breakLevel);
						if (flag5)
						{
							artifactQuanlityFx.SetData((ulong)breakLevel, go.transform.Find("Icon/Icon/Effects"), path);
						}
					}
				}
			}
		}

		private void RestQuanlityFx()
		{
			for (int i = 0; i < 10; i++)
			{
				bool flag = this.m_fuseBreakFx[i] != null;
				if (flag)
				{
					this.m_fuseBreakFx[i].Reset();
				}
			}
		}

		private void _FillInitInfos(UnitAppearance data)
		{
			this.m_PlayerProfession = data.unitType;
			IXUILabel ixuilabel = base.uiBehaviour.transform.Find("Bg/InfoPanel/EquipLayer/CharacterInfoFrame/CharacterFrame/PowerPoint").GetComponent("XUILabel") as IXUILabel;
			ixuilabel.SetText(data.PowerPoint.ToString());
			this.m_PlayerLevel = data.level;
			base.uiBehaviour.m_InfoPlayerName.SetText(string.Concat(new object[]
			{
				"Lv.",
				this.m_PlayerLevel,
				" ",
				this.m_PlayerName
			}));
			IXUILabel ixuilabel2 = base.uiBehaviour.transform.Find("Bg/InfoPanel/AvatarLayer/CharacterInfoFrame/CharacterFrame/PowerPoint").GetComponent("XUILabel") as IXUILabel;
			ixuilabel2.SetText(data.PowerPoint.ToString());
			this.m_Attributes = this.GetAttrByUnitAppearance(data);
			this.m_CharacterAttrHandler.SetAttributes(this.m_Attributes);
		}

		private void _FillInitAvatar(UnitAppearance data)
		{
			int i = 0;
			int num = this.allParts.Length;
			while (i < num)
			{
				this.allParts[i] = 0u;
				i++;
			}
			bool flag = data.outlook != null && data.outlook.display_fashion != null;
			if (flag)
			{
				i = 0;
				num = data.outlook.display_fashion.display_fashions.Count;
				while (i < num)
				{
					uint num2 = data.outlook.display_fashion.display_fashions[i];
					FashionList.RowData fashionConf = XBagDocument.GetFashionConf((int)num2);
					bool flag2 = fashionConf == null || (int)fashionConf.EquipPos >= this.allParts.Length;
					if (!flag2)
					{
						this.allParts[(int)fashionConf.EquipPos] = num2;
					}
					i++;
				}
			}
			i = 0;
			while (i < 10 && i < this.allParts.Length)
			{
				uint num3 = this.allParts[i];
				GameObject gameObject = base.uiBehaviour.transform.Find("Bg/InfoPanel/AvatarLayer/EquipFrame/Part" + (11 + i).ToString()).gameObject;
				IXUISprite ixuisprite = gameObject.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite;
				ixuisprite.ID = (ulong)num3;
				ixuisprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnClickOutLookBg));
				XItemDrawerMgr.Param.bHideBinding = true;
				XItemDrawerMgr.Param.Profession = data.unitType % 10u;
				XSingleton<XItemDrawerMgr>.singleton.normalItemDrawer.DrawItem(gameObject, (int)num3, 0, false);
				i++;
			}
		}

		private void OnClickOutLookBg(IXUISprite sprite)
		{
			int num = (int)sprite.ID;
			bool flag = num == 0;
			if (!flag)
			{
				XSingleton<UiUtility>.singleton.ShowTooltipDialog(num, null, this.m_PlayerProfession % 10u);
			}
		}

		private void _FillInitSkillData(UnitAppearance data)
		{
			this._bindsSkills.Clear();
			this._skillLevel.Clear();
			for (int i = 0; i < data.bindskills.Count; i++)
			{
				this._bindsSkills.Add(data.bindskills[i]);
			}
			for (int j = 0; j < data.skills.Count; j++)
			{
				this._skillLevel[data.skills[j].skillHash] = data.skills[j].skillLevel;
			}
		}

		private void _FillRoleDummy(UnitAppearance data)
		{
			bool flag = data.uID > 0UL;
			if (flag)
			{
				this._PlayerDummy = XSingleton<X3DAvatarMgr>.singleton.CreateCommonRoleDummy(this.m_dummPool, data.uID, data.unitType, data.outlook, this.m_uiBehaviour.m_CurrentSnapshot, this._PlayerDummy);
			}
		}

		private void RefreshEmblemInfo(UnitAppearance data)
		{
			bool flag = data == null;
			if (!flag)
			{
				for (int i = 0; i < 16; i++)
				{
					GameObject gameObject = base.uiBehaviour.m_EmblemBg[i];
					bool flag2 = data.emblem.Count > i;
					if (flag2)
					{
						Item item = data.emblem[i];
						bool flag3 = item.ItemID > 0u;
						if (flag3)
						{
							XItem xitem = XBagDocument.MakeXItem(item);
							this.m_ItemDic[xitem.itemID] = xitem;
							XItemDrawerMgr.Param.bHideBinding = true;
							XItemDrawerMgr.Param.Profession = data.unitType % 10u;
							XSingleton<XItemDrawerMgr>.singleton.DrawItem(gameObject, xitem);
							gameObject.SetActive(true);
							IXUISprite ixuisprite = gameObject.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite;
							bool flag4 = xitem != null;
							if (flag4)
							{
								ixuisprite.ID = (ulong)((long)xitem.itemID);
								ixuisprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnClickItemBg));
							}
						}
						else
						{
							gameObject.SetActive(false);
						}
					}
					else
					{
						gameObject.SetActive(false);
					}
				}
			}
		}

		private void RefreshArtifactInfo(UnitAppearance data)
		{
			bool flag = data == null;
			if (!flag)
			{
				for (int i = 0; i < 4; i++)
				{
					GameObject gameObject = base.uiBehaviour.m_artifactGo[i];
					bool flag2 = data.artifact.Count > i;
					if (flag2)
					{
						Item item = data.artifact[i];
						XItem xitem = XBagDocument.MakeXItem(item);
						this.m_artifactBag[i] = xitem;
						bool flag3 = item.ItemID > 0u;
						if (flag3)
						{
							this.m_ItemDic[xitem.itemID] = xitem;
							XItemDrawerMgr.Param.bHideBinding = true;
							XSingleton<XItemDrawerMgr>.singleton.DrawItem(gameObject, xitem);
							bool flag4 = xitem != null && xitem.itemConf != null;
							if (flag4)
							{
								this.SetArtifactEffect(gameObject, xitem.itemID, i);
							}
							gameObject.SetActive(true);
							gameObject.transform.Find("Icon/RedPoint").gameObject.SetActive(false);
							IXUISprite ixuisprite = gameObject.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite;
							bool flag5 = xitem != null;
							if (flag5)
							{
								ixuisprite.ID = (ulong)((long)xitem.itemID);
								ixuisprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnClickItemBg));
							}
						}
						else
						{
							gameObject.SetActive(false);
						}
					}
					else
					{
						gameObject.SetActive(false);
					}
				}
			}
		}

		private void SetArtifactEffect(GameObject go, int itemId, int slot)
		{
			bool flag = slot >= this.m_artifactQuanlityFx.Length;
			if (!flag)
			{
				bool flag2 = go == null;
				if (!flag2)
				{
					ItemList.RowData itemConf = XBagDocument.GetItemConf(itemId);
					bool flag3 = itemConf == null;
					if (!flag3)
					{
						ArtifactListTable.RowData artifactListRowData = ArtifactDocument.GetArtifactListRowData((uint)itemId);
						bool flag4 = artifactListRowData == null;
						if (!flag4)
						{
							ArtifactQuanlityFx artifactQuanlityFx = this.m_artifactQuanlityFx[slot];
							bool flag5 = artifactQuanlityFx == null;
							if (flag5)
							{
								artifactQuanlityFx = new ArtifactQuanlityFx();
								this.m_artifactQuanlityFx[slot] = artifactQuanlityFx;
							}
							ulong key = this.m_doc.MakeKey((uint)itemConf.ItemQuality, artifactListRowData.AttrType);
							string path;
							bool flag6 = !this.m_doc.GetArtifactEffectPath(key, out path);
							if (flag6)
							{
								artifactQuanlityFx.Reset();
							}
							else
							{
								bool flag7 = !artifactQuanlityFx.IsCanReuse(key);
								if (flag7)
								{
									artifactQuanlityFx.SetData(key, go.transform.Find("Icon/Icon/Effects"), path);
								}
							}
						}
					}
				}
			}
		}

		public void InitGuildInfo()
		{
			base.uiBehaviour.m_GuildLogo.SetSprite("");
			base.uiBehaviour.m_GuildName.SetText("");
			base.uiBehaviour.m_GuildMasterName.SetText("");
			base.uiBehaviour.m_GuildLevel.SetText("0");
			base.uiBehaviour.m_GuildNumber.SetText("0/0");
			base.uiBehaviour.m_GuildContent.SetText("");
			base.uiBehaviour.m_GuildLogo.SetVisible(false);
		}

		public void RefreshGuildInfo(GetOtherGuildBriefRes res)
		{
			bool flag = res.icon == 0u;
			if (flag)
			{
				base.uiBehaviour.m_GuildLogo.SetSprite("");
				base.uiBehaviour.m_GuildLogo.SetVisible(false);
			}
			else
			{
				base.uiBehaviour.m_GuildLogo.SetSprite(XGuildDocument.GetPortraitName((int)res.icon));
				base.uiBehaviour.m_GuildLogo.SetVisible(true);
			}
			base.uiBehaviour.m_GuildName.SetText(res.guildname);
			base.uiBehaviour.m_GuildMasterName.SetText(res.leadername);
			base.uiBehaviour.m_GuildLevel.SetText(res.guildlevel.ToString());
			base.uiBehaviour.m_GuildNumber.SetText(res.currentcount.ToString() + "/" + res.allcount.ToString());
			base.uiBehaviour.m_GuildContent.SetText(res.announcement);
		}

		public void RefreshPetInfo(UnitAppearance data)
		{
			bool flag = !base.IsVisible() || base.uiBehaviour == null || base.uiBehaviour.m_PetLayer == null || !base.uiBehaviour.m_PetLayer.IsVisible();
			if (!flag)
			{
				this.m_PlayerLevel = data.level;
				bool flag2 = base.uiBehaviour.m_InfoPlayerName != null;
				if (flag2)
				{
					base.uiBehaviour.m_InfoPlayerName.SetText(string.Concat(new object[]
					{
						"Lv.",
						this.m_PlayerLevel,
						" ",
						this.m_PlayerName
					}));
				}
				bool flag3 = data.pet == null;
				if (flag3)
				{
					bool flag4 = base.uiBehaviour.m_PetInfo != null;
					if (flag4)
					{
						base.uiBehaviour.m_PetInfo.gameObject.SetActive(false);
					}
					bool flag5 = base.uiBehaviour.m_PetEmpty != null;
					if (flag5)
					{
						base.uiBehaviour.m_PetEmpty.gameObject.SetActive(true);
					}
				}
				else
				{
					XPet xpet = new XPet();
					xpet.Init(data.pet, PetChange.None);
					bool flag6 = base.uiBehaviour.m_PetInfo != null;
					if (flag6)
					{
						base.uiBehaviour.m_PetInfo.gameObject.SetActive(true);
					}
					bool flag7 = base.uiBehaviour.m_PetEmpty != null;
					if (flag7)
					{
						base.uiBehaviour.m_PetEmpty.gameObject.SetActive(false);
					}
					this.m_SkillHandler.Refresh(xpet);
					this.RefreshPetDummy(xpet.ID);
					this.RefreshAttribute(xpet);
				}
			}
		}

		private void RefreshAttribute(XPet pet)
		{
			bool flag = pet == null;
			if (!flag)
			{
				PetInfoTable.RowData petInfo = XPetDocument.GetPetInfo(pet.ID);
				BuffTable.RowData buffData = XSingleton<XBuffTemplateManager>.singleton.GetBuffData((int)petInfo.SpeedBuff, 1);
				bool flag2 = buffData == null || 1201 != (int)buffData.BuffChangeAttribute[0, 0];
				if (flag2)
				{
					XSingleton<XDebug>.singleton.AddErrorLog("Buff No Find XAttr_RUN_SPEED_Percent.\nSp BuffId:" + petInfo.SpeedBuff, null, null, null, null, null);
				}
				else
				{
					base.uiBehaviour.m_SpeedUp.SetText(string.Format("{0}%", (buffData.BuffChangeAttribute[0, 1] + 100f).ToString()));
				}
				DlgBase<XPetMainView, XPetMainBehaviour>.singleton.SetPetSex(base.uiBehaviour.m_PetSex, pet.Sex);
				base.uiBehaviour.m_PetName.SetText(pet.Name);
				base.uiBehaviour.m_PetPPT.SetText(pet.PPT.ToString());
				base.uiBehaviour.m_PetLevel.SetText(string.Format("(Lv.{0})", pet.showLevel.ToString()));
				PetLevelTable.RowData petLevel = XPetDocument.GetPetLevel(pet);
				PetLevelTable.RowData petLevel2 = XPetDocument.GetPetLevel(pet.ID, pet.Level + 1);
				base.uiBehaviour.m_AttributePool.ReturnAll(false);
				int num = 0;
				while ((long)num < (long)((ulong)XPetMainView.ATTRIBUTE_NUM_MAX))
				{
					bool flag3 = num >= petLevel.PetsAttributes.Count;
					if (!flag3)
					{
						GameObject gameObject = base.uiBehaviour.m_AttributePool.FetchGameObject(false);
						int spriteHeight = (gameObject.transform.GetComponent("XUISprite") as IXUISprite).spriteHeight;
						IXUILabel ixuilabel = gameObject.transform.Find("AttributeName").GetComponent("XUILabel") as IXUILabel;
						IXUILabel ixuilabel2 = gameObject.transform.Find("AttributeName/AttributeVal").GetComponent("XUILabel") as IXUILabel;
						IXUILabel ixuilabel3 = gameObject.transform.Find("AttributeName/GrowUp").GetComponent("XUILabel") as IXUILabel;
						gameObject.transform.localPosition = new Vector3(0f, (float)(-(float)spriteHeight * num), 0f);
						string attrStr = XAttributeCommon.GetAttrStr((int)petLevel.PetsAttributes[num, 0]);
						ixuilabel.SetText(attrStr);
						uint num2 = 0u;
						for (int i = 1; i <= pet.Level; i++)
						{
							PetLevelTable.RowData petLevel3 = XPetDocument.GetPetLevel(pet.ID, i);
							num2 += petLevel3.PetsAttributes[num, 1];
						}
						ixuilabel2.SetText(XAttributeCommon.GetAttrValueStr(petLevel.PetsAttributes[num, 0], num2, false));
						bool flag4 = petLevel2 != null;
						if (flag4)
						{
							ixuilabel3.SetText(string.Format("+{0}", petLevel2.PetsAttributes[num, 1].ToString()));
						}
						else
						{
							ixuilabel3.SetText("");
						}
					}
					num++;
				}
			}
		}

		public void RefreshPetDummy(uint petID)
		{
			bool flag = petID > 0u;
			if (flag)
			{
				this.lastPetID = petID;
			}
			this._PlayerDummy = XSingleton<X3DAvatarMgr>.singleton.CreateCommonEntityDummy(this.m_dummPool, XPetDocument.GetPresentID(this.lastPetID), this.m_uiBehaviour.m_CurrentSnapshot, this._PlayerDummy, 1f);
			DlgBase<XPetMainView, XPetMainBehaviour>.singleton.PetActionChange(XPetActionFile.IDLE, this.lastPetID, this._PlayerDummy, false);
		}

		public void RefreshPlayerInfo(UnitAppearance data)
		{
			this._FillCharacterInfoFrame(data);
		}

		public void RefreshSpriteInfo(uint level, List<SpriteInfo> list, UnitAppearance data)
		{
			bool flag = !base.IsVisible() || !base.uiBehaviour.m_SpriteLayer.IsVisible();
			if (!flag)
			{
				this.m_PlayerLevel = level;
				base.uiBehaviour.m_InfoPlayerName.SetText(string.Concat(new object[]
				{
					"Lv.",
					this.m_PlayerLevel,
					" ",
					this.m_PlayerName
				}));
				bool flag2 = list.Count != 4;
				if (flag2)
				{
					XSingleton<XDebug>.singleton.AddErrorLog("Get OtherPlayerInfo 's SpriteInfo 's cout is not 4.", null, null, null, null, null);
				}
				else
				{
					bool flag3 = false;
					for (int i = 0; i < 4; i++)
					{
						bool flag4 = list[i] == null || list[i].SpriteID == 0u;
						if (flag4)
						{
							this._SpriteAvatarHandler[i].SetSpriteInfo(null, null, 0, false, true);
							this._SpriteAvatarHandler[i].HideAvatar();
						}
						else
						{
							flag3 = true;
							XAttributes attrByUnitAppearance = this.GetAttrByUnitAppearance(data);
							this._SpriteAvatarHandler[i].SetSpriteInfo(list[i], attrByUnitAppearance, i + 7, true, true);
						}
					}
					base.uiBehaviour.m_SpriteLayer.gameObject.transform.Find("Empty").gameObject.SetActive(!flag3);
				}
			}
		}

		public void ShowTab(Player_Info type, ulong param1 = 0UL, ulong param2 = 0UL)
		{
			base.uiBehaviour.m_MenuPanel.SetVisible(false);
			base.uiBehaviour.m_InfoPanel.SetVisible(true);
			int num = XFastEnumIntEqualityComparer<Player_Info>.ToInt(type) - 1;
			bool flag = num < this.m_InfoCheck.Count;
			if (flag)
			{
				this.m_InfoCheck[num].bChecked = true;
				this.InitContentArea(type, param1, param2);
			}
		}

		public bool ShowDetailInfo(IXUIButton sp)
		{
			this.ShowTab(Player_Info.Equip, 0UL, 0UL);
			return true;
		}

		public bool AddFriend(IXUIButton sp)
		{
			base.uiBehaviour.m_MenuPanel.SetVisible(false);
			DlgBase<XOtherPlayerInfoView, XOtherPlayerInfoBehaviour>.singleton.SetVisibleWithAnimation(false, null);
			DlgBase<XFriendsView, XFriendsBehaviour>.singleton.AddFriendById(this.m_PlayerId);
			return true;
		}

		public bool RemoveFriend(IXUIButton sp)
		{
			base.uiBehaviour.m_MenuPanel.SetVisible(false);
			DlgBase<XOtherPlayerInfoView, XOtherPlayerInfoBehaviour>.singleton.SetVisibleWithAnimation(false, null);
			DlgBase<XFriendsView, XFriendsBehaviour>.singleton.RemoveFriend(this.m_PlayerId);
			return true;
		}

		public bool SendFlower(IXUIButton sp)
		{
			base.uiBehaviour.m_MenuPanel.SetVisible(false);
			DlgBase<XOtherPlayerInfoView, XOtherPlayerInfoBehaviour>.singleton.SetVisibleWithAnimation(false, null);
			DlgBase<XFlowerSendView, XFlowerSendBehaviour>.singleton.ShowBoard(this.m_PlayerId, this.m_PlayerName);
			return true;
		}

		public bool PrivateChat(IXUIButton sp)
		{
			bool flag = sp != null;
			if (flag)
			{
				base.uiBehaviour.m_MenuPanel.SetVisible(false);
				DlgBase<XOtherPlayerInfoView, XOtherPlayerInfoBehaviour>.singleton.SetVisibleWithAnimation(false, null);
			}
			bool flag2 = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsBlock(this.m_PlayerId);
			if (flag2)
			{
				XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("CHAT_BLOCK_2"), "fece00");
			}
			else
			{
				ChatFriendData chatFriendData = new ChatFriendData();
				chatFriendData.name = this.m_PlayerName;
				chatFriendData.roleid = this.m_PlayerId;
				chatFriendData.powerpoint = this.m_PowerPoint;
				chatFriendData.profession = this.m_PlayerProfession;
				chatFriendData.isfriend = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsMyFriend(this.m_PlayerId);
				chatFriendData.msgtime = DateTime.Now;
				chatFriendData.viplevel = 0u;
				chatFriendData.setid = this.m_setid;
				XEntity entity = XSingleton<XEntityMgr>.singleton.GetEntity(this.m_PlayerId);
				bool flag3 = entity != null;
				if (flag3)
				{
					XRoleAttributes xroleAttributes = (XRoleAttributes)entity.Attributes;
					chatFriendData.profession = (uint)xroleAttributes.Profession;
				}
				DlgBase<XChatView, XChatBehaviour>.singleton.PrivateChatTo(chatFriendData);
			}
			return true;
		}

		public void OnClickItemBg(IXUISprite sp)
		{
			int key = (int)sp.ID;
			XItem xitem = null;
			this.m_ItemDic.TryGetValue(key, out xitem);
			bool flag = xitem != null;
			if (flag)
			{
				ItemType type = xitem.Type;
				if (type != ItemType.EQUIP)
				{
					if (type != ItemType.FASHION)
					{
						if (type == ItemType.ARTIFACT)
						{
							XSingleton<TooltipParam>.singleton.BodyBag = this.m_artifactBag;
						}
					}
					else
					{
						XSingleton<TooltipParam>.singleton.FashionOnBody = this.m_FashionBag;
					}
				}
				else
				{
					XSingleton<TooltipParam>.singleton.BodyBag = this.m_EquipBag;
				}
				XSingleton<TooltipParam>.singleton.mainAttributes = this.m_Attributes;
				XSingleton<UiUtility>.singleton.ShowTooltipDialog(xitem, null, sp, false, this.m_PlayerProfession % 10u);
			}
		}

		public bool Block(IXUIButton sp)
		{
			base.uiBehaviour.m_MenuPanel.SetVisible(false);
			DlgBase<XFriendsView, XFriendsBehaviour>.singleton.AddBlockFriend(this.m_PlayerId);
			DlgBase<XOtherPlayerInfoView, XOtherPlayerInfoBehaviour>.singleton.SetVisibleWithAnimation(false, null);
			return true;
		}

		public bool UnBlock(IXUIButton sp)
		{
			base.uiBehaviour.m_MenuPanel.SetVisible(false);
			DlgBase<XFriendsView, XFriendsBehaviour>.singleton.RemoveBlockFriend(this.m_PlayerId);
			DlgBase<XOtherPlayerInfoView, XOtherPlayerInfoBehaviour>.singleton.SetVisibleWithAnimation(false, null);
			return true;
		}

		public void RequirePlayerInfo()
		{
			bool flag = this.m_PlayerId == 0UL;
			if (!flag)
			{
				RpcC2M_GetUnitAppearanceNew rpcC2M_GetUnitAppearanceNew = new RpcC2M_GetUnitAppearanceNew();
				rpcC2M_GetUnitAppearanceNew.oArg.roleid = this.m_PlayerId;
				rpcC2M_GetUnitAppearanceNew.oArg.mask = 558063;
				rpcC2M_GetUnitAppearanceNew.oArg.type = 2u;
				XSingleton<XClientNetwork>.singleton.Send(rpcC2M_GetUnitAppearanceNew);
			}
		}

		public void RequireSpriteInfo()
		{
			bool flag = this.m_PlayerId == 0UL;
			if (!flag)
			{
				RpcC2M_GetUnitAppearanceNew rpcC2M_GetUnitAppearanceNew = new RpcC2M_GetUnitAppearanceNew();
				rpcC2M_GetUnitAppearanceNew.oArg.roleid = this.m_PlayerId;
				rpcC2M_GetUnitAppearanceNew.oArg.mask = 17335023;
				rpcC2M_GetUnitAppearanceNew.oArg.type = 5u;
				XSingleton<XClientNetwork>.singleton.Send(rpcC2M_GetUnitAppearanceNew);
			}
		}

		public void RequirePetInfo(ulong playerId, ulong petUID)
		{
			bool flag = this.m_PlayerId == 0UL;
			if (!flag)
			{
				bool flag2 = this.hasPetInfo;
				if (flag2)
				{
					this.RefreshPetDummy(0u);
				}
				else
				{
					this.hasPetInfo = true;
					bool flag3 = playerId == 0UL;
					if (flag3)
					{
						playerId = this.m_PlayerId;
					}
					RpcC2M_GetUnitAppearanceNew rpcC2M_GetUnitAppearanceNew = new RpcC2M_GetUnitAppearanceNew();
					rpcC2M_GetUnitAppearanceNew.oArg.roleid = playerId;
					rpcC2M_GetUnitAppearanceNew.oArg.mask = XFastEnumIntEqualityComparer<UnitAppearanceField>.ToInt(UnitAppearanceField.UNIT_PETS);
					rpcC2M_GetUnitAppearanceNew.oArg.type = 6u;
					rpcC2M_GetUnitAppearanceNew.oArg.petId = petUID;
					XSingleton<XClientNetwork>.singleton.Send(rpcC2M_GetUnitAppearanceNew);
				}
			}
		}

		public bool ShowPlayerInfo(IXUICheckBox iXUICheckBox)
		{
			Player_Info option = (Player_Info)iXUICheckBox.ID;
			bool bChecked = iXUICheckBox.bChecked;
			if (bChecked)
			{
				this.InitContentArea(option, 0UL, 0UL);
			}
			return true;
		}

		public bool ClickClosePanel(IXUIButton sp)
		{
			this.SetPlayerInfo(0UL, "", new List<uint>(), 0u, 1u);
			this.SetVisible(false, true);
			return true;
		}

		private void SetupSkillFrame()
		{
			int num = 10;
			IXUICheckBox ixuicheckBox = null;
			base.uiBehaviour.m_SkillTabs.ReturnAll(false);
			Vector3 tplPos = base.uiBehaviour.m_SkillTabs.TplPos;
			int num2 = 0;
			int i = (int)this.m_PlayerProfession;
			while (i != 0)
			{
				i /= 10;
				num2++;
			}
			for (int j = 0; j < num2; j++)
			{
				int profID = (int)(this.m_PlayerProfession % (uint)num);
				GameObject gameObject = base.uiBehaviour.m_SkillTabs.FetchGameObject(false);
				gameObject.transform.localPosition = new Vector3(tplPos.x, tplPos.y - (float)(j * base.uiBehaviour.m_SkillTabs.TplHeight));
				IXUILabel ixuilabel = gameObject.transform.Find("TextLabel").GetComponent("XUILabel") as IXUILabel;
				ixuilabel.SetText(XSingleton<XProfessionSkillMgr>.singleton.GetProfName(profID));
				IXUILabel ixuilabel2 = gameObject.transform.Find("SelectedTextLabel").GetComponent("XUILabel") as IXUILabel;
				ixuilabel2.SetText(XSingleton<XProfessionSkillMgr>.singleton.GetProfName(profID));
				IXUICheckBox ixuicheckBox2 = gameObject.GetComponent("XUICheckBox") as IXUICheckBox;
				ixuicheckBox2.ForceSetFlag(false);
				ixuicheckBox2.ID = (ulong)((long)j);
				ixuicheckBox2.RegisterOnCheckEventHandler(new CheckBoxOnCheckEventHandler(this.OnSkillTabsClick));
				bool flag = j == 0;
				if (flag)
				{
					ixuicheckBox = ixuicheckBox2;
				}
				num *= 10;
			}
			ixuicheckBox.bChecked = true;
			this.SetupSkillTree(0);
		}

		private bool OnSkillTabsClick(IXUICheckBox icb)
		{
			bool flag = !icb.bChecked;
			bool result;
			if (flag)
			{
				result = true;
			}
			else
			{
				this.SetupSkillTree((int)icb.ID);
				result = true;
			}
			return result;
		}

		private void SetupSkillTree(int promote)
		{
			base.uiBehaviour.m_SkillScrollView.SetPosition(0f);
			base.uiBehaviour.m_Skills.ReturnAll(false);
			base.uiBehaviour.m_SkillArrow.ReturnAll(false);
			int num = 10;
			for (int i = 0; i < promote; i++)
			{
				num *= 10;
			}
			List<uint> profSkillID = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID((int)(this.m_PlayerProfession % (uint)num));
			int num2 = 0;
			for (int j = 0; j < profSkillID.Count; j++)
			{
				GameObject gameObject = base.uiBehaviour.m_Skills.FetchGameObject(false);
				gameObject.name = string.Format("Skill{0}", ++num2);
				this.SetupSkill(gameObject, profSkillID[j]);
			}
		}

		private void SetupSkill(GameObject go, uint skillID)
		{
			uint num = 0u;
			this._skillLevel.TryGetValue(skillID, out num);
			SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, num);
			uint skillID2 = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(skillConfig.PreSkill, 0u);
			SkillList.RowData skillConfig2 = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID2, 0u);
			int skillMaxLevel = XSingleton<XSkillEffectMgr>.singleton.GetSkillMaxLevel(skillID, 0u);
			SkillTypeEnum skillType = (SkillTypeEnum)skillConfig.SkillType;
			IXUISprite ixuisprite = go.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite;
			IXUISprite ixuisprite2 = go.transform.Find("Icon/P").GetComponent("XUISprite") as IXUISprite;
			IXUILabel ixuilabel = go.transform.Find("Text").GetComponent("XUILabel") as IXUILabel;
			IXUISprite ixuisprite3 = go.transform.Find("Tip").GetComponent("XUISprite") as IXUISprite;
			ixuisprite3.SetVisible(this._bindsSkills.Contains(skillID));
			go.transform.localPosition = new Vector3(base.uiBehaviour.m_Skills.TplPos.x + (float)((int)(skillConfig.XPostion - 1) * base.uiBehaviour.m_Skills.TplWidth), (float)skillConfig.YPostion);
			ixuisprite.SetSprite(skillConfig.Icon, skillConfig.Atlas, false);
			ixuilabel.SetText(num + "/" + skillMaxLevel);
			SkillTypeEnum skillTypeEnum = skillType;
			if (skillTypeEnum != SkillTypeEnum.Skill_Big)
			{
				if (skillTypeEnum != SkillTypeEnum.Skill_Buff)
				{
					ixuisprite2.SetSprite("JN_dk");
				}
				else
				{
					ixuisprite2.SetSprite("JN_dk_buff");
				}
			}
			else
			{
				ixuisprite2.SetSprite("JN_dk_0");
			}
			bool flag = skillConfig2 != null;
			if (flag)
			{
				Vector3 localPosition = go.transform.localPosition;
				Vector3 vector;
				vector= new Vector3(base.uiBehaviour.m_Skills.TplPos.x + (float)((int)(skillConfig2.XPostion - 1) * base.uiBehaviour.m_Skills.TplWidth), (float)skillConfig2.YPostion);
				Vector3 vector2 = (localPosition + vector) / 2f;
				GameObject gameObject = base.uiBehaviour.m_SkillArrow.FetchGameObject(false);
				IXUISprite ixuisprite4 = gameObject.GetComponent("XUISprite") as IXUISprite;
				bool flag2 = skillConfig.XPostion == skillConfig2.XPostion || skillConfig.YPostion == skillConfig2.YPostion;
				if (flag2)
				{
					bool flag3 = skillConfig.XPostion == skillConfig2.XPostion;
					if (flag3)
					{
						ixuisprite4.SetSprite("SkillTree_3");
						ixuisprite4.spriteHeight = (int)((float)(skillConfig2.YPostion - skillConfig.YPostion) - (float)ixuisprite.spriteHeight * 1.5f);
						ixuisprite4.spriteWidth = base.uiBehaviour.m_SkillArrow.TplWidth;
						gameObject.transform.localPosition = vector2;
						gameObject.transform.localScale = new Vector3(1f, 1f);
						gameObject.transform.localRotation = Quaternion.identity;
					}
					else
					{
						ixuisprite4.SetSprite("SkillTree_3");
						int num2 = (skillConfig.XPostion < skillConfig2.XPostion) ? 1 : -1;
						ixuisprite4.spriteHeight = (int)((float)((int)(skillConfig2.XPostion - skillConfig.XPostion) * (num2 * base.uiBehaviour.m_Skills.TplWidth)) - (float)ixuisprite.spriteWidth * 1.5f);
						ixuisprite4.spriteWidth = base.uiBehaviour.m_SkillArrow.TplWidth;
						gameObject.transform.localPosition = vector2;
						gameObject.transform.localScale = new Vector3(1f, 1f);
						gameObject.transform.localRotation = Quaternion.Euler(0f, 0f, (float)(-(float)num2 * 90));
					}
				}
				else
				{
					ixuisprite4.SetSprite("SkillTree_4");
					ixuisprite4.spriteHeight = (int)Math.Abs(localPosition.y - vector.y) - ixuisprite.spriteHeight / 2;
					ixuisprite4.spriteWidth = (int)Math.Abs(localPosition.x - vector.x) - ixuisprite.spriteWidth / 2;
					int num3 = (skillConfig.XPostion < skillConfig2.XPostion) ? 1 : -1;
					gameObject.transform.localPosition = vector2 + new Vector3((float)(ixuisprite.spriteWidth / 2 * -(float)num3), (float)(ixuisprite.spriteHeight / 2));
					gameObject.transform.localScale = new Vector3((float)num3, 1f);
					gameObject.transform.localRotation = Quaternion.identity;
				}
			}
			ixuisprite.SetEnabled(num > 0u);
			ixuisprite2.SetEnabled(num > 0u);
		}
	}
}