+scripts

1 files changed, 487 insertions, 0 deletions

diff --git a/Client/Assets/Scripts/XMainClient/Guild/XGuildSkillView.cs b/Client/Assets/Scripts/XMainClient/Guild/XGuildSkillView.cs
new file mode 100644
index 00000000..d78f7781
--- /dev/null
+++ b/Client/Assets/Scripts/XMainClient/Guild/XGuildSkillView.cs
@@ -0,0 +1,487 @@
+using System;

+using System.Collections.Generic;

+using UILib;

+using UnityEngine;

+using XMainClient.UI;

+using XMainClient.UI.UICommon;

+using XUtliPoolLib;

+

+namespace XMainClient

+{

+	internal class XGuildSkillView : DlgBase<XGuildSkillView, XGuildSkillBehaviour>

+	{

+		public override int layer

+		{

+			get

+			{

+				return 1;

+			}

+		}

+

+		public override bool pushstack

+		{

+			get

+			{

+				return true;

+			}

+		}

+

+		public override string fileName

+		{

+			get

+			{

+				return "Guild/GuildSystem/GuildSkillDlg";

+			}

+		}

+

+		public override bool hideMainMenu

+		{

+			get

+			{

+				return true;

+			}

+		}

+

+		public override bool autoload

+		{

+			get

+			{

+				return true;

+			}

+		}

+

+		public override bool fullscreenui

+		{

+			get

+			{

+				return true;

+			}

+		}

+

+		public XGuildSkillDocument _doc = null;

+

+		public XGuildSkillStudyHandle _StudyHandle = null;

+

+		private Transform m_studyHandlePanel = null;

+

+		private bool m_showEffect = false;

+

+		protected override void OnLoad()

+		{

+			base.OnLoad();

+			this.m_studyHandlePanel = base.uiBehaviour.transform.Find("Bg");

+			this._StudyHandle = DlgHandlerBase.EnsureCreate<XGuildSkillStudyHandle>(ref this._StudyHandle, this.m_studyHandlePanel, false, this);

+		}

+

+		protected override void OnUnload()

+		{

+			DlgHandlerBase.EnsureUnload<XGuildSkillStudyHandle>(ref this._StudyHandle);

+			base.OnUnload();

+		}

+

+		protected override void Init()

+		{

+			base.Init();

+			this._doc = XDocuments.GetSpecificDocument<XGuildSkillDocument>(XGuildSkillDocument.uuID);

+			this._doc.SKillView = this;

+			this._doc.Player = XSingleton<XAttributeMgr>.singleton.XPlayerData;

+			this._doc.BagDoc = XDocuments.GetSpecificDocument<XBagDocument>(XBagDocument.uuID);

+			this._doc.GuildDoc = XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID);

+		}

+

+		protected override void OnShow()

+		{

+			base.OnShow();

+			this._doc.GetSkillList();

+			this.SetupSkillList(true, false);

+		}

+

+		public override void RegisterEvent()

+		{

+			base.RegisterEvent();

+			base.uiBehaviour.m_Close.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnCloseClick));

+			base.uiBehaviour.m_LevelUp.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnLevelUpClick));

+			base.uiBehaviour.m_DetailUpMaxLevel.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnUpMaxLevelClick));

+		}

+

+		private bool OnCloseClick(IXUIButton button)

+		{

+			this.SetVisibleWithAnimation(false, null);

+			return true;

+		}

+

+		private bool OnUpMaxLevelClick(IXUIButton button)

+		{

+			this._StudyHandle.SetVisible(true);

+			this._StudyHandle.SetDetailInfo();

+			return false;

+		}

+

+		private bool OnLevelUpClick(IXUIButton button)

