diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XLevelSealDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XLevelSealDocument.cs | 625 |
1 files changed, 625 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XLevelSealDocument.cs b/Client/Assets/Scripts/XMainClient/XLevelSealDocument.cs new file mode 100644 index 00000000..9576eafb --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XLevelSealDocument.cs @@ -0,0 +1,625 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using UnityEngine;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XLevelSealDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XLevelSealDocument.uuID;
+ }
+ }
+
+ public XLevelSealView View
+ {
+ get
+ {
+ return this._view;
+ }
+ set
+ {
+ this._view = value;
+ }
+ }
+
+ public static XLevelSealDocument Doc
+ {
+ get
+ {
+ return XSingleton<XGame>.singleton.Doc.GetXComponent(XLevelSealDocument.uuID) as XLevelSealDocument;
+ }
+ }
+
+ public float ExpBuff
+ {
+ get
+ {
+ return this._expBuff;
+ }
+ set
+ {
+ this._expBuff = value;
+ }
+ }
+
+ public uint SealType
+ {
+ get
+ {
+ return this._sealType;
+ }
+ set
+ {
+ this._sealType = value;
+ }
+ }
+
+ public uint SealLevel
+ {
+ get
+ {
+ return this._sealLevel;
+ }
+ set
+ {
+ this._sealLevel = value;
+ }
+ }
+
+ public int CurrentSelfCollectIndex
+ {
+ get
+ {
+ return this._currentSelfCollectIndex;
+ }
+ set
+ {
+ this._currentSelfCollectIndex = value;
+ }
+ }
+
+ public uint Status
+ {
+ get
+ {
+ return this._status;
+ }
+ }
+
+ public bool HasRedPoint
+ {
+ get
+ {
+ return this.m_HasRedPoint;
+ }
+ }
+
+ public bool SelfGiftRedPoint
+ {
+ get
+ {
+ return this.m_SelfGiftRedPoint;
+ }
+ }
+
+ public bool RedPoint
+ {
+ get
+ {
+ return this.m_HasRedPoint || this.m_SelfGiftRedPoint;
+ }
+ }
+
+ public int SealMoeny
+ {
+ get
+ {
+ return int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("LevelSealFragmentID"));
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("LevelSealDocument");
+
+ private XLevelSealView _view = null;
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private static LevelSealTypeTable _LevelSealTypeTable = new LevelSealTypeTable();
+
+ private static LevelSealNewFunctionTable _LevelSealNewFunctionTable = new LevelSealNewFunctionTable();
+
+ public static readonly uint REWARD_TIPS_COUNT_MAX = 4u;
+
+ private float _expBuff;
+
+ private uint _sealType = 0u;
+
+ private uint _nextSealLevel;
+
+ private uint _sealLevel = 0u;
+
+ private uint _endTime;
+
+ private uint _killBossCnt;
+
+ private uint _needKillBossCnt;
+
+ private uint _totalCollectCount;
+
+ private uint _selfCollectCount;
+
+ private int _currentSelfCollectIndex;
+
+ private string _UnlockBossName;
+
+ private uint _status;
+
+ private XFx _FxFirework;
+
+ private bool m_HasRedPoint = false;
+
+ private bool m_SelfGiftRedPoint = false;
+
+ public static void GetSealLevelRange(int curLevel, out int min, out int max)
+ {
+ min = 0;
+ max = curLevel;
+ int i = 0;
+ int num = XLevelSealDocument._LevelSealTypeTable.Table.Length;
+ while (i < num)
+ {
+ bool flag = (long)curLevel <= (long)((ulong)XLevelSealDocument._LevelSealTypeTable.Table[i].Level);
+ if (flag)
+ {
+ max = (int)XLevelSealDocument._LevelSealTypeTable.Table[i].Level;
+ bool flag2 = XLevelSealDocument._LevelSealTypeTable.Table[i].Type > 2u;
+ if (flag2)
+ {
+ uint key = XLevelSealDocument._LevelSealTypeTable.Table[i].Type - 2u;
+ LevelSealTypeTable.RowData byType = XLevelSealDocument._LevelSealTypeTable.GetByType(key);
+ min = (int)byType.Level;
+ }
+ else
+ {
+ min = 0;
+ }
+ break;
+ }
+ i++;
+ }
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ bool flag = this._sealLevel == 0u && XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HALL;
+ if (flag)
+ {
+ this.ReqGetLevelSealInfo();
+ }
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ base.RegisterEvent(XEventDefine.XEvent_AddItem, new XComponent.XEventHandler(this.OnAddItem));
+ base.RegisterEvent(XEventDefine.XEvent_RemoveItem, new XComponent.XEventHandler(this.OnRemoveItem));
+ base.RegisterEvent(XEventDefine.XEvent_ItemNumChanged, new XComponent.XEventHandler(this.OnItemNumChanged));
+ base.RegisterEvent(XEventDefine.XEvent_PlayerLevelChange, new XComponent.XEventHandler(this.OnPlayerLevelChange));
+ }
+
+ public bool OnAddItem(XEventArgs args)
+ {
+ XAddItemEventArgs xaddItemEventArgs = args as XAddItemEventArgs;
+ for (int i = 0; i < xaddItemEventArgs.items.Count; i++)
+ {
+ bool flag = xaddItemEventArgs.items[i].itemID == this.SealMoeny;
+ if (flag)
+ {
+ this.RefreshRedPoint(xaddItemEventArgs.items[i].itemCount);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public bool OnRemoveItem(XEventArgs args)
+ {
+ XRemoveItemEventArgs xremoveItemEventArgs = args as XRemoveItemEventArgs;
+ for (int i = 0; i < xremoveItemEventArgs.types.Count; i++)
+ {
+ bool flag = xremoveItemEventArgs.ids[i] == this.SealMoeny;
+ if (flag)
+ {
+ this.RefreshRedPoint(0);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public bool OnItemNumChanged(XEventArgs args)
+ {
+ XItemNumChangedEventArgs xitemNumChangedEventArgs = args as XItemNumChangedEventArgs;
+ bool flag = xitemNumChangedEventArgs.item.itemID == this.SealMoeny;
+ bool result;
+ if (flag)
+ {
+ this.RefreshRedPoint(xitemNumChangedEventArgs.item.itemCount);
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ return result;
+ }
+
+ public override void Update(float fDeltaT)
+ {
+ base.Update(fDeltaT);
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ bool flag = this._sealLevel == 0u;
+ if (flag)
+ {
+ this.ReqGetLevelSealInfo();
+ }
+ }
+
+ public int GetSealLevel(uint type)
+ {
+ bool flag = type < 1u;
+ int result;
+ if (flag)
+ {
+ result = 0;
+ }
+ else
+ {
+ LevelSealTypeTable.RowData byType = XLevelSealDocument._LevelSealTypeTable.GetByType(type);
+ result = (int)((byType == null) ? uint.MaxValue : byType.Level);
+ }
+ return result;
+ }
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XLevelSealDocument.AsyncLoader.AddTask("Table/LevelSealType", XLevelSealDocument._LevelSealTypeTable, false);
+ XLevelSealDocument.AsyncLoader.AddTask("Table/LevelSealNewFunction", XLevelSealDocument._LevelSealNewFunctionTable, false);
+ XLevelSealDocument.AsyncLoader.Execute(callback);
+ }
+
+ public void ReqGetLevelSealInfo()
+ {
+ RpcC2G_GetLevelSealInfo rpc = new RpcC2G_GetLevelSealInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void ReqLevelSealButtonClick()
+ {
+ RpcC2G_LevelSealButtonStatus rpc = new RpcC2G_LevelSealButtonStatus();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void ReqBuyGift()
+ {
+ RpcC2G_LevelSealExchange rpc = new RpcC2G_LevelSealExchange();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void ReqGetSelfGift()
+ {
+ RpcC2G_GetLevelSealSelfGift rpcC2G_GetLevelSealSelfGift = new RpcC2G_GetLevelSealSelfGift();
+ rpcC2G_GetLevelSealSelfGift.oArg.count = (uint)this.CurrentSelfCollectIndex;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GetLevelSealSelfGift);
+ }
+
+ public void LevelSealButtonClick(LevelSealOverExpArg oArg, LevelSealOverExpRes oRes)
+ {
+ uint status = this._status;
+ this._status = oRes.m_uStatus;
+ bool flag = this._status == 0u;
+ if (flag)
+ {
+ bool flag2 = status == 1u;
+ if (flag2)
+ {
+ this.CreateAndPlayFxFxFirework();
+ DlgBase<XOperatingActivityView, XOperatingActivityBehaviour>.singleton.Show(XSysDefine.XSys_LevelSeal, false);
+ }
+ else
+ {
+ bool flag3 = status == 2u;
+ if (flag3)
+ {
+ this.ShowNextLevelSeal(true, Vector3.zero);
+ this.CreateAndPlayFxFxFirework();
+ }
+ }
+ }
+ bool flag4 = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
+ if (flag4)
+ {
+ this.RefreshLevelSealTip();
+ }
+ }
+
+ public void ShowNextLevelSeal(bool isRemove, Vector3 pos)
+ {
+ DlgBase<NextLevelSealView, NextLevelSealBehaviour>.singleton.SetVisibleWithAnimation(true, null);
+ DlgBase<NextLevelSealView, NextLevelSealBehaviour>.singleton.SetNextSealLabel(this.GetNextSealTitleInfo(isRemove));
+ DlgBase<NextLevelSealView, NextLevelSealBehaviour>.singleton.SetPosition(pos);
+ }
+
+ public void SetShowInfo(GetLevelSealInfoArg oArg, GetLevelSealInfoRes oRes)
+ {
+ this._killBossCnt = oRes.levelSealData.unLockBossCount;
+ this._totalCollectCount = oRes.levelSealData.totalCollectCount;
+ this._selfCollectCount = oRes.levelSealData.selfCollectCount;
+ this._currentSelfCollectIndex = oRes.levelSealData.selfAwardCountIndex + 1;
+ bool flag = this._sealLevel == 0u;
+ if (flag)
+ {
+ this.UseLevelSealInfo(oRes.levelSealData);
+ }
+ bool flag2 = this.View == null || !this.View.IsVisible();
+ if (flag2)
+ {
+ }
+ }
+
+ public void RefreshSelfGift()
+ {
+ LevelSealTypeTable.RowData levelSealType = XLevelSealDocument.GetLevelSealType(this._sealType);
+ string text = XSingleton<XStringTable>.singleton.GetString("RunOutLevelSealSelfCollect");
+ bool flag = this._currentSelfCollectIndex < levelSealType.PlayerAward.Count;
+ if (flag)
+ {
+ uint num = levelSealType.PlayerAward[this._currentSelfCollectIndex, 0];
+ text = string.Format("{0}/{1}", this._selfCollectCount, num);
+ }
+ this.RefreshRedPoint(-1);
+ }
+
+ public void UseLevelSealInfo(PtcG2C_LevelSealNtf roPtc)
+ {
+ this.UseLevelSealInfo(roPtc.Data);
+ }
+
+ public void UseLevelSealInfo(LevelSealInfo data)
+ {
+ this._status = data.status;
+ this._sealType = data.type;
+ this._endTime = data.endTime;
+ this._totalCollectCount = data.totalCollectCount;
+ this._selfCollectCount = data.selfCollectCount;
+ this._currentSelfCollectIndex = data.selfAwardCountIndex + 1;
+ this._sealLevel = 0u;
+ for (int i = 0; i < XLevelSealDocument._LevelSealTypeTable.Table.Length; i++)
+ {
+ LevelSealTypeTable.RowData rowData = XLevelSealDocument._LevelSealTypeTable.Table[i];
+ bool flag = this._sealType == rowData.Type;
+ if (flag)
+ {
+ this._sealLevel = rowData.Level;
+ this._needKillBossCnt = rowData.UnlockBossCount;
+ this._UnlockBossName = rowData.UnlockBossName;
+ bool flag2 = i < XLevelSealDocument._LevelSealTypeTable.Table.Length - 1;
+ if (flag2)
+ {
+ i++;
+ }
+ this._nextSealLevel = XLevelSealDocument._LevelSealTypeTable.Table[i].Level;
+ break;
+ }
+ }
+ bool flag3 = this._sealLevel == 0u && XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HALL;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Table LevelSealType Error: Type = ", this._sealType.ToString(), " No Find!", null, null, null);
+ }
+ bool flag4 = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
+ if (flag4)
+ {
+ this.RefreshLevelSealTip();
+ }
+ this.RefreshRedPoint(-1);
+ }
+
+ public void RefreshRedPoint(int money = -1)
+ {
+ LevelSealTypeTable.RowData levelSealType = XLevelSealDocument.GetLevelSealType(this._sealType);
+ bool flag = levelSealType == null;
+ if (!flag)
+ {
+ uint num = levelSealType.ExchangeInfo[0];
+ bool flag2 = money == -1;
+ if (flag2)
+ {
+ money = (int)XBagDocument.BagDoc.GetItemCount(this.SealMoeny);
+ }
+ this.m_HasRedPoint = ((long)money >= (long)((ulong)num));
+ this.m_SelfGiftRedPoint = this.GetSelfGiftRedPoint();
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_LevelSeal, true);
+ }
+ }
+
+ private bool GetSelfGiftRedPoint()
+ {
+ LevelSealTypeTable.RowData levelSealType = XLevelSealDocument.GetLevelSealType(this._sealType);
+ bool flag = levelSealType == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ int count = levelSealType.CollectAward.Count;
+ bool flag2 = this._currentSelfCollectIndex < levelSealType.PlayerAward.Count;
+ if (flag2)
+ {
+ uint num = levelSealType.PlayerAward[this._currentSelfCollectIndex, 0];
+ result = (num <= this._selfCollectCount);
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ return result;
+ }
+
+ public static LevelSealTypeTable.RowData GetLevelSealType(uint type)
+ {
+ return XLevelSealDocument._LevelSealTypeTable.GetByType(type);
+ }
+
+ public Queue<LevelSealNewFunctionTable.RowData> GetLevelSealNewFunction(uint type)
+ {
+ Queue<LevelSealNewFunctionTable.RowData> queue = new Queue<LevelSealNewFunctionTable.RowData>();
+ for (int i = 0; i < XLevelSealDocument._LevelSealNewFunctionTable.Table.Length; i++)
+ {
+ LevelSealNewFunctionTable.RowData rowData = XLevelSealDocument._LevelSealNewFunctionTable.Table[i];
+ bool flag = (ulong)type == (ulong)((long)rowData.Type);
+ if (flag)
+ {
+ queue.Enqueue(rowData);
+ }
+ }
+ return queue;
+ }
+
+ public string GetConditionInfo()
+ {
+ return XSingleton<UiUtility>.singleton.TimeFormatSince1970((int)this._endTime, XStringDefineProxy.GetString("TIME_FORMAT_MONTHDAYHOUR"), true);
+ }
+
+ public int GetLeftTime()
+ {
+ return (int)XSingleton<UiUtility>.singleton.TimeFormatLastTime(this._endTime, true);
+ }
+
+ public string GetNowSealTitleInfo()
+ {
+ return string.Format(XStringDefineProxy.GetString("SEAL_NOW_DESCRIPTION"), this._UnlockBossName);
+ }
+
+ public string GetNextSealTitleInfo(bool isRemove)
+ {
+ string result;
+ if (isRemove)
+ {
+ result = string.Format(XStringDefineProxy.GetString("SEAL_REMOVE_DESCRIPTION"), this._sealLevel);
+ }
+ else
+ {
+ result = string.Format(XStringDefineProxy.GetString("SEAL_NEXT_DESCRIPTION"), this._nextSealLevel);
+ }
+ return result;
+ }
+
+ public void LevelUp(uint curLevel)
+ {
+ bool flag = curLevel >= this._sealLevel && this._sealLevel > 0u;
+ if (flag)
+ {
+ this._status = 1u;
+ this.RefreshLevelSealTip();
+ }
+ }
+
+ public void RefreshLevelSealTip()
+ {
+ bool flag = !DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible();
+ if (!flag)
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_LevelSeal_Tip, true);
+ }
+ }
+
+ public bool IsShowLevelSealIcon()
+ {
+ return XSingleton<XAttributeMgr>.singleton.XPlayerData.Level >= this._sealLevel && this._sealLevel != 0u && this._status == 0u;
+ }
+
+ public bool IsInLevelSeal()
+ {
+ return XSingleton<XAttributeMgr>.singleton.XPlayerData.Level >= this._sealLevel && this._sealLevel > 0u;
+ }
+
+ public void CreateAndPlayFxFxFirework()
+ {
+ bool flag = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.uiBehaviour == null || DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.uiBehaviour.m_FxFirework == null;
+ if (!flag)
+ {
+ XSingleton<XAudioMgr>.singleton.PlayUISound("Audio/UI/zhuanzhi", true, AudioChannel.Action);
+ this.DestroyFx(this._FxFirework);
+ this._FxFirework = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_yh", null, true);
+ this._FxFirework.Play(DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.uiBehaviour.m_FxFirework.transform, Vector3.zero, Vector3.one, 1f, true, false);
+ }
+ }
+
+ public void DestroyFx(XFx fx)
+ {
+ bool flag = fx == null;
+ if (!flag)
+ {
+ XSingleton<XFxMgr>.singleton.DestroyFx(fx, true);
+ fx = null;
+ }
+ }
+
+ public uint GetSealType()
+ {
+ uint result = 1u;
+ for (int i = 0; i < XLevelSealDocument._LevelSealTypeTable.Table.Length; i++)
+ {
+ bool flag = this.SealLevel <= XLevelSealDocument._LevelSealTypeTable.Table[i].Level;
+ if (flag)
+ {
+ result = XLevelSealDocument._LevelSealTypeTable.Table[i].Type;
+ break;
+ }
+ }
+ return result;
+ }
+
+ public uint GetRemoveSealType(uint curlevel)
+ {
+ uint result = 0u;
+ for (int i = 0; i < XLevelSealDocument._LevelSealTypeTable.Table.Length; i++)
+ {
+ bool flag = curlevel >= XLevelSealDocument._LevelSealTypeTable.Table[i].Level;
+ if (!flag)
+ {
+ break;
+ }
+ result = XLevelSealDocument._LevelSealTypeTable.Table[i].Type;
+ }
+ return result;
+ }
+
+ private bool OnPlayerLevelChange(XEventArgs arg)
+ {
+ XPlayerLevelChangedEventArgs xplayerLevelChangedEventArgs = arg as XPlayerLevelChangedEventArgs;
+ this.LevelUp(xplayerLevelChangedEventArgs.level);
+ return true;
+ }
+ }
+}
|