From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Scripts/XMainClient/XLevelSealDocument.cs | 625 +++++++++++++++++++++ 1 file changed, 625 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/XLevelSealDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/XLevelSealDocument.cs') 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.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.singleton.GetValue("LevelSealFragmentID")); + } + } + + public new static readonly uint uuID = XSingleton.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.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.singleton.Send(rpc); + } + + public void ReqLevelSealButtonClick() + { + RpcC2G_LevelSealButtonStatus rpc = new RpcC2G_LevelSealButtonStatus(); + XSingleton.singleton.Send(rpc); + } + + public void ReqBuyGift() + { + RpcC2G_LevelSealExchange rpc = new RpcC2G_LevelSealExchange(); + XSingleton.singleton.Send(rpc); + } + + public void ReqGetSelfGift() + { + RpcC2G_GetLevelSealSelfGift rpcC2G_GetLevelSealSelfGift = new RpcC2G_GetLevelSealSelfGift(); + rpcC2G_GetLevelSealSelfGift.oArg.count = (uint)this.CurrentSelfCollectIndex; + XSingleton.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.singleton.Show(XSysDefine.XSys_LevelSeal, false); + } + else + { + bool flag3 = status == 2u; + if (flag3) + { + this.ShowNextLevelSeal(true, Vector3.zero); + this.CreateAndPlayFxFxFirework(); + } + } + } + bool flag4 = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag4) + { + this.RefreshLevelSealTip(); + } + } + + public void ShowNextLevelSeal(bool isRemove, Vector3 pos) + { + DlgBase.singleton.SetVisibleWithAnimation(true, null); + DlgBase.singleton.SetNextSealLabel(this.GetNextSealTitleInfo(isRemove)); + DlgBase.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.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.singleton.SceneType == SceneType.SCENE_HALL; + if (flag3) + { + XSingleton.singleton.AddErrorLog("Table LevelSealType Error: Type = ", this._sealType.ToString(), " No Find!", null, null, null); + } + bool flag4 = XSingleton.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.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 GetLevelSealNewFunction(uint type) + { + Queue queue = new Queue(); + 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.singleton.TimeFormatSince1970((int)this._endTime, XStringDefineProxy.GetString("TIME_FORMAT_MONTHDAYHOUR"), true); + } + + public int GetLeftTime() + { + return (int)XSingleton.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.singleton.IsVisible(); + if (!flag) + { + DlgBase.singleton.RefreshH5ButtonState(XSysDefine.XSys_LevelSeal_Tip, true); + } + } + + public bool IsShowLevelSealIcon() + { + return XSingleton.singleton.XPlayerData.Level >= this._sealLevel && this._sealLevel != 0u && this._status == 0u; + } + + public bool IsInLevelSeal() + { + return XSingleton.singleton.XPlayerData.Level >= this._sealLevel && this._sealLevel > 0u; + } + + public void CreateAndPlayFxFxFirework() + { + bool flag = DlgBase.singleton.uiBehaviour == null || DlgBase.singleton.uiBehaviour.m_FxFirework == null; + if (!flag) + { + XSingleton.singleton.PlayUISound("Audio/UI/zhuanzhi", true, AudioChannel.Action); + this.DestroyFx(this._FxFirework); + this._FxFirework = XSingleton.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_yh", null, true); + this._FxFirework.Play(DlgBase.singleton.uiBehaviour.m_FxFirework.transform, Vector3.zero, Vector3.one, 1f, true, false); + } + } + + public void DestroyFx(XFx fx) + { + bool flag = fx == null; + if (!flag) + { + XSingleton.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; + } + } +} -- cgit v1.1-26-g67d0