diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XTitleDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XTitleDocument.cs | 295 |
1 files changed, 295 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XTitleDocument.cs b/Client/Assets/Scripts/XMainClient/XTitleDocument.cs new file mode 100644 index 00000000..66ba5472 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XTitleDocument.cs @@ -0,0 +1,295 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XTitleDocument : XDocComponent
+ {
+ public TitleDlg TitleView { get; set; }
+
+ public static uint TitleMaxLevel { get; private set; }
+
+ public bool bEnableTitleLevelUp
+ {
+ get
+ {
+ return this.m_enableTitleLevelUp;
+ }
+ set
+ {
+ this.m_enableTitleLevelUp = value;
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Title, true);
+ }
+ }
+
+ public bool bAvaibleTitleIcon
+ {
+ get
+ {
+ return XSingleton<XGameSysMgr>.singleton.IsSystemOpen(XFastEnumIntEqualityComparer<XSysDefine>.ToInt(XSysDefine.XSys_Title));
+ }
+ }
+
+ public override uint ID
+ {
+ get
+ {
+ return XTitleDocument.uuID;
+ }
+ }
+
+ public uint CurrentTitleID
+ {
+ get
+ {
+ return XSingleton<XAttributeMgr>.singleton.XPlayerData.TitleID;
+ }
+ }
+
+ public TitleTable.RowData CurrentTitle
+ {
+ get
+ {
+ return XTitleDocument.GetTitle(this.CurrentTitleID);
+ }
+ }
+
+ public bool IsMax
+ {
+ get
+ {
+ return XTitleDocument.TitleMaxLevel <= this.CurrentTitleID;
+ }
+ }
+
+ public TitleTable.RowData NextTitle
+ {
+ get
+ {
+ bool flag = this.CurrentTitleID >= XTitleDocument.TitleMaxLevel;
+ TitleTable.RowData result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ result = XTitleDocument.GetTitle(this.CurrentTitleID + 1u);
+ }
+ return result;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("XTitleDocument");
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private static TitleTable m_TitleTable = new TitleTable();
+
+ public static int TITLE_FRAME_RATE = 10;
+
+ private static Dictionary<uint, Dictionary<uint, TitleTable.RowData>> m_cacheTitles = new Dictionary<uint, Dictionary<uint, TitleTable.RowData>>();
+
+ private bool m_enableTitleLevelUp = false;
+
+ public static string GetTitleWithFormat(uint titleID, string name)
+ {
+ string text = name;
+ bool flag = titleID > 0u;
+ if (flag)
+ {
+ TitleTable.RowData title = XTitleDocument.GetTitle(titleID);
+ bool flag2 = title != null;
+ if (flag2)
+ {
+ text = XSingleton<XCommon>.singleton.StringCombine(XLabelSymbolHelper.FormatAnimation(title.RankAtlas, title.RankIcon, 10), text);
+ }
+ }
+ return text;
+ }
+
+ public static TitleTable.RowData GetTitle(uint titleID)
+ {
+ Dictionary<uint, TitleTable.RowData> dictionary;
+ bool flag = XTitleDocument.m_cacheTitles.TryGetValue(XItemDrawerParam.DefaultProfession, out dictionary);
+ if (flag)
+ {
+ TitleTable.RowData result;
+ bool flag2 = dictionary.TryGetValue(titleID, out result);
+ if (flag2)
+ {
+ return result;
+ }
+ }
+ return null;
+ }
+
+ public bool TryGetTitle(uint titleID, out TitleTable.RowData rowData)
+ {
+ rowData = XTitleDocument.GetTitle(titleID);
+ return rowData != null;
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ }
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XTitleDocument.AsyncLoader.AddTask("Table/TitleTable", XTitleDocument.m_TitleTable, false);
+ XTitleDocument.AsyncLoader.Execute(callback);
+ XTitleDocument.m_cacheTitles.Clear();
+ }
+
+ public static void OnTableLoaded()
+ {
+ int i = 0;
+ int num = XTitleDocument.m_TitleTable.Table.Length;
+ while (i < num)
+ {
+ Dictionary<uint, TitleTable.RowData> dictionary;
+ bool flag = !XTitleDocument.m_cacheTitles.TryGetValue(XTitleDocument.m_TitleTable.Table[i].BasicProfession, out dictionary);
+ if (flag)
+ {
+ dictionary = new Dictionary<uint, TitleTable.RowData>();
+ XTitleDocument.m_cacheTitles.Add(XTitleDocument.m_TitleTable.Table[i].BasicProfession, dictionary);
+ }
+ dictionary.Add(XTitleDocument.m_TitleTable.Table[i].RankID, XTitleDocument.m_TitleTable.Table[i]);
+ XTitleDocument.TitleMaxLevel = Math.Max(XTitleDocument.m_TitleTable.Table[i].RankID, XTitleDocument.TitleMaxLevel);
+ i++;
+ }
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ base.RegisterEvent(XEventDefine.XEvent_VirtualItemChanged, new XComponent.XEventHandler(this.OnVirtualItemChanged));
+ base.RegisterEvent(XEventDefine.XEvent_ItemChangeFinished, new XComponent.XEventHandler(this.OnVirtualItemChanged));
+ base.RegisterEvent(XEventDefine.XEvent_AttributeChange, new XComponent.XEventHandler(this.OnAttributeChange));
+ }
+
+ private bool OnAttributeChange(XEventArgs e)
+ {
+ bool flag = !this.bAvaibleTitleIcon;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XAttrChangeEventArgs xattrChangeEventArgs = e as XAttrChangeEventArgs;
+ bool flag2 = xattrChangeEventArgs.AttrKey == XAttributeDefine.XAttr_POWER_POINT_Basic;
+ if (flag2)
+ {
+ this.RefreshTitleLevelUp();
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ private bool OnVirtualItemChanged(XEventArgs args)
+ {
+ bool flag = !this.bAvaibleTitleIcon;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ this.RefreshTitleLevelUp();
+ result = true;
+ }
+ return result;
+ }
+
+ public void RefreshTitleLevelUp()
+ {
+ TitleTable.RowData nextTitle = this.NextTitle;
+ bool bEnableTitleLevelUp = true;
+ bool flag = nextTitle == null || nextTitle.NeedPowerPoint > XSingleton<XAttributeMgr>.singleton.XPlayerData.GetAttr(XAttributeDefine.XAttr_POWER_POINT_Basic);
+ if (flag)
+ {
+ bEnableTitleLevelUp = false;
+ }
+ else
+ {
+ int i = 0;
+ int count = nextTitle.NeedItem.Count;
+ while (i < count)
+ {
+ int num = (int)XBagDocument.BagDoc.GetItemCount((int)nextTitle.NeedItem[i, 0]);
+ bool flag2 = (long)num < (long)((ulong)nextTitle.NeedItem[i, 1]);
+ if (flag2)
+ {
+ bEnableTitleLevelUp = false;
+ break;
+ }
+ i++;
+ }
+ }
+ this.bEnableTitleLevelUp = bEnableTitleLevelUp;
+ bool flag3 = this.TitleView != null && this.TitleView.IsVisible();
+ if (flag3)
+ {
+ this.TitleView.Refresh();
+ }
+ }
+
+ public void GetTitleLevelUp()
+ {
+ bool flag = !this.bEnableTitleLevelUp;
+ if (!flag)
+ {
+ RpcC2G_TitleLevelUp rpc = new RpcC2G_TitleLevelUp();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+ }
+
+ public void OnGetTitleLevelUp(TitleLevelUpRes oRes)
+ {
+ bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errorcode, "fece00");
+ }
+ else
+ {
+ XSingleton<XAttributeMgr>.singleton.XPlayerData.TitleID = oRes.titleID;
+ XTitleInfoChange @event = XEventPool<XTitleInfoChange>.GetEvent();
+ @event.Firer = XSingleton<XEntityMgr>.singleton.Player;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ this.RefreshTitleLevelUp();
+ bool flag2 = oRes.titleID > 0u && !DlgBase<TitleShareDlg, TitleShareBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<TitleShareDlg, TitleShareBehaviour>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ }
+ }
+
+ public void TitleLevelChange(uint titleID)
+ {
+ bool flag = XSingleton<XAttributeMgr>.singleton.XPlayerData.TitleID != titleID;
+ if (flag)
+ {
+ XSingleton<XAttributeMgr>.singleton.XPlayerData.TitleID = titleID;
+ XTitleInfoChange @event = XEventPool<XTitleInfoChange>.GetEvent();
+ @event.Firer = XSingleton<XEntityMgr>.singleton.Player;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ this.RefreshTitleLevelUp();
+ bool flag2 = titleID > 0u && !DlgBase<TitleShareDlg, TitleShareBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<TitleShareDlg, TitleShareBehaviour>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ }
+ }
+ }
+}
|