diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XHeroBattleDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XHeroBattleDocument.cs | 906 |
1 files changed, 906 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XHeroBattleDocument.cs b/Client/Assets/Scripts/XMainClient/XHeroBattleDocument.cs new file mode 100644 index 00000000..7ec32f8c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XHeroBattleDocument.cs @@ -0,0 +1,906 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XHeroBattleDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XHeroBattleDocument.uuID;
+ }
+ }
+
+ private XHeroBattleSkillDocument _skillDoc
+ {
+ get
+ {
+ bool flag = this._valueDoc == null;
+ if (flag)
+ {
+ this._valueDoc = XDocuments.GetSpecificDocument<XHeroBattleSkillDocument>(XHeroBattleSkillDocument.uuID);
+ }
+ return this._valueDoc;
+ }
+ }
+
+ public OverWatchTable OverWatchReader
+ {
+ get
+ {
+ return XHeroBattleDocument._overWatchReader;
+ }
+ }
+
+ public HeroBattleMapCenter HeroBattleMapReader
+ {
+ get
+ {
+ return XHeroBattleDocument._heroBattleMapReader;
+ }
+ }
+
+ public HeroBattleTips HerobattletipsReader
+ {
+ get
+ {
+ return XHeroBattleDocument._herobattletips;
+ }
+ }
+
+ public HeroBattleWeekReward HeroBattleWeekRewardReader
+ {
+ get
+ {
+ return XHeroBattleDocument._heroBattleWeekReward;
+ }
+ }
+
+ public HeroBattleExperienceHero HeroExperienceReader
+ {
+ get
+ {
+ return XHeroBattleDocument._experienceReader;
+ }
+ }
+
+ public List<BattleRecordGameInfo> RecordList
+ {
+ get
+ {
+ return this._recordList;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("HeroBattleDocument");
+
+ private XHeroBattleSkillDocument _valueDoc;
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private static OverWatchTable _overWatchReader = new OverWatchTable();
+
+ private static HeroBattleMapCenter _heroBattleMapReader = new HeroBattleMapCenter();
+
+ private static HeroBattleTips _herobattletips = new HeroBattleTips();
+
+ private static HeroBattleWeekReward _heroBattleWeekReward = new HeroBattleWeekReward();
+
+ private static HeroBattleExperienceHero _experienceReader = new HeroBattleExperienceHero();
+
+ private List<BattleRecordGameInfo> _recordList = new List<BattleRecordGameInfo>();
+
+ private Dictionary<ulong, string> _nameIndex = new Dictionary<ulong, string>();
+
+ public HeroBattleHandler _HeroBattleHandler;
+
+ public List<XCaptainPVPInfo> RankList = new List<XCaptainPVPInfo>();
+
+ public List<XTeamBloodUIData> TeamBlood = new List<XTeamBloodUIData>();
+
+ public Dictionary<ulong, uint> heroIDIndex = new Dictionary<ulong, uint>();
+
+ public List<HeroBattleRankData> MainRankList = new List<HeroBattleRankData>();
+
+ public HeroBattleRankData MyRankData = new HeroBattleRankData();
+
+ public List<HeroBattleRankData> LastWeek_MainRankList = new List<HeroBattleRankData>();
+
+ public HeroBattleRankData LastWeek_MyRankData = new HeroBattleRankData();
+
+ public bool MaininterfaceState = false;
+
+ public uint BattleTotal;
+
+ public uint BattleWin;
+
+ public uint BattleLose;
+
+ public uint WinThisWeek;
+
+ public uint JoinToday;
+
+ public uint MyTeam;
+
+ public ulong SpectateUid = 0UL;
+
+ public HeroBattleRewardState RewardState;
+
+ public uint GetRewardStage;
+
+ public static bool LoadSkillHandler = false;
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XHeroBattleDocument.AsyncLoader.AddTask("Table/OverWatch", XHeroBattleDocument._overWatchReader, false);
+ XHeroBattleDocument.AsyncLoader.AddTask("Table/HeroBattleTips", XHeroBattleDocument._herobattletips, false);
+ XHeroBattleDocument.AsyncLoader.AddTask("Table/HeroBattleWeekReward", XHeroBattleDocument._heroBattleWeekReward, false);
+ XHeroBattleDocument.AsyncLoader.AddTask("Table/HeroBattleMapCenter", XHeroBattleDocument._heroBattleMapReader, false);
+ XHeroBattleDocument.AsyncLoader.AddTask("Table/HeroBattleExperienceHero", XHeroBattleDocument._experienceReader, false);
+ XHeroBattleDocument.AsyncLoader.Execute(callback);
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ base.RegisterEvent(XEventDefine.XEvent_RealDead, new XComponent.XEventHandler(this.OnPlayerDeathEvent));
+ base.RegisterEvent(XEventDefine.XEvent_OnRevived, new XComponent.XEventHandler(this.OnPlayerReviveEvent));
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ base.OnEnterSceneFinally();
+ bool loadSkillHandler = XHeroBattleDocument.LoadSkillHandler;
+ if (loadSkillHandler)
+ {
+ XHeroBattleSkillDocument.IsWeekendNestLoad = true;
+ XHeroBattleDocument.LoadSkillHandler = false;
+ }
+ bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HEROBATTLE;
+ if (flag)
+ {
+ XTeamDocument specificDocument = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
+ bool flag2 = !XSingleton<XScene>.singleton.bSpectator && !specificDocument.bInTeam;
+ if (flag2)
+ {
+ XSingleton<XUICacheMgr>.singleton.CacheUI(XSysDefine.XSys_HeroBattle, EXStage.Hall);
+ }
+ }
+ else
+ {
+ bool isWeekendNestLoad = XHeroBattleSkillDocument.IsWeekendNestLoad;
+ if (isWeekendNestLoad)
+ {
+ XSingleton<XTimerMgr>.singleton.SetTimer(2f, new XTimerMgr.ElapsedEventHandler(this.ShowHeroNestTips), null);
+ }
+ }
+ }
+
+ private void ShowHeroNestTips(object o = null)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("WeekendHeroNestLevelTips"), "fece00");
+ }
+
+ public override void OnLeaveScene()
+ {
+ base.OnLeaveScene();
+ this.TeamBlood.Clear();
+ }
+
+ public void QueryHeroBattleUIInfo()
+ {
+ RpcC2G_GetHeroBattleInfo rpc = new RpcC2G_GetHeroBattleInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void QueryGetReward()
+ {
+ RpcC2G_GetHeroBattleWeekReward rpc = new RpcC2G_GetHeroBattleWeekReward();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetRewardSuccess(bool getState, uint stage)
+ {
+ this.GetRewardStage = stage;
+ this.RewardState = HeroBattleRewardState.CanNotGet;
+ if (getState)
+ {
+ this.RewardState = HeroBattleRewardState.CanGet;
+ }
+ bool flag = this.GetRewardStage == this.HeroBattleWeekRewardReader.Table[this.HeroBattleWeekRewardReader.Table.Length - 1].id;
+ if (flag)
+ {
+ this.GetRewardStage -= 1u;
+ this.RewardState = HeroBattleRewardState.GetEnd;
+ }
+ bool flag2 = DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.RefreshInfo();
+ }
+ }
+
+ public void QueryBattleRecord()
+ {
+ RpcC2G_GetHeroBattleGameRecord rpc = new RpcC2G_GetHeroBattleGameRecord();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void QueryRankInfo()
+ {
+ RpcC2M_ClientQueryRankListNtf rpcC2M_ClientQueryRankListNtf = new RpcC2M_ClientQueryRankListNtf();
+ rpcC2M_ClientQueryRankListNtf.oArg.RankType = (uint)XFastEnumIntEqualityComparer<RankeType>.ToInt(RankeType.HeroBattleRank);
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_ClientQueryRankListNtf);
+ }
+
+ public void QueryLastSeasonRankInfo()
+ {
+ RpcC2M_ClientQueryRankListNtf rpcC2M_ClientQueryRankListNtf = new RpcC2M_ClientQueryRankListNtf();
+ rpcC2M_ClientQueryRankListNtf.oArg.RankType = (uint)XFastEnumIntEqualityComparer<RankeType>.ToInt(RankeType.LastWeek_HeroBattleRank);
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_ClientQueryRankListNtf);
+ }
+
+ public void SetBattleRecord(List<HeroBattleOneGame> list)
+ {
+ this._recordList.Clear();
+ for (int i = list.Count - 1; i >= 0; i--)
+ {
+ BattleRecordGameInfo battleRecordGameInfo = new BattleRecordGameInfo();
+ bool flag = true;
+ for (int j = 0; j < list[i].team1.Count; j++)
+ {
+ bool flag2 = list[i].team1[j].roleID == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag2)
+ {
+ flag = true;
+ battleRecordGameInfo.left.Add(this.GetOnePlayerInfo(list[i].team1[j]));
+ }
+ }
+ for (int k = 0; k < list[i].team2.Count; k++)
+ {
+ bool flag3 = list[i].team2[k].roleID == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag3)
+ {
+ flag = false;
+ battleRecordGameInfo.left.Add(this.GetOnePlayerInfo(list[i].team2[k]));
+ }
+ }
+ for (int l = 0; l < list[i].team1.Count; l++)
+ {
+ bool flag4 = list[i].team1[l].roleID == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (!flag4)
+ {
+ bool flag5 = flag;
+ if (flag5)
+ {
+ battleRecordGameInfo.left.Add(this.GetOnePlayerInfo(list[i].team1[l]));
+ }
+ else
+ {
+ battleRecordGameInfo.right.Add(this.GetOnePlayerInfo(list[i].team1[l]));
+ }
+ }
+ }
+ for (int m = 0; m < list[i].team2.Count; m++)
+ {
+ bool flag6 = list[i].team2[m].roleID == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (!flag6)
+ {
+ bool flag7 = flag;
+ if (flag7)
+ {
+ battleRecordGameInfo.right.Add(this.GetOnePlayerInfo(list[i].team2[m]));
+ }
+ else
+ {
+ battleRecordGameInfo.left.Add(this.GetOnePlayerInfo(list[i].team2[m]));
+ }
+ }
+ }
+ battleRecordGameInfo.result = list[i].over;
+ battleRecordGameInfo.militaryExploit = list[i].exploit;
+ this._recordList.Add(battleRecordGameInfo);
+ }
+ bool flag8 = DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.IsVisible() && DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.m_HeroBattleRecordHandler != null && DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.m_HeroBattleRecordHandler.IsVisible();
+ if (flag8)
+ {
+ DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.m_HeroBattleRecordHandler.SetupRecord(this.RecordList);
+ }
+ bool flag9 = DlgBase<MilitaryRankDlg, MilitaryRankBehaviour>.singleton.IsVisible() && DlgBase<MilitaryRankDlg, MilitaryRankBehaviour>.singleton.m_BattleRecordHandler != null && DlgBase<MilitaryRankDlg, MilitaryRankBehaviour>.singleton.m_BattleRecordHandler.IsVisible();
+ if (flag9)
+ {
+ DlgBase<MilitaryRankDlg, MilitaryRankBehaviour>.singleton.m_BattleRecordHandler.SetupRecord(this.RecordList);
+ }
+ }
+
+ public BattleRecordPlayerInfo GetOnePlayerInfo(RoleSmallInfo data)
+ {
+ return new BattleRecordPlayerInfo
+ {
+ name = data.roleName,
+ profression = data.roleProfession,
+ roleID = data.roleID
+ };
+ }
+
+ public void SetHeroBattleInfo(GetHeroBattleInfoRes data)
+ {
+ this._skillDoc.SetHeroHoldStatus(data.weekhero, data.havehero, data.experiencehero, data.experienceherolefttime);
+ this.BattleTotal = data.totalnum;
+ this.BattleWin = data.winnum;
+ this.BattleLose = data.losenum;
+ this.WinThisWeek = data.winthisweek;
+ this.JoinToday = data.todaygetspcount;
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_HeroBattle, true);
+ this.GetRewardStage = data.weekprize;
+ this.RewardState = HeroBattleRewardState.CanNotGet;
+ bool cangetprize = data.cangetprize;
+ if (cangetprize)
+ {
+ this.RewardState = HeroBattleRewardState.CanGet;
+ }
+ bool flag = this.GetRewardStage == this.HeroBattleWeekRewardReader.Table[this.HeroBattleWeekRewardReader.Table.Length - 1].id;
+ if (flag)
+ {
+ this.GetRewardStage -= 1u;
+ this.RewardState = HeroBattleRewardState.GetEnd;
+ }
+ bool flag2 = DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.RefreshInfo();
+ bool flag3 = DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.m_HeroBattleSkillHandler != null;
+ if (flag3)
+ {
+ DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.m_HeroBattleSkillHandler.SetupTabs();
+ }
+ }
+ bool flag4 = DlgBase<MobaEntranceView, MobaEntranceBehaviour>.singleton.IsVisible();
+ if (flag4)
+ {
+ bool flag5 = DlgBase<MobaEntranceView, MobaEntranceBehaviour>.singleton.m_HeroBattleSkillHandler != null;
+ if (flag5)
+ {
+ DlgBase<MobaEntranceView, MobaEntranceBehaviour>.singleton.m_HeroBattleSkillHandler.SetupTabs();
+ }
+ }
+ }
+
+ public void SetHeroBattleInfo(HeroBattleRecord data)
+ {
+ this._skillDoc.SetHeroHoldStatus(data.freeweekhero, data.havehero, data.experiencehero, data.experienceherotime);
+ this.BattleTotal = data.totalnum;
+ this.BattleWin = data.winnum;
+ this.BattleLose = data.losenum;
+ this.WinThisWeek = data.winthisweek;
+ this.JoinToday = data.todayspcount;
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_HeroBattle, true);
+ this.GetRewardStage = data.weekprize;
+ this.RewardState = HeroBattleRewardState.CanNotGet;
+ bool cangetprize = data.cangetprize;
+ if (cangetprize)
+ {
+ this.RewardState = HeroBattleRewardState.CanGet;
+ }
+ bool flag = this.GetRewardStage == this.HeroBattleWeekRewardReader.Table[this.HeroBattleWeekRewardReader.Table.Length - 1].id;
+ if (flag)
+ {
+ this.GetRewardStage -= 1u;
+ this.RewardState = HeroBattleRewardState.GetEnd;
+ }
+ }
+
+ public void SetHeroBattleMyTeam(HeroBattleTeamRoleData data)
+ {
+ bool flag = XSingleton<XAttributeMgr>.singleton.XPlayerData == null;
+ if (!flag)
+ {
+ bool bSpectator = XSingleton<XScene>.singleton.bSpectator;
+ ulong num;
+ if (bSpectator)
+ {
+ num = this.SpectateUid;
+ }
+ else
+ {
+ num = XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ }
+ this.heroIDIndex.Clear();
+ for (int i = 0; i < data.members1.Count; i++)
+ {
+ this.heroIDIndex[data.members1[i].uid] = data.members1[i].heroid;
+ bool flag2 = data.members1[i].uid == num;
+ if (flag2)
+ {
+ this.MyTeam = data.team1;
+ bool flag3 = !this._skillDoc.AlSelectHero && data.members1[i].heroid > 0u;
+ if (flag3)
+ {
+ this._skillDoc.SetAlreadySelectHero();
+ }
+ }
+ }
+ for (int j = 0; j < data.members2.Count; j++)
+ {
+ this.heroIDIndex[data.members2[j].uid] = data.members2[j].heroid;
+ bool flag4 = data.members2[j].uid == num;
+ if (flag4)
+ {
+ this.MyTeam = data.team2;
+ bool flag5 = !this._skillDoc.AlSelectHero && data.members2[j].heroid > 0u;
+ if (flag5)
+ {
+ this._skillDoc.SetAlreadySelectHero();
+ }
+ }
+ }
+ BattleIndicateHandler battleIndicateHandler = XSingleton<XScene>.singleton.bSpectator ? DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IndicateHandler : DlgBase<BattleMain, BattleMainBehaviour>.singleton.IndicateHandler;
+ bool flag6 = battleIndicateHandler != null;
+ if (flag6)
+ {
+ for (int k = 0; k < data.members1.Count; k++)
+ {
+ battleIndicateHandler.SetHeroMiniMapElement(data.members1[k].uid, data.members1[k].heroid, data.team1 == this.MyTeam, false);
+ bool flag7 = data.members1[k].uid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag7)
+ {
+ bool flag8 = this._HeroBattleHandler != null && this._HeroBattleHandler.IsVisible();
+ if (flag8)
+ {
+ this._HeroBattleHandler.RefreshScoreBoard(data.members1[k].killnum, data.members1[k].deathnum, data.members1[k].assitnum);
+ }
+ }
+ }
+ for (int l = 0; l < data.members2.Count; l++)
+ {
+ battleIndicateHandler.SetHeroMiniMapElement(data.members2[l].uid, data.members2[l].heroid, data.team2 == this.MyTeam, false);
+ bool flag9 = data.members2[l].uid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag9)
+ {
+ bool flag10 = this._HeroBattleHandler != null && this._HeroBattleHandler.IsVisible();
+ if (flag10)
+ {
+ this._HeroBattleHandler.RefreshScoreBoard(data.members2[l].killnum, data.members2[l].deathnum, data.members2[l].assitnum);
+ }
+ }
+ }
+ }
+ bool flag11 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded() && DlgBase<BattleMain, BattleMainBehaviour>.singleton.TeamMonitor != null;
+ if (flag11)
+ {
+ this.TeamBlood.Clear();
+ this._skillDoc.TAS.Clear();
+ bool flag12 = this.MyTeam == data.team1;
+ if (flag12)
+ {
+ for (int m = 0; m < data.members1.Count; m++)
+ {
+ this.TeamBlood.Add(this.Turn2TeamBloodData(data.members1[m]));
+ bool flag13 = data.members1[m].uid != num;
+ if (flag13)
+ {
+ this._skillDoc.TAS.Add(data.members1[m].heroid);
+ }
+ }
+ }
+ else
+ {
+ for (int n = 0; n < data.members2.Count; n++)
+ {
+ this.TeamBlood.Add(this.Turn2TeamBloodData(data.members2[n]));
+ bool flag14 = data.members2[n].uid != num;
+ if (flag14)
+ {
+ this._skillDoc.TAS.Add(data.members2[n].heroid);
+ }
+ }
+ }
+ bool flag15 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HEROBATTLE;
+ if (flag15)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.TeamMonitor.TeamInfoChangeOnSpectate(this.TeamBlood);
+ }
+ bool flag16 = this._skillDoc._HeroBattleTeamHandler != null;
+ if (flag16)
+ {
+ this._skillDoc._HeroBattleTeamHandler.Refresh();
+ }
+ bool flag17 = !this._skillDoc.CSSH && this._skillDoc.m_HeroBattleSkillHandler != null;
+ if (flag17)
+ {
+ this._skillDoc.m_HeroBattleSkillHandler.RefreshTab();
+ }
+ }
+ bool flag18 = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IsLoaded() && DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.SpectateTeamMonitor != null;
+ if (flag18)
+ {
+ DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.SpectateTeamMonitor.OnTeamInfoChanged();
+ }
+ bool flag19 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HEROBATTLE;
+ if (flag19)
+ {
+ this.RankList.Clear();
+ bool flag20 = !DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded() || data.team1 == this.MyTeam;
+ if (flag20)
+ {
+ for (int num2 = 0; num2 < data.members1.Count; num2++)
+ {
+ this.RankList.Add(this.Turn2DamageData(data.members1[num2]));
+ }
+ }
+ bool flag21 = !DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded() || data.team2 == this.MyTeam;
+ if (flag21)
+ {
+ for (int num3 = 0; num3 < data.members2.Count; num3++)
+ {
+ this.RankList.Add(this.Turn2DamageData(data.members2[num3]));
+ }
+ }
+ XSceneDamageRankDocument specificDocument = XDocuments.GetSpecificDocument<XSceneDamageRankDocument>(XSceneDamageRankDocument.uuID);
+ specificDocument.OnGetRank(this.RankList);
+ }
+ }
+ }
+
+ private XTeamBloodUIData Turn2TeamBloodData(HeroBattleTeamMember data)
+ {
+ return new XTeamBloodUIData
+ {
+ uid = data.uid,
+ entityID = data.uid,
+ level = 0u,
+ name = data.name,
+ bIsLeader = false,
+ profession = RoleType.Role_Warrior
+ };
+ }
+
+ private XCaptainPVPInfo Turn2DamageData(HeroBattleTeamMember data)
+ {
+ return new XCaptainPVPInfo
+ {
+ name = data.name,
+ kill = (int)data.killnum,
+ dead = (int)data.deathnum,
+ id = data.uid,
+ assit = (int)data.assitnum
+ };
+ }
+
+ public void SetHeroBattleTeamData(HeroBattleTeamMsg data)
+ {
+ bool flag = this._HeroBattleHandler != null;
+ if (flag)
+ {
+ this._HeroBattleHandler.SetTeamData(data);
+ }
+ }
+
+ public void SetHeroBattleProgressData(HeroBattleSyncData data)
+ {
+ bool flag = this._HeroBattleHandler != null;
+ if (flag)
+ {
+ this._HeroBattleHandler.SetProgressData(data);
+ }
+ }
+
+ public void SetHeroBattleInCircleData(HeroBattleInCircle data)
+ {
+ bool flag = this._HeroBattleHandler != null;
+ if (flag)
+ {
+ this._HeroBattleHandler.SetInCircleData(data);
+ }
+ }
+
+ public void StartHeroBattleAddTime(int time)
+ {
+ bool flag = this._HeroBattleHandler != null;
+ if (flag)
+ {
+ this._HeroBattleHandler.StartAddTime(time);
+ }
+ }
+
+ public bool OnPlayerDeathEvent(XEventArgs args)
+ {
+ bool flag = this._HeroBattleHandler == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XRealDeadEventArgs xrealDeadEventArgs = args as XRealDeadEventArgs;
+ bool flag2 = !xrealDeadEventArgs.TheDead.IsPlayer;
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ this._HeroBattleHandler.SetDeathGoState(true);
+ this._HeroBattleHandler.SetReviveLeftTime();
+ bool flag3 = this._skillDoc.m_HeroBattleSkillHandler != null;
+ if (flag3)
+ {
+ this._skillDoc.m_HeroBattleSkillHandler.SetCountDown(float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("HeroBattleReviveTime")), false);
+ }
+ result = true;
+ }
+ }
+ return result;
+ }
+
+ public bool OnPlayerReviveEvent(XEventArgs args)
+ {
+ bool flag = this._HeroBattleHandler == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XOnRevivedArgs xonRevivedArgs = args as XOnRevivedArgs;
+ bool flag2 = !xonRevivedArgs.entity.IsPlayer;
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ this._HeroBattleHandler.SetDeathGoState(false);
+ result = true;
+ }
+ }
+ return result;
+ }
+
+ public void SetUIDeathGoState(bool state)
+ {
+ bool flag = this._HeroBattleHandler != null;
+ if (flag)
+ {
+ this._HeroBattleHandler.SetDeathGoState(state);
+ }
+ bool flag2 = this._skillDoc.m_HeroBattleSkillHandler != null;
+ if (flag2)
+ {
+ this._skillDoc.m_HeroBattleSkillHandler.SetVisible(false);
+ }
+ }
+
+ public void ReceiveBattleSkill(PvpBattleKill battleSkillInfo)
+ {
+ bool flag = XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_HEROBATTLE;
+ if (!flag)
+ {
+ GVGBattleSkill gvgbattleSkill = new GVGBattleSkill();
+ gvgbattleSkill.killerID = battleSkillInfo.killID;
+ gvgbattleSkill.deadID = battleSkillInfo.deadID;
+ gvgbattleSkill.contiKillCount = battleSkillInfo.contiKillCount;
+ bool flag2 = false;
+ for (int i = 0; i < battleSkillInfo.assitids.Count; i++)
+ {
+ bool flag3 = battleSkillInfo.assitids[i] == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag3)
+ {
+ flag2 = true;
+ break;
+ }
+ }
+ bool flag4 = flag2;
+ if (flag4)
+ {
+ gvgbattleSkill.contiKillCount = -1;
+ DlgBase<BattleContiDlg, BattleContiBehaviour>.singleton.AddBattleSkill(gvgbattleSkill);
+ }
+ else
+ {
+ XEntity entityConsiderDeath = XSingleton<XEntityMgr>.singleton.GetEntityConsiderDeath(gvgbattleSkill.killerID);
+ XEntity entityConsiderDeath2 = XSingleton<XEntityMgr>.singleton.GetEntityConsiderDeath(gvgbattleSkill.deadID);
+ bool flag5 = entityConsiderDeath == null || entityConsiderDeath2 == null;
+ if (flag5)
+ {
+ XSingleton<XDebug>.singleton.AddLog("entity id: " + gvgbattleSkill.killerID, " dead id: " + gvgbattleSkill.deadID, null, null, null, null, XDebugColor.XDebug_None);
+ return;
+ }
+ gvgbattleSkill.killerName = entityConsiderDeath.Name;
+ gvgbattleSkill.deadName = entityConsiderDeath2.Name;
+ gvgbattleSkill.killerPosition = XSingleton<XEntityMgr>.singleton.IsAlly(entityConsiderDeath);
+ DlgBase<BattleContiDlg, BattleContiBehaviour>.singleton.AddBattleSkill(gvgbattleSkill);
+ XSingleton<XDebug>.singleton.AddGreenLog(string.Format("ReceiveBattleSkill:{0} --- ,{1} ,.... {2}", gvgbattleSkill.killerName, gvgbattleSkill.deadName, gvgbattleSkill.contiKillCount), null, null, null, null, null);
+ }
+ for (int j = 0; j < this.RankList.Count; j++)
+ {
+ bool flag6 = battleSkillInfo.killID == this.RankList[j].id;
+ if (flag6)
+ {
+ this.RankList[j].kill++;
+ }
+ bool flag7 = battleSkillInfo.deadID == this.RankList[j].id;
+ if (flag7)
+ {
+ this.RankList[j].dead++;
+ }
+ }
+ XSceneDamageRankDocument specificDocument = XDocuments.GetSpecificDocument<XSceneDamageRankDocument>(XSceneDamageRankDocument.uuID);
+ specificDocument.OnGetRank(this.RankList);
+ }
+ }
+
+ public void GetBattleTips(uint id)
+ {
+ bool flag = !DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
+ if (!flag)
+ {
+ HeroBattleTips.RowData byid = XHeroBattleDocument._herobattletips.GetByid(id);
+ bool flag2 = byid != null;
+ if (flag2)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.ShowNotice(byid.tips, 3f, 3f);
+ }
+ }
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ bool flag = DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ this.QueryHeroBattleUIInfo();
+ }
+ }
+
+ public void StartMvpCutScene()
+ {
+ bool flag = DlgBase<HeroAttrDlg, HeroAttrBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<HeroAttrDlg, HeroAttrBehaviour>.singleton.SetVisible(false, true);
+ }
+ HeroBattleMapCenter.RowData bySceneID = XHeroBattleDocument._heroBattleMapReader.GetBySceneID(XSingleton<XScene>.singleton.SceneID);
+ bool flag2 = bySceneID == null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Can't find mvp map data by sceneID = ", XSingleton<XScene>.singleton.SceneID.ToString(), null, null, null, null);
+ }
+ else
+ {
+ XSingleton<XCutScene>.singleton.Start(bySceneID.MVPCutScene, true, true);
+ }
+ }
+
+ public uint GetExperienceTicketID(uint heroID)
+ {
+ for (int i = 0; i < XHeroBattleDocument._experienceReader.Table.Length; i++)
+ {
+ bool flag = XHeroBattleDocument._experienceReader.Table[i].HeroID == heroID;
+ if (flag)
+ {
+ ulong itemCount = XBagDocument.BagDoc.GetItemCount((int)XHeroBattleDocument._experienceReader.Table[i].ItemID);
+ bool flag2 = itemCount > 0UL;
+ if (flag2)
+ {
+ return XHeroBattleDocument._experienceReader.Table[i].ItemID;
+ }
+ }
+ }
+ return 0u;
+ }
+
+ public void SetRankInfo(ClientQueryRankListRes oRes, bool LastWeek = false)
+ {
+ bool flag = oRes.ErrorCode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.ErrorCode, "fece00");
+ }
+ else
+ {
+ bool flag2 = oRes.RankList == null;
+ if (!flag2)
+ {
+ HeroBattleRankData heroBattleRankData = LastWeek ? this.LastWeek_MyRankData : this.MyRankData;
+ List<HeroBattleRankData> list = LastWeek ? this.LastWeek_MainRankList : this.MainRankList;
+ heroBattleRankData.roleID = 0UL;
+ heroBattleRankData.name = XSingleton<XAttributeMgr>.singleton.XPlayerData.Name;
+ heroBattleRankData.rank = oRes.RoleRankData.Rank;
+ heroBattleRankData.winTotal = this.BattleWin;
+ heroBattleRankData.fightTotal = this.BattleTotal;
+ list.Clear();
+ for (int i = 0; i < oRes.RankList.RankData.Count; i++)
+ {
+ list.Add(this.TurnServerData(oRes.RankList.RankData[i], (uint)i));
+ }
+ bool flag3 = DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.IsVisible() && !LastWeek;
+ if (flag3)
+ {
+ DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.SetupRankFrame();
+ }
+ }
+ }
+ }
+
+ public HeroBattleRankData TurnServerData(RankData data, uint rank)
+ {
+ return new HeroBattleRankData
+ {
+ roleID = data.RoleId,
+ name = data.RoleName,
+ rank = rank,
+ winTotal = data.heroinfo.winNum,
+ fightTotal = data.heroinfo.totalNum,
+ maxContinue = data.heroinfo.continueWinNum,
+ maxKills = data.heroinfo.maxKillNum
+ };
+ }
+
+ public static void GetIconByHeroID(uint heroID, out string atlas, out string icon)
+ {
+ OverWatchTable.RowData byHeroID = XHeroBattleDocument._overWatchReader.GetByHeroID(heroID);
+ bool flag = byHeroID != null;
+ if (flag)
+ {
+ atlas = byHeroID.IconAtlas;
+ icon = byHeroID.Icon;
+ }
+ else
+ {
+ atlas = "";
+ icon = "";
+ }
+ }
+
+ public static string GetSmallIconByHeroID(uint heroID)
+ {
+ OverWatchTable.RowData byHeroID = XHeroBattleDocument._overWatchReader.GetByHeroID(heroID);
+ bool flag = byHeroID != null;
+ string result;
+ if (flag)
+ {
+ result = byHeroID.MiniMapIcon;
+ }
+ else
+ {
+ result = "";
+ }
+ return result;
+ }
+
+ public static OverWatchTable.RowData GetDataByHeroID(uint heroID)
+ {
+ return XHeroBattleDocument._overWatchReader.GetByHeroID(heroID);
+ }
+
+ public void OnAncientPercentGet(float percent)
+ {
+ bool flag = DlgBase<BattleMain, BattleMainBehaviour>.singleton.m_HeroBattleHandler != null;
+ if (flag)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.m_HeroBattleHandler.SetAncientPercent(percent);
+ }
+ }
+
+ public void QueryUseAncientSkill(int skillIndex)
+ {
+ RpcC2G_SelectHeroAncientPower rpcC2G_SelectHeroAncientPower = new RpcC2G_SelectHeroAncientPower();
+ rpcC2G_SelectHeroAncientPower.oArg.selectpower = (uint)skillIndex;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_SelectHeroAncientPower);
+ }
+ }
+}
|