From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Scripts/XMainClient/XQualifyingDocument.cs | 791 +++++++++++++++++++++ 1 file changed, 791 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/XQualifyingDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/XQualifyingDocument.cs') diff --git a/Client/Assets/Scripts/XMainClient/XQualifyingDocument.cs b/Client/Assets/Scripts/XMainClient/XQualifyingDocument.cs new file mode 100644 index 00000000..8be63147 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XQualifyingDocument.cs @@ -0,0 +1,791 @@ +using System; +using System.Collections.Generic; +using KKSG; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XQualifyingDocument : XDocComponent + { + public override uint ID + { + get + { + return XQualifyingDocument.uuID; + } + } + + public uint MatchTime + { + get + { + return this._matchTime; + } + } + + public uint CurrentTime + { + get + { + return this._currentTime; + } + } + + public bool IsMatching + { + get + { + return this._isMatching; + } + } + + public uint RankRewardLeftTime + { + get + { + return this._rankRewardLeftTime; + } + } + + public float RewardSignTime + { + get + { + return this._rewardSignTime; + } + } + + public uint MatchTotalCount + { + get + { + return this._matchTotalWin[this.CurrentSelect] + this._matchTotalLose[this.CurrentSelect] + this._matchTotalDraw[this.CurrentSelect]; + } + } + + public uint MatchTotalWin + { + get + { + return this._matchTotalWin[this.CurrentSelect]; + } + } + + public uint MatchTotalDraw + { + get + { + return this._matchTotalDraw[this.CurrentSelect]; + } + } + + public uint MatchTotalLose + { + get + { + return this._matchTotalLose[this.CurrentSelect]; + } + } + + public uint ContinueWin + { + get + { + return this._continueWin; + } + } + + public uint ContinueLose + { + get + { + return this._continueLose; + } + } + + public List ProfessionWin + { + get + { + return this._professionWin; + } + } + + public uint MaxRewardRank + { + get + { + return XQualifyingDocument._maxRewardRank; + } + } + + public uint MatchTotalPercent + { + get + { + bool flag = this.MatchTotalCount == 0u; + uint result; + if (flag) + { + result = 0u; + } + else + { + bool flag2 = this.MatchTotalWin == 0u; + if (flag2) + { + result = 0u; + } + else + { + result = Math.Max(1u, 100u * this.MatchTotalWin / this.MatchTotalCount); + } + } + return result; + } + } + + public uint MatchRank + { + get + { + return this._matchRank[this.CurrentSelect]; + } + } + + public uint WinStreak + { + get + { + return this._winStreak; + } + } + + public uint WinOfPoint + { + get + { + return this._winOfPoint[this.CurrentSelect]; + } + } + + public int LastWinOfPoint + { + get + { + return this._lastWinOfPoint[this.CurrentSelect]; + } + set + { + this._lastWinOfPoint[this.CurrentSelect] = value; + } + } + + public uint LeftFirstRewardCount + { + get + { + return this._leftFirstRewardCount; + } + } + + public List GameRecords + { + get + { + return this._gameRecords; + } + } + + public List GameRecords2V2 + { + get + { + return this._gameRecords2V2; + } + } + + public List PointRewardList + { + get + { + return this._pointRewardList; + } + } + + public List RankRewardList + { + get + { + return this._rankRewardList; + } + } + + public List> RankList + { + get + { + return this._rankList; + } + } + + public bool RedPoint + { + get + { + return this._redPoint; + } + set + { + this._redPoint = value; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("QualifyingDocument"); + + public static readonly int DATACOUNT = 2; + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + private uint _matchTime = 0u; + + private uint _currentTime = 0u; + + private bool _isMatching = false; + + private uint _rankRewardLeftTime = 0u; + + private float _rewardSignTime; + + private uint[] _matchTotalWin = new uint[XQualifyingDocument.DATACOUNT]; + + private uint[] _matchTotalDraw = new uint[XQualifyingDocument.DATACOUNT]; + + private uint[] _matchTotalLose = new uint[XQualifyingDocument.DATACOUNT]; + + private uint _continueWin = 0u; + + private uint _continueLose = 0u; + + private List _professionWin = new List(); + + private uint[] _matchRank = new uint[XQualifyingDocument.DATACOUNT]; + + private static uint _maxRewardRank; + + private uint _winStreak = 0u; + + private uint[] _winOfPoint = new uint[XQualifyingDocument.DATACOUNT]; + + private int[] _lastWinOfPoint = new int[XQualifyingDocument.DATACOUNT]; + + private uint _leftFirstRewardCount = 0u; + + private List _gameRecords = new List(); + + private List _gameRecords2V2 = new List(); + + private float _beginTime = 0f; + + private static PkPointTable _pkPointTable = new PkPointTable(); + + private static PkRankTable _pkRankTable = new PkRankTable(); + + private List _pointRewardList = new List(); + + private List _rankRewardList = new List(); + + private List> _rankList = new List>(); + + public List LastSeasonRankList = new List(); + + private bool _redPoint = false; + + public List PkInfoList = new List(); + + private bool _lastSceneIsQualifying = false; + + public int CurrentSelect = 0; + + public void SetCurrentSys(int num) + { + this.CurrentSelect = num; + bool flag = DlgBase.singleton.IsVisible(); + if (flag) + { + DlgBase.singleton.Refresh(true); + } + } + + public void InitFxNum() + { + for (int i = 0; i < this._lastWinOfPoint.Length; i++) + { + this._lastWinOfPoint[i] = -1000; + } + } + + public static void Execute(OnLoadedCallback callback = null) + { + XQualifyingDocument.AsyncLoader.AddTask("Table/PkPointReward", XQualifyingDocument._pkPointTable, false); + XQualifyingDocument.AsyncLoader.AddTask("Table/PkRankReward", XQualifyingDocument._pkRankTable, false); + XQualifyingDocument.AsyncLoader.Execute(callback); + } + + public override void OnEnterSceneFinally() + { + base.OnEnterSceneFinally(); + DlgBase.singleton.HidePkLoading(); + DlgBase.singleton.HidePkLoading(); + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall && this._lastSceneIsQualifying; + if (flag) + { + this._lastSceneIsQualifying = false; + this.SendQueryPKInfo(); + } + bool flag2 = XSingleton.singleton.SceneType == SceneType.SCENE_PK || XSingleton.singleton.SceneType == SceneType.SCENE_PKTWO; + if (flag2) + { + this._lastSceneIsQualifying = true; + } + bool flag3 = XSingleton.singleton.SceneType == SceneType.SCENE_PKTWO; + if (flag3) + { + XTeamDocument specificDocument = XDocuments.GetSpecificDocument(XTeamDocument.uuID); + bool flag4 = !XSingleton.singleton.bSpectator && !specificDocument.bInTeam; + if (flag4) + { + XSingleton.singleton.CacheUI(XSysDefine.XSys_Qualifying, EXStage.Hall); + } + } + } + + public override void OnLeaveScene() + { + base.OnLeaveScene(); + this._isMatching = false; + } + + public void SendBeginMatch() + { + bool flag = this.CurrentSelect == 0; + if (flag) + { + RpcC2M_PkReqC2M rpcC2M_PkReqC2M = new RpcC2M_PkReqC2M(); + rpcC2M_PkReqC2M.oArg.type = PkReqType.PKREQ_ADDPK; + XSingleton.singleton.Send(rpcC2M_PkReqC2M); + } + else + { + bool isMatching = this.IsMatching; + if (isMatching) + { + RpcC2M_PkReqC2M rpcC2M_PkReqC2M2 = new RpcC2M_PkReqC2M(); + rpcC2M_PkReqC2M2.oArg.type = PkReqType.PKREQ_REMOVEPK; + XSingleton.singleton.Send(rpcC2M_PkReqC2M2); + } + XTeamDocument specificDocument = XDocuments.GetSpecificDocument(XTeamDocument.uuID); + specificDocument.ReqMatchStateChange(KMatchType.KMT_PKTWO, KMatchOp.KMATCH_OP_START, false); + } + } + + public void SendEndMatch() + { + bool flag = this.CurrentSelect == 0; + if (flag) + { + RpcC2M_PkReqC2M rpcC2M_PkReqC2M = new RpcC2M_PkReqC2M(); + rpcC2M_PkReqC2M.oArg.type = PkReqType.PKREQ_REMOVEPK; + XSingleton.singleton.Send(rpcC2M_PkReqC2M); + } + else + { + XTeamDocument specificDocument = XDocuments.GetSpecificDocument(XTeamDocument.uuID); + specificDocument.ReqMatchStateChange(KMatchType.KMT_PKTWO, KMatchOp.KMATCH_OP_STOP, false); + } + } + + public void SendQueryPKInfo() + { + RpcC2M_PkReqC2M rpcC2M_PkReqC2M = new RpcC2M_PkReqC2M(); + rpcC2M_PkReqC2M.oArg.type = PkReqType.PKREQ_ALLINFO; + XSingleton.singleton.Send(rpcC2M_PkReqC2M); + } + + public void SendQueryRankInfo(uint profession) + { + RpcC2M_ClientQueryRankListNtf rpcC2M_ClientQueryRankListNtf = new RpcC2M_ClientQueryRankListNtf(); + bool flag = this.CurrentSelect == 0; + if (flag) + { + rpcC2M_ClientQueryRankListNtf.oArg.RankType = (uint)XFastEnumIntEqualityComparer.ToInt(RankeType.PkRealTimeRank); + } + else + { + rpcC2M_ClientQueryRankListNtf.oArg.RankType = (uint)XFastEnumIntEqualityComparer.ToInt(RankeType.PkRank2v2); + } + rpcC2M_ClientQueryRankListNtf.oArg.TimeStamp = 1u; + rpcC2M_ClientQueryRankListNtf.oArg.profession = profession; + XSingleton.singleton.Send(rpcC2M_ClientQueryRankListNtf); + } + + public void SendFetchPointReward(uint index) + { + RpcC2M_PkReqC2M rpcC2M_PkReqC2M = new RpcC2M_PkReqC2M(); + rpcC2M_PkReqC2M.oArg.type = PkReqType.PKREQ_FETCHPOINTREWARD; + rpcC2M_PkReqC2M.oArg.index = index; + XSingleton.singleton.Send(rpcC2M_PkReqC2M); + } + + public void SetQulifyingRewardCount(PkRecord data) + { + bool flag = data == null; + if (!flag) + { + this._leftFirstRewardCount = data.rewardcounttoday; + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_Qualifying, true); + } + } + + public void SetQualifyingInfo(QueryPkInfoRes oRes) + { + this._matchTotalWin[0] = oRes.info.histweek.win; + this._matchTotalDraw[0] = oRes.info.histweek.draw; + this._matchTotalLose[0] = oRes.info.histweek.lose; + this._matchTotalWin[1] = oRes.info.info2v2.seasondata.win; + this._matchTotalDraw[1] = oRes.info.info2v2.seasondata.draw; + this._matchTotalLose[1] = oRes.info.info2v2.seasondata.lose; + this._matchRank[0] = oRes.rank1v1; + this._matchRank[1] = oRes.rank2v2; + this._winOfPoint[0] = oRes.info.point; + this._winOfPoint[1] = oRes.info.info2v2.point; + this._leftFirstRewardCount = oRes.rewardcount; + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_Qualifying, true); + this._winStreak = oRes.info.histweek.continuewin; + this._rankRewardLeftTime = oRes.rankrewardleftT; + this._rewardSignTime = Time.time; + XQualifyingDocument._maxRewardRank = XQualifyingDocument._pkRankTable.Table[XQualifyingDocument._pkRankTable.Table.Length - 1].rank[1]; + this.RedPoint = false; + this._pointRewardList.Clear(); + for (int i = 0; i < XQualifyingDocument._pkPointTable.Table.Length; i++) + { + PointRewardStatus pointRewardStatus = new PointRewardStatus(); + pointRewardStatus.point = XQualifyingDocument._pkPointTable.Table[i].point; + pointRewardStatus.reward = XQualifyingDocument._pkPointTable.Table[i].reward; + bool flag = i < oRes.info.boxtaken.Count; + if (flag) + { + pointRewardStatus.status = oRes.info.boxtaken[i]; + bool flag2 = oRes.info.boxtaken[i] == 1u; + if (flag2) + { + this.RedPoint = true; + } + } + else + { + pointRewardStatus.status = 0u; + } + this._pointRewardList.Add(pointRewardStatus); + } + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_Qualifying, true); + this._rankRewardList.Clear(); + for (int j = 0; j < XQualifyingDocument._pkRankTable.Table.Length; j++) + { + RankRewardStatus rankRewardStatus = new RankRewardStatus(); + rankRewardStatus.rank = XQualifyingDocument._pkRankTable.Table[j].rank[1]; + rankRewardStatus.reward = XQualifyingDocument._pkRankTable.Table[j].reward; + rankRewardStatus.isRange = (XQualifyingDocument._pkRankTable.Table[j].rank[0] != XQualifyingDocument._pkRankTable.Table[j].rank[1]); + this._rankRewardList.Add(rankRewardStatus); + } + this._gameRecords.Clear(); + for (int k = oRes.info.records.Count - 1; k >= 0; k--) + { + this._gameRecords.Add(oRes.info.records[k]); + } + this.Set2V2BattleRecord(oRes.info.info2v2.recs); + bool flag3 = DlgBase.singleton.IsVisible(); + if (flag3) + { + DlgBase.singleton.Refresh(false); + } + } + + public void Set2V2BattleRecord(List list) + { + this._gameRecords2V2.Clear(); + for (int i = 0; i < list.Count; i++) + { + BattleRecordGameInfo battleRecordGameInfo = new BattleRecordGameInfo(); + for (int j = 0; j < list[i].myside.Count; j++) + { + bool flag = list[i].myside[j].roleid == XSingleton.singleton.XPlayerData.RoleID; + if (flag) + { + battleRecordGameInfo.left.Insert(0, this.GetOnePlayerInfo(list[i].myside[j])); + } + else + { + battleRecordGameInfo.left.Add(this.GetOnePlayerInfo(list[i].myside[j])); + } + } + for (int k = 0; k < list[i].opside.Count; k++) + { + battleRecordGameInfo.right.Add(this.GetOnePlayerInfo(list[i].opside[k])); + } + battleRecordGameInfo.result = (HeroBattleOver)XFastEnumIntEqualityComparer.ToInt(list[i].ret); + battleRecordGameInfo.point2V2 = list[i].cpoint; + this._gameRecords2V2.Add(battleRecordGameInfo); + } + } + + public BattleRecordPlayerInfo GetOnePlayerInfo(PvpRoleBrief data) + { + return new BattleRecordPlayerInfo + { + name = data.rolename, + profression = data.roleprofession, + roleID = data.roleid + }; + } + + public int GetIconIndex(uint point) + { + int result = 0; + for (int i = 0; i < XQualifyingDocument._pkPointTable.Table.Length; i++) + { + bool flag = point > XQualifyingDocument._pkPointTable.Table[i].point; + if (flag) + { + result = XQualifyingDocument._pkPointTable.Table[i].IconIndex; + } + } + return result; + } + + public void SetChallengeRecordInfo(QueryPkInfoRes oRes) + { + this._continueWin = oRes.info.histweek.continuewin; + this._continueLose = oRes.info.histweek.continuelose; + this._professionWin.Clear(); + for (int i = 0; i < oRes.info.prowin.Count; i++) + { + uint num = oRes.info.prowin[i] + oRes.info.prolose[i]; + bool flag = num == 0u; + if (flag) + { + this._professionWin.Add(0u); + } + else + { + bool flag2 = oRes.info.prowin[i] == 0u; + if (flag2) + { + this._professionWin.Add(0u); + } + else + { + this._professionWin.Add(Math.Max(1u, 100u * oRes.info.prowin[i] / num)); + } + } + } + } + + public void SetMatchTime(uint time, bool status) + { + this._matchTime = time; + this._isMatching = status; + this._currentTime = 0u; + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + bool flag2 = !this.IsMatching; + if (flag2) + { + DlgBase.singleton.SetBeginMatchButton(XStringDefineProxy.GetString("BEGIN_MATCH")); + } + else + { + DlgBase.singleton.SetBeginMatchButton(string.Format("{0}...\n{1}", XStringDefineProxy.GetString("MATCHING"), XStringDefineProxy.GetString("LEFT_MATCH_TIME", new object[] + { + this.CurrentTime, + this.MatchTime + }))); + this._beginTime = Time.time; + } + } + } + + public void SetMatchButtonTime() + { + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + this._currentTime = (uint)(Time.time - this._beginTime); + DlgBase.singleton.SetBeginMatchButton(string.Format("{0}...\n{1}", XStringDefineProxy.GetString("MATCHING"), XStringDefineProxy.GetString("LEFT_MATCH_TIME", new object[] + { + this.CurrentTime, + this.MatchTime + }))); + } + } + + public int PointRewardCompare(int reward1, int reward2) + { + int num = (int)this.PointRewardList[reward1].status; + int num2 = (int)this.PointRewardList[reward2].status; + bool flag = num == 2; + if (flag) + { + num = -1; + } + bool flag2 = num2 == 2; + if (flag2) + { + num2 = -1; + } + bool flag3 = num2 == num; + int result; + if (flag3) + { + result = reward1.CompareTo(reward2); + } + else + { + result = num2.CompareTo(num); + } + return result; + } + + public void RefreshPointReward(uint index) + { + this._pointRewardList[(int)index].status = 2u; + this.RedPoint = false; + for (int i = 0; i < XQualifyingDocument._pkPointTable.Table.Length; i++) + { + bool flag = this._pointRewardList[i].status == 1u; + if (flag) + { + this.RedPoint = true; + break; + } + } + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_Qualifying, true); + bool flag2 = !DlgBase.singleton.IsVisible(); + if (!flag2) + { + DlgBase.singleton.uiBehaviour.m_PointRewardRedPoint.gameObject.SetActive(this.RedPoint); + DlgBase.singleton.SetupPointRewardWindow(false); + } + } + + public void OnGetRankInfo(ClientQueryRankListRes oRes, int profession) + { + this._rankList[profession].Clear(); + for (int i = 0; i < oRes.RankList.RankData.Count; i++) + { + QualifyingRankInfo qualifyingRankInfo = new QualifyingRankInfo(); + qualifyingRankInfo.uid = oRes.RankList.RankData[i].RoleId; + qualifyingRankInfo.rank = (uint)(i + 1); + qualifyingRankInfo.level = oRes.RankList.RankData[i].RoleLevel; + qualifyingRankInfo.name = oRes.RankList.RankData[i].RoleName; + qualifyingRankInfo.point = oRes.RankList.RankData[i].pkpoint; + this._rankList[profession].Add(qualifyingRankInfo); + } + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + bool isVisible = DlgBase.singleton.uiBehaviour.m_RankWindow.IsVisible; + if (isVisible) + { + DlgBase.singleton.SetupRankWindow(this.RankList[profession]); + } + } + } + + public void OnGetLastSeasonRankInfo(ClientQueryRankListRes oRes) + { + bool flag = oRes.RankList == null; + if (!flag) + { + this.LastSeasonRankList.Clear(); + for (int i = 0; i < oRes.RankList.RankData.Count; i++) + { + QualifyingRankInfo qualifyingRankInfo = new QualifyingRankInfo(); + qualifyingRankInfo.uid = oRes.RankList.RankData[i].RoleId; + qualifyingRankInfo.rank = (uint)(i + 1); + qualifyingRankInfo.level = oRes.RankList.RankData[i].RoleLevel; + qualifyingRankInfo.name = oRes.RankList.RankData[i].RoleName; + qualifyingRankInfo.point = oRes.RankList.RankData[i].pkpoint; + bool flag2 = oRes.RankList.RankData[i].pkextradata != null; + if (flag2) + { + qualifyingRankInfo.totalNum = oRes.RankList.RankData[i].pkextradata.joincount; + } + this.LastSeasonRankList.Add(qualifyingRankInfo); + } + } + } + + public void SetPkRoleInfo(List otherInfo) + { + this.PkInfoList.Clear(); + int num = -1; + for (int i = 0; i < otherInfo.Count; i++) + { + PkInfo pkInfo = new PkInfo(); + pkInfo.brief = otherInfo[i].rolebrief; + pkInfo.lose = otherInfo[i].pkrec.lose; + pkInfo.point = otherInfo[i].pkrec.point; + pkInfo.records = otherInfo[i].pkrec.records; + pkInfo.win = otherInfo[i].pkrec.win; + bool flag = pkInfo.brief.roleID != XSingleton.singleton.XPlayerData.EntityID; + if (flag) + { + this.PkInfoList.Add(pkInfo); + } + else + { + bool flag2 = i < 2; + if (flag2) + { + num = 1 - i; + } + else + { + num = 5 - i; + } + this.PkInfoList.Insert(0, pkInfo); + } + } + bool flag3 = num != -1 && num < otherInfo.Count; + if (flag3) + { + int num2 = 2; + while (num2 < 4 && num2 < this.PkInfoList.Count) + { + bool flag4 = this.PkInfoList[num2].brief.roleID == otherInfo[num].rolebrief.roleID; + if (flag4) + { + PkInfo item = this.PkInfoList[num2]; + this.PkInfoList.RemoveAt(num2); + this.PkInfoList.Insert(1, item); + break; + } + num2++; + } + } + } + + public static void OnPkHyperLinkClick(string param) + { + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + } + } +} -- cgit v1.1-26-g67d0