+		{

+			string empty = string.Empty;

+			uint currentSkillID = this._doc.CurrentSkillID;

+			uint curGuildSkillLevel = this._doc.GetCurGuildSkillLevel(currentSkillID);

+			GuildSkillTable.RowData rowData;

+			bool flag = !this._doc.TryGetGuildSkill(currentSkillID, curGuildSkillLevel, out rowData);

+			bool result;

+			if (flag)

+			{

+				result = false;

+			}

+			else

+			{

+				uint skillMaxLevel = this._doc.GetSkillMaxLevel(currentSkillID);

+				bool flag2 = curGuildSkillLevel < skillMaxLevel;

+				if (flag2)

+				{

+					this._doc.SendLearnGuildSkill();

+				}

+				else

+				{

+					uint num = XGuildDocument.GuildConfig.GetTotalStudyCount((int)rowData.glevel, (int)this._doc.GuildDoc.Level) + this._doc.GetGuildSkillInitLevel(rowData.skillid);

+					bool flag3 = skillMaxLevel < num;

+					if (flag3)

+					{

+						XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("ERR_GUILD_SKILL_STUDY_LEVEL_DOWN"), "fece00");

+					}

+					else

+					{

+						bool flag4 = this._doc.GuildDoc.Level < XGuildDocument.GuildConfig.MaxLevel;

+						if (flag4)

+						{

+							XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("ERR_GUILD_SKILL_GUILD_LEVEL_DOWN"), "fece00");

+						}

+						else

+						{

+							XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("ERR_GUILD_SKILL_LEVEL_FULL"), "fece00");

+						}

+					}

+				}

+				result = true;

+			}

+			return result;

+		}

+

+		private void OnSkillClick(IXUISprite sp)

+		{

+			bool flag = this._doc.CurrentSkillID == (uint)sp.ID;

+			if (!flag)

+			{

+				this._doc.CurrentSkillID = (uint)sp.ID;

+				this.RefreshSkillLight();

+				this.SetupDetailSkill();

+			}

+		}

+

+		public void SetupSkillList(bool refresh = true, bool showEffect = false)

+		{

+			base.uiBehaviour.m_SkillPool.FakeReturnAll();

+			this.m_showEffect = showEffect;

+			List<uint> guildSkillIDs = XGuildSkillDocument.GuildSkillIDs;

+			int num = base.uiBehaviour.m_SkillPool.TplWidth + 30;

+			guildSkillIDs.Sort(new Comparison<uint>(XGuildSkillView.SkillSortCompare));

+			int num2 = 0;

+			for (int i = 0; i < guildSkillIDs.Count; i++)

+			{

+				GameObject gameObject = base.uiBehaviour.m_SkillPool.FetchGameObject(false);

+				gameObject.name = string.Format("Skill{0}", ++num2);

+				this.SetupSkill(gameObject, guildSkillIDs[i]);

+				gameObject.transform.localPosition = base.uiBehaviour.m_SkillPool.TplPos + new Vector3((float)(i % 2 * base.uiBehaviour.m_SkillPool.TplWidth), (float)(-(float)i / 2 * base.uiBehaviour.m_SkillPool.TplHeight));

+			}

+			base.uiBehaviour.m_SkillPool.ActualReturnAll(false);

+			if (refresh)

+			{

+				this._doc.CurrentSkillID = guildSkillIDs[0];

+				base.uiBehaviour.m_SkillScroll.ResetPosition();

+			}

+			this.RefreshSkillLight();

+			this.SetupDetailSkill();

+			this.RefreshGuildPoint();

+		}

+

+		private void SetupSkill(GameObject go, uint skillID)

