From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../XMainClient/XBattleCaptainPVPDocument.cs | 1064 ++++++++++++++++++++ 1 file changed, 1064 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/XBattleCaptainPVPDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/XBattleCaptainPVPDocument.cs') diff --git a/Client/Assets/Scripts/XMainClient/XBattleCaptainPVPDocument.cs b/Client/Assets/Scripts/XMainClient/XBattleCaptainPVPDocument.cs new file mode 100644 index 00000000..9078230e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XBattleCaptainPVPDocument.cs @@ -0,0 +1,1064 @@ +using System; +using System.Collections.Generic; +using System.Text; +using KKSG; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XBattleCaptainPVPDocument : XDocComponent + { + public override uint ID + { + get + { + return XBattleCaptainPVPDocument.uuID; + } + } + + public BattleCaptainPVPHandler Handler + { + get + { + return this._handler; + } + set + { + this._handler = value; + } + } + + public XCaptainPVPDocument CaptainDoc + { + get + { + bool flag = this._capDoc == null; + if (flag) + { + this._capDoc = XDocuments.GetSpecificDocument(XCaptainPVPDocument.uuID); + } + return this._capDoc; + } + } + + public bool InCaptainPVPTeam + { + get + { + return this.TeamBlood != null && this.TeamBlood.Count != 0; + } + } + + public ulong myId + { + get + { + return XSingleton.singleton.XPlayerData.RoleID; + } + } + + public static int InfoDelayTime + { + get + { + return XSingleton.singleton.GetInt("PVPInfoDelayTime"); + } + } + + public static int ReviveTime + { + get + { + return XSingleton.singleton.GetInt("PVPDieReviveTime"); + } + } + + public static int EndTime + { + get + { + return XSingleton.singleton.GetInt("PVPTimeDown"); + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("BattleCaptainPVPDocument"); + + public static readonly uint CONTINUOUS_KILL = 5u; + + public static readonly uint GAME_INFO = 3u; + + private BattleCaptainPVPHandler _handler = null; + + private XCaptainPVPDocument _capDoc = null; + + public List RankList = new List(); + + public List TeamBlood = new List(); + + private int num; + + public int myTeam; + + public int spectateInitTeam; + + public int spectateNowTeam; + + public ulong groupLeader1; + + public ulong groupLeader2; + + public string KillLeader; + + public string DeadLeader; + + private float lastShowInfoTime; + + private float lastKillTime; + + private float lastDeadTime; + + private float lastEndTime; + + private XBetterDictionary userIdToRole = new XBetterDictionary(0); + + public Queue qInfo = new Queue(); + + public int ShowConKillcnt = 0; + + private bool isChange = false; + + public bool isDead = false; + + public bool isEnd = false; + + private bool isEndAll = false; + + public bool playedBigResult = false; + + private XFx _ScaleFx1 = null; + + private XFx _ScaleFx2 = null; + + public string red = "[ef2717]"; + + public string blue = "[21b2ff]"; + + public static int ConKillIconDis = 130; + + public static int ConKillIconShowTime = 3; + + public struct KillInfo + { + public string KillName; + + public string DeadName; + + public bool IsDoodad; + } + + public struct RoleData + { + public ulong roleID; + + public int group; + + public uint Level; + + public string Name; + + public uint Profession; + } + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + } + + public override void OnEnterSceneFinally() + { + bool flag = XSingleton.singleton.SceneType == SceneType.SCENE_PVP; + if (flag) + { + this.Handler.SetVisible(true); + this._ScaleFx1 = XSingleton.singleton.CreateFx("Effects/FX_Particle/Roles/Lzg_Ty/Ty_bhdz", null, true); + this._ScaleFx2 = XSingleton.singleton.CreateFx("Effects/FX_Particle/Roles/Lzg_Ty/Ty_bhdz", null, true); + this.ReqBattleCaptainPVPRefreshInfo(true); + bool bSpectator = XSingleton.singleton.bSpectator; + if (bSpectator) + { + this.spectateInitTeam = 0; + this.spectateNowTeam = 0; + } + else + { + DlgBase.singleton.TeamMonitor.TeamInfoChangeOnSpectate(this.TeamBlood); + XTeamDocument specificDocument = XDocuments.GetSpecificDocument(XTeamDocument.uuID); + bool flag2 = !specificDocument.bInTeam; + if (flag2) + { + XSingleton.singleton.CacheUI(XSysDefine.XSys_Activity_CaptainPVP, EXStage.Hall); + } + } + } + } + + public override void OnLeaveScene() + { + bool flag = XSingleton.singleton.SceneType == SceneType.SCENE_PVP; + if (flag) + { + bool flag2 = this._ScaleFx1 != null; + if (flag2) + { + XSingleton.singleton.DestroyFx(this._ScaleFx1, true); + this._ScaleFx1 = null; + } + bool flag3 = this._ScaleFx2 != null; + if (flag3) + { + XSingleton.singleton.DestroyFx(this._ScaleFx2, true); + this._ScaleFx2 = null; + } + } + } + + protected override void EventSubscribe() + { + base.EventSubscribe(); + base.RegisterEvent(XEventDefine.XEvent_OnRevived, new XComponent.XEventHandler(this.OnPlayerReviveEvent)); + } + + public bool OnPlayerReviveEvent(XEventArgs args) + { + bool flag = this.Handler == null; + bool result; + if (flag) + { + result = false; + } + else + { + XOnRevivedArgs xonRevivedArgs = args as XOnRevivedArgs; + bool flag2 = !xonRevivedArgs.entity.IsPlayer; + if (flag2) + { + result = false; + } + else + { + this.Handler.m_Relive.gameObject.SetActive(false); + XSingleton.singleton.AddGreenLog("PlayerRevive", null, null, null, null, null); + result = true; + } + } + return result; + } + + public override void Update(float fDeltaT) + { + base.Update(fDeltaT); + bool flag = this.Handler == null || XSingleton.singleton.SceneType != SceneType.SCENE_PVP; + if (!flag) + { + this.Handler.RefreshLeaderHp(); + bool flag2 = Time.time > this.lastShowInfoTime + (float)XBattleCaptainPVPDocument.InfoDelayTime; + if (flag2) + { + while (this.qInfo.Count != 0) + { + this.qInfo.Clear(); + this.isChange = true; + } + } + bool flag3 = Time.time > this.lastKillTime + (float)XBattleCaptainPVPDocument.ConKillIconShowTime; + if (flag3) + { + bool flag4 = this.ShowConKillcnt != 0; + if (flag4) + { + this.ShowConKillcnt = 0; + this.isChange = true; + } + } + bool flag5 = Time.time > this.lastDeadTime + (float)XBattleCaptainPVPDocument.ReviveTime; + if (flag5) + { + bool flag6 = this.isDead; + if (flag6) + { + this.isDead = false; + this.Handler.ShowReviveTime(this.lastDeadTime + (float)XBattleCaptainPVPDocument.ReviveTime - Time.time, true); + } + } + bool flag7 = Time.time > this.lastEndTime + (float)XBattleCaptainPVPDocument.EndTime - 0.3f; + if (flag7) + { + bool flag8 = this.isEnd; + if (flag8) + { + this.isEnd = false; + this.Handler.ShowEndTime(this.lastEndTime + (float)XBattleCaptainPVPDocument.EndTime - Time.time, true, this.isEndAll); + } + } + bool flag9 = this.isEnd; + if (flag9) + { + this.Handler.ShowEndTime(this.lastEndTime + (float)XBattleCaptainPVPDocument.EndTime - Time.time, false, this.isEndAll); + } + bool flag10 = this.isDead; + if (flag10) + { + this.Handler.ShowReviveTime(this.lastDeadTime + (float)XBattleCaptainPVPDocument.ReviveTime - Time.time, false); + } + bool flag11 = this.isChange; + if (flag11) + { + this.Handler.ShowGameInfo(); + this.Handler.ShowConKill(this.ShowConKillcnt); + this.isChange = false; + } + } + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + bool flag = XSingleton.singleton.SceneType == SceneType.SCENE_PVP; + if (flag) + { + this.ReqBattleCaptainPVPRefreshInfo(true); + } + } + + public void ReqBattleCaptainPVPRefreshInfo(bool bNoShowLog) + { + RpcC2G_PvpNowAllData rpcC2G_PvpNowAllData = new RpcC2G_PvpNowAllData(); + rpcC2G_PvpNowAllData.oArg.bNoShowLog = bNoShowLog; + XSingleton.singleton.Send(rpcC2G_PvpNowAllData); + } + + public void SetReqBattleCaptainPVPRefreshInfo(roArg oArg, PvpNowGameData oRes) + { + bool flag = this.Handler == null || oRes.isAllEnd; + if (!flag) + { + this.Handler.StartAutoRefresh(null); + List nowUnitdData = oRes.nowUnitdData; + this.num = nowUnitdData.Count; + this.userIdToRole.Clear(); + for (int i = 0; i < this.num; i++) + { + XBattleCaptainPVPDocument.RoleData value; + value.roleID = nowUnitdData[i].roleID; + value.group = nowUnitdData[i].groupid; + value.Level = nowUnitdData[i].roleLevel; + value.Name = nowUnitdData[i].roleName; + value.Profession = nowUnitdData[i].roleProfession; + this.userIdToRole.Add(nowUnitdData[i].roleID, value); + bool flag2 = DlgBase.singleton.IsLoaded(); + if (flag2) + { + bool flag3 = this.myId == nowUnitdData[i].roleID; + if (flag3) + { + this.myTeam = nowUnitdData[i].groupid; + } + } + } + bool flag4 = DlgBase.singleton.IsLoaded(); + if (flag4) + { + bool flag5 = this.spectateInitTeam == 0; + if (flag5) + { + bool flag6 = XSingleton.singleton.Player.WatchTo == null; + if (flag6) + { + XSingleton.singleton.AddErrorLog("WatchTo is Null", null, null, null, null, null); + return; + } + this.SpectateTeamChange(XSingleton.singleton.Player.WatchTo.ID); + } + } + bool flag7 = this.GetInitTeam() == 0; + if (flag7) + { + XSingleton.singleton.AddErrorLog("No Team", null, null, null, null, null); + } + bool flag8 = DlgBase.singleton.IsLoaded(); + if (flag8) + { + this.TeamBlood.Clear(); + for (int j = 0; j < this.num; j++) + { + bool flag9 = this.myTeam != nowUnitdData[j].groupid; + if (!flag9) + { + XTeamBloodUIData xteamBloodUIData = new XTeamBloodUIData(); + xteamBloodUIData.uid = nowUnitdData[j].roleID; + xteamBloodUIData.entityID = nowUnitdData[j].roleID; + xteamBloodUIData.level = nowUnitdData[j].roleLevel; + xteamBloodUIData.name = nowUnitdData[j].roleName; + xteamBloodUIData.profession = (RoleType)nowUnitdData[j].roleProfession; + xteamBloodUIData.bIsLeader = false; + this.TeamBlood.Add(xteamBloodUIData); + } + } + DlgBase.singleton.TeamMonitor.TeamInfoChangeOnSpectate(this.TeamBlood); + } + this.RankList.Clear(); + int k = 0; + while (k < this.num) + { + bool flag10 = DlgBase.singleton.IsLoaded(); + if (!flag10) + { + goto IL_2F9; + } + bool flag11 = this.myTeam != nowUnitdData[k].groupid; + if (!flag11) + { + goto IL_2F9; + } + IL_35F: + k++; + continue; + IL_2F9: + XCaptainPVPInfo xcaptainPVPInfo = new XCaptainPVPInfo(); + xcaptainPVPInfo.name = nowUnitdData[k].roleName; + xcaptainPVPInfo.kill = nowUnitdData[k].killCount; + xcaptainPVPInfo.dead = nowUnitdData[k].dieCount; + xcaptainPVPInfo.id = nowUnitdData[k].roleID; + this.RankList.Add(xcaptainPVPInfo); + goto IL_35F; + } + XSceneDamageRankDocument specificDocument = XDocuments.GetSpecificDocument(XSceneDamageRankDocument.uuID); + specificDocument.OnGetRank(this.RankList); + bool flag12 = this.GetInitTeam() == 1; + if (flag12) + { + this.Handler.m_Blue.SetText(oRes.group1WinCount.ToString()); + this.Handler.m_Red.SetText(oRes.group2WinCount.ToString()); + } + else + { + bool flag13 = this.GetInitTeam() == 2; + if (flag13) + { + this.Handler.m_Blue.SetText(oRes.group2WinCount.ToString()); + this.Handler.m_Red.SetText(oRes.group1WinCount.ToString()); + } + } + bool flag14 = DlgBase.singleton.IsLoaded() && oRes.LeftTime > 0u; + if (flag14) + { + DlgBase.singleton.SetLeftTime(oRes.LeftTime, -1); + } + bool flag15 = DlgBase.singleton.IsLoaded() && oRes.LeftTime > 0u; + if (flag15) + { + DlgBase.singleton.SetLeftTime(oRes.LeftTime); + } + this.ClearPosition(); + this.RefreshLeader(oRes.group1Leader, oRes.group2Leader); + } + } + + private void RefreshLeader(ulong Leader1, ulong Leader2) + { + bool active = false; + this.groupLeader1 = Leader1; + this.groupLeader2 = Leader2; + bool flag = this.groupLeader1 == 0UL && this.groupLeader2 == 0UL; + if (!flag) + { + ulong num = this.MyPosition(true); + ulong redLeader = (num == this.groupLeader1) ? this.groupLeader2 : this.groupLeader1; + bool flag2 = DlgBase.singleton.IsLoaded(); + if (flag2) + { + this.ChangePosition(this.TeamBlood, num); + active = (num == this.myId); + this.Handler.ShowLeaderHpName(num, redLeader); + } + bool flag3 = DlgBase.singleton.IsLoaded(); + if (flag3) + { + XSpectateSceneDocument specificDocument = XDocuments.GetSpecificDocument(XSpectateSceneDocument.uuID); + bool flag4 = this.MyPosition(false) == this.groupLeader1; + if (flag4) + { + this.ChangePosition(specificDocument.LeftTeamMonitorData, this.groupLeader1); + this.ChangePosition(specificDocument.RightTeamMonitorData, this.groupLeader2); + this.Handler.ShowLeaderHpName(this.groupLeader1, this.groupLeader2); + } + else + { + bool flag5 = this.MyPosition(false) == this.groupLeader2; + if (flag5) + { + this.ChangePosition(specificDocument.LeftTeamMonitorData, this.groupLeader2); + this.ChangePosition(specificDocument.RightTeamMonitorData, this.groupLeader1); + this.Handler.ShowLeaderHpName(this.groupLeader2, this.groupLeader1); + } + } + } + XBattleCaptainPVPDocument.RoleData roleInfo = this.GetRoleInfo(num); + bool flag6 = roleInfo.roleID == 0UL; + if (flag6) + { + this.Handler.m_Leader.SetText(""); + } + else + { + this.Handler.m_Leader.SetText(roleInfo.Name); + } + bool flag7 = DlgBase.singleton.IsLoaded(); + if (flag7) + { + DlgBase.singleton.TeamMonitor.OnTeamInfoChanged(); + DlgBase.singleton.uiBehaviour.m_TeamLeader.SetActive(active); + DlgBase.singleton.IndicateHandler.ClearTeamIndicate(); + } + bool flag8 = DlgBase.singleton.IsLoaded(); + if (flag8) + { + DlgBase.singleton.SpectateTeamMonitor.OnTeamInfoChanged(); + } + bool flag9 = this.GetInitTeam() == 1; + if (flag9) + { + bool flag10 = DlgBase.singleton.IsLoaded(); + if (flag10) + { + XBattleDocument.SetMiniMapElement(this.groupLeader1, "smap_10", 20, 16); + XBattleDocument.SetMiniMapElement(this.groupLeader2, "smap_11", 20, 16); + } + bool flag11 = DlgBase.singleton.IsLoaded(); + if (flag11) + { + XSpectateSceneDocument.SetMiniMapElement(this.groupLeader1, "smap_10", 20, 16); + XSpectateSceneDocument.SetMiniMapElement(this.groupLeader2, "smap_11", 20, 16); + } + } + bool flag12 = this.GetInitTeam() == 2; + if (flag12) + { + bool flag13 = DlgBase.singleton.IsLoaded(); + if (flag13) + { + XBattleDocument.SetMiniMapElement(this.groupLeader2, "smap_10", 20, 16); + XBattleDocument.SetMiniMapElement(this.groupLeader1, "smap_11", 20, 16); + } + bool flag14 = DlgBase.singleton.IsLoaded(); + if (flag14) + { + XSpectateSceneDocument.SetMiniMapElement(this.groupLeader2, "smap_10", 20, 16); + XSpectateSceneDocument.SetMiniMapElement(this.groupLeader1, "smap_11", 20, 16); + } + } + this.FxPlay(); + } + } + + private void ClearPosition() + { + bool flag = this.groupLeader1 == 0UL && this.groupLeader2 == 0UL; + if (!flag) + { + bool flag2 = this._ScaleFx1 != null; + if (flag2) + { + this._ScaleFx1.Stop(); + } + bool flag3 = this._ScaleFx2 != null; + if (flag3) + { + this._ScaleFx2.Stop(); + } + bool flag4 = DlgBase.singleton.IsLoaded(); + if (flag4) + { + XBattleDocument.ResetMiniMapElement(this.groupLeader1); + XBattleDocument.ResetMiniMapElement(this.groupLeader2); + this.ChangePosition(this.TeamBlood, 0UL); + DlgBase.singleton.TeamMonitor.OnTeamInfoChanged(); + DlgBase.singleton.uiBehaviour.m_TeamLeader.SetActive(false); + } + bool flag5 = DlgBase.singleton.IsLoaded(); + if (flag5) + { + XSpectateSceneDocument specificDocument = XDocuments.GetSpecificDocument(XSpectateSceneDocument.uuID); + XSpectateSceneDocument.ResetMiniMapElement(this.groupLeader1); + XSpectateSceneDocument.ResetMiniMapElement(this.groupLeader2); + this.ChangePosition(specificDocument.LeftTeamMonitorData, 0UL); + this.ChangePosition(specificDocument.RightTeamMonitorData, 0UL); + DlgBase.singleton.SpectateTeamMonitor.OnTeamInfoChanged(); + } + this.groupLeader1 = 0UL; + this.groupLeader2 = 0UL; + } + } + + public void SetBattleBegin(PtcG2C_PvpBattleBeginNtf roPtc) + { + XSingleton.singleton.AddLog("SetBattleBegin", Time.time.ToString(), null, null, null, null, XDebugColor.XDebug_None); + bool flag = this.Handler != null; + if (flag) + { + this.Handler.ShowStart(); + } + this.ClearPosition(); + this.RefreshLeader(roPtc.Data.group1Leader, roPtc.Data.group2Leader); + } + + public void SetBattleEnd(PtcG2C_PvpBattleEndNtf roPtc) + { + XSingleton.singleton.AddLog("SetBattleEnd ", Time.time.ToString(), null, null, null, null, XDebugColor.XDebug_None); + bool flag = this.Handler == null; + if (!flag) + { + this.Handler.RefreshLeaderHp(); + this.isEndAll = roPtc.Data.isAllEnd; + this.isEnd = true; + this.Handler.m_Relive.gameObject.SetActive(false); + this.ShowConKillcnt = 0; + this.isChange = true; + bool flag2 = roPtc.Data.wingroup == 3; + if (!flag2) + { + bool flag3 = roPtc.Data.wingroup == this.GetInitTeam(); + if (flag3) + { + this.Handler.ShowSorce(true); + } + else + { + this.Handler.ShowSorce(false); + } + } + this.PlaySmallResult(roPtc); + } + } + + public void PlaySmallResult(PtcG2C_PvpBattleEndNtf roPtc) + { + this.lastEndTime = Time.time; + this.Handler.m_End.PlayTween(true, -1f); + this.Handler.m_EndIcon.gameObject.SetActive(false); + this.Handler.m_Draw.SetActive(false); + this.Handler.m_Win.SetActive(false); + this.Handler.m_Lose.SetActive(false); + bool flag = roPtc.Data.wingroup == 3; + if (flag) + { + this.Handler.m_Draw.SetActive(true); + } + else + { + bool flag2 = roPtc.Data.wingroup == this.GetNowTeam(); + if (flag2) + { + this.Handler.m_Win.SetActive(true); + } + else + { + this.Handler.m_Lose.SetActive(true); + } + } + bool flag3 = PVP_ONEGAMEEND_REASON.PVP_OGE_TIMELIMIT == roPtc.Data.reason; + if (flag3) + { + bool flag4 = roPtc.Data.wingroup == 3; + if (flag4) + { + this.Handler.m_EndText.SetText(XStringDefineProxy.GetString("CAPTAIN_DRAW")); + } + else + { + bool flag5 = roPtc.Data.wingroup == this.GetNowTeam(); + if (flag5) + { + this.Handler.m_EndText.SetText(XStringDefineProxy.GetString("CAPTAIN_WIN_OVERTIME")); + } + else + { + this.Handler.m_EndText.SetText(XStringDefineProxy.GetString("CAPTAIN_LOSE_OVERTIME")); + } + } + } + else + { + bool flag6 = roPtc.Data.wingroup == 3; + if (flag6) + { + this.Handler.m_EndText.SetText(XStringDefineProxy.GetString("CAPTAIN_DRAW")); + } + else + { + bool flag7 = roPtc.Data.wingroup == this.GetNowTeam(); + if (flag7) + { + string @string = XStringDefineProxy.GetString("CAPTAIN_WIN"); + bool flag8 = string.IsNullOrEmpty(this.DeadLeader) || string.IsNullOrEmpty(this.KillLeader); + if (flag8) + { + this.Handler.m_EndText.SetText(""); + } + else + { + this.Handler.m_EndText.SetText(string.Format(XStringDefineProxy.GetString("CAPTAIN_WIN"), this.DeadLeader, this.KillLeader)); + } + this.DeadLeader = null; + this.KillLeader = null; + } + else + { + this.Handler.m_EndText.SetText(XStringDefineProxy.GetString("CAPTAIN_LOSE")); + } + } + } + } + + public void PlayBigResult() + { + bool flag = this.playedBigResult; + if (!flag) + { + this.isEnd = true; + this.playedBigResult = true; + this.lastEndTime = Time.time; + this.Handler.m_End.PlayTween(true, -1f); + this.Handler.m_EndIcon.gameObject.SetActive(false); + this.Handler.m_Draw.SetActive(false); + this.Handler.m_Win.SetActive(false); + this.Handler.m_Lose.SetActive(false); + string format = "atlas/UI/Battle/{0}"; + this.Handler.m_EndIcon.gameObject.SetActive(true); + int res = this.GetRes(); + bool flag2 = res == 0; + if (flag2) + { + this.Handler.picPath = string.Format(format, "draw"); + this.Handler.m_EndIcon.SetTexturePath(this.Handler.picPath); + } + else + { + bool flag3 = res > 0; + if (flag3) + { + this.Handler.picPath = string.Format(format, "victery"); + this.Handler.m_EndIcon.SetTexturePath(this.Handler.picPath); + this.Handler.PlayAudio(6); + } + else + { + bool flag4 = res < 0; + if (flag4) + { + this.Handler.picPath = string.Format(format, "failure"); + this.Handler.m_EndIcon.SetTexturePath(this.Handler.picPath); + this.Handler.PlayAudio(7); + } + } + } + } + } + + public void SetBattleKill(PtcG2C_PvpBattleKill roPtc) + { + bool flag = this.Handler == null; + if (!flag) + { + ulong killID = roPtc.Data.killID; + ulong deadID = roPtc.Data.deadID; + XBattleCaptainPVPDocument.RoleData roleInfo = this.GetRoleInfo(killID); + XBattleCaptainPVPDocument.RoleData roleInfo2 = this.GetRoleInfo(deadID); + bool flag2 = roleInfo.roleID == 0UL || roleInfo2.roleID == 0UL; + if (!flag2) + { + bool flag3 = this.GetInitTeam() == roleInfo.group; + string text; + string text2; + if (flag3) + { + text = this.blue; + text2 = this.red; + } + else + { + text = this.red; + text2 = this.blue; + } + text += roleInfo.Name; + text2 += roleInfo2.Name; + this.AddGameInfo(text, text2, false); + bool flag4 = this.myId == killID; + if (flag4) + { + this.ShowConKillcnt = roPtc.Data.contiKillCount; + XSingleton.singleton.AddLog("ConKillcnt:" + this.ShowConKillcnt.ToString(), null, null, null, null, null, XDebugColor.XDebug_None); + this.lastKillTime = Time.time; + XSingleton.singleton.PlayUISound("Audio/UI/pVP_kill", true, AudioChannel.Action); + } + bool flag5 = this.myId == deadID; + if (flag5) + { + this.isDead = true; + this.lastDeadTime = Time.time; + bool flag6 = this.Handler != null; + if (flag6) + { + this.Handler.m_Relive.PlayTween(true, -1f); + } + } + bool flag7 = this.groupLeader1 == deadID || this.groupLeader2 == deadID; + if (flag7) + { + this.KillLeader = text; + this.DeadLeader = text2; + } + this.isChange = true; + for (int i = 0; i < this.RankList.Count; i++) + { + bool flag8 = killID == this.RankList[i].id; + if (flag8) + { + bool flag9 = deadID == this.groupLeader1 || deadID == this.groupLeader2; + if (flag9) + { + this.RankList[i].kill += XSingleton.singleton.GetInt("PVPLeaderKillCount"); + } + else + { + this.RankList[i].kill++; + } + } + bool flag10 = deadID == this.RankList[i].id; + if (flag10) + { + this.RankList[i].dead++; + } + } + XSceneDamageRankDocument specificDocument = XDocuments.GetSpecificDocument(XSceneDamageRankDocument.uuID); + specificDocument.OnGetRank(this.RankList); + } + } + } + + public void AddGameInfo(ulong roleID, uint doodadID) + { + XBattleCaptainPVPDocument.RoleData roleInfo = this.GetRoleInfo(roleID); + BuffTable.RowData buffData = XSingleton.singleton.GetBuffData((int)doodadID, 1); + string text = string.Empty; + bool flag = buffData == null; + if (flag) + { + XSingleton.singleton.AddErrorLog(string.Format("CaptainPVP: Buff data not found: [{0} {1}]", doodadID, 1), null, null, null, null, null); + } + else + { + text = buffData.BuffName; + } + bool flag2 = this.GetInitTeam() == roleInfo.group; + string infoLeft; + if (flag2) + { + infoLeft = string.Format("{0}{1}", this.blue, roleInfo.Name); + } + else + { + infoLeft = string.Format("{0}{1}", this.red, roleInfo.Name); + } + StringBuilder stringBuilder = new StringBuilder(); + bool flag3 = false; + for (int i = 0; i < text.Length; i++) + { + bool flag4 = text[i] == '['; + if (flag4) + { + flag3 = true; + } + bool flag5 = text[i] == ')'; + if (flag5) + { + flag3 = false; + } + bool flag6 = flag3; + if (flag6) + { + stringBuilder.Append(text[i]); + } + bool flag7 = text[i] == '('; + if (flag7) + { + flag3 = true; + } + bool flag8 = text[i] == ']'; + if (flag8) + { + flag3 = false; + } + } + this.AddGameInfo(infoLeft, stringBuilder.ToString(), true); + } + + public void AddGameInfo(string infoLeft, string infoRight, bool IsDoodad = false) + { + this.lastShowInfoTime = Time.time; + XBattleCaptainPVPDocument.KillInfo item; + item.KillName = infoLeft; + item.DeadName = infoRight; + item.IsDoodad = IsDoodad; + this.qInfo.Enqueue(item); + bool flag = (long)this.qInfo.Count > (long)((ulong)XBattleCaptainPVPDocument.GAME_INFO); + if (flag) + { + this.qInfo.Dequeue(); + } + bool flag2 = this.Handler != null; + if (flag2) + { + this.Handler.ShowGameInfo(); + } + } + + private void FxPlay() + { + XEntity entity = XSingleton.singleton.GetEntity(this.groupLeader1); + bool flag = entity != null && this._ScaleFx1 != null; + if (flag) + { + this._ScaleFx1.Play(entity.EngineObject, Vector3.zero, entity.Height / entity.Scale * Vector3.one, 1f, true, false, "", 0f); + } + XEntity entity2 = XSingleton.singleton.GetEntity(this.groupLeader2); + bool flag2 = entity2 != null && this._ScaleFx2 != null; + if (flag2) + { + this._ScaleFx2.Play(entity2.EngineObject, Vector3.zero, entity2.Height / entity2.Scale * Vector3.one, 1f, true, false, "", 0f); + } + } + + public void SpectateTeamChange(ulong roleID) + { + bool flag = DlgBase.singleton.IsLoaded(); + if (flag) + { + bool flag2 = this.userIdToRole != null && this.userIdToRole.size > 0; + if (flag2) + { + this.spectateInitTeam = this.GetRoleInfo(roleID).group; + this.spectateNowTeam = this.spectateInitTeam; + } + else + { + XSingleton.singleton.AddErrorLog("userIdToRole Is Null", null, null, null, null, null); + } + } + } + + public XBattleCaptainPVPDocument.RoleData GetRoleInfo(ulong roleId) + { + XBattleCaptainPVPDocument.RoleData result; + bool flag = !this.userIdToRole.TryGetValue(roleId, out result); + if (flag) + { + XSingleton.singleton.AddErrorLog("No Find roleId! roleId:" + roleId, null, null, null, null, null); + for (int i = 0; i < this.userIdToRole.size; i++) + { + XSingleton.singleton.AddGreenLog("RoleId:" + this.userIdToRole.BufferKeys[i], null, null, null, null, null); + } + } + return result; + } + + public void ChangePosition(List team, ulong leaderId) + { + for (int i = 0; i < team.Count; i++) + { + team[i].bIsLeader = (leaderId == team[i].uid); + } + } + + public ulong MyPosition(bool isNowTeam) + { + if (isNowTeam) + { + bool flag = this.GetNowTeam() == 1; + if (flag) + { + return this.groupLeader1; + } + bool flag2 = this.GetNowTeam() == 2; + if (flag2) + { + return this.groupLeader2; + } + } + else + { + bool flag3 = this.GetInitTeam() == 1; + if (flag3) + { + return this.groupLeader1; + } + bool flag4 = this.GetInitTeam() == 2; + if (flag4) + { + return this.groupLeader2; + } + } + return 0UL; + } + + private int GetNowTeam() + { + bool flag = DlgBase.singleton.IsLoaded(); + int result; + if (flag) + { + result = this.spectateNowTeam; + } + else + { + result = this.myTeam; + } + return result; + } + + private int GetInitTeam() + { + bool flag = DlgBase.singleton.IsLoaded(); + int result; + if (flag) + { + result = this.spectateInitTeam; + } + else + { + result = this.myTeam; + } + return result; + } + + private int GetRes() + { + bool flag = DlgBase.singleton.IsLoaded() && this.spectateNowTeam == 2; + int num; + int num2; + if (flag) + { + num = int.Parse(this.Handler.m_Red.GetText()); + num2 = int.Parse(this.Handler.m_Blue.GetText()); + } + else + { + num = int.Parse(this.Handler.m_Blue.GetText()); + num2 = int.Parse(this.Handler.m_Red.GetText()); + } + return num - num2; + } + } +} -- cgit v1.1-26-g67d0