diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Guild/XGuildArenaBattleDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/Guild/XGuildArenaBattleDocument.cs | 1157 |
1 files changed, 1157 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/Guild/XGuildArenaBattleDocument.cs b/Client/Assets/Scripts/XMainClient/Guild/XGuildArenaBattleDocument.cs new file mode 100644 index 00000000..3bb2f2b6 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Guild/XGuildArenaBattleDocument.cs @@ -0,0 +1,1157 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XGuildArenaBattleDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XGuildArenaBattleDocument.uuID;
+ }
+ }
+
+ public GVGBattleInfo BlueInfo
+ {
+ get
+ {
+ return this._blueInfo;
+ }
+ }
+
+ public GVGBattleInfo RedInfo
+ {
+ get
+ {
+ return this._redInfo;
+ }
+ }
+
+ public double InspireCDTime
+ {
+ get
+ {
+ return this.m_InspireCDTime;
+ }
+ }
+
+ private IGVGBattlePrepare CurView
+ {
+ get
+ {
+ bool flag = this.Pattern == GuildArenaBattlePattern.GMF || this.Pattern == GuildArenaBattlePattern.GPR;
+ IGVGBattlePrepare singleton;
+ if (flag)
+ {
+ singleton = DlgBase<InnerGVGBattlePrepareView, InnerGVGBattlePrepareBehaviour>.singleton;
+ }
+ else
+ {
+ singleton = DlgBase<CrossGVGBattlePrepareView, CrossGVGBattlePrepareBehaviour>.singleton;
+ }
+ return singleton;
+ }
+ }
+
+ private bool IsGVG
+ {
+ get
+ {
+ SceneType sceneType = XSingleton<XScene>.singleton.SceneType;
+ return sceneType == SceneType.SCENE_GPR || sceneType == SceneType.SCENE_GMF || sceneType == SceneType.SCENE_GCF;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("XGuildArenaBattleDocument");
+
+ private GVGBattleInfo _blueInfo = new GVGBattleInfo();
+
+ private GVGBattleInfo _redInfo = new GVGBattleInfo();
+
+ public double m_InspireCDTime = 0.0;
+
+ public uint ReviveItemID = 0u;
+
+ public uint ReviveItemNumber = 0u;
+
+ public GuildArenaBattlePattern Pattern = GuildArenaBattlePattern.GPR;
+
+ public XGuildArenaBattleDocument.ReadyType MyReadyType = XGuildArenaBattleDocument.ReadyType.Observer;
+
+ public GuildMatchFightState MyFightState = GuildMatchFightState.GUILD_MF_NONE;
+
+ public GmfRoleDatas mGmfRoleDatas = null;
+
+ public int GMFGroupBlueMatchPoint = 0;
+
+ public int GMFGroupRedMatchPoint = 0;
+
+ public XGuildArenaBattleDocument.BattleEndData blueBattleEndData = new XGuildArenaBattleDocument.BattleEndData();
+
+ public XGuildArenaBattleDocument.BattleEndData redBattleEndData = new XGuildArenaBattleDocument.BattleEndData();
+
+ public XGuildArenaBattleDocument.GuildArenaSection mArenaSection;
+
+ public GVGCombatInfo blueCombatInfo = new GVGCombatInfo();
+
+ public GVGCombatInfo redCombatInfo = new GVGCombatInfo();
+
+ public XGuildArenaBattleDocument.BattleEndData blueAllFightEnd = new XGuildArenaBattleDocument.BattleEndData();
+
+ public XGuildArenaBattleDocument.BattleEndData redAllFightEnd = new XGuildArenaBattleDocument.BattleEndData();
+
+ public uint _kicked_token = 0u;
+
+ public bool bCantUpForKicked = false;
+
+ protected internal XFx fxEncourageButton;
+
+ protected internal XFx fxEncourageProgressNum;
+
+ protected internal XFx fxEncourageProgressAdd;
+
+ public GVGDuelResult BlueDuelResult = new GVGDuelResult();
+
+ public GVGDuelResult RedDuelResult = new GVGDuelResult();
+
+ public uint Round = 0u;
+
+ public bool InBattleGroup = false;
+
+ public enum GuildArenaSection
+ {
+ Prepare,
+ Battle,
+ Result
+ }
+
+ public enum ReadyType
+ {
+ Ready,
+ NoReady,
+ Observer
+ }
+
+ public class BattleEndData
+ {
+ public bool isWin = true;
+
+ public GmfRoleBrief Role = null;
+
+ public GmfGuildBrief Guild = null;
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ }
+
+ private ulong GetMyGuildID()
+ {
+ return XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID).BasicData.uid;
+ }
+
+ public int GetBattleSignNumber()
+ {
+ SceneType sceneType = XSingleton<XScene>.singleton.SceneType;
+ int result = 0;
+ bool flag = sceneType == SceneType.SCENE_GPR || sceneType == SceneType.SCENE_GCF;
+ if (flag)
+ {
+ result = XSingleton<XGlobalConfig>.singleton.GetInt("GuildArenaBattleGpr");
+ }
+ else
+ {
+ bool flag2 = sceneType == SceneType.SCENE_GMF;
+ if (flag2)
+ {
+ result = XSingleton<XGlobalConfig>.singleton.GetInt("GuildArenaBattleNumber");
+ }
+ }
+ return result;
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ base.OnEnterSceneFinally();
+ bool isGVG = this.IsGVG;
+ if (isGVG)
+ {
+ this.EnterGVG();
+ }
+ }
+
+ public override void OnLeaveScene()
+ {
+ bool isGVG = this.IsGVG;
+ if (isGVG)
+ {
+ this.LeaveGVG();
+ }
+ }
+
+ public override void Update(float fDeltaT)
+ {
+ base.Update(fDeltaT);
+ this.InspireUpdate(fDeltaT);
+ }
+
+ public void OnUpdateGuildArenaBattle(GmfRoleDatas data)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("OnUpdateGuildArenaBattle", data.halfrole11.inspire.ToString(), " ", data.halfrole22.inspire.ToString(), null, null);
+ this.mGmfRoleDatas = data;
+ this.MyFightState = GuildMatchFightState.GUILD_MF_NONE;
+ this.MyReadyType = XGuildArenaBattleDocument.ReadyType.Observer;
+ ulong myGuildID = this.GetMyGuildID();
+ bool flag = data.halfrole11.guildb.guildid == myGuildID;
+ if (flag)
+ {
+ this.InBattleGroup = true;
+ this._blueInfo.Convert(data.halfrole11);
+ this._redInfo.Convert(data.halfrole22);
+ this.CheckRoleState(this._blueInfo.Group, XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID, ref this.MyFightState, ref this.MyReadyType);
+ }
+ else
+ {
+ bool flag2 = data.halfrole22.guildb.guildid == myGuildID;
+ if (flag2)
+ {
+ this.InBattleGroup = true;
+ this._blueInfo.Convert(data.halfrole22);
+ this._redInfo.Convert(data.halfrole11);
+ this.CheckRoleState(this._blueInfo.Group, XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID, ref this.MyFightState, ref this.MyReadyType);
+ }
+ else
+ {
+ this.InBattleGroup = false;
+ this._blueInfo.Convert(data.halfrole11);
+ this._redInfo.Convert(data.halfrole22);
+ }
+ }
+ bool flag3 = this.IsGMF();
+ if (flag3)
+ {
+ this.MatchPoint();
+ }
+ bool flag4 = this.CurView.IsVisible();
+ if (flag4)
+ {
+ this.CurView.ReFreshGroup();
+ }
+ }
+
+ private void CheckRoleState(List<GmfRole> roles, ulong roleID, ref GuildMatchFightState state, ref XGuildArenaBattleDocument.ReadyType type)
+ {
+ bool flag = roles == null;
+ if (!flag)
+ {
+ type = XGuildArenaBattleDocument.ReadyType.NoReady;
+ int i = 0;
+ int count = roles.Count;
+ while (i < count)
+ {
+ bool flag2 = roles[i].roleID == roleID;
+ if (flag2)
+ {
+ state = roles[i].state;
+ type = XGuildArenaBattleDocument.ReadyType.Ready;
+ break;
+ }
+ i++;
+ }
+ }
+ }
+
+ private void SpectateSpecial(GmfRoleDatas data)
+ {
+ bool bSpectator = XSingleton<XScene>.singleton.bSpectator;
+ if (bSpectator)
+ {
+ XSpectateSceneDocument specificDocument = XDocuments.GetSpecificDocument<XSpectateSceneDocument>(XSpectateSceneDocument.uuID);
+ bool flag = specificDocument.BlueSaveID == 0UL || specificDocument.RedSaveID == 0UL;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.SpectateSpecial ", specificDocument.BlueSaveID.ToString(), " <-> ", specificDocument.RedSaveID.ToString(), null, null, XDebugColor.XDebug_None);
+ }
+ else
+ {
+ bool flag2 = specificDocument.BlueSaveID == data.halfrole11.guildb.guildid;
+ if (flag2)
+ {
+ this._blueInfo.Convert(data.halfrole11);
+ this._redInfo.Convert(data.halfrole22);
+ this.MyReadyType = XGuildArenaBattleDocument.ReadyType.NoReady;
+ foreach (GmfRole gmfRole in this._blueInfo.Group)
+ {
+ bool flag3 = gmfRole.roleID == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag3)
+ {
+ this.MyReadyType = XGuildArenaBattleDocument.ReadyType.Ready;
+ this.MyFightState = gmfRole.state;
+ break;
+ }
+ }
+ }
+ else
+ {
+ bool flag4 = specificDocument.BlueSaveID == data.halfrole22.guildb.guildid;
+ if (flag4)
+ {
+ this._blueInfo.Convert(data.halfrole22);
+ this._redInfo.Convert(data.halfrole11);
+ this.MyReadyType = XGuildArenaBattleDocument.ReadyType.NoReady;
+ foreach (GmfRole gmfRole2 in this._blueInfo.Group)
+ {
+ bool flag5 = gmfRole2.roleID == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag5)
+ {
+ this.MyReadyType = XGuildArenaBattleDocument.ReadyType.Ready;
+ this.MyFightState = gmfRole2.state;
+ break;
+ }
+ }
+ }
+ else
+ {
+ this._blueInfo.Convert(data.halfrole11);
+ this._redInfo.Convert(data.halfrole22);
+ this.MyReadyType = XGuildArenaBattleDocument.ReadyType.Observer;
+ }
+ }
+ }
+ }
+ }
+
+ private void MatchPoint()
+ {
+ int num = 0;
+ int num2 = 0;
+ foreach (GmfRole gmfRole in this._blueInfo.Group)
+ {
+ bool flag = gmfRole.roleID == 0UL;
+ if (!flag)
+ {
+ GuildMatchFightState state = gmfRole.state;
+ if (state == GuildMatchFightState.GUILD_MF_WAITING || state == GuildMatchFightState.GUILD_MF_FIGHTING)
+ {
+ num++;
+ }
+ }
+ }
+ foreach (GmfRole gmfRole2 in this._redInfo.Group)
+ {
+ bool flag2 = gmfRole2.roleID == 0UL;
+ if (!flag2)
+ {
+ GuildMatchFightState state2 = gmfRole2.state;
+ if (state2 == GuildMatchFightState.GUILD_MF_WAITING || state2 == GuildMatchFightState.GUILD_MF_FIGHTING)
+ {
+ num2++;
+ }
+ }
+ }
+ this.GMFGroupBlueMatchPoint = num;
+ this.GMFGroupRedMatchPoint = num2;
+ }
+
+ public void OnUpdateBattleEnd(GmfOneBattleEnd data)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnUpdateBattleEnd ", data.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ bool flag = !this.IsGMF();
+ if (!flag)
+ {
+ bool flag2 = DlgBase<XChatView, XChatBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XChatView, XChatBehaviour>.singleton.SetVisible(false, true);
+ }
+ bool flag3 = data.winguild.guildid == XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID).BasicData.uid;
+ if (flag3)
+ {
+ this.blueBattleEndData.isWin = true;
+ this.redBattleEndData.isWin = false;
+ this.blueBattleEndData.Role = data.winrole;
+ this.redBattleEndData.Role = data.loselrole;
+ this.blueBattleEndData.Guild = data.winguild;
+ this.redBattleEndData.Guild = data.loseguild;
+ }
+ else
+ {
+ bool flag4 = data.loseguild.guildid == XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID).BasicData.uid;
+ if (flag4)
+ {
+ this.blueBattleEndData.isWin = false;
+ this.redBattleEndData.isWin = true;
+ this.blueBattleEndData.Role = data.loselrole;
+ this.redBattleEndData.Role = data.winrole;
+ this.blueBattleEndData.Guild = data.loseguild;
+ this.redBattleEndData.Guild = data.winguild;
+ }
+ else
+ {
+ this.blueBattleEndData.isWin = true;
+ this.redBattleEndData.isWin = false;
+ this.blueBattleEndData.Role = data.winrole;
+ this.redBattleEndData.Role = data.loselrole;
+ this.blueBattleEndData.Guild = data.winguild;
+ this.redBattleEndData.Guild = data.loseguild;
+ }
+ }
+ ulong roleID = XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ bool flag5 = roleID == this.blueBattleEndData.Role.roleid;
+ bool flag6 = roleID == this.redBattleEndData.Role.roleid;
+ bool flag7 = flag5;
+ if (flag7)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.GmfOneBattleEnd Killer", null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ bool flag8 = flag6;
+ if (flag8)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.GmfOneBattleEnd Deader", null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ string smallResult = string.Empty;
+ switch (data.reason)
+ {
+ case GMFFailReason.GMF_FAIL_NONE:
+ case GMFFailReason.GMF_FAIL_DIE:
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetSmallResult("");
+ break;
+ case GMFFailReason.GMF_FAIL_TIMEOVER:
+ smallResult = string.Format(XStringDefineProxy.GetString("GUILD_ARENA_OVERTIME_WINER_PERSONAL"), data.winrole.rolename);
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetSmallResult(smallResult);
+ break;
+ case GMFFailReason.GMF_FAIL_QUIT:
+ smallResult = string.Format(XStringDefineProxy.GetString("GUILD_ARENA_THEY_QUITE_PERSONAL"), data.loselrole.rolename);
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetSmallResult(smallResult);
+ break;
+ case GMFFailReason.GMF_FAIL_REFRESE:
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetSmallResult("");
+ break;
+ default:
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetSmallResult("");
+ break;
+ }
+ }
+ }
+
+ public void ReceiveGuildCombatNotify(GmfGuildCombatPara param)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.ReceiveGuildCombatNotify ", null, null, null, null, null, XDebugColor.XDebug_None);
+ bool flag = param.guildcombat11 == null || param.guildcombat22 == null;
+ if (!flag)
+ {
+ ulong myGuildID = this.GetMyGuildID();
+ bool flag2 = param.guildcombat11.gmfguild.guildid == myGuildID;
+ if (flag2)
+ {
+ this.blueCombatInfo.Set(param.guildcombat11);
+ this.redCombatInfo.Set(param.guildcombat22);
+ this.BlueInfo.Convert(param.guildcombat11.rolecombat);
+ this.RedInfo.Convert(param.guildcombat22.rolecombat);
+ }
+ else
+ {
+ bool flag3 = param.guildcombat22.gmfguild.guildid == myGuildID;
+ if (flag3)
+ {
+ this.blueCombatInfo.Set(param.guildcombat22);
+ this.redCombatInfo.Set(param.guildcombat11);
+ this.BlueInfo.Convert(param.guildcombat22.rolecombat);
+ this.RedInfo.Convert(param.guildcombat11.rolecombat);
+ }
+ else
+ {
+ this.blueCombatInfo.Set(param.guildcombat11);
+ this.redCombatInfo.Set(param.guildcombat22);
+ this.BlueInfo.Convert(param.guildcombat11.rolecombat);
+ this.RedInfo.Convert(param.guildcombat22.rolecombat);
+ }
+ }
+ this.Round = param.guildcombat11.score + param.guildcombat22.score;
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.ReceiveGuildCombatNotify ", this.Round.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ bool flag4 = this.CurView.IsVisible();
+ if (flag4)
+ {
+ this.CurView.ReFreshGroup();
+ }
+ }
+ }
+
+ public void OnAllFightEnd(GmfAllFightEnd data)
+ {
+ bool flag = !this.IsGMF();
+ if (!flag)
+ {
+ bool flag2 = DlgBase<XChatView, XChatBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XChatView, XChatBehaviour>.singleton.SetVisible(false, true);
+ }
+ string log = "winguild:" + data.winguild.ToString() + "loseguildid:" + data.loseguild.ToString();
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnAllFightEnd ", log, null, null, null, null, XDebugColor.XDebug_None);
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.RefreahCountTime(10f, true);
+ bool flag3 = data.winguild.guildid == XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID).BasicData.uid;
+ if (flag3)
+ {
+ this.blueAllFightEnd.isWin = true;
+ this.redAllFightEnd.isWin = false;
+ this.blueAllFightEnd.Guild = data.winguild;
+ this.redAllFightEnd.Guild = data.loseguild;
+ }
+ else
+ {
+ bool flag4 = data.loseguild.guildid == XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID).BasicData.uid;
+ if (flag4)
+ {
+ this.blueAllFightEnd.isWin = false;
+ this.redAllFightEnd.isWin = true;
+ this.blueAllFightEnd.Guild = data.loseguild;
+ this.redAllFightEnd.Guild = data.winguild;
+ }
+ else
+ {
+ this.blueAllFightEnd.isWin = true;
+ this.redAllFightEnd.isWin = false;
+ this.blueAllFightEnd.Guild = data.winguild;
+ this.redAllFightEnd.Guild = data.loseguild;
+ }
+ }
+ GmfGuildBrief winguild = data.winguild;
+ GmfGuildBrief loseguild = data.loseguild;
+ this.CurView.SetVisible(false, true);
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetVisible(true, true);
+ string guildResult = string.Empty;
+ bool flag5 = winguild.guildid == loseguild.guildid;
+ if (flag5)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("data.winguildid = data.loseguildid", null, null, null, null, null);
+ }
+ else
+ {
+ bool flag6 = winguild.guildid == XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID).BasicData.uid;
+ if (flag6)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnAllFightEnd Guild Win", null, null, null, null, null, XDebugColor.XDebug_None);
+ switch (data.wintype)
+ {
+ case GMF_FINAL_WIN_TYPE.GMF_FWY_NORMAL:
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetGuildResult("");
+ break;
+ case GMF_FINAL_WIN_TYPE.GMF_FWY_OPNONE:
+ guildResult = string.Format(XStringDefineProxy.GetString("GUILD_ARENA_QUITE"), loseguild.guildname);
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetGuildResult(guildResult);
+ break;
+ case GMF_FINAL_WIN_TYPE.GMF_FWY_RANK:
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetGuildResult(XStringDefineProxy.GetString("GUILD_ARENA_WIN_GUILDALL_RANK"));
+ break;
+ }
+ }
+ else
+ {
+ bool flag7 = loseguild.guildid == XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID).BasicData.uid;
+ if (flag7)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnAllFightEnd Guild Failed", null, null, null, null, null, XDebugColor.XDebug_None);
+ switch (data.wintype)
+ {
+ case GMF_FINAL_WIN_TYPE.GMF_FWY_NORMAL:
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetGuildResult("");
+ break;
+ case GMF_FINAL_WIN_TYPE.GMF_FWY_OPNONE:
+ guildResult = string.Format(XStringDefineProxy.GetString("GUILD_ARENA_QUITE"), loseguild.guildname);
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetGuildResult(guildResult);
+ break;
+ case GMF_FINAL_WIN_TYPE.GMF_FWY_RANK:
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetGuildResult(XStringDefineProxy.GetString("GUILD_ARENA_WIN_GUILDALL_RANK"));
+ break;
+ }
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnAllFightEnd winguildid Observer", null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ }
+ }
+ }
+ }
+
+ public void OnGmfJoinBattle(GmfJoinBattleArg oRes)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.GmfJoinBattleArg ", oRes.leftTime.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+
+ public void GetJoinBattleRes()
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.GetJoinBattleRes ", null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+
+ public void OnWaitOtherLoad(GmfWaitOtherArg oRes)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnWaitOtherLoad ", oRes.lefttime.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+
+ public void OnWaitFightBegin(GmfWaitFightArg oRes)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnWaitFightBegin ", oRes.lefttime.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+
+ public void ReadyReq(ulong roleid, GMFReadyType type)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.ReadyReq ", type.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ RpcC2G_GmfReadyReq rpcC2G_GmfReadyReq = new RpcC2G_GmfReadyReq();
+ rpcC2G_GmfReadyReq.oArg.roleid = roleid;
+ rpcC2G_GmfReadyReq.oArg.type = type;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GmfReadyReq);
+ }
+
+ public void OnReadyReq(GmfReadyRes oRes)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnReadyReq ", oRes.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ bool flag = oRes.errcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errcode, "fece00");
+ }
+ else
+ {
+ bool flag2 = this.CurView.IsVisible();
+ if (flag2)
+ {
+ this.CurView.ReFreshGroup();
+ }
+ }
+ }
+
+ public void InspireReq()
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.InspireReq ", null, null, null, null, null, XDebugColor.XDebug_None);
+ RpcC2G_InspireReq rpc = new RpcC2G_InspireReq();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ private void InspireUpdate(float detailTime)
+ {
+ bool flag = this.m_InspireCDTime > 0.0;
+ if (flag)
+ {
+ this.m_InspireCDTime -= (double)detailTime;
+ }
+ else
+ {
+ this.m_InspireCDTime = 0.0;
+ }
+ }
+
+ public void OnInspireReq(InspireRes oRes)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnInspireReq ", oRes.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ bool flag = oRes.ErrorCode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.ErrorCode, "fece00");
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("XMainClient.XGuildArenaBattleDocument.Inspire.Cooldowntime:", oRes.cooldowntime.ToString(), null, null, null, null);
+ this.m_InspireCDTime = double.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("GMFInspireCoolDown"));
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("GUILDARENA_INSPIRE_NOTICE"), "fece00");
+ bool flag2 = this.CurView.IsLoaded() && this.CurView.IsVisible();
+ if (flag2)
+ {
+ this.CurView.RefreshInspire();
+ }
+ }
+ }
+
+ public void OnBattleState(GmfBatlleStatePara Data)
+ {
+ XSingleton<XDebug>.singleton.AddLog("XMainClient.XGuildArenaBattleDocument.OnBattleState ", Data.state.ToString(), " ", Data.lefttime.ToString(), null, null, XDebugColor.XDebug_None);
+ switch (Data.state)
+ {
+ case GmfBattleState.GMF_BS_WAIT:
+ {
+ this.mArenaSection = XGuildArenaBattleDocument.GuildArenaSection.Prepare;
+ bool flag = DlgBase<GuildArenaDuelRoundResultDlg, GuildArenaDuelRoundResultBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<GuildArenaDuelRoundResultDlg, GuildArenaDuelRoundResultBehaviour>.singleton.ReturnHall();
+ }
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetVisible(false, true);
+ bool flag2 = !this.CurView.IsVisible();
+ if (flag2)
+ {
+ this.CurView.SetVisible(true, true);
+ }
+ else
+ {
+ this.CurView.RefreshSection();
+ }
+ this.CurView.RefreahCountTime(Data.lefttime);
+ break;
+ }
+ case GmfBattleState.GMF_BS_FIGHT:
+ {
+ this.mArenaSection = XGuildArenaBattleDocument.GuildArenaSection.Battle;
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetVisible(false, true);
+ bool flag3 = !this.CurView.IsVisible();
+ if (flag3)
+ {
+ this.CurView.SetVisible(true, true);
+ }
+ else
+ {
+ this.CurView.RefreshSection();
+ }
+ this.CurView.RefreahCountTime(Data.lefttime);
+ break;
+ }
+ case GmfBattleState.GMF_BS_RESULT:
+ {
+ this.CurView.SetVisible(false, true);
+ bool flag4 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_GMF;
+ if (flag4)
+ {
+ this.mArenaSection = XGuildArenaBattleDocument.GuildArenaSection.Result;
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.SetVisible(true, true);
+ DlgBase<GuildArenaDefeatDlg, GuildArenaDefeatBehaviour>.singleton.RefreahCountTime(Data.lefttime, false);
+ }
+ else
+ {
+ bool flag5 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_GPR;
+ if (flag5)
+ {
+ this.mArenaSection = XGuildArenaBattleDocument.GuildArenaSection.Prepare;
+ }
+ }
+ break;
+ }
+ case GmfBattleState.GMF_BS_NONE:
+ XSingleton<XDebug>.singleton.AddErrorLog("XMainClient.XGuildArenaBattleDocument.OnInspireReq ", Data.state.ToString(), " ", Data.lefttime.ToString(), null, null);
+ break;
+ }
+ }
+
+ public void OnBekicked(GmfKickRes res)
+ {
+ string text = string.Format(XSingleton<XStringTable>.singleton.GetString("GUILD_ARENA_BEKICKED"), res.kickname);
+ XSingleton<UiUtility>.singleton.ShowSystemTip(text, "fece00");
+ bool flag = res.cooldowntime > 0.01f;
+ if (flag)
+ {
+ this.bCantUpForKicked = true;
+ bool flag2 = this._kicked_token > 0u;
+ if (flag2)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._kicked_token);
+ }
+ this._kicked_token = XSingleton<XTimerMgr>.singleton.SetTimer(res.cooldowntime, new XTimerMgr.ElapsedEventHandler(this.OnBekickedCallback), null);
+ }
+ bool flag3 = this.CurView.IsLoaded();
+ if (flag3)
+ {
+ this.CurView.UpdateDownUp();
+ }
+ }
+
+ private void OnBekickedCallback(object o)
+ {
+ this.bCantUpForKicked = false;
+ bool flag = this.CurView.IsLoaded();
+ if (flag)
+ {
+ this.CurView.UpdateDownUp();
+ }
+ }
+
+ public void ChangeSpectator(XRole role)
+ {
+ }
+
+ private void ConvertSceneTypeToPattern(SceneType type, ref GuildArenaBattlePattern pattern)
+ {
+ if (type != SceneType.SCENE_GMF)
+ {
+ if (type != SceneType.SCENE_GPR)
+ {
+ if (type == SceneType.SCENE_GCF)
+ {
+ pattern = GuildArenaBattlePattern.GCF;
+ }
+ }
+ else
+ {
+ pattern = GuildArenaBattlePattern.GPR;
+ }
+ }
+ else
+ {
+ pattern = GuildArenaBattlePattern.GMF;
+ }
+ }
+
+ private void EnterGVG()
+ {
+ this.ConvertSceneTypeToPattern(XSingleton<XScene>.singleton.SceneType, ref this.Pattern);
+ this.CurView.OnEnterSceneFinally();
+ this.bCantUpForKicked = false;
+ bool flag = this.fxEncourageButton == null;
+ if (flag)
+ {
+ this.fxEncourageButton = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_Encourage", null, true);
+ }
+ bool flag2 = this.fxEncourageProgressNum == null;
+ if (flag2)
+ {
+ this.fxEncourageProgressNum = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_Encourage_Num", null, true);
+ }
+ bool flag3 = this.fxEncourageProgressAdd == null;
+ if (flag3)
+ {
+ this.fxEncourageProgressAdd = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_Encourage_Add", null, true);
+ }
+ bool flag4 = this.mGmfRoleDatas != null;
+ if (flag4)
+ {
+ this.SpectateSpecial(this.mGmfRoleDatas);
+ }
+ }
+
+ private void LeaveGVG()
+ {
+ bool flag = this.fxEncourageButton != null;
+ if (flag)
+ {
+ XSingleton<XFxMgr>.singleton.DestroyFx(this.fxEncourageButton, true);
+ this.fxEncourageButton = null;
+ }
+ bool flag2 = this.fxEncourageProgressNum != null;
+ if (flag2)
+ {
+ XSingleton<XFxMgr>.singleton.DestroyFx(this.fxEncourageProgressNum, true);
+ this.fxEncourageProgressNum = null;
+ }
+ bool flag3 = this.fxEncourageProgressAdd != null;
+ if (flag3)
+ {
+ XSingleton<XFxMgr>.singleton.DestroyFx(this.fxEncourageProgressAdd, true);
+ this.fxEncourageProgressAdd = null;
+ }
+ }
+
+ public void ReceiveDuelRoundResult(GprOneBattleEnd res)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("XMainClient.XGuildArenaBattleDocument.ReceiveDuelRoundResult", null, null, null, null, null);
+ bool flag = !this.IsGPR() && !this.IsGCF();
+ if (!flag)
+ {
+ bool flag2 = DlgBase<XChatView, XChatBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XChatView, XChatBehaviour>.singleton.SetVisible(false, true);
+ }
+ ulong myGuildID = this.GetMyGuildID();
+ bool cross = this.IsGCF();
+ bool flag3 = res.winguild.guildid == myGuildID;
+ if (flag3)
+ {
+ this.InBattleGroup = true;
+ this.BlueDuelResult.Setup(res.winguild, res.winrolecombat, true, cross);
+ this.RedDuelResult.Setup(res.loseguild, res.loserolecombat, false, cross);
+ }
+ else
+ {
+ bool flag4 = res.loseguild.guildid == myGuildID;
+ if (flag4)
+ {
+ this.InBattleGroup = true;
+ this.BlueDuelResult.Setup(res.loseguild, res.loserolecombat, false, cross);
+ this.RedDuelResult.Setup(res.winguild, res.winrolecombat, true, cross);
+ }
+ else
+ {
+ this.InBattleGroup = false;
+ this.BlueDuelResult.Setup(res.winguild, res.winrolecombat, true, cross);
+ this.RedDuelResult.Setup(res.loseguild, res.loserolecombat, false, cross);
+ }
+ }
+ DlgBase<GuildArenaDuelRoundResultDlg, GuildArenaDuelRoundResultBehaviour>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ }
+
+ public void ReceiveDuelFinalResult(GprAllFightEnd res)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("XMainClient.XGuildArenaBattleDocument.ReceiveDuelFinalResult", null, null, null, null, null);
+ bool flag = !this.IsGPR() && !this.IsGCF();
+ if (!flag)
+ {
+ bool flag2 = DlgBase<XChatView, XChatBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XChatView, XChatBehaviour>.singleton.SetVisible(false, true);
+ }
+ ulong myGuildID = this.GetMyGuildID();
+ bool cross = this.IsGCF();
+ bool flag3 = res.winguild.guildid == myGuildID;
+ if (flag3)
+ {
+ this.BlueDuelResult.Setup(res.winguild, res.winscore, true, cross);
+ this.RedDuelResult.Setup(res.loseguild, res.losescore, false, cross);
+ }
+ else
+ {
+ bool flag4 = res.loseguild.guildid == myGuildID;
+ if (flag4)
+ {
+ this.BlueDuelResult.Setup(res.loseguild, res.losescore, false, cross);
+ this.RedDuelResult.Setup(res.winguild, res.winscore, true, cross);
+ }
+ else
+ {
+ this.BlueDuelResult.Setup(res.winguild, res.winscore, true, cross);
+ this.RedDuelResult.Setup(res.loseguild, res.losescore, false, cross);
+ }
+ }
+ DlgBase<GuildArenaDuelFinalResultDlg, GuildArenaDuelFinalResultBehaviour>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ base.RegisterEvent(XEventDefine.XEvent_RealDead, new XComponent.XEventHandler(this.OnActionEvent));
+ base.RegisterEvent(XEventDefine.XEvent_FightGroupChanged, new XComponent.XEventHandler(this.OnFightGroupChanged));
+ }
+
+ private bool OnFightGroupChanged(XEventArgs e)
+ {
+ bool flag = !this.IsGPR() && !this.IsGCF();
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ XFightGroupChangedArgs xfightGroupChangedArgs = e as XFightGroupChangedArgs;
+ bool flag2 = xfightGroupChangedArgs == null || xfightGroupChangedArgs.targetEntity == null;
+ if (flag2)
+ {
+ result = true;
+ }
+ else
+ {
+ BattleIndicateHandler battleIndicateHandler = null;
+ XSingleton<XDebug>.singleton.AddGreenLog("OnFightGroupChanged", null, null, null, null, null);
+ bool bSpectator = XSingleton<XScene>.singleton.bSpectator;
+ if (bSpectator)
+ {
+ bool flag3 = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IsLoaded();
+ if (flag3)
+ {
+ battleIndicateHandler = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IndicateHandler;
+ }
+ }
+ else
+ {
+ bool flag4 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
+ if (flag4)
+ {
+ battleIndicateHandler = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IndicateHandler;
+ }
+ }
+ bool flag5 = battleIndicateHandler == null;
+ if (flag5)
+ {
+ result = true;
+ }
+ else
+ {
+ bool isPlayer = xfightGroupChangedArgs.targetEntity.IsPlayer;
+ if (isPlayer)
+ {
+ List<XEntity> all = XSingleton<XEntityMgr>.singleton.GetAll();
+ int i = 0;
+ int count = all.Count;
+ while (i < count)
+ {
+ bool isPlayer2 = all[i].IsPlayer;
+ if (!isPlayer2)
+ {
+ this.UpdateIndicateHandle(battleIndicateHandler, all[i]);
+ }
+ i++;
+ }
+ }
+ else
+ {
+ this.UpdateIndicateHandle(battleIndicateHandler, xfightGroupChangedArgs.targetEntity);
+ }
+ result = true;
+ }
+ }
+ }
+ return result;
+ }
+
+ private void UpdateIndicateHandle(BattleIndicateHandler handler, XEntity entity)
+ {
+ handler.MiniMapDel(entity);
+ handler.MiniMapAdd(entity);
+ }
+
+ private bool OnActionEvent(XEventArgs arg)
+ {
+ XRealDeadEventArgs xrealDeadEventArgs = arg as XRealDeadEventArgs;
+ bool flag = !xrealDeadEventArgs.TheDead.IsPlayer;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag2 = this.IsGPR();
+ int @int;
+ if (flag2)
+ {
+ @int = XSingleton<XGlobalConfig>.singleton.GetInt("GPRReviveTime");
+ }
+ else
+ {
+ bool flag3 = this.IsGCF();
+ if (!flag3)
+ {
+ return false;
+ }
+ @int = XSingleton<XGlobalConfig>.singleton.GetInt("GPCFReviveTime");
+ }
+ bool flag4 = this.CurView.IsVisible();
+ if (flag4)
+ {
+ this.CurView.SetResurgence(@int);
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ public void ReceiveBattleSkill(PvpBattleKill battleSkillInfo)
+ {
+ bool flag = !this.CurView.IsVisible();
+ if (!flag)
+ {
+ GVGBattleSkill gvgbattleSkill = new GVGBattleSkill();
+ gvgbattleSkill.killerID = battleSkillInfo.killID;
+ gvgbattleSkill.deadID = battleSkillInfo.deadID;
+ gvgbattleSkill.contiKillCount = battleSkillInfo.contiKillCount;
+ bool killerPosition = false;
+ bool flag2 = this.TryGetBattleName(battleSkillInfo.killID, out gvgbattleSkill.killerName, out killerPosition);
+ if (flag2)
+ {
+ gvgbattleSkill.killerPosition = killerPosition;
+ }
+ this.TryGetBattleName(battleSkillInfo.deadID, out gvgbattleSkill.deadName, out killerPosition);
+ 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);
+ }
+ }
+
+ private bool TryGetBattleName(ulong roleID, out string targetName, out bool position)
+ {
+ targetName = string.Empty;
+ position = false;
+ GmfRole gmfRole = null;
+ bool flag = this._redInfo.TryGetMember(roleID, out gmfRole);
+ bool result;
+ if (flag)
+ {
+ targetName = gmfRole.rolename;
+ position = true;
+ result = true;
+ }
+ else
+ {
+ bool flag2 = this._blueInfo.TryGetMember(roleID, out gmfRole);
+ if (flag2)
+ {
+ targetName = gmfRole.rolename;
+ position = false;
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ return result;
+ }
+
+ public bool IsGPR()
+ {
+ return XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_GPR;
+ }
+
+ public bool IsGMF()
+ {
+ return XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_GMF;
+ }
+
+ public bool IsGCF()
+ {
+ return XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_GCF;
+ }
+
+ public void NotifyVSPayRevive(VsPayRevivePara para)
+ {
+ this.ReviveItemID = para.itemid;
+ this.ReviveItemNumber = para.itemcount;
+ }
+
+ public void SendVSPayRevive()
+ {
+ bool flag = this.ReviveItemID > 0u;
+ if (flag)
+ {
+ ulong itemCount = XBagDocument.BagDoc.GetItemCount((int)this.ReviveItemID);
+ bool flag2 = itemCount >= (ulong)this.ReviveItemNumber;
+ if (flag2)
+ {
+ RpcC2G_VsPayReviveReq rpc = new RpcC2G_VsPayReviveReq();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+ else
+ {
+ ItemList.RowData itemConf = XBagDocument.GetItemConf((int)this.ReviveItemID);
+ bool flag3 = itemConf != null;
+ if (flag3)
+ {
+ UiUtility singleton = XSingleton<UiUtility>.singleton;
+ string key = "FASHION_HAIR_COLORING";
+ object[] itemName = itemConf.ItemName;
+ singleton.ShowSystemTip(XStringDefineProxy.GetString(key, itemName), "fece00");
+ }
+ }
+ }
+ }
+
+ public void ReceiveVSPayRevive(VsPayRevivePara oArg, VsPayReviveRes oRes)
+ {
+ bool flag = oRes.ret > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.ret, "fece00");
+ }
+ bool flag2 = this.CurView.IsVisible();
+ if (flag2)
+ {
+ this.CurView.SetResurgence(0);
+ }
+ }
+ }
+}
|