+		{

+			uint level = this._doc.GuildDoc.BasicData.level;

+			uint curGuildSkillLevel = this._doc.GetCurGuildSkillLevel(skillID);

+			GuildSkillTable.RowData rowData;

+			bool flag = !this._doc.TryGetGuildSkill(skillID, curGuildSkillLevel, out rowData);

+			if (!flag)

+			{

+				uint glevel = rowData.glevel;

+				uint skillMaxLevel = this._doc.GetSkillMaxLevel(skillID);

+				IXUISprite ixuisprite = go.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite;

+				IXUILabel ixuilabel = go.transform.Find("Name").GetComponent("XUILabel") as IXUILabel;

+				IXUILabel ixuilabel2 = go.transform.Find("Level").GetComponent("XUILabel") as IXUILabel;

+				IXUILabel ixuilabel3 = go.transform.Find("Attr").GetComponent("XUILabel") as IXUILabel;

+				Transform transform = go.transform.Find("Light");

+				IXUISprite ixuisprite2 = go.GetComponent("XUISprite") as IXUISprite;

+				Transform transform2 = go.transform.Find("RedPoint");

+				IXUISprite ixuisprite3 = go.transform.Find("Bg").GetComponent("XUISprite") as IXUISprite;

+				IXUILabel ixuilabel4 = go.transform.Find("LevelText").GetComponent("XUILabel") as IXUILabel;

+				IXUILabel ixuilabel5 = go.transform.Find("GuildLevel").GetComponent("XUILabel") as IXUILabel;

+				IXUISprite ixuisprite4 = go.transform.Find("Profecssion").GetComponent("XUISprite") as IXUISprite;

+				ixuilabel5.SetText(XStringDefineProxy.GetString("OPEN_AT_GUILD_LEVEL", new object[]

+				{

+					glevel

+				}));

+				bool flag2 = false;

+				bool flag3 = rowData.needtype == 2u;

+				if (flag3)

+				{

+					flag2 = true;

+				}

+				else

+				{

+					bool flag4 = rowData.profecssion != null;

+					if (flag4)

+					{

+						int i = 0;

+						int num = rowData.profecssion.Length;

+						while (i < num)

+						{

+							bool flag5 = XBagDocument.IsProfMatched(rowData.profecssion[i]);

+							if (flag5)

+							{

+								flag2 = true;

+								break;

+							}

+							i++;

+						}

+					}

+				}

+				ixuisprite4.SetVisible(flag2);

+				bool flag6 = flag2;

+				if (flag6)

+				{

+					bool flag7 = rowData.needtype == 2u;

+					if (flag7)

+					{

+						ixuisprite4.SetSprite("icon_yjs", "Social/Guild", false);

+					}

+					else

+					{

+						ixuisprite4.SetSprite("Recharge_tj", "ReCharge/ReCharge", false);

+					}

+				}

+				bool flag8 = curGuildSkillLevel == 0u;

+				if (flag8)

+				{

+					ixuisprite3.SetEnabled(false);

+					ixuisprite.SetEnabled(false);

+					ixuilabel.SetEnabled(false);

+					ixuilabel2.SetEnabled(false);

+					ixuilabel3.SetEnabled(false);

+					ixuilabel4.SetEnabled(false);

+				}

+				else

+				{

+					ixuisprite3.SetEnabled(true);

+					ixuisprite.SetEnabled(true);

+					ixuilabel.SetEnabled(true);

+					ixuilabel2.SetEnabled(true);

+					ixuilabel3.SetEnabled(true);

+					ixuilabel4.SetEnabled(true);

+				}

+				bool flag9 = this.m_showEffect && skillID == this._doc.CurrentSkillID;

+				if (flag9)

+				{

+					this.m_showEffect = false;

+					XSingleton<XFxMgr>.singleton.CreateAndPlay("Effects/FX_Particle/UIfx/UI_qianghua_03", ixuisprite.gameObject.transform, Vector3.zero, Vector3.one, 1f, true, 2f, true);

+				}

+				bool flag10 = level < glevel;

+				ixuilabel4.SetVisible(!flag10);

+				ixuilabel2.SetVisible(!flag10);

+				ixuilabel3.SetVisible(!flag10);

+				ixuilabel5.SetVisible(flag10);

+				transform.gameObject.SetActive(false);

+				ixuisprite.SetSprite(rowData.icon, rowData.atlas, false);

+				ixuilabel.SetText(rowData.name);

+				ixuilabel2.SetText(string.Format("{0}/{1}", curGuildSkillLevel.ToString(), skillMaxLevel));

+				ixuilabel3.SetText(string.Format(string.Format(rowData.currentLevelDescription, rowData.attribute[0, 1]), new object[0]));

+				transform2.gameObject.SetActive(false);

+				ixuisprite2.ID = (ulong)skillID;

+				ixuisprite2.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnSkillClick));

+			}

+		}

+

+		public void SetupDetailSkill()

