diff options
| author | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
|---|---|---|
| committer | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
| commit | 6eb915c129fc90c6f4c82ae097dd6ffad5239efc (patch) | |
| tree | 7dd2be50edf41f36b60fac84696e731c13afe617 /Client/Assets/Scripts/XMainClient/XLevelRewardDocument.cs | |
+scripts
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XLevelRewardDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XLevelRewardDocument.cs | 2473 |
1 files changed, 2473 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XLevelRewardDocument.cs b/Client/Assets/Scripts/XMainClient/XLevelRewardDocument.cs new file mode 100644 index 00000000..4bdbb9b9 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XLevelRewardDocument.cs @@ -0,0 +1,2473 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using UnityEngine;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XLevelRewardDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XLevelRewardDocument.uuID;
+ }
+ }
+
+ public bool RequestServer
+ {
+ get
+ {
+ return this._requestServer;
+ }
+ set
+ {
+ this._requestServer = value;
+ }
+ }
+
+ public uint Rank
+ {
+ get
+ {
+ return this.GetRankByBit(this._rank);
+ }
+ }
+
+ public uint FirstStars { get; set; }
+
+ public SceneType CurrentStage
+ {
+ get
+ {
+ return XSingleton<XScene>.singleton.SceneType;
+ }
+ }
+
+ public uint CurrentScene
+ {
+ get
+ {
+ return XSingleton<XScene>.singleton.SceneID;
+ }
+ }
+
+ public SceneTable.RowData CurrentSceneData
+ {
+ get
+ {
+ return this._current_scene_data;
+ }
+ }
+
+ public int LevelFinishTime { get; set; }
+
+ public uint LevelFinishHp { get; set; }
+
+ public bool CanPeerBox
+ {
+ get
+ {
+ bool flag = this.CurrentSceneData == null;
+ return !flag && this.CurrentSceneData.PeerBox[0] > 0u;
+ }
+ }
+
+ public uint PeerBoxCost
+ {
+ get
+ {
+ bool flag = this.CurrentSceneData == null;
+ uint result;
+ if (flag)
+ {
+ result = 0u;
+ }
+ else
+ {
+ result = this.CurrentSceneData.PeerBox[1];
+ }
+ return result;
+ }
+ }
+
+ public bool IsArenaMiss { get; set; }
+
+ public int ArenaRankUp { get; set; }
+
+ public uint ArenaGemUp { get; set; }
+
+ public int TotalDamage { get; set; }
+
+ public bool IsSelect { get; set; }
+
+ public int SelectLeftTime { get; set; }
+
+ public bool IsWin { get; set; }
+
+ public bool IsStageFailed { get; set; }
+
+ public int PickUpTotalTime { get; set; }
+
+ public int RandomTaskExp { get; set; }
+
+ public int RandomTaskMoney { get; set; }
+
+ public int RandomTask { get; set; }
+
+ public int StartLevel { get; set; }
+
+ public float StartPercent { get; set; }
+
+ public float TotalExpPercent { get; set; }
+
+ public float CurrentExpPercent { get; set; }
+
+ public float GrowExpPercent { get; set; }
+
+ public float TotalExp { get; set; }
+
+ public int SmallMonsterRank { get; set; }
+
+ public bool BrokeRecords { get; set; }
+
+ public bool RedSmallMonsterKilled { get; set; }
+
+ public int TowerFloor { get; set; }
+
+ public bool IsEndLevel { get; set; }
+
+ public uint WatchCount { get; set; }
+
+ public uint LikeCount { get; set; }
+
+ public static int MEMBER_COUNT = 16;
+
+ public RiftResult RiftResult;
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("LevelRewardDocument");
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private bool _requestServer = false;
+
+ private uint _rank = 0u;
+
+ public List<uint> Stars = new List<uint>();
+
+ public List<ItemBrief> Items = new List<ItemBrief>();
+
+ public List<ItemBrief> StarsItems = new List<ItemBrief>();
+
+ private SceneTable.RowData _current_scene_data = null;
+
+ private float _last_query_box_time = 0f;
+
+ public List<XLevelRewardDocument.DamageRank> Member = new List<XLevelRewardDocument.DamageRank>();
+
+ public Dictionary<ulong, int> MemberSelectChest = new Dictionary<ulong, int>();
+
+ public static StageRankTable Table = new StageRankTable();
+
+ public XLevelRewardDocument.PVPData PvpBattleData = default(XLevelRewardDocument.PVPData);
+
+ public XLevelRewardDocument.HeroBattleData HeroData = default(XLevelRewardDocument.HeroBattleData);
+
+ public XLevelRewardDocument.HeroBattleData MobaData = default(XLevelRewardDocument.HeroBattleData);
+
+ public XLevelRewardDocument.RaceData RaceBattleData = default(XLevelRewardDocument.RaceData);
+
+ public XLevelRewardDocument.InvFightData InvFightBattleData = default(XLevelRewardDocument.InvFightData);
+
+ public XLevelRewardDocument.SkyArenaData SkyArenaBattleData = default(XLevelRewardDocument.SkyArenaData);
+
+ public XLevelRewardDocument.AbyssPartyData AbyssPartyBattleData = default(XLevelRewardDocument.AbyssPartyData);
+
+ public XLevelRewardDocument.BigMeleeData BigMeleeBattleData = default(XLevelRewardDocument.BigMeleeData);
+
+ public XLevelRewardDocument.BattleFieldData BattleFieldBattleData = default(XLevelRewardDocument.BattleFieldData);
+
+ public XLevelRewardDocument.GuildMineData GuildMineBattleData = default(XLevelRewardDocument.GuildMineData);
+
+ public XLevelRewardDocument.GerenalData GerenalBattleData = default(XLevelRewardDocument.GerenalData);
+
+ public XLevelRewardDocument.SelectChestData SelectChestFrameData = default(XLevelRewardDocument.SelectChestData);
+
+ public XLevelRewardDocument.DragonCrusadeData DragonCrusadeDataWin = default(XLevelRewardDocument.DragonCrusadeData);
+
+ public List<XLevelRewardDocument.BattleData> BattleDataList = new List<XLevelRewardDocument.BattleData>();
+
+ public XLevelRewardDocument.QualifyingData QualifyingBattleData = default(XLevelRewardDocument.QualifyingData);
+
+ public XLevelRewardDocument.CustomBattleGameData CustomBattleData = default(XLevelRewardDocument.CustomBattleGameData);
+
+ public XLevelRewardDocument.WeekendPartyData WeekendPartyBattleData = default(XLevelRewardDocument.WeekendPartyData);
+
+ public XLevelRewardDocument.BattleRoyaleData BattleRoyaleDataInfo = default(XLevelRewardDocument.BattleRoyaleData);
+
+ private float LastLeaveSceneTime = 0f;
+
+ private XFx TheGoddessWinFx = null;
+
+ private uint _autoReturnTimeToken = 0u;
+
+ public struct DamageRank
+ {
+ public string Name { get; set; }
+
+ public int Damage { get; set; }
+ }
+
+ public struct PVPRoleInfo
+ {
+ public string Name;
+
+ public ulong uID;
+
+ public uint Level;
+
+ public int Prof;
+
+ public int KillCount;
+
+ public int MaxKillCount;
+
+ public uint DeathCount;
+
+ public uint AssitCount;
+
+ public bool IsMvp;
+
+ public ulong Damage;
+
+ public uint BeHit;
+
+ public float Kda;
+
+ public ulong Heal;
+
+ public uint ServerID;
+
+ public uint militaryRank;
+
+ public bool isescape;
+ }
+
+ public struct PVPData
+ {
+ public int PVPResult;
+
+ public List<ItemBrief> DayJoinReward;
+
+ public List<ItemBrief> WinReward;
+
+ public List<XLevelRewardDocument.PVPRoleInfo> Team1Data;
+
+ public List<XLevelRewardDocument.PVPRoleInfo> Team2Data;
+
+ public void Init()
+ {
+ this.PVPResult = 0;
+ this.DayJoinReward = new List<ItemBrief>();
+ this.WinReward = new List<ItemBrief>();
+ this.Team1Data = new List<XLevelRewardDocument.PVPRoleInfo>();
+ this.Team2Data = new List<XLevelRewardDocument.PVPRoleInfo>();
+ }
+ }
+
+ public struct CustomBattleInfo
+ {
+ public string RoleName;
+
+ public ulong RoleID;
+
+ public int RoleProf;
+
+ public int KillCount;
+
+ public int MaxKillCount;
+
+ public int DeathCount;
+
+ public ulong Damage;
+
+ public ulong Heal;
+
+ public int PointChange;
+
+ public bool IsMvp;
+ }
+
+ public struct CustomBattleGameData
+ {
+ public uint GameType;
+
+ public PkResultType Result;
+
+ public List<XLevelRewardDocument.CustomBattleInfo> Team1Data;
+
+ public List<XLevelRewardDocument.CustomBattleInfo> Team2Data;
+
+ public void Init()
+ {
+ this.GameType = 0u;
+ this.Result = PkResultType.PkResult_Draw;
+ this.Team1Data = new List<XLevelRewardDocument.CustomBattleInfo>();
+ this.Team2Data = new List<XLevelRewardDocument.CustomBattleInfo>();
+ }
+ }
+
+ public struct WeekendPartyData
+ {
+ public uint WarTime;
+
+ public List<WeekendPartyBattleRoleInfo> AllRoleData;
+
+ public uint Team1Score;
+
+ public uint Team2Score;
+
+ public uint PlayerRedBlue;
+
+ public List<ulong> HasRewardsID;
+
+ public void Init()
+ {
+ this.WarTime = 0u;
+ this.Team1Score = 0u;
+ this.Team2Score = 0u;
+ this.PlayerRedBlue = 0u;
+ this.AllRoleData = new List<WeekendPartyBattleRoleInfo>();
+ this.HasRewardsID = new List<ulong>();
+ }
+ }
+
+ public struct HeroBattleData
+ {
+ public HeroBattleOver Result;
+
+ public uint MvpHeroID;
+
+ public int KillMax;
+
+ public int DeathMin;
+
+ public int AssitMax;
+
+ public ulong DamageMax;
+
+ public uint BeHitMax;
+
+ public ulong DamageMaxUid;
+
+ public ulong BeHitMaxUid;
+
+ public List<ItemBrief> DayJoinReward;
+
+ public List<ItemBrief> WinReward;
+
+ public XLevelRewardDocument.PVPRoleInfo MvpData;
+
+ public List<XLevelRewardDocument.PVPRoleInfo> Team1Data;
+
+ public List<XLevelRewardDocument.PVPRoleInfo> Team2Data;
+
+ public void Init()
+ {
+ this.MvpHeroID = 1u;
+ this.KillMax = 0;
+ this.AssitMax = 0;
+ this.DamageMax = 0UL;
+ this.BeHitMax = 0u;
+ this.DeathMin = int.MaxValue;
+ this.DayJoinReward = new List<ItemBrief>();
+ this.WinReward = new List<ItemBrief>();
+ this.Team1Data = new List<XLevelRewardDocument.PVPRoleInfo>();
+ this.Team2Data = new List<XLevelRewardDocument.PVPRoleInfo>();
+ }
+ }
+
+ public struct GuildMineData
+ {
+ public uint mine;
+
+ public List<ItemBrief> item;
+
+ public void Init()
+ {
+ this.mine = 0u;
+ this.item = new List<ItemBrief>();
+ }
+ }
+
+ public struct RaceData
+ {
+ public List<string> rolename;
+
+ public List<int> profession;
+
+ public List<List<ItemBrief>> item;
+
+ public List<uint> time;
+
+ public List<uint> petid;
+
+ public List<uint> rank;
+
+ public void Init()
+ {
+ this.rolename = new List<string>();
+ this.profession = new List<int>();
+ this.item = new List<List<ItemBrief>>();
+ this.time = new List<uint>();
+ this.petid = new List<uint>();
+ this.rank = new List<uint>();
+ }
+ }
+
+ public struct InvFightData
+ {
+ public string rivalName;
+
+ public bool isWin;
+
+ public void Init()
+ {
+ this.rivalName = "";
+ this.isWin = false;
+ }
+ }
+
+ public struct SkyArenaData
+ {
+ public List<ulong> roleid;
+
+ public List<int> killcount;
+
+ public List<int> deathcount;
+
+ public List<ulong> damage;
+
+ public List<bool> ismvp;
+
+ public uint floor;
+
+ public List<ItemBrief> item;
+
+ public void Init()
+ {
+ this.roleid = new List<ulong>();
+ this.killcount = new List<int>();
+ this.deathcount = new List<int>();
+ this.damage = new List<ulong>();
+ this.ismvp = new List<bool>();
+ this.floor = 0u;
+ this.item = new List<ItemBrief>();
+ }
+ }
+
+ public struct AbyssPartyData
+ {
+ public int AbysssPartyListId;
+
+ public uint Time;
+
+ public List<ItemBrief> item;
+
+ public void Init()
+ {
+ this.AbysssPartyListId = 0;
+ this.Time = 0u;
+ this.item = new List<ItemBrief>();
+ }
+ }
+
+ public struct BigMeleeData
+ {
+ public uint rank;
+
+ public uint score;
+
+ public uint kill;
+
+ public uint death;
+
+ public List<ItemBrief> item;
+
+ public void Init()
+ {
+ this.rank = 0u;
+ this.score = 0u;
+ this.kill = 0u;
+ this.death = 0u;
+ this.item = new List<ItemBrief>();
+ }
+ }
+
+ public struct BattleRankRoleInfo
+ {
+ public ulong RoleID;
+
+ public uint Rank;
+
+ public string Name;
+
+ public string ServerName;
+
+ public uint KillCount;
+
+ public uint CombKill;
+
+ public uint DeathCount;
+
+ public bool isMVP;
+
+ public ulong Damage;
+
+ public int RoleProf;
+
+ public uint Point;
+ }
+
+ public struct BattleFieldData
+ {
+ public bool allend;
+
+ public List<XLevelRewardDocument.BattleRankRoleInfo> MemberData;
+
+ public List<ItemBrief> item;
+
+ public void Init()
+ {
+ this.allend = false;
+ this.MemberData = new List<XLevelRewardDocument.BattleRankRoleInfo>();
+ this.item = new List<ItemBrief>();
+ }
+ }
+
+ public struct GerenalData
+ {
+ public uint Rank;
+
+ public uint Score;
+
+ public List<uint> Stars;
+
+ public List<ItemBrief> Items;
+
+ public uint LevelFinishTime;
+
+ public uint StartLevel;
+
+ public float StartPercent;
+
+ public float TotalExpPercent;
+
+ public float CurrentExpPercent;
+
+ public float GrowExpPercent;
+
+ public float TotalExp;
+
+ public float GuildBuff;
+
+ public int SwitchLeftTime;
+
+ public uint GuildExp;
+
+ public uint GuildContribution;
+
+ public uint GuildDragonCoin;
+
+ public ItemBrief GoldGroupReward;
+
+ public bool isHelper;
+
+ public bool noneReward;
+
+ public bool isSeal;
+
+ public void Init()
+ {
+ this.Rank = 0u;
+ this.Stars = new List<uint>();
+ this.Items = new List<ItemBrief>();
+ this.LevelFinishTime = 0u;
+ this.StartLevel = 0u;
+ this.StartPercent = 0f;
+ this.TotalExpPercent = 0f;
+ this.CurrentExpPercent = 0f;
+ this.GrowExpPercent = 0f;
+ this.TotalExp = 0f;
+ this.SwitchLeftTime = 0;
+ this.GuildExp = 0u;
+ this.GuildContribution = 0u;
+ this.GuildDragonCoin = 0u;
+ this.GoldGroupReward = null;
+ this.isHelper = false;
+ this.noneReward = false;
+ this.isSeal = false;
+ }
+ }
+
+ public struct LevelRewardRoleData
+ {
+ public ulong uid;
+
+ public string Name;
+
+ public uint Level;
+
+ public bool isLeader;
+
+ public bool isHelper;
+
+ public bool noneReward;
+
+ public int ProfID;
+
+ public uint Rank;
+
+ public int BoxID;
+
+ public uint ServerID;
+
+ public List<BattleRewardChest> chestList;
+
+ public void Init()
+ {
+ this.uid = 0UL;
+ this.Name = "";
+ this.Level = 0u;
+ this.isLeader = false;
+ this.isHelper = false;
+ this.noneReward = false;
+ this.ProfID = 0;
+ this.Rank = 0u;
+ this.BoxID = 0;
+ this.chestList = new List<BattleRewardChest>();
+ }
+ }
+
+ public struct SelectChestData
+ {
+ public XLevelRewardDocument.LevelRewardRoleData Player;
+
+ public List<XLevelRewardDocument.LevelRewardRoleData> Others;
+
+ public int SelectLeftTime;
+
+ public void Init()
+ {
+ this.Player.Init();
+ this.Others = new List<XLevelRewardDocument.LevelRewardRoleData>();
+ this.SelectLeftTime = 0;
+ }
+ }
+
+ public struct DragonCrusadeData
+ {
+ public XLevelRewardDocument.LevelRewardRoleData Player;
+
+ public List<XLevelRewardDocument.LevelRewardRoleData> Others;
+
+ public int BossDamageHP;
+
+ public int BossLeftHP;
+
+ public DragonExpResult MyResult;
+
+ public void Init()
+ {
+ this.Player.Init();
+ this.Others = new List<XLevelRewardDocument.LevelRewardRoleData>();
+ this.BossDamageHP = 0;
+ this.BossLeftHP = 0;
+ this.MyResult = null;
+ }
+ }
+
+ public struct BattleData
+ {
+ public ulong uid;
+
+ public string Name;
+
+ public int ProfID;
+
+ public bool isLeader;
+
+ public uint Rank;
+
+ public ulong DamageTotal;
+
+ public float DamagePercent;
+
+ public ulong HealTotal;
+
+ public uint DeathCount;
+
+ public uint ComboCount;
+ }
+
+ public struct QualifyingData
+ {
+ public PkResultType QualifyingResult;
+
+ public int QualifyingRankChange;
+
+ public int FirstRank;
+
+ public int QualifyingPointChange;
+
+ public uint QualifyingHonorChange;
+
+ public List<ItemBrief> QualifyingHonorItems;
+
+ public KKVsRoleState myState;
+
+ public KKVsRoleState opState;
+
+ public void Init()
+ {
+ this.QualifyingResult = PkResultType.PkResult_Draw;
+ this.QualifyingRankChange = 0;
+ this.FirstRank = 0;
+ this.QualifyingPointChange = 0;
+ this.QualifyingHonorChange = 0u;
+ this.QualifyingHonorItems = new List<ItemBrief>();
+ this.myState = KKVsRoleState.KK_VS_ROLE_NORMAL;
+ this.opState = KKVsRoleState.KK_VS_ROLE_NORMAL;
+ }
+ }
+
+ public struct BattleRoyaleData
+ {
+ public uint SelfRank;
+
+ public uint AllRank;
+
+ public uint KillCount;
+
+ public string KilledBy;
+
+ public uint LiveTime;
+
+ public int AddPoint;
+
+ public void Init()
+ {
+ this.SelfRank = 0u;
+ this.AllRank = 0u;
+ this.KillCount = 0u;
+ this.KilledBy = "";
+ this.LiveTime = 0u;
+ this.AddPoint = 0;
+ }
+ }
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XLevelRewardDocument.AsyncLoader.AddTask("Table/StageRank", XLevelRewardDocument.Table, false);
+ XLevelRewardDocument.AsyncLoader.Execute(callback);
+ }
+
+ public override void OnEnterScene()
+ {
+ base.OnEnterScene();
+ this.PvpBattleData.Init();
+ this.InvFightBattleData.Init();
+ this.SkyArenaBattleData.Init();
+ this.AbyssPartyBattleData.Init();
+ this.BigMeleeBattleData.Init();
+ this.BattleFieldBattleData.Init();
+ this.RaceBattleData.Init();
+ this.GuildMineBattleData.Init();
+ this.GerenalBattleData.Init();
+ this.SelectChestFrameData.Init();
+ this.DragonCrusadeDataWin.Init();
+ this.QualifyingBattleData.Init();
+ this.CustomBattleData.Init();
+ this._current_scene_data = XSingleton<XSceneMgr>.singleton.GetSceneData(this.CurrentScene);
+ }
+
+ public override void OnLeaveScene()
+ {
+ base.OnLeaveScene();
+ this.DestroyFx(this.TheGoddessWinFx);
+ this.TheGoddessWinFx = null;
+ }
+
+ public void SendLeaveScene()
+ {
+ bool flag = Time.time - this.LastLeaveSceneTime < 3f;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("CLICK_TOO_FAST"), "fece00");
+ }
+ else
+ {
+ this.LastLeaveSceneTime = Time.time;
+ XSingleton<XScene>.singleton.ReqLeaveScene();
+ }
+ }
+
+ public void SendSelectChest(uint index)
+ {
+ RpcC2G_SelectChestReward rpcC2G_SelectChestReward = new RpcC2G_SelectChestReward();
+ rpcC2G_SelectChestReward.oArg.chestIdx = index;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_SelectChestReward);
+ }
+
+ public void SendPeerChest(uint index)
+ {
+ RpcC2G_PeerBox rpcC2G_PeerBox = new RpcC2G_PeerBox();
+ rpcC2G_PeerBox.oArg.index = index;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_PeerBox);
+ }
+
+ public void SetPeerChest(uint index, ItemBrief item, uint type)
+ {
+ this.SelectChestFrameData.Player.chestList[(int)index].itemID = (int)item.itemID;
+ this.SelectChestFrameData.Player.chestList[(int)index].itemCount = (int)item.itemCount;
+ this.SelectChestFrameData.Player.chestList[(int)index].isbind = item.isbind;
+ this.SelectChestFrameData.Player.chestList[(int)index].chestType = (int)type;
+ bool flag = !DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.IsVisible();
+ if (!flag)
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.SetPeerResult();
+ }
+ }
+
+ public void SendQueryBoxs(bool force = false)
+ {
+ bool flag = !force && Time.time - this._last_query_box_time < 1f;
+ if (!flag)
+ {
+ this._last_query_box_time = Time.time;
+ RpcC2G_QueryBoxs rpc = new RpcC2G_QueryBoxs();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+ }
+
+ public void SetSelectBoxLeftTime(uint leftTime)
+ {
+ this.SelectChestFrameData.SelectLeftTime = (int)leftTime;
+ bool flag = !DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.IsVisible();
+ if (!flag)
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.RefreshSelectChestLeftTime();
+ }
+ }
+
+ public void SetBoxsInfo(List<BoxInfos> boxs)
+ {
+ this.SetSelectBoxLeftTime(0u);
+ for (int i = 0; i < boxs.Count; i++)
+ {
+ bool flag = boxs[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ this.SelectChestFrameData.Player.BoxID = (int)boxs[i].index;
+ for (int j = 0; j < this.SelectChestFrameData.Player.chestList.Count; j++)
+ {
+ this.SelectChestFrameData.Player.chestList[j].itemID = (int)boxs[i].items[j].itemID;
+ this.SelectChestFrameData.Player.chestList[j].itemCount = (int)boxs[i].items[j].itemCount;
+ this.SelectChestFrameData.Player.chestList[j].isbind = boxs[i].items[j].isbind;
+ this.SelectChestFrameData.Player.chestList[j].chestType = (int)boxs[i].type[j];
+ }
+ }
+ else
+ {
+ for (int k = 0; k < this.SelectChestFrameData.Others.Count; k++)
+ {
+ bool flag2 = boxs[i].roleid == this.SelectChestFrameData.Others[k].uid;
+ if (flag2)
+ {
+ XLevelRewardDocument.LevelRewardRoleData levelRewardRoleData = this.SelectChestFrameData.Others[k];
+ levelRewardRoleData.BoxID = (int)boxs[i].index;
+ for (int l = 0; l < this.SelectChestFrameData.Player.chestList.Count; l++)
+ {
+ levelRewardRoleData.chestList[l].itemID = (int)boxs[i].items[l].itemID;
+ levelRewardRoleData.chestList[l].itemCount = (int)boxs[i].items[l].itemCount;
+ levelRewardRoleData.chestList[l].isbind = boxs[i].items[l].isbind;
+ levelRewardRoleData.chestList[l].chestType = (int)boxs[i].type[l];
+ }
+ this.SelectChestFrameData.Others[k] = levelRewardRoleData;
+ }
+ }
+ }
+ }
+ bool flag3 = !DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.IsVisible();
+ if (!flag3)
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowAllChest();
+ }
+ }
+
+ public void SendReturnWaitBattleField()
+ {
+ bool flag = Time.time - this.LastLeaveSceneTime < 3f;
+ if (!flag)
+ {
+ this.LastLeaveSceneTime = Time.time;
+ PtcC2M_GoBackReadySceneNtf proto = new PtcC2M_GoBackReadySceneNtf();
+ XSingleton<XClientNetwork>.singleton.Send(proto);
+ }
+ }
+
+ public void ReEnterLevel()
+ {
+ bool flag = Time.time - this.LastLeaveSceneTime < 3f;
+ if (!flag)
+ {
+ this.LastLeaveSceneTime = Time.time;
+ PtcC2G_EnterSceneReq ptcC2G_EnterSceneReq = new PtcC2G_EnterSceneReq();
+ ptcC2G_EnterSceneReq.Data.sceneID = this.CurrentScene;
+ XSingleton<XClientNetwork>.singleton.Send(ptcC2G_EnterSceneReq);
+ }
+ }
+
+ public void SendReEnterAbyssParty(uint ID)
+ {
+ bool flag = Time.time - this.LastLeaveSceneTime < 3f;
+ if (!flag)
+ {
+ this.LastLeaveSceneTime = Time.time;
+ bool flag2 = ID == 0u;
+ if (flag2)
+ {
+ DlgBase<AbyssPartyEntranceView, AbyssPartyEntranceBehaviour>.singleton.OnJoinClicked(null);
+ }
+ else
+ {
+ XAbyssPartyDocument.Doc.AbyssPartyEnter((int)ID);
+ }
+ }
+ }
+
+ public void SendReEnterRiskBattle()
+ {
+ bool flag = Time.time - this.LastLeaveSceneTime < 3f;
+ if (!flag)
+ {
+ this.LastLeaveSceneTime = Time.time;
+ RpcC2G_ReEnterRiskBattle rpc = new RpcC2G_ReEnterRiskBattle();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+ }
+
+ public void SetBattleResult(List<uint> stars, uint money, List<ItemBrief> items, uint firstStars, List<ItemBrief> starsItems)
+ {
+ this.Stars.Clear();
+ for (int i = 0; i < stars.Count; i++)
+ {
+ this.Stars.Add(stars[i]);
+ }
+ this.Items.Clear();
+ for (int j = 0; j < items.Count; j++)
+ {
+ bool flag = false;
+ for (int k = 0; k < this.Items.Count; k++)
+ {
+ bool flag2 = items[j].itemID == this.Items[k].itemID;
+ if (flag2)
+ {
+ flag = true;
+ this.Items[k].itemCount += items[j].itemCount;
+ break;
+ }
+ }
+ bool flag3 = !flag;
+ if (flag3)
+ {
+ this.Items.Add(this.CopyItemBrief(items[j]));
+ }
+ }
+ bool flag4 = money > 0u;
+ if (flag4)
+ {
+ ItemBrief itemBrief = new ItemBrief
+ {
+ itemID = (uint)XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.GOLD),
+ itemCount = money
+ };
+ bool flag = false;
+ for (int l = 0; l < this.Items.Count; l++)
+ {
+ bool flag5 = itemBrief.itemID == this.Items[l].itemID;
+ if (flag5)
+ {
+ flag = true;
+ this.Items[l].itemCount += itemBrief.itemCount;
+ break;
+ }
+ }
+ bool flag6 = !flag;
+ if (flag6)
+ {
+ this.Items.Add(this.CopyItemBrief(itemBrief));
+ }
+ }
+ this.FirstStars = firstStars;
+ this.StarsItems.Clear();
+ for (int m = 0; m < starsItems.Count; m++)
+ {
+ this.StarsItems.Add(this.CopyItemBrief(starsItems[m]));
+ }
+ this.MemberSelectChest.Clear();
+ this.IsSelect = false;
+ this.SelectLeftTime = XSingleton<XGlobalConfig>.singleton.GetInt("LevelFinishSelectChestTime");
+ }
+
+ public void SetQualifyingResult(PkResult data)
+ {
+ this.IsWin = (data.result == PkResultType.PkResult_Win);
+ this.QualifyingBattleData.Init();
+ this.QualifyingBattleData.QualifyingResult = data.result;
+ this.QualifyingBattleData.QualifyingRankChange = data.rank;
+ this.QualifyingBattleData.FirstRank = data.firstrank;
+ this.QualifyingBattleData.QualifyingPointChange = data.winpoint;
+ this.QualifyingBattleData.QualifyingHonorChange = data.honorpoint;
+ this.QualifyingBattleData.QualifyingHonorItems = data.items;
+ bool flag = data.dragoncount > 0u;
+ if (flag)
+ {
+ ItemBrief itemBrief = new ItemBrief();
+ itemBrief.itemID = 7u;
+ itemBrief.itemCount = data.dragoncount;
+ this.QualifyingBattleData.QualifyingHonorItems.Add(itemBrief);
+ }
+ this.QualifyingBattleData.myState = data.mystate;
+ this.QualifyingBattleData.opState = data.opstate;
+ }
+
+ public void SetDamageRank(List<string> name, List<uint> damage)
+ {
+ this.Member.Clear();
+ this.TotalDamage = 0;
+ for (int i = 0; i < name.Count; i++)
+ {
+ XLevelRewardDocument.DamageRank item = new XLevelRewardDocument.DamageRank
+ {
+ Name = name[i],
+ Damage = (int)damage[i]
+ };
+ this.Member.Add(item);
+ this.TotalDamage += item.Damage;
+ }
+ this.TotalDamage = Math.Max(1, this.TotalDamage);
+ this.Member.Sort(new Comparison<XLevelRewardDocument.DamageRank>(XLevelRewardDocument.DamageCompare));
+ }
+
+ public void ShowBattleResultFrame()
+ {
+ bool flag = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
+ if (flag)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SkillHandler.ResetPressState();
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SetVisiblePure(false);
+ }
+ bool flag2 = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IsLoaded();
+ if (flag2)
+ {
+ DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.SetVisiblePure(false);
+ }
+ bool flag3 = DlgBase<ReviveDlg, ReviveDlgBehaviour>.singleton.IsLoaded();
+ if (flag3)
+ {
+ DlgBase<ReviveDlg, ReviveDlgBehaviour>.singleton.SetVisiblePure(false);
+ }
+ bool isWin = this.IsWin;
+ if (isWin)
+ {
+ XLevelFinishMgr.PlayVictory();
+ }
+ bool isEndLevel = this.IsEndLevel;
+ if (isEndLevel)
+ {
+ this.DestroyFx(this.TheGoddessWinFx);
+ this.TheGoddessWinFx = null;
+ this.TheGoddessWinFx = XSingleton<XFxMgr>.singleton.CreateAndPlay("Effects/FX_Particle/UIfx/UI_TheGoddessWin", XSingleton<XGameUI>.singleton.UIRoot, Vector3.zero, Vector3.one, 1f, true, (float)XSingleton<XGlobalConfig>.singleton.GetInt("LevelFinishFxTime"), true);
+ XSingleton<XTimerMgr>.singleton.SetTimer((float)XSingleton<XGlobalConfig>.singleton.GetInt("LevelFinishFxTime"), new XTimerMgr.ElapsedEventHandler(this.ShowLevelRewardUI), null);
+ }
+ else
+ {
+ XSingleton<XTimerMgr>.singleton.SetTimer(1f, new XTimerMgr.ElapsedEventHandler(this.ShowLevelRewardUI), null);
+ }
+ }
+
+ public void ShowLevelReward()
+ {
+ this.ShowLevelRewardUI(null);
+ }
+
+ private void ShowLevelRewardUI(object o)
+ {
+ this.DestroyFx(this.TheGoddessWinFx);
+ this.TheGoddessWinFx = null;
+ bool bSpectator = XSingleton<XScene>.singleton.bSpectator;
+ if (!bSpectator)
+ {
+ XSingleton<XVirtualTab>.singleton.Cancel();
+ bool flag = !DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.SetVisible(true, true);
+ }
+ SceneType currentStage = this.CurrentStage;
+ switch (currentStage)
+ {
+ case SceneType.SCENE_BATTLE:
+ case SceneType.SCENE_NEST:
+ case (SceneType)4:
+ case (SceneType)6:
+ case SceneType.SCENE_WORLDBOSS:
+ case (SceneType)8:
+ case SceneType.SCENE_BOSSRUSH:
+ case SceneType.SCENE_GUILD_HALL:
+ case SceneType.SCENE_GUILD_BOSS:
+ case SceneType.SCENE_ABYSSS:
+ case (SceneType)14:
+ case SceneType.SCENE_FAMILYGARDEN:
+ case SceneType.SCENE_TOWER:
+ case SceneType.SCENE_DRAGON:
+ case SceneType.SCENE_GMF:
+ case SceneType.SCENE_GODDESS:
+ case SceneType.SCENE_ENDLESSABYSS:
+ goto IL_2A9;
+ case SceneType.SCENE_ARENA:
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/UI/PvP_Victory");
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(SceneType.SCENE_ARENA);
+ goto IL_2CE;
+ case SceneType.SCENE_PK:
+ break;
+ case SceneType.SCENE_PVP:
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/mapambience/PVP_score");
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(SceneType.SCENE_PVP);
+ goto IL_2CE;
+ case SceneType.SCENE_DRAGON_EXP:
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/UI/guankashenli");
+ DlgBase<DragonCrusadeGateWin, DragonCrusadeGateWinBehavior>.singleton.SetVisible(true, true);
+ DlgBase<DragonCrusadeGateWin, DragonCrusadeGateWinBehavior>.singleton.Refresh();
+ goto IL_2CE;
+ case SceneType.SCENE_RISK:
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/UI/guankashenli");
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(SceneType.SCENE_RISK);
+ goto IL_2CE;
+ default:
+ switch (currentStage)
+ {
+ case SceneType.SCENE_WEEK_NEST:
+ case SceneType.SCENE_VS_CHALLENGE:
+ case SceneType.SCENE_HORSE:
+ case SceneType.SCENE_HORSE_RACE:
+ case SceneType.SCENE_CASTLE_WAIT:
+ case SceneType.SCENE_CASTLE_FIGHT:
+ case SceneType.SCENE_LEAGUE_BATTLE:
+ case SceneType.SCENE_ACTIVITY_ONE:
+ case SceneType.SCENE_ACTIVITY_TWO:
+ case SceneType.SCENE_ACTIVITY_THREE:
+ case SceneType.SCENE_ABYSS_PARTY:
+ goto IL_2A9;
+ case SceneType.SCENE_HEROBATTLE:
+ case SceneType.SCENE_MOBA:
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(this.CurrentStage);
+ goto IL_2CE;
+ case SceneType.SCENE_INVFIGHT:
+ {
+ bool isWin = this.InvFightBattleData.isWin;
+ if (isWin)
+ {
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/UI/PvP_Victory");
+ }
+ else
+ {
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/UI/PvP_Lose");
+ }
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(SceneType.SCENE_INVFIGHT);
+ goto IL_2CE;
+ }
+ case SceneType.SCENE_CUSTOMPK:
+ case SceneType.SCENE_CUSTOMPKTWO:
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/mapambience/PVP_score");
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(this.CurrentStage);
+ goto IL_2CE;
+ case SceneType.SCENE_PKTWO:
+ break;
+ case SceneType.SCENE_WEEKEND4V4_MONSTERFIGHT:
+ case SceneType.SCENE_WEEKEND4V4_GHOSTACTION:
+ case SceneType.SCENE_WEEKEND4V4_LIVECHALLENGE:
+ case SceneType.SCENE_WEEKEND4V4_CRAZYBOMB:
+ case SceneType.SCENE_WEEKEND4V4_HORSERACING:
+ case SceneType.SCENE_WEEKEND4V4_DUCK:
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(this.CurrentStage);
+ goto IL_2CE;
+ default:
+ if (currentStage != SceneType.SCENE_SURVIVE)
+ {
+ goto IL_2A9;
+ }
+ goto IL_2CE;
+ }
+ break;
+ }
+ bool flag2 = this.QualifyingBattleData.QualifyingResult == PkResultType.PkResult_Win;
+ if (flag2)
+ {
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/UI/PvP_Victory");
+ }
+ else
+ {
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/UI/PvP_Lose");
+ }
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(SceneType.SCENE_PK);
+ goto IL_2CE;
+ IL_2A9:
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/UI/guankashenli");
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(this.CurrentStage);
+ IL_2CE:
+ int sceneAutoLeaveTime = XSingleton<XSceneMgr>.singleton.GetSceneAutoLeaveTime(this.CurrentScene);
+ bool flag3 = sceneAutoLeaveTime != 0;
+ if (flag3)
+ {
+ this._autoReturnTimeToken = XSingleton<XTimerMgr>.singleton.SetTimer((float)sceneAutoLeaveTime, new XTimerMgr.ElapsedEventHandler(this.AutoLeaveScene), null);
+ }
+ }
+ }
+
+ public void ShowStageFailUI(object o)
+ {
+ bool bSpectator = XSingleton<XScene>.singleton.bSpectator;
+ if (!bSpectator)
+ {
+ XSingleton<XVirtualTab>.singleton.Cancel();
+ bool flag = !DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.SetVisible(true, true);
+ }
+ SceneType currentStage = this.CurrentStage;
+ if (currentStage != SceneType.SCENE_RISK)
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowStageFailFrame(this.CurrentStage);
+ }
+ else
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowStageFailFrame(SceneType.SCENE_RISK);
+ }
+ }
+ }
+
+ private void AutoLeaveScene(object o)
+ {
+ bool flag = this.CurrentScene != XSingleton<XScene>.singleton.SceneID;
+ if (!flag)
+ {
+ bool flag2 = this.CurrentStage == SceneType.SCENE_GODDESS || this.CurrentStage == SceneType.SCENE_ENDLESSABYSS;
+ if (flag2)
+ {
+ XTeamDocument specificDocument = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
+ bool flag3 = !specificDocument.bIsLeader;
+ if (!flag3)
+ {
+ XExpeditionDocument specificDocument2 = XDocuments.GetSpecificDocument<XExpeditionDocument>(XExpeditionDocument.uuID);
+ int num = 0;
+ bool flag4 = this.CurrentStage == SceneType.SCENE_GODDESS;
+ if (flag4)
+ {
+ num = specificDocument2.GetDayCount(TeamLevelType.TeamLevelGoddessTrial, null);
+ }
+ else
+ {
+ bool flag5 = this.CurrentStage == SceneType.SCENE_ENDLESSABYSS;
+ if (flag5)
+ {
+ num = specificDocument2.GetDayCount(TeamLevelType.TeamLevelEndlessAbyss, null);
+ }
+ }
+ bool flag6 = num - 1 <= 0;
+ if (!flag6)
+ {
+ specificDocument.ReqTeamOp(TeamOperate.TEAM_BATTLE_CONTINUE, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ }
+ }
+ }
+ else
+ {
+ this.SendLeaveScene();
+ }
+ }
+ }
+
+ public void ShowSelectChestFrame()
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowSelectChestFrame();
+ }
+
+ public void ShowFirstPassShareView()
+ {
+ bool flag = XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_DungeonShareReward);
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("ShowFirstPassShareView", null, null, null, null, null, XDebugColor.XDebug_None);
+ XAchievementDocument specificDocument = XDocuments.GetSpecificDocument<XAchievementDocument>(XAchievementDocument.uuID);
+ bool flag2 = this.CurrentScene != 0u && this.CurrentScene == specificDocument.FirstPassSceneID;
+ if (flag2)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._autoReturnTimeToken);
+ this._autoReturnTimeToken = 0u;
+ XScreenShotShareDocument specificDocument2 = XDocuments.GetSpecificDocument<XScreenShotShareDocument>(XScreenShotShareDocument.uuID);
+ XSingleton<PDatabase>.singleton.shareCallbackType = ShareCallBackType.DungeonShare;
+ specificDocument2.CurShareBgType = ShareBgType.DungeonType;
+ DlgBase<DungeonShareView, DungeonShareBehavior>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ }
+ }
+
+ private static int DamageCompare(XLevelRewardDocument.DamageRank member1, XLevelRewardDocument.DamageRank member2)
+ {
+ return member2.Damage.CompareTo(member1.Damage);
+ }
+
+ public void SetPickItemList(List<ItemBrief> items)
+ {
+ for (int i = 0; i < items.Count; i++)
+ {
+ this.Items.Add(this.CopyItemBrief(items[i]));
+ }
+ }
+
+ public void SetBattleResultData(NewBattleResult data)
+ {
+ this.IsWin = true;
+ int index = 0;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ index = i;
+ break;
+ }
+ }
+ this.IsEndLevel = data.isFinalResult;
+ StageRoleResult stageRoleResult = data.roleReward[index];
+ bool flag2 = !stageRoleResult.ishelper;
+ if (flag2)
+ {
+ XSingleton<XStageProgress>.singleton.SetRank((int)data.stageInfo.stageID, (int)stageRoleResult.stars);
+ }
+ this._rank = stageRoleResult.stars;
+ this.SetBattleResult(this.GetStarsByBit(stageRoleResult.stars), stageRoleResult.money, stageRoleResult.items, stageRoleResult.firststars, stageRoleResult.starreward);
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ if (syncMode)
+ {
+ this.LevelFinishTime = (int)data.stageInfo.timespan;
+ }
+ bool flag3 = data.specialStage != null;
+ if (flag3)
+ {
+ this.ArenaRankUp = (int)data.specialStage.arenaup;
+ this.IsArenaMiss = data.specialStage.arenamissed;
+ }
+ this.ArenaGemUp = 0u;
+ for (int j = 0; j < stageRoleResult.items.Count; j++)
+ {
+ bool flag4 = stageRoleResult.items[j].itemID == 7u;
+ if (flag4)
+ {
+ this.ArenaGemUp = stageRoleResult.items[j].itemCount;
+ }
+ }
+ this.IsStageFailed = data.stageInfo.isStageFailed;
+ bool flag5 = stageRoleResult.pkresult != null;
+ if (flag5)
+ {
+ this.SetQualifyingResult(stageRoleResult.pkresult);
+ }
+ bool flag6 = stageRoleResult.stars < 7u && data.stageInfo.stageType == 2u;
+ if (flag6)
+ {
+ XPlayer player = XSingleton<XEntityMgr>.singleton.Player;
+ bool flag7 = player != null && player.Attributes.Level > 10u;
+ if (flag7)
+ {
+ XFPStrengthenDocument specificDocument = XDocuments.GetSpecificDocument<XFPStrengthenDocument>(XFPStrengthenDocument.uuID);
+ specificDocument.TryShowBrief();
+ }
+ }
+ bool flag8 = stageRoleResult.guildGoblinResult != null;
+ if (flag8)
+ {
+ this.SmallMonsterRank = stageRoleResult.guildGoblinResult.curRank;
+ this.RedSmallMonsterKilled = stageRoleResult.guildGoblinResult.getGuildBonus;
+ }
+ bool flag9 = data.specialStage != null;
+ if (flag9)
+ {
+ this.BrokeRecords = false;
+ bool flag10 = data.specialStage.bossrushresult != null;
+ if (flag10)
+ {
+ this.BrokeRecords = (data.specialStage.bossrushresult.lastmax < data.specialStage.bossrushresult.currentmax);
+ }
+ }
+ bool flag11 = stageRoleResult.towerResult != null;
+ if (flag11)
+ {
+ this.BrokeRecords = stageRoleResult.towerResult.isNewRecord;
+ this.TowerFloor = stageRoleResult.towerResult.towerFloor;
+ }
+ this.WatchCount = 0u;
+ this.LikeCount = 0u;
+ bool flag12 = data.watchinfo != null;
+ if (flag12)
+ {
+ this.WatchCount = data.watchinfo.wathccount;
+ this.LikeCount = data.watchinfo.likecount;
+ }
+ XSingleton<XLevelStatistics>.singleton.OnSetBattleResult();
+ this.SetBattleDataList(data);
+ this.SetSelectChestResult(data);
+ this.SetGerenalResult(data);
+ SceneType stageType = (SceneType)data.stageInfo.stageType;
+ if (stageType <= SceneType.SCENE_WEEKEND4V4_DUCK)
+ {
+ if (stageType != SceneType.SCENE_PVP)
+ {
+ if (stageType != SceneType.SCENE_DRAGON_EXP)
+ {
+ switch (stageType)
+ {
+ case SceneType.SKYCITY_FIGHTING:
+ this.SetSkyArenaResult(data);
+ break;
+ case SceneType.SCENE_RESWAR_PVP:
+ case SceneType.SCENE_RESWAR_PVE:
+ this.SetGuildMineResult(data);
+ break;
+ case SceneType.SCENE_HORSE_RACE:
+ this.SetRaceResult(data);
+ break;
+ case SceneType.SCENE_HEROBATTLE:
+ this.SetHeroBattleResult(data);
+ break;
+ case SceneType.SCENE_INVFIGHT:
+ this.SetInviFightResult(data);
+ break;
+ case SceneType.SCENE_ABYSS_PARTY:
+ this.SetAbyssPartyResult(data);
+ break;
+ case SceneType.SCENE_CUSTOMPK:
+ case SceneType.SCENE_CUSTOMPKTWO:
+ this.SetCustomBattleResult(data);
+ break;
+ case SceneType.SCENE_MOBA:
+ this.SetMobaBattleResult(data);
+ break;
+ case SceneType.SCENE_WEEKEND4V4_MONSTERFIGHT:
+ case SceneType.SCENE_WEEKEND4V4_GHOSTACTION:
+ case SceneType.SCENE_WEEKEND4V4_LIVECHALLENGE:
+ case SceneType.SCENE_WEEKEND4V4_CRAZYBOMB:
+ case SceneType.SCENE_WEEKEND4V4_HORSERACING:
+ case SceneType.SCENE_WEEKEND4V4_DUCK:
+ this.SetWeekendPartyBattleResult(data);
+ break;
+ }
+ }
+ else
+ {
+ this.SetDragonCrusadeResult(data);
+ }
+ }
+ else
+ {
+ this.SetPVPResult(data);
+ }
+ }
+ else if (stageType != SceneType.SCENE_BIGMELEE_FIGHT)
+ {
+ if (stageType != SceneType.SCENE_BATTLEFIELD_FIGHT)
+ {
+ if (stageType == SceneType.SCENE_RIFT)
+ {
+ this.SetRiftData(data);
+ }
+ }
+ else
+ {
+ this.SetBattleFieldResult(data);
+ }
+ }
+ else
+ {
+ this.SetBigMeleeResult(data);
+ }
+ bool canDrawBox = this.CurrentSceneData.CanDrawBox;
+ if (canDrawBox)
+ {
+ this.SendQueryBoxs(false);
+ }
+ }
+
+ private void SetWeekendPartyBattleResult(NewBattleResult data)
+ {
+ this.WeekendPartyBattleData.Init();
+ StageRoleResult stageRoleResult = null;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ stageRoleResult = data.roleReward[i];
+ bool flag2 = data.roleReward[i].weekend4v4roledata != null;
+ if (flag2)
+ {
+ this.WeekendPartyBattleData.PlayerRedBlue = stageRoleResult.weekend4v4roledata.redblue;
+ XSingleton<XDebug>.singleton.AddLog("WeekendPary result selfRedBlue = " + this.WeekendPartyBattleData.PlayerRedBlue.ToString(), null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ break;
+ }
+ }
+ bool flag3 = stageRoleResult == null;
+ if (!flag3)
+ {
+ for (int j = 0; j < data.roleReward.Count; j++)
+ {
+ WeekendPartyBattleRoleInfo weekendPartyBattleRoleInfo = new WeekendPartyBattleRoleInfo();
+ WeekEnd4v4BattleRoleData weekend4v4roledata = data.roleReward[j].weekend4v4roledata;
+ bool flag4 = weekend4v4roledata != null && weekend4v4roledata.isline;
+ if (flag4)
+ {
+ weekendPartyBattleRoleInfo.roleName = weekend4v4roledata.rolename;
+ weekendPartyBattleRoleInfo.roleID = weekend4v4roledata.roleid;
+ weekendPartyBattleRoleInfo.kill = weekend4v4roledata.killCount;
+ weekendPartyBattleRoleInfo.beKilled = weekend4v4roledata.bekilledCount;
+ weekendPartyBattleRoleInfo.score = weekend4v4roledata.score;
+ weekendPartyBattleRoleInfo.redBlue = weekend4v4roledata.redblue;
+ weekendPartyBattleRoleInfo.RoleProf = (int)weekend4v4roledata.profession;
+ this.WeekendPartyBattleData.AllRoleData.Add(weekendPartyBattleRoleInfo);
+ }
+ }
+ bool flag5 = data.stageInfo != null && data.stageInfo.weekend4v4tmresult != null;
+ if (flag5)
+ {
+ this.WeekendPartyBattleData.WarTime = data.stageInfo.weekend4v4tmresult.teamSeconds;
+ this.WeekendPartyBattleData.Team1Score = ((this.WeekendPartyBattleData.PlayerRedBlue == 1u) ? data.stageInfo.weekend4v4tmresult.redTeamScore : data.stageInfo.weekend4v4tmresult.blueTeamScore);
+ this.WeekendPartyBattleData.Team2Score = ((this.WeekendPartyBattleData.PlayerRedBlue != 1u) ? data.stageInfo.weekend4v4tmresult.redTeamScore : data.stageInfo.weekend4v4tmresult.blueTeamScore);
+ this.WeekendPartyBattleData.HasRewardsID = data.stageInfo.weekend4v4tmresult.hasRewardsID;
+ XSingleton<XDebug>.singleton.AddLog("WeekendPary result redTeamScore = " + data.stageInfo.weekend4v4tmresult.redTeamScore.ToString(), null, null, null, null, null, XDebugColor.XDebug_None);
+ XSingleton<XDebug>.singleton.AddLog("WeekendPary result blueTeamScore = " + data.stageInfo.weekend4v4tmresult.blueTeamScore.ToString(), null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ }
+ }
+
+ private void SetRiftData(NewBattleResult data)
+ {
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ StageRoleResult stageRoleResult = data.roleReward[i];
+ this.RiftResult = stageRoleResult.riftResult;
+ break;
+ }
+ }
+ }
+
+ private void SetCustomBattleResult(NewBattleResult data)
+ {
+ this.CustomBattleData.Init();
+ StageRoleResult stageRoleResult = null;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ stageRoleResult = data.roleReward[i];
+ break;
+ }
+ }
+ bool flag2 = stageRoleResult == null;
+ if (!flag2)
+ {
+ this.CustomBattleData.GameType = (uint)XFastEnumIntEqualityComparer<CustomBattleType>.ToInt(stageRoleResult.custombattle.type);
+ this.CustomBattleData.Result = stageRoleResult.custombattle.result;
+ for (int j = 0; j < data.roleReward.Count; j++)
+ {
+ XLevelRewardDocument.CustomBattleInfo item = new XLevelRewardDocument.CustomBattleInfo
+ {
+ RoleName = data.roleReward[j].rolename,
+ RoleID = data.roleReward[j].roleid,
+ RoleProf = data.roleReward[j].profession,
+ KillCount = data.roleReward[j].killcount,
+ MaxKillCount = data.roleReward[j].killcontinuemax,
+ DeathCount = (int)data.roleReward[j].deathcount,
+ Damage = (ulong)data.roleReward[j].damage,
+ Heal = (ulong)data.roleReward[j].treat,
+ PointChange = data.roleReward[j].custombattle.point,
+ IsMvp = false
+ };
+ bool flag3 = stageRoleResult.custombattle.fightgroup == data.roleReward[j].custombattle.fightgroup;
+ if (flag3)
+ {
+ this.CustomBattleData.Team1Data.Add(item);
+ }
+ else
+ {
+ this.CustomBattleData.Team2Data.Add(item);
+ }
+ }
+ }
+ }
+
+ public void SetDragonCrusadeWin()
+ {
+ }
+
+ public void SetPlayerSelectChestID(int index)
+ {
+ this.SelectChestFrameData.Player.BoxID = index;
+ bool flag = !DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.IsVisible();
+ if (!flag)
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.RefreshSelectChest();
+ }
+ }
+
+ public void SetBattleDataList(NewBattleResult data)
+ {
+ this.BattleDataList.Clear();
+ float num = 0f;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ num += data.roleReward[i].damage;
+ }
+ bool flag = num == 0f;
+ if (flag)
+ {
+ num = 1f;
+ }
+ for (int j = 0; j < data.roleReward.Count; j++)
+ {
+ XLevelRewardDocument.BattleData item = new XLevelRewardDocument.BattleData
+ {
+ uid = data.roleReward[j].roleid,
+ Name = data.roleReward[j].rolename,
+ ProfID = data.roleReward[j].profession,
+ Rank = this.GetRankByBit(data.roleReward[j].stars),
+ isLeader = data.roleReward[j].isLeader,
+ DamageTotal = (ulong)data.roleReward[j].damage,
+ DamagePercent = data.roleReward[j].damage * 100f / num,
+ HealTotal = (ulong)data.roleReward[j].treat,
+ DeathCount = data.roleReward[j].deathcount,
+ ComboCount = data.roleReward[j].maxcombo
+ };
+ this.BattleDataList.Add(item);
+ }
+ }
+
+ private void SetSelectChestResult(NewBattleResult data)
+ {
+ this.SelectChestFrameData.Init();
+ StageRoleResult stageRoleResult = null;
+ int num = -1;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ stageRoleResult = data.roleReward[i];
+ num = i;
+ break;
+ }
+ }
+ bool flag2 = stageRoleResult == null;
+ if (!flag2)
+ {
+ this.SelectChestFrameData.Player.uid = stageRoleResult.roleid;
+ this.SelectChestFrameData.Player.Name = stageRoleResult.rolename;
+ this.SelectChestFrameData.Player.Rank = this.GetRankByBit(stageRoleResult.stars);
+ this.SelectChestFrameData.Player.Level = stageRoleResult.endlevel;
+ this.SelectChestFrameData.Player.ProfID = stageRoleResult.profession;
+ this.SelectChestFrameData.Player.isLeader = stageRoleResult.isLeader;
+ this.SelectChestFrameData.Player.BoxID = 0;
+ List<BattleRewardChest> chestList = new List<BattleRewardChest>
+ {
+ new BattleRewardChest(),
+ new BattleRewardChest(),
+ new BattleRewardChest(),
+ new BattleRewardChest()
+ };
+ this.SelectChestFrameData.Player.chestList = chestList;
+ this.SelectChestFrameData.Player.isHelper = stageRoleResult.ishelper;
+ this.SelectChestFrameData.Player.noneReward = stageRoleResult.isboxexcept;
+ this.SelectChestFrameData.Others.Clear();
+ for (int j = 0; j < data.roleReward.Count; j++)
+ {
+ bool flag3 = j != num;
+ if (flag3)
+ {
+ chestList = new List<BattleRewardChest>
+ {
+ new BattleRewardChest(),
+ new BattleRewardChest(),
+ new BattleRewardChest(),
+ new BattleRewardChest()
+ };
+ XLevelRewardDocument.LevelRewardRoleData item = new XLevelRewardDocument.LevelRewardRoleData
+ {
+ uid = data.roleReward[j].roleid,
+ Name = data.roleReward[j].rolename,
+ Level = data.roleReward[j].endlevel,
+ ProfID = data.roleReward[j].profession,
+ isLeader = data.roleReward[j].isLeader,
+ Rank = this.GetRankByBit(data.roleReward[j].stars),
+ BoxID = 0,
+ chestList = chestList,
+ isHelper = data.roleReward[j].ishelper,
+ noneReward = data.roleReward[j].isboxexcept,
+ ServerID = data.roleReward[j].serverid
+ };
+ this.SelectChestFrameData.Others.Add(item);
+ }
+ }
+ this.SelectChestFrameData.SelectLeftTime = XSingleton<XGlobalConfig>.singleton.GetInt("LevelFinishSelectChestTime");
+ }
+ }
+
+ private void SetGerenalResult(NewBattleResult data)
+ {
+ this.GerenalBattleData.Init();
+ StageRoleResult stageRoleResult = null;
+ int num = -1;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ stageRoleResult = data.roleReward[i];
+ num = i;
+ break;
+ }
+ }
+ bool flag2 = stageRoleResult == null;
+ if (!flag2)
+ {
+ this.GerenalBattleData.Score = stageRoleResult.score;
+ this.GerenalBattleData.Rank = this.GetRankByBit(this._rank);
+ List<uint> starsByBit = this.GetStarsByBit(this._rank);
+ for (int j = 0; j < starsByBit.Count; j++)
+ {
+ this.GerenalBattleData.Stars.Add(starsByBit[j]);
+ }
+ this.GerenalBattleData.Items.Clear();
+ for (int k = 0; k < stageRoleResult.items.Count; k++)
+ {
+ bool flag3 = false;
+ for (int l = 0; l < this.GerenalBattleData.Items.Count; l++)
+ {
+ bool flag4 = stageRoleResult.items[k].itemID == this.GerenalBattleData.Items[l].itemID;
+ if (flag4)
+ {
+ flag3 = true;
+ this.GerenalBattleData.Items[l].itemCount += stageRoleResult.items[k].itemCount;
+ break;
+ }
+ }
+ bool flag5 = !flag3;
+ if (flag5)
+ {
+ this.GerenalBattleData.Items.Add(this.CopyItemBrief(stageRoleResult.items[k]));
+ }
+ }
+ bool flag6 = stageRoleResult.money > 0u;
+ if (flag6)
+ {
+ ItemBrief itemBrief = new ItemBrief
+ {
+ itemID = (uint)XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.GOLD),
+ itemCount = stageRoleResult.money
+ };
+ bool flag3 = false;
+ for (int m = 0; m < this.GerenalBattleData.Items.Count; m++)
+ {
+ bool flag7 = itemBrief.itemID == this.Items[m].itemID;
+ if (flag7)
+ {
+ flag3 = true;
+ this.GerenalBattleData.Items[m].itemCount += itemBrief.itemCount;
+ break;
+ }
+ }
+ bool flag8 = !flag3;
+ if (flag8)
+ {
+ this.GerenalBattleData.Items.Add(this.CopyItemBrief(itemBrief));
+ }
+ }
+ this.GerenalBattleData.LevelFinishTime = data.stageInfo.timespan;
+ XPlayerAttributes xplayerData = XSingleton<XAttributeMgr>.singleton.XPlayerData;
+ this.GerenalBattleData.StartLevel = stageRoleResult.startLevel;
+ this.GerenalBattleData.StartPercent = 1f * stageRoleResult.startExp / (float)xplayerData.GetLevelUpExp((int)(stageRoleResult.startLevel + 1u));
+ this.GerenalBattleData.TotalExpPercent = stageRoleResult.endlevel - stageRoleResult.startLevel + 1f * stageRoleResult.endexp / (float)xplayerData.GetLevelUpExp((int)(stageRoleResult.endlevel + 1u)) - 1f * stageRoleResult.startExp / (float)xplayerData.GetLevelUpExp((int)(stageRoleResult.startLevel + 1u));
+ this.GerenalBattleData.CurrentExpPercent = 1f * stageRoleResult.startExp / (float)xplayerData.GetLevelUpExp((int)(stageRoleResult.startLevel + 1u));
+ this.GerenalBattleData.GrowExpPercent = this.GerenalBattleData.TotalExpPercent / 60f;
+ this.GerenalBattleData.TotalExp = stageRoleResult.exp;
+ this.GerenalBattleData.GuildBuff = 0f;
+ for (int n = 0; n < data.roleReward.Count; n++)
+ {
+ bool flag9 = num != n && data.roleReward[n].gid != 0UL && data.roleReward[num].gid == data.roleReward[n].gid;
+ if (flag9)
+ {
+ SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(this.CurrentScene);
+ this.GerenalBattleData.GuildBuff = sceneData.GuildExpBounus;
+ break;
+ }
+ }
+ this.GerenalBattleData.SwitchLeftTime = 0;
+ this.GerenalBattleData.GuildExp = stageRoleResult.guildexp;
+ this.GerenalBattleData.GuildContribution = stageRoleResult.guildcon;
+ this.GerenalBattleData.GuildDragonCoin = stageRoleResult.guilddargon;
+ bool flag10 = stageRoleResult.teamcostreward != null;
+ if (flag10)
+ {
+ this.GerenalBattleData.GoldGroupReward = new ItemBrief();
+ this.GerenalBattleData.GoldGroupReward.itemID = stageRoleResult.teamcostreward.itemID;
+ this.GerenalBattleData.GoldGroupReward.itemCount = stageRoleResult.teamcostreward.itemCount;
+ this.GerenalBattleData.GoldGroupReward.isbind = stageRoleResult.teamcostreward.isbind;
+ }
+ this.GerenalBattleData.isHelper = stageRoleResult.ishelper;
+ this.GerenalBattleData.noneReward = stageRoleResult.isboxexcept;
+ this.GerenalBattleData.isSeal = stageRoleResult.isexpseal;
+ }
+ }
+
+ private void SetPVPResult(NewBattleResult data)
+ {
+ this.PvpBattleData.Init();
+ PVPResult pvpresult = null;
+ int num = -1;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ pvpresult = data.roleReward[i].pvpresult;
+ num = i;
+ break;
+ }
+ }
+ bool flag2 = pvpresult == null;
+ if (!flag2)
+ {
+ this.IsWin = (pvpresult.wingroup == pvpresult.mygroup);
+ bool flag3 = pvpresult.wingroup == 3;
+ if (flag3)
+ {
+ this.PvpBattleData.PVPResult = 3;
+ }
+ else
+ {
+ bool flag4 = pvpresult.wingroup == pvpresult.mygroup;
+ if (flag4)
+ {
+ this.PvpBattleData.PVPResult = 1;
+ }
+ else
+ {
+ this.PvpBattleData.PVPResult = 2;
+ }
+ }
+ for (int j = 0; j < pvpresult.dayjoinreward.Count; j++)
+ {
+ this.PvpBattleData.DayJoinReward.Add(pvpresult.dayjoinreward[j]);
+ }
+ for (int k = 0; k < pvpresult.winreward.Count; k++)
+ {
+ this.PvpBattleData.WinReward.Add(pvpresult.winreward[k]);
+ }
+ this.PvpBattleData.Team1Data.Add(this.GetPVPRoleInfo(num, data, true));
+ for (int l = 0; l < data.roleReward.Count; l++)
+ {
+ bool flag5 = l == num;
+ if (!flag5)
+ {
+ bool flag6 = pvpresult.mygroup == data.roleReward[l].pvpresult.mygroup;
+ if (flag6)
+ {
+ this.PvpBattleData.Team1Data.Add(this.GetPVPRoleInfo(l, data, true));
+ }
+ else
+ {
+ this.PvpBattleData.Team2Data.Add(this.GetPVPRoleInfo(l, data, true));
+ }
+ }
+ }
+ }
+ }
+
+ private void SetHeroBattleResult(NewBattleResult data)
+ {
+ this.HeroData.Init();
+ uint num = uint.MaxValue;
+ int num2 = -1;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ this.HeroData.Result = data.roleReward[i].heroresult.over;
+ num = data.roleReward[i].heroresult.teamid;
+ num2 = i;
+ break;
+ }
+ }
+ bool flag2 = num == uint.MaxValue;
+ if (!flag2)
+ {
+ this.HeroData.Team1Data.Add(this.GetPVPRoleInfo(num2, data, false));
+ for (int j = 0; j < data.roleReward[num2].heroresult.winreward.Count; j++)
+ {
+ this.HeroData.WinReward.Add(this.CopyItemBrief(data.roleReward[num2].heroresult.winreward[j]));
+ }
+ for (int k = 0; k < data.roleReward[num2].heroresult.dayjoinreward.Count; k++)
+ {
+ this.HeroData.DayJoinReward.Add(this.CopyItemBrief(data.roleReward[num2].heroresult.dayjoinreward[k]));
+ }
+ for (int l = 0; l < data.roleReward.Count; l++)
+ {
+ bool flag3 = data.roleReward[l].heroresult.mvpid == data.roleReward[l].roleid;
+ if (flag3)
+ {
+ this.HeroData.MvpData = this.GetPVPRoleInfo(l, data, false);
+ this.HeroData.MvpHeroID = data.roleReward[l].heroresult.mvpheroid;
+ }
+ bool flag4 = data.roleReward[l].killcount > this.HeroData.KillMax;
+ if (flag4)
+ {
+ this.HeroData.KillMax = data.roleReward[l].killcount;
+ }
+ bool flag5 = (ulong)data.roleReward[l].deathcount < (ulong)((long)this.HeroData.DeathMin);
+ if (flag5)
+ {
+ this.HeroData.DeathMin = (int)data.roleReward[l].deathcount;
+ }
+ bool flag6 = (ulong)data.roleReward[l].assitnum > (ulong)((long)this.HeroData.AssitMax);
+ if (flag6)
+ {
+ this.HeroData.AssitMax = (int)data.roleReward[l].assitnum;
+ }
+ bool flag7 = data.roleReward[l].damage > this.HeroData.DamageMax;
+ if (flag7)
+ {
+ this.HeroData.DamageMax = (ulong)data.roleReward[l].damage;
+ }
+ bool flag8 = data.roleReward[l].behitdamage > this.HeroData.BeHitMax;
+ if (flag8)
+ {
+ this.HeroData.BeHitMax = data.roleReward[l].behitdamage;
+ }
+ bool flag9 = l == num2;
+ if (!flag9)
+ {
+ bool flag10 = num == data.roleReward[l].heroresult.teamid;
+ if (flag10)
+ {
+ this.HeroData.Team1Data.Add(this.GetPVPRoleInfo(l, data, false));
+ }
+ else
+ {
+ this.HeroData.Team2Data.Add(this.GetPVPRoleInfo(l, data, false));
+ }
+ }
+ }
+ }
+ }
+
+ private void SetMobaBattleResult(NewBattleResult data)
+ {
+ this.MobaData.Init();
+ XMobaBattleDocument specificDocument = XDocuments.GetSpecificDocument<XMobaBattleDocument>(XMobaBattleDocument.uuID);
+ int num = -1;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ this.MobaData.Result = (data.roleReward[i].mobabattle.isWin ? HeroBattleOver.HeroBattleOver_Win : HeroBattleOver.HeroBattleOver_Lose);
+ num = i;
+ break;
+ }
+ }
+ bool flag2 = num == -1;
+ if (!flag2)
+ {
+ this.MobaData.Team1Data.Add(this.GetMobaRoleInfo(num, data, false));
+ for (int j = 0; j < data.roleReward[num].mobabattle.winreward.Count; j++)
+ {
+ this.MobaData.WinReward.Add(this.CopyItemBrief(data.roleReward[num].mobabattle.winreward[j]));
+ }
+ this.MobaData.BeHitMaxUid = data.stageInfo.mobabattle.behitdamagemaxid;
+ this.MobaData.DamageMaxUid = data.stageInfo.mobabattle.damagemaxid;
+ for (int k = 0; k < data.roleReward.Count; k++)
+ {
+ bool flag3 = data.stageInfo.mobabattle.mvpid == data.roleReward[k].roleid;
+ if (flag3)
+ {
+ this.MobaData.MvpData = this.GetMobaRoleInfo(k, data, false);
+ this.MobaData.MvpHeroID = data.roleReward[k].mobabattle.heroid;
+ }
+ bool flag4 = data.roleReward[k].killcount > this.MobaData.KillMax;
+ if (flag4)
+ {
+ this.MobaData.KillMax = data.roleReward[k].killcount;
+ }
+ bool flag5 = (ulong)data.roleReward[k].deathcount < (ulong)((long)this.MobaData.DeathMin);
+ if (flag5)
+ {
+ this.MobaData.DeathMin = (int)data.roleReward[k].deathcount;
+ }
+ bool flag6 = (ulong)data.roleReward[k].assitnum > (ulong)((long)this.MobaData.AssitMax);
+ if (flag6)
+ {
+ this.MobaData.AssitMax = (int)data.roleReward[k].assitnum;
+ }
+ bool flag7 = k == num;
+ if (!flag7)
+ {
+ bool flag8 = specificDocument.isAlly(data.roleReward[k].roleid);
+ if (flag8)
+ {
+ this.MobaData.Team1Data.Add(this.GetMobaRoleInfo(k, data, false));
+ }
+ else
+ {
+ this.MobaData.Team2Data.Add(this.GetMobaRoleInfo(k, data, false));
+ }
+ }
+ }
+ }
+ }
+
+ private void SetGuildMineResult(NewBattleResult data)
+ {
+ this.GuildMineBattleData.Init();
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ this.GuildMineBattleData.item = data.roleReward[i].items;
+ this.GuildMineBattleData.mine = data.roleReward[i].reswar;
+ break;
+ }
+ }
+ }
+
+ private void SetRaceResult(NewBattleResult data)
+ {
+ this.RaceBattleData.Init();
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ StageRoleResult stageRoleResult = data.roleReward[i];
+ bool flag = stageRoleResult.money > 0u;
+ if (flag)
+ {
+ ItemBrief item = new ItemBrief
+ {
+ itemID = (uint)XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.GOLD),
+ itemCount = stageRoleResult.money
+ };
+ stageRoleResult.items.Add(item);
+ }
+ this.RaceBattleData.rolename.Add(stageRoleResult.rolename);
+ this.RaceBattleData.profession.Add(stageRoleResult.profession);
+ this.RaceBattleData.item.Add(stageRoleResult.items);
+ this.RaceBattleData.time.Add(stageRoleResult.horse.time);
+ this.RaceBattleData.petid.Add(stageRoleResult.horse.horse);
+ this.RaceBattleData.rank.Add(stageRoleResult.horse.rank);
+ }
+ }
+
+ private void SetInviFightResult(NewBattleResult data)
+ {
+ this.InvFightBattleData.Init();
+ int num = 0;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ num = i;
+ break;
+ }
+ }
+ StageRoleResult stageRoleResult = (num < data.roleReward.Count) ? data.roleReward[num] : null;
+ bool flag2 = stageRoleResult != null;
+ if (flag2)
+ {
+ this.InvFightBattleData.isWin = (stageRoleResult.invfightresult.resulttype == PkResultType.PkResult_Win);
+ this.InvFightBattleData.rivalName = stageRoleResult.invfightresult.opname;
+ }
+ }
+
+ private void SetSkyArenaResult(NewBattleResult data)
+ {
+ this.SkyArenaBattleData.Init();
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ StageRoleResult stageRoleResult = data.roleReward[i];
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ this.SkyArenaBattleData.roleid.Add(stageRoleResult.roleid);
+ this.SkyArenaBattleData.killcount.Add(stageRoleResult.killcount);
+ this.SkyArenaBattleData.deathcount.Add((int)stageRoleResult.deathcount);
+ this.SkyArenaBattleData.damage.Add((ulong)stageRoleResult.damage);
+ this.SkyArenaBattleData.ismvp.Add(stageRoleResult.skycity.ismvp);
+ this.SkyArenaBattleData.item = stageRoleResult.skycity.item;
+ this.SkyArenaBattleData.floor = stageRoleResult.skycity.floor;
+ }
+ }
+ for (int j = 0; j < data.roleReward.Count; j++)
+ {
+ bool flag2 = data.roleReward[j].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (!flag2)
+ {
+ StageRoleResult stageRoleResult = data.roleReward[j];
+ this.SkyArenaBattleData.roleid.Add(stageRoleResult.roleid);
+ this.SkyArenaBattleData.killcount.Add(stageRoleResult.killcount);
+ this.SkyArenaBattleData.deathcount.Add((int)stageRoleResult.deathcount);
+ this.SkyArenaBattleData.damage.Add((ulong)stageRoleResult.damage);
+ this.SkyArenaBattleData.ismvp.Add(stageRoleResult.skycity.ismvp);
+ }
+ }
+ }
+
+ private void SetAbyssPartyResult(NewBattleResult data)
+ {
+ this.AbyssPartyBattleData.Init();
+ this.AbyssPartyBattleData.Time = data.stageInfo.timespan;
+ bool flag = data.roleReward.Count > 0;
+ if (flag)
+ {
+ this.AbyssPartyBattleData.item = data.roleReward[0].items;
+ }
+ this.AbyssPartyBattleData.AbysssPartyListId = (int)data.stageInfo.abyssid;
+ }
+
+ private void SetBigMeleeResult(NewBattleResult data)
+ {
+ this.BigMeleeBattleData.Init();
+ bool flag = data.roleReward.Count == 0;
+ if (!flag)
+ {
+ this.BigMeleeBattleData.rank = data.roleReward[0].bigmelee.rank;
+ this.BigMeleeBattleData.score = data.roleReward[0].bigmelee.score;
+ this.BigMeleeBattleData.kill = data.roleReward[0].bigmelee.kill;
+ this.BigMeleeBattleData.death = data.roleReward[0].bigmelee.death;
+ this.BigMeleeBattleData.item = data.roleReward[0].bigmelee.items;
+ }
+ }
+
+ private void SetBattleFieldResult(NewBattleResult data)
+ {
+ this.BattleFieldBattleData.Init();
+ this.BattleFieldBattleData.allend = data.stageInfo.end;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ XLevelRewardDocument.BattleRankRoleInfo battleRankRoleInfo = default(XLevelRewardDocument.BattleRankRoleInfo);
+ battleRankRoleInfo.RoleID = data.roleReward[i].battlefield.roleid;
+ battleRankRoleInfo.Rank = data.roleReward[i].battlefield.rank;
+ battleRankRoleInfo.Point = data.roleReward[i].battlefield.point;
+ battleRankRoleInfo.KillCount = data.roleReward[i].battlefield.killer;
+ battleRankRoleInfo.DeathCount = data.roleReward[i].battlefield.death;
+ battleRankRoleInfo.ServerName = data.roleReward[i].battlefield.svrname;
+ battleRankRoleInfo.isMVP = data.roleReward[i].battlefield.ismvp;
+ battleRankRoleInfo.Damage = (ulong)data.roleReward[i].battlefield.hurt;
+ battleRankRoleInfo.Name = data.roleReward[i].battlefield.name;
+ battleRankRoleInfo.RoleProf = (int)data.roleReward[i].battlefield.job;
+ battleRankRoleInfo.CombKill = data.roleReward[i].battlefield.killstreak;
+ this.BattleFieldBattleData.MemberData.Add(battleRankRoleInfo);
+ bool flag = battleRankRoleInfo.RoleID == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ this.BattleFieldBattleData.item = data.roleReward[i].items;
+ }
+ }
+ }
+
+ public void ShowBattleRoyaleResultUI()
+ {
+ bool flag = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
+ if (flag)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SkillHandler.ResetPressState();
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SetVisiblePure(false);
+ DlgBase<RadioBattleDlg, RadioBattleBahaviour>.singleton.Show(false);
+ DlgBase<XChatSmallView, XChatSmallBehaviour>.singleton.SetFakeHide(true);
+ }
+ bool flag2 = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IsLoaded();
+ if (flag2)
+ {
+ DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.SetVisiblePure(false);
+ DlgBase<RadioDlg, RadioBehaviour>.singleton.Show(false);
+ DlgBase<XChatSmallView, XChatSmallBehaviour>.singleton.SetFakeHide(false);
+ }
+ bool flag3 = DlgBase<ReviveDlg, ReviveDlgBehaviour>.singleton.IsLoaded();
+ if (flag3)
+ {
+ DlgBase<ReviveDlg, ReviveDlgBehaviour>.singleton.SetVisiblePure(false);
+ }
+ bool flag4 = DlgBase<XChatView, XChatBehaviour>.singleton.IsLoaded();
+ if (flag4)
+ {
+ DlgBase<XChatView, XChatBehaviour>.singleton.SetVisible(false, true);
+ }
+ XSingleton<XVirtualTab>.singleton.Cancel();
+ bool flag5 = !DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.IsVisible();
+ if (flag5)
+ {
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.SetVisible(true, true);
+ }
+ DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.ShowLevelReward(SceneType.SCENE_SURVIVE);
+ }
+
+ private void SetDragonCrusadeResult(NewBattleResult data)
+ {
+ this.DragonCrusadeDataWin.Init();
+ StageRoleResult stageRoleResult = null;
+ int num = -1;
+ for (int i = 0; i < data.roleReward.Count; i++)
+ {
+ bool flag = data.roleReward[i].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ stageRoleResult = data.roleReward[i];
+ num = i;
+ this.DragonCrusadeDataWin.MyResult = data.roleReward[i].deresult;
+ break;
+ }
+ }
+ bool flag2 = stageRoleResult == null;
+ if (!flag2)
+ {
+ this.DragonCrusadeDataWin.Player.uid = stageRoleResult.roleid;
+ this.DragonCrusadeDataWin.Player.Name = stageRoleResult.rolename;
+ this.DragonCrusadeDataWin.Player.Rank = this.GetRankByBit(stageRoleResult.stars);
+ this.DragonCrusadeDataWin.Player.Level = stageRoleResult.endlevel;
+ this.DragonCrusadeDataWin.Player.ProfID = stageRoleResult.profession;
+ this.DragonCrusadeDataWin.Player.isLeader = stageRoleResult.isLeader;
+ this.DragonCrusadeDataWin.Player.BoxID = 0;
+ this.DragonCrusadeDataWin.Player.chestList = stageRoleResult.box;
+ this.DragonCrusadeDataWin.Player.isHelper = stageRoleResult.ishelper;
+ this.DragonCrusadeDataWin.Others.Clear();
+ for (int j = 0; j < data.roleReward.Count; j++)
+ {
+ bool flag3 = j != num;
+ if (flag3)
+ {
+ XLevelRewardDocument.LevelRewardRoleData item = new XLevelRewardDocument.LevelRewardRoleData
+ {
+ uid = data.roleReward[j].roleid,
+ Name = data.roleReward[j].rolename,
+ Level = data.roleReward[j].endlevel,
+ ProfID = data.roleReward[j].profession,
+ isLeader = data.roleReward[j].isLeader,
+ Rank = this.GetRankByBit(data.roleReward[j].stars),
+ BoxID = 0,
+ chestList = data.roleReward[j].box,
+ isHelper = data.roleReward[j].ishelper
+ };
+ this.DragonCrusadeDataWin.Others.Add(item);
+ }
+ }
+ }
+ }
+
+ private XLevelRewardDocument.PVPRoleInfo GetPVPRoleInfo(int id, NewBattleResult data, bool isCapData = true)
+ {
+ return new XLevelRewardDocument.PVPRoleInfo
+ {
+ uID = data.roleReward[id].roleid,
+ Name = data.roleReward[id].rolename,
+ Prof = data.roleReward[id].profession,
+ Level = data.roleReward[id].endlevel,
+ KillCount = data.roleReward[id].killcount,
+ MaxKillCount = data.roleReward[id].killcontinuemax,
+ DeathCount = data.roleReward[id].deathcount,
+ AssitCount = data.roleReward[id].assitnum,
+ IsMvp = (isCapData ? data.roleReward[id].pvpresult.ismvp : (data.roleReward[id].heroresult.mvpid == data.roleReward[id].roleid || data.roleReward[id].heroresult.losemvpid == data.roleReward[id].roleid)),
+ Damage = (ulong)data.roleReward[id].damage,
+ BeHit = data.roleReward[id].behitdamage,
+ Kda = ((data.roleReward[id].heroresult == null) ? 0f : data.roleReward[id].heroresult.kda),
+ Heal = (ulong)data.roleReward[id].treat,
+ ServerID = data.roleReward[id].serverid,
+ militaryRank = data.roleReward[id].military_rank
+ };
+ }
+
+ private XLevelRewardDocument.PVPRoleInfo GetMobaRoleInfo(int id, NewBattleResult data, bool isCapData = true)
+ {
+ return new XLevelRewardDocument.PVPRoleInfo
+ {
+ uID = data.roleReward[id].roleid,
+ Name = data.roleReward[id].rolename,
+ Prof = data.roleReward[id].profession,
+ Level = data.roleReward[id].endlevel,
+ KillCount = data.roleReward[id].killcount,
+ MaxKillCount = (int)data.roleReward[id].multikillcountmax,
+ DeathCount = data.roleReward[id].deathcount,
+ AssitCount = data.roleReward[id].assitnum,
+ IsMvp = (data.roleReward[id].roleid == data.stageInfo.mobabattle.mvpid || data.roleReward[id].roleid == data.stageInfo.mobabattle.losemvpid),
+ Damage = (ulong)data.roleReward[id].damage,
+ BeHit = data.roleReward[id].behitdamage,
+ Kda = ((data.roleReward[id].mobabattle == null) ? 0f : data.roleReward[id].mobabattle.kda),
+ Heal = (ulong)data.roleReward[id].treat,
+ ServerID = data.roleReward[id].serverid,
+ militaryRank = data.roleReward[id].military_rank,
+ isescape = data.roleReward[id].mobabattle.isescape
+ };
+ }
+
+ private List<uint> GetStarsByBit(uint rank)
+ {
+ List<uint> list = new List<uint>();
+ int i = 0;
+ int num = 1;
+ while (i < 5)
+ {
+ bool flag = ((ulong)rank & (ulong)((long)num)) > 0UL;
+ if (flag)
+ {
+ list.Add(1u);
+ }
+ else
+ {
+ list.Add(0u);
+ }
+ i++;
+ num <<= 1;
+ }
+ return list;
+ }
+
+ public uint GetRankByBit(uint bit)
+ {
+ uint num = 0u;
+ while (bit > 0u)
+ {
+ bool flag = (bit & 1u) == 1u;
+ if (flag)
+ {
+ num += 1u;
+ }
+ bit >>= 1;
+ }
+ return num;
+ }
+
+ public ItemBrief CopyItemBrief(ItemBrief item)
+ {
+ return new ItemBrief
+ {
+ itemID = item.itemID,
+ itemCount = item.itemCount,
+ isbind = item.isbind
+ };
+ }
+
+ public void DestroyFx(XFx fx)
+ {
+ bool flag = fx == null;
+ if (!flag)
+ {
+ XSingleton<XFxMgr>.singleton.DestroyFx(fx, true);
+ }
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ bool flag = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.World && (this._requestServer || XSingleton<XGame>.singleton.SyncMode);
+ if (flag)
+ {
+ XSingleton<XLevelFinishMgr>.singleton.SendBattleReport(null);
+ }
+ }
+
+ public void ReportPlayer(ulong uid, List<reportType> list)
+ {
+ RpcC2G_ReportBadPlayer rpcC2G_ReportBadPlayer = new RpcC2G_ReportBadPlayer();
+ rpcC2G_ReportBadPlayer.oArg.roleid = uid;
+ rpcC2G_ReportBadPlayer.oArg.reason.Clear();
+ for (int i = 0; i < list.Count; i++)
+ {
+ bool state = list[i].state;
+ if (state)
+ {
+ rpcC2G_ReportBadPlayer.oArg.reason.Add(list[i].type);
+ }
+ }
+ rpcC2G_ReportBadPlayer.oArg.scenetype = (uint)XFastEnumIntEqualityComparer<SceneType>.ToInt(XSingleton<XScene>.singleton.SceneType);
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_ReportBadPlayer);
+ }
+
+ public List<string> GetMobaIconList(XLevelRewardDocument.PVPRoleInfo data, ulong DamageMaxUid = 0UL, ulong BeHitMaxUid = 0UL, int KillMax = 0, int AssistsMax = 0)
+ {
+ List<string> list = new List<string>();
+ bool flag = data.MaxKillCount > 2;
+ if (flag)
+ {
+ int maxKillCount = data.MaxKillCount;
+ if (maxKillCount != 3)
+ {
+ if (maxKillCount != 4)
+ {
+ list.Add("ic_pf5");
+ }
+ else
+ {
+ list.Add("ic_pf4");
+ }
+ }
+ else
+ {
+ list.Add("ic_pf3");
+ }
+ }
+ bool flag2 = data.KillCount == KillMax && KillMax != 0;
+ if (flag2)
+ {
+ list.Add("ic_pf1");
+ }
+ bool flag3 = (ulong)data.AssitCount == (ulong)((long)AssistsMax) && AssistsMax != 0;
+ if (flag3)
+ {
+ list.Add("ic_pf6");
+ }
+ bool flag4 = data.uID == BeHitMaxUid && BeHitMaxUid > 0UL;
+ if (flag4)
+ {
+ list.Add("ic_pf2");
+ }
+ bool flag5 = data.uID == DamageMaxUid && DamageMaxUid > 0UL;
+ if (flag5)
+ {
+ list.Add("ic_pf0");
+ }
+ bool isescape = data.isescape;
+ if (isescape)
+ {
+ list.Add("ic_pf8");
+ }
+ return list;
+ }
+ }
+}
|