From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Scripts/XMainClient/XFlowerRankDocument.cs | 497 +++++++++++++++++++++ 1 file changed, 497 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/XFlowerRankDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/XFlowerRankDocument.cs') diff --git a/Client/Assets/Scripts/XMainClient/XFlowerRankDocument.cs b/Client/Assets/Scripts/XMainClient/XFlowerRankDocument.cs new file mode 100644 index 00000000..7d43cf47 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XFlowerRankDocument.cs @@ -0,0 +1,497 @@ +using System; +using System.Collections.Generic; +using KKSG; +using UnityEngine; +using XMainClient.UI; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XFlowerRankDocument : XDocComponent + { + public override uint ID + { + get + { + return XFlowerRankDocument.uuID; + } + } + + public bool CanGetAward + { + get + { + return this._canGetAward; + } + set + { + this._canGetAward = value; + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_FlowerRank, true); + bool flag = this.View != null; + if (flag) + { + this.View.RefreshRedPoint(); + } + } + } + + public bool CanGetActivityAward + { + get + { + return this._canGetActivityAward; + } + set + { + this._canGetActivityAward = value; + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_FlowerRank, true); + bool flag = this.View != null; + if (flag) + { + this.View.RefreshRedPoint(); + } + } + } + + public XFlowerRankHandler View { get; set; } + + public XFlowerAwardListInfo AwardListInfo + { + get + { + return this._awardListInfo; + } + } + + public ShowFlowerPageRes FlowerPageData + { + get + { + return this._myFlowerPageData; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("FlowerRankDocument"); + + public static readonly uint INVALID_RANK = uint.MaxValue; + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + private static FlowerRankRewardTable _flowerRankRewardTable = new FlowerRankRewardTable(); + + private static FlowerWeekRankReward _flowerWeekRankRewardTable = new FlowerWeekRankReward(); + + private bool _canGetAward = false; + + private bool _canGetActivityAward = false; + + public XRankType currentSelectRankTab = XRankType.FlowerTodayRank; + + public uint currentSelectIndex = 0u; + + private XFlowerAwardListInfo _awardListInfo; + + private XBaseRankList _todayRankList; + + private XBaseRankList _yesterdayRankList; + + private XBaseRankList _historyRankList; + + private XBaseRankList _weekRankList; + + private XBaseRankList _activityRankList; + + private List _awardList; + + private ShowFlowerPageRes _myFlowerPageData = null; + + private Dictionary _rankDic = new Dictionary(default(XFastEnumIntEqualityComparer)); + + private float _lastTime = 0f; + + private uint _recordTime = 0u; + + private uint _secondStageTimeStart = 0u; + + public static void Execute(OnLoadedCallback callback = null) + { + XFlowerRankDocument.AsyncLoader.AddTask("Table/FlowerRankReward", XFlowerRankDocument._flowerRankRewardTable, false); + XFlowerRankDocument.AsyncLoader.AddTask("Table/FlowerWeekRankReward", XFlowerRankDocument._flowerWeekRankRewardTable, false); + XFlowerRankDocument.AsyncLoader.Execute(callback); + } + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._todayRankList = new XFlowerRankNormalList(); + this._weekRankList = new XFlowerRankNormalList(); + this._yesterdayRankList = new XFlowerRankNormalList(); + this._historyRankList = new XFlowerRankNormalList(); + this._activityRankList = new XFlowerRankActivityList(); + this._awardListInfo = new XFlowerAwardListInfo(); + this._rankDic.Clear(); + this._rankDic.Add(XRankType.FlowerTodayRank, this._todayRankList); + this._rankDic.Add(XRankType.FlowerYesterdayRank, this._yesterdayRankList); + this._rankDic.Add(XRankType.FlowerHistoryRank, this._historyRankList); + this._rankDic.Add(XRankType.FlowerWeekRank, this._weekRankList); + this._rankDic.Add(XRankType.FlowerActivityRank, this._activityRankList); + } + + public XBaseRankList GetRankList(XRankType type) + { + XBaseRankList xbaseRankList; + bool flag = this._rankDic.TryGetValue(type, out xbaseRankList); + XBaseRankList result; + if (flag) + { + result = xbaseRankList; + } + else + { + result = null; + } + return result; + } + + public void SelectItem(uint index, bool refresh = false) + { + this.currentSelectIndex = index; + XBaseRankList rankList = this.GetRankList(this.currentSelectRankTab); + bool flag = rankList != null; + if (flag) + { + bool flag2 = (ulong)index < (ulong)((long)rankList.rankList.Count); + if (flag2) + { + XBaseRankInfo xbaseRankInfo = rankList.rankList[(int)index]; + this.View.RefreshCharacterInfo(xbaseRankInfo, index); + this.ReqUnitAppearance(xbaseRankInfo.id); + } + else + { + XSingleton.singleton.AddLog(string.Format("index out of range. index = {0} while list count = {1}", index, rankList.rankList.Count), null, null, null, null, null, XDebugColor.XDebug_None); + } + } + bool flag3 = this.View != null && this.View.IsVisible() && refresh; + if (flag3) + { + this.View.RefreshRankContent(); + } + } + + public void ReqUnitAppearance(ulong id) + { + RpcC2M_GetUnitAppearanceNew rpcC2M_GetUnitAppearanceNew = new RpcC2M_GetUnitAppearanceNew(); + rpcC2M_GetUnitAppearanceNew.oArg.roleid = id; + rpcC2M_GetUnitAppearanceNew.oArg.type = 3u; + rpcC2M_GetUnitAppearanceNew.oArg.mask = 524495; + XSingleton.singleton.Send(rpcC2M_GetUnitAppearanceNew); + } + + public void OnGetUnitAppearance(GetUnitAppearanceRes oRes) + { + bool flag = oRes.UnitAppearance == null; + if (!flag) + { + bool flag2 = this.View != null && this.View.IsVisible(); + if (flag2) + { + this.View.UpdateCharacterInfo(oRes); + } + } + } + + public void ReqRankList(XRankType type) + { + XBaseRankList rankList = this.GetRankList(type); + bool flag = rankList != null; + if (flag) + { + RpcC2M_ClientQueryRankListNtf rpcC2M_ClientQueryRankListNtf = new RpcC2M_ClientQueryRankListNtf(); + rpcC2M_ClientQueryRankListNtf.oArg.RankType = (uint)XFastEnumIntEqualityComparer.ToInt(XBaseRankList.GetKKSGType(type)); + rpcC2M_ClientQueryRankListNtf.oArg.TimeStamp = rankList.timeStamp; + XSingleton.singleton.Send(rpcC2M_ClientQueryRankListNtf); + } + else + { + XSingleton.singleton.AddErrorLog("Rank type not init: ", type.ToString(), null, null, null, null); + } + } + + public void OnGetRankList(ClientQueryRankListRes oRes) + { + XRankType xtype = XBaseRankList.GetXType((RankeType)oRes.RankType); + bool flag = oRes.ErrorCode == ErrorCode.ERR_SUCCESS; + if (flag) + { + XBaseRankList rankList = this.GetRankList(xtype); + bool flag2 = rankList != null; + if (flag2) + { + rankList.timeStamp = oRes.TimeStamp; + XFlowerRankDocument.ProcessRankListData(oRes.RankList, rankList); + XFlowerRankDocument.ProcessSelfRankData(oRes, rankList); + } + else + { + XSingleton.singleton.AddErrorLog("Rank type not inited: ", xtype.ToString(), null, null, null, null); + } + } + bool flag3 = this.View != null && this.View.IsVisible(); + if (flag3) + { + this.View.RefreshRankWindow(); + } + } + + public static void ProcessRankListData(RankList data, XBaseRankList rank) + { + int num = Math.Max(rank.rankList.Count, data.RankData.Count); + for (int i = rank.rankList.Count; i < num; i++) + { + rank.rankList.Add(rank.CreateNewInfo()); + } + bool flag = data.RankData.Count < rank.rankList.Count; + if (flag) + { + rank.rankList.RemoveRange(data.RankData.Count, rank.rankList.Count - data.RankData.Count); + } + for (int j = 0; j < rank.rankList.Count; j++) + { + XBaseRankInfo xbaseRankInfo = rank.rankList[j]; + xbaseRankInfo.ProcessData(data.RankData[j]); + xbaseRankInfo.rank = (uint)j; + } + } + + public static void ProcessSelfRankData(ClientQueryRankListRes oRes, XBaseRankList rank) + { + bool flag = oRes.RoleRankData != null; + if (flag) + { + rank.myRankInfo = rank.CreateNewInfo(); + rank.myRankInfo.ProcessData(oRes.RoleRankData); + rank.upperBound = oRes.RankAllCount; + bool flag2 = oRes.RankList.RankData.Count > 0 && rank.myRankInfo.name == ""; + if (flag2) + { + rank.myRankInfo.name = XSingleton.singleton.XPlayerData.Name; + rank.myRankInfo.id = XSingleton.singleton.XPlayerData.RoleID; + rank.myRankInfo.rank = XFlowerRankDocument.INVALID_RANK; + } + } + else + { + rank.myRankInfo = null; + } + } + + public void ReqAward() + { + RpcC2G_GetFlowerReward rpc = new RpcC2G_GetFlowerReward(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetAward(GetFlowerRewardArg oArg, GetFlowerRewardRes oRes) + { + bool flag = oRes.errorCode > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.AddErrorLog(XStringDefineProxy.GetString(oRes.errorCode), null, null, null, null, null); + } + this.CanGetAward = false; + this._awardListInfo.canGetAward = false; + bool flag2 = this.View != null && this.View.IsVisible(); + if (flag2) + { + this.View.RefreshAwardInfo(); + } + } + + public void ReqAwardList() + { + RpcC2M_MSGetFlowerRewardList rpc = new RpcC2M_MSGetFlowerRewardList(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetAwardList(NewGetFlowerRewardListArg oArg, NewGetFlowerRewardListRes oRes) + { + bool flag = oRes.errorCode == ErrorCode.ERR_SUCCESS; + if (flag) + { + this._awardListInfo.listCount = this.GetAwardCount(); + this._awardListInfo.canGetAward = oRes.canGetReward; + this._awardListInfo.selfIndex = -1; + this._awardList = oRes.briefList; + for (int i = 0; i < oRes.briefList.Count; i++) + { + bool flag2 = oRes.briefList[i].roleID == XSingleton.singleton.PlayerID; + if (flag2) + { + this._awardListInfo.selfIndex = i; + } + } + } + bool flag3 = this.View != null && this.View.IsVisible(); + if (flag3) + { + this.View.RefreshAwardInfo(); + } + } + + public int GetAwardCount() + { + FlowerRankRewardTable.RowData[] table = XFlowerRankDocument._flowerRankRewardTable.Table; + int num = 0; + for (int i = 0; i < table.Length; i++) + { + bool flag = table[i].reward[0, 0] != 0; + if (flag) + { + num = i; + } + } + FlowerRankRewardTable.RowData rowData = table[num]; + return rowData.rank[1]; + } + + public SeqListRef GetAwardInfo(int index, out uint designationID, bool yesterday) + { + int num = index + 1; + foreach (FlowerRankRewardTable.RowData rowData in XFlowerRankDocument._flowerRankRewardTable.Table) + { + bool flag = rowData.rank[0] <= num && rowData.rank[1] >= num; + if (flag) + { + designationID = (yesterday ? rowData.yesterday : rowData.history); + return rowData.reward; + } + } + designationID = 0u; + return default(SeqListRef); + } + + public int GetActivityAwardCount() + { + FlowerRankRewardTable.RowData[] table = XFlowerRankDocument._flowerRankRewardTable.Table; + int num = 0; + for (int i = 0; i < table.Length; i++) + { + bool flag = table[i].activity[0, 0] != 0; + if (flag) + { + num = i; + } + } + FlowerRankRewardTable.RowData rowData = table[num]; + return rowData.rank[1]; + } + + public SeqListRef GetActivityAwardInfo(int index) + { + int num = index + 1; + foreach (FlowerRankRewardTable.RowData rowData in XFlowerRankDocument._flowerRankRewardTable.Table) + { + bool flag = rowData.rank[0] <= num && rowData.rank[1] >= num; + if (flag) + { + return rowData.activity; + } + } + return default(SeqListRef); + } + + public void ReqMyFlowersInfo() + { + RpcC2M_ShowFlowerPageNew rpcC2M_ShowFlowerPageNew = new RpcC2M_ShowFlowerPageNew(); + rpcC2M_ShowFlowerPageNew.oArg.roleid = XSingleton.singleton.XPlayerData.RoleID; + XSingleton.singleton.Send(rpcC2M_ShowFlowerPageNew); + } + + public void OnGetMyFlowers(ShowFlowerPageRes oRes) + { + this._myFlowerPageData = oRes; + this.View.RefreshMyFlowersPage(); + } + + public static uint GetFlowerCharmPoint(ulong flowerID) + { + string[] andSeparateValue = XSingleton.singleton.GetAndSeparateValue("Flower2Charm", XGlobalConfig.AllSeparators); + uint result = 0u; + for (int i = 0; i < andSeparateValue.Length; i += 2) + { + bool flag = flowerID == ulong.Parse(andSeparateValue[i]); + if (flag) + { + result = uint.Parse(andSeparateValue[i + 1]); + } + } + return result; + } + + public void CanGetAwardNtf() + { + this.CanGetAward = true; + } + + public SeqListRef GetWeekRankAward(int rank = 1) + { + for (int i = 0; i < XFlowerRankDocument._flowerWeekRankRewardTable.Table.Length; i++) + { + FlowerWeekRankReward.RowData rowData = XFlowerRankDocument._flowerWeekRankRewardTable.Table[i]; + bool flag = rank >= rowData.Rank[0] && rank <= rowData.Rank[1]; + if (flag) + { + return rowData.Reward; + } + } + return default(SeqListRef); + } + + public void GetFlowerActivityReward() + { + RpcC2M_GetFlowerActivityReward rpc = new RpcC2M_GetFlowerActivityReward(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetFlowerActivityReward(GetFlowerActivityRewardRes oRes) + { + bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.errorcode, "fece00"); + } + else + { + this.CanGetActivityAward = false; + } + } + + public bool ShowRedPoint() + { + return this._canGetAward || this._canGetActivityAward; + } + + public void RecordActivityPastTime(uint time, SeqListRef timestage) + { + this._lastTime = Time.realtimeSinceStartup; + this._recordTime = time; + bool flag = timestage.count >= 2; + if (flag) + { + this._secondStageTimeStart = (timestage[0, 0] * 60u + timestage[0, 1]) * 60u; + } + } + + public bool IsActivityShowTime() + { + float num = Time.realtimeSinceStartup - this._lastTime; + float num2 = this._recordTime + num; + return num2 > this._secondStageTimeStart; + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + } + } +} -- cgit v1.1-26-g67d0