+		{

+			uint currentSkillID = this._doc.CurrentSkillID;

+			uint curGuildSkillLevel = this._doc.GetCurGuildSkillLevel(currentSkillID);

+			uint skillMaxLevel = this._doc.GetSkillMaxLevel(currentSkillID);

+			GuildSkillTable.RowData guildSkill = this._doc.GetGuildSkill(currentSkillID, curGuildSkillLevel);

+			GuildSkillTable.RowData guildSkill2 = this._doc.GetGuildSkill(currentSkillID, curGuildSkillLevel + 1u);

+			base.uiBehaviour.m_DetailSkillIcon.SetSprite(guildSkill.icon, guildSkill.atlas, false);

+			base.uiBehaviour.m_DetailSkillName.SetText(guildSkill.name);

+			base.uiBehaviour.m_DetailCurrLevel.SetText(string.Format("{0} {1}", XStringDefineProxy.GetString("XAttr_Level"), curGuildSkillLevel));

+			base.uiBehaviour.m_DetailNextLevel.SetText((curGuildSkillLevel + 1u).ToString());

+			base.uiBehaviour.m_DetailMaxLevel.SetText(skillMaxLevel.ToString());

+			base.uiBehaviour.m_DetailCurrAttr.SetText(string.Format(guildSkill.currentLevelDescription, guildSkill.attribute[0, 1]));

+			base.uiBehaviour.m_DetailNextAttr.SetText(guildSkill2.attribute[0, 1].ToString());

+			base.uiBehaviour.m_RedPoint.gameObject.SetActive(false);

+			string text = "";

+			bool flag = false;

+			bool flag2 = !flag && !this.TryCheckRedGuildLevel(guildSkill, curGuildSkillLevel, out text);

+			if (flag2)

+			{

+				flag = true;

+				base.uiBehaviour.m_DetailSkillName.SetText(guildSkill.name);

+			}

+			else

+			{

+				base.uiBehaviour.m_DetailSkillName.SetText(string.Format("{0}({1}/{2})", guildSkill.name, curGuildSkillLevel, skillMaxLevel));

+			}

+			bool flag3 = !flag && !this.TryCheckRoleLevel(guildSkill, curGuildSkillLevel, out text);

+			if (flag3)

+			{

+			}

+			base.uiBehaviour.m_DetailTip.SetText(text);

+			bool flag4 = this._doc.GuildDoc.IHavePermission(GuildPermission.GPEM_STUDY_SKILL) && guildSkill.needtype == 1u;

+			if (flag4)

+			{

+				base.uiBehaviour.m_DetailUpMaxLevel.SetVisible(true);

+			}

+			else

+			{

+				base.uiBehaviour.m_DetailUpMaxLevel.SetVisible(false);

+			}

+			string text2 = string.Empty;

+			bool flag5 = curGuildSkillLevel < skillMaxLevel;

+			bool flag6;

+			if (flag5)

+			{

+				text2 = XStringDefineProxy.GetString("GUILD_SKILL_UPDATE");

+				flag6 = false;

+			}

+			else

+			{

+				flag6 = true;

+				uint num = XGuildDocument.GuildConfig.GetTotalStudyCount((int)guildSkill.glevel, (int)this._doc.GuildDoc.Level) + this._doc.GetGuildSkillInitLevel(currentSkillID);

+				bool flag7 = skillMaxLevel < num;

+				if (flag7)

+				{

+					text2 = XStringDefineProxy.GetString("GUILD_SKILL_STUDY_LEVEL_DOWN");

+				}

+				else

+				{

+					bool flag8 = this._doc.GuildDoc.Level < XGuildDocument.GuildConfig.MaxLevel;

+					if (flag8)

+					{

+						text2 = XStringDefineProxy.GetString("GUILD_SKILL_GUILD_LEVEL_DOWN");

+					}

+					else

+					{

+						text2 = XStringDefineProxy.GetString("GUILD_SKILL_LEVEL_FULL");

+					}

+				}

+			}

+			base.uiBehaviour.m_LevelUpLabel.SetText(text2);

+			base.uiBehaviour.m_LevelUp.SetGrey(!flag6);

+			bool flag9 = this.TryCheckLevelUpCost(guildSkill, curGuildSkillLevel, out text);

+			if (flag9)

+			{

+				base.uiBehaviour.m_DetailCost.SetVisible(false);

+				base.uiBehaviour.m_DetailCostRed.SetVisible(true);

+				base.uiBehaviour.m_DetailCostRed.InputText = text;

+			}

+			else

+			{

+				base.uiBehaviour.m_DetailCost.SetVisible(true);

+				base.uiBehaviour.m_DetailCostRed.SetVisible(false);

+				base.uiBehaviour.m_DetailCost.InputText = text;

+			}

+		}

+

+		private bool TryCheckFullLevel(GuildSkillTable.RowData currData, uint skillLevel, out string strTemp)

+		{

+			strTemp = string.Empty;

+			uint num = XGuildDocument.GuildConfig.GetTotalStudyCount((int)currData.glevel, (int)this._doc.GuildDoc.Level) + this._doc.GetGuildSkillInitLevel(currData.skillid);

+			bool flag = skillLevel >= num;

+			bool result;

+			if (flag)

+			{

+				strTemp = XStringDefineProxy.GetString("GUILD_SKILL_LEVEL_FULL");

+				result = true;

+			}

+			else

+			{

+				result = false;

+			}

+			return result;

+		}

+

+		private bool TryCheckLevelUpCost(GuildSkillTable.RowData currData, uint skillLevel, out string strTemp)

+		{

+			strTemp = "";

+			uint num = currData.need[0, 1];

+			strTemp = string.Format("{0}{1}", XLabelSymbolHelper.FormatSmallIcon(22), num);

+			return (ulong)num > (ulong)((long)((int)XSingleton<XGame>.singleton.Doc.XBagDoc.GetVirtualItemCount(ItemEnum.GUILD_CONTRIBUTE)));

+		}

+

+		private bool TryCheckRoleLevel(GuildSkillTable.RowData currData, uint skillLevel, out string strTemp)

+		{

+			strTemp = "";

+			bool flag = currData.roleLevel > XSingleton<XAttributeMgr>.singleton.XPlayerData.Level;

+			bool result;

+			if (flag)

+			{

+				strTemp = string.Format("{0}{1}: {2}\n", strTemp, XStringDefineProxy.GetString("NEED_PLAYER_LEVEL"), currData.glevel);

+				result = false;

+			}

+			else

+			{

+				result = true;

+			}

+			return result;

+		}

+

+		private bool TryCheckRedGuildLevel(GuildSkillTable.RowData currData, uint skillLevel, out string strTemp)

+		{

+			uint glevel = currData.glevel;

+			strTemp = "";

+			bool flag = glevel > this._doc.GuildDoc.Level;

+			bool result;

+			if (flag)

+			{

+				strTemp = string.Format("{0}{1}: {2}\n", strTemp, XStringDefineProxy.GetString("NEED_GUILD_LEVEL"), glevel);

+				result = false;

+			}

+			else

+			{

+				result = true;

+			}

+			return result;

+		}

+

+		private void RefreshSkillLight()

+		{

+			List<GameObject> list = ListPool<GameObject>.Get();

+			base.uiBehaviour.m_SkillPool.GetActiveList(list);

+			for (int i = 0; i < list.Count; i++)

+			{

+				IXUISprite ixuisprite = list[i].GetComponent("XUISprite") as IXUISprite;

+				bool flag = ixuisprite.ID == (ulong)this._doc.CurrentSkillID;

+				if (flag)

+				{

+					list[i].transform.Find("Light").gameObject.SetActive(true);

+				}

+				else

+				{

+					list[i].transform.Find("Light").gameObject.SetActive(false);

+				}

+			}

+			ListPool<GameObject>.Release(list);

+		}

+

+		private void RefreshGuildPoint()

+		{

+			base.uiBehaviour.m_GuildPoint.SetText(this._doc.BagDoc.VirtualItems[22].ToString());

+		}

+

+		private static int SkillSortCompare(uint skill1, uint skill2)

+		{

+			return skill1.CompareTo(skill2);

+		}

+	}

+}