diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Guild/XGuildTerritoryDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/Guild/XGuildTerritoryDocument.cs | 1220 |
1 files changed, 1220 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/Guild/XGuildTerritoryDocument.cs b/Client/Assets/Scripts/XMainClient/Guild/XGuildTerritoryDocument.cs new file mode 100644 index 00000000..897ec27d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Guild/XGuildTerritoryDocument.cs @@ -0,0 +1,1220 @@ +using System;
+using System.Collections.Generic;
+using System.Text;
+using KKSG;
+using UILib;
+using UnityEngine;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XGuildTerritoryDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XGuildTerritoryDocument.uuID;
+ }
+ }
+
+ public uint bHavaTerritoryRecCount
+ {
+ get
+ {
+ return this.mHaveTerritoryCount;
+ }
+ set
+ {
+ this.mHaveTerritoryCount = value;
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildTerritoryAllianceInterface, true);
+ }
+ }
+
+ public XGuildTerritoryDocument.GuildTerritoryStyle TerritoryStyle
+ {
+ get
+ {
+ return this.mCurTerritoryStyle;
+ }
+ set
+ {
+ this.mCurTerritoryStyle = value;
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildTerritoryIconInterface, true);
+ this.RefreshGuildTerritoryInfo();
+ }
+ }
+
+ public bool bHavaShowMessageIcon
+ {
+ get
+ {
+ return this.mShowMessageIcon;
+ }
+ set
+ {
+ this.mShowMessageIcon = value;
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildTerritoryMessageInterface, true);
+ }
+ }
+
+ public List<GuildTerrChallInfo> GuildTerrChallList
+ {
+ get
+ {
+ return this.mGuildTerrChall;
+ }
+ }
+
+ public List<CityData> CityDataList
+ {
+ get
+ {
+ return this.mCityDataList;
+ }
+ }
+
+ public List<GuildTerritoryAllianceInfo> GuildTerrAllianceInfos
+ {
+ get
+ {
+ return this.mGuildTerritoryAllianceList;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("XGuildTerritoryDocument");
+
+ public static readonly uint GAME_INFO = 1u;
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private static FightDesignation mGuildDestination = new FightDesignation();
+
+ public static GuildTransfer mGuildTransfer = new GuildTransfer();
+
+ public static TerritoryBattle mGuildTerritoryList = new TerritoryBattle();
+
+ public static TerritoryRewd mTerritoryRewd = new TerritoryRewd();
+
+ public XFx[] fxJvDians = new XFx[9];
+
+ public Vector3[] fxJvPos = new Vector3[3];
+
+ private float lastShowInfoTime;
+
+ public Queue<XBattleCaptainPVPDocument.KillInfo> qInfo = new Queue<XBattleCaptainPVPDocument.KillInfo>();
+
+ public uint mapid = 0u;
+
+ public List<GCFJvDianInfo> jvdians = new List<GCFJvDianInfo>();
+
+ public List<GCFGuild> guilds = new List<GCFGuild>();
+
+ public List<GCFRoleBrief> roles = new List<GCFRoleBrief>();
+
+ public List<GCFBattleField> fields = new List<GCFBattleField>();
+
+ public List<ItemBrief> rwds = new List<ItemBrief>();
+
+ public GCFRoleBrief mmyinfo = new GCFRoleBrief();
+
+ public uint feats = 0u;
+
+ public GCFGuildBrief winguild;
+
+ public uint ready_lefttime = 0u;
+
+ public uint fight_lefttime = 0u;
+
+ public uint territoryid = 0u;
+
+ public bool myPostion = true;
+
+ private uint[] maptoken = new uint[3];
+
+ private string[] fxs = new string[]
+ {
+ "Effects/FX_Particle/UIfx/UI_xdtts_white",
+ "Effects/FX_Particle/UIfx/UI_xdtts_bule",
+ "Effects/FX_Particle/UIfx/UI_xdtts_red"
+ };
+
+ private Dictionary<uint, CityData> mCityDataDic = new Dictionary<uint, CityData>();
+
+ private List<CityData> mCityDataList = new List<CityData>();
+
+ private List<GuildTerrChallInfo> mGuildTerrChall = new List<GuildTerrChallInfo>();
+
+ private List<GuildTerritoryAllianceInfo> mGuildTerritoryAllianceList = new List<GuildTerritoryAllianceInfo>();
+
+ private uint mHaveTerritoryCount = 0u;
+
+ private XGuildTerritoryDocument.GuildTerritoryStyle mCurTerritoryStyle = XGuildTerritoryDocument.GuildTerritoryStyle.NONE;
+
+ public ulong Allianceid = 0UL;
+
+ public GUILDTERRTYPE CurrentType = GUILDTERRTYPE.TERR_NOT_OPEN;
+
+ public uint SelfGuildTerritoryID = 0u;
+
+ public uint SelfTargetTerritoryID = 0u;
+
+ public List<GuildTerrAllianceInfo> guildAllianceInfos;
+
+ public bool mShowMessage = true;
+
+ public bool mShowMessageIcon = false;
+
+ public ulong SelfAllianceID = 0UL;
+
+ public uint CurrentTerritoryID = 0u;
+
+ public uint EnterBattleTime = 0u;
+
+ public enum GuildTerritoryStyle
+ {
+ NONE,
+ INFORM,
+ ACTIVITY
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ bool flag = DlgBase<GuildTerritoryReportDlg, GuildTerritoryBahaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ this.SendGCFCommonReq(GCFReqType.GCF_FIGHT_REPORT);
+ }
+ }
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XGuildTerritoryDocument.AsyncLoader.AddTask("Table/TerritoryBattleDesignation", XGuildTerritoryDocument.mGuildDestination, false);
+ XGuildTerritoryDocument.AsyncLoader.AddTask("Table/TerritoryBattleTransfer", XGuildTerritoryDocument.mGuildTransfer, false);
+ XGuildTerritoryDocument.AsyncLoader.AddTask("Table/territorybattle", XGuildTerritoryDocument.mGuildTerritoryList, false);
+ XGuildTerritoryDocument.AsyncLoader.AddTask("Table/TerritoryRewd", XGuildTerritoryDocument.mTerritoryRewd, false);
+ XGuildTerritoryDocument.AsyncLoader.Execute(callback);
+ }
+
+ public static void OnLoadcallback()
+ {
+ }
+
+ public override void OnEnterScene()
+ {
+ base.OnEnterScene();
+ bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HALL;
+ if (flag)
+ {
+ GuildMiniReportHandler.msgs.Clear();
+ }
+ bool flag2 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_WAIT;
+ if (flag2)
+ {
+ XSingleton<GuildPassMgr>.singleton.InitBoard();
+ }
+ bool flag3 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_FIGHT;
+ if (flag3)
+ {
+ for (int i = 0; i < this.fxJvDians.Length; i++)
+ {
+ bool flag4 = i % 3 == 0;
+ if (flag4)
+ {
+ this.fxJvDians[i] = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/Roles/Lzg_Ty/Ty_ldzd_fanwei_grey", null, true);
+ }
+ else
+ {
+ bool flag5 = i % 3 == 1;
+ if (flag5)
+ {
+ this.fxJvDians[i] = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/Roles/Lzg_Ty/Ty_ldzd_fanwei_red", null, true);
+ }
+ else
+ {
+ this.fxJvDians[i] = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/Roles/Lzg_Ty/Ty_ldzd_fanwei_blue", null, true);
+ }
+ }
+ bool flag6 = i / 3 == 0;
+ if (flag6)
+ {
+ List<float> floatList = XSingleton<XGlobalConfig>.singleton.GetFloatList("GuildTerritoryUpPos");
+ Vector3 vector;
+ vector= new Vector3(floatList[0], floatList[1], floatList[2]);
+ float num = float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("TerritoryBattleUpRadius")) * float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("TerritoryBattleClientRadiusK"));
+ this.fxJvDians[i].Play(vector, Quaternion.identity, new Vector3(num, 1f, num), 1f);
+ this.fxJvPos[0] = vector;
+ }
+ else
+ {
+ bool flag7 = i / 3 == 1;
+ if (flag7)
+ {
+ List<float> floatList2 = XSingleton<XGlobalConfig>.singleton.GetFloatList("GuildTerritoryMidPos");
+ Vector3 vector2;
+ vector2= new Vector3(floatList2[0], floatList2[1], floatList2[2]);
+ float num2 = float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("TerritoryBattleMidRadius")) * float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("TerritoryBattleClientRadiusK"));
+ this.fxJvDians[i].Play(vector2, Quaternion.identity, new Vector3(num2, 1f, num2), 1f);
+ this.fxJvPos[1] = vector2;
+ }
+ else
+ {
+ List<float> floatList3 = XSingleton<XGlobalConfig>.singleton.GetFloatList("GuildTerritoryBtmPos");
+ Vector3 vector3;
+ vector3= new Vector3(floatList3[0], floatList3[1], floatList3[2]);
+ float num3 = float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("TerritoryBattleBtmRadius")) * float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("TerritoryBattleClientRadiusK"));
+ this.fxJvDians[i].Play(vector3, Quaternion.identity, new Vector3(num3, 1f, num3), 1f);
+ this.fxJvPos[2] = vector3;
+ }
+ }
+ }
+ }
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ base.OnEnterSceneFinally();
+ this.CheckJvDianState();
+ bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_WAIT;
+ if (flag)
+ {
+ bool flag2 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded() && DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SkillHandler.SetVisible(false);
+ }
+ }
+ bool flag3 = Process_RpcC2G_DoEnterScene.runstate > 0u;
+ if (flag3)
+ {
+ bool flag4 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_WAIT || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_FIGHT;
+ if (flag4)
+ {
+ XLevelRewardDocument specificDocument = XDocuments.GetSpecificDocument<XLevelRewardDocument>(XLevelRewardDocument.uuID);
+ bool flag5 = specificDocument != null;
+ if (flag5)
+ {
+ bool flag6 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
+ if (flag6)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SkillHandler.ResetPressState();
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SetVisiblePure(false);
+ DlgBase<RadioBattleDlg, RadioBattleBahaviour>.singleton.Show(false);
+ DlgBase<XChatSmallView, XChatSmallBehaviour>.singleton.SetFakeHide(true);
+ }
+ specificDocument.ShowLevelReward();
+ }
+ }
+ }
+ }
+
+ public override void OnLeaveScene()
+ {
+ bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_WAIT;
+ if (flag)
+ {
+ XSingleton<GuildPassMgr>.singleton.ClearAll();
+ bool flag2 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded() && DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SkillHandler.SetVisible(true);
+ }
+ }
+ bool flag3 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_FIGHT;
+ if (flag3)
+ {
+ for (int i = 0; i < this.fxJvDians.Length; i++)
+ {
+ bool flag4 = this.fxJvDians[i] != null;
+ if (flag4)
+ {
+ XSingleton<XFxMgr>.singleton.DestroyFx(this.fxJvDians[i], true);
+ }
+ this.fxJvDians[i] = null;
+ }
+ XBattleDocument.DelMiniMapFx(this.maptoken[0]);
+ XBattleDocument.DelMiniMapFx(this.maptoken[1]);
+ XBattleDocument.DelMiniMapFx(this.maptoken[2]);
+ }
+ base.OnLeaveScene();
+ }
+
+ public override void OnDetachFromHost()
+ {
+ this.jvdians.Clear();
+ this.roles.Clear();
+ this.guilds.Clear();
+ this.rwds.Clear();
+ base.OnDetachFromHost();
+ }
+
+ public override void PostUpdate(float fDeltaT)
+ {
+ base.PostUpdate(fDeltaT);
+ bool flag = Time.frameCount % 60 == 0;
+ if (flag)
+ {
+ bool flag2 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_WAIT;
+ if (flag2)
+ {
+ this.SendGCFReadysInfo();
+ this.SendGFCFightInfo();
+ }
+ else
+ {
+ bool flag3 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_FIGHT;
+ if (flag3)
+ {
+ this.SendGFCFightInfo();
+ }
+ }
+ }
+ bool flag4 = Time.time > this.lastShowInfoTime + 10f;
+ if (flag4)
+ {
+ bool flag5 = this.qInfo.Count != 0;
+ if (flag5)
+ {
+ this.qInfo.Clear();
+ }
+ bool flag6 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsVisible() && DlgBase<BattleMain, BattleMainBehaviour>.singleton.m_miniReportHandler != null;
+ if (flag6)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.m_miniReportHandler.ShowBuffs();
+ }
+ }
+ }
+
+ public FightDesignation.RowData GetDesignation(uint hit)
+ {
+ FightDesignation.RowData[] table = XGuildTerritoryDocument.mGuildDestination.Table;
+ for (int i = table.Length - 1; i >= 0; i--)
+ {
+ bool flag = table[i].ID <= hit;
+ if (flag)
+ {
+ return table[i];
+ }
+ }
+ return null;
+ }
+
+ public void ActiveJvDian(GCFJvDianType type, int index)
+ {
+ bool flag = type == GCFJvDianType.GCF_JUDIAN_UP;
+ if (flag)
+ {
+ bool flag2 = this.fxJvDians[0] != null && this.fxJvDians[1] != null && this.fxJvDians[2] != null;
+ if (flag2)
+ {
+ this.fxJvDians[0].SetActive(index == 0);
+ this.fxJvDians[1].SetActive(index == 1);
+ this.fxJvDians[2].SetActive(index == 2);
+ }
+ }
+ else
+ {
+ bool flag3 = type == GCFJvDianType.GCF_JUDIAN_MID;
+ if (flag3)
+ {
+ bool flag4 = this.fxJvDians[3] != null && this.fxJvDians[4] != null && this.fxJvDians[5] != null;
+ if (flag4)
+ {
+ this.fxJvDians[3].SetActive(index == 0);
+ this.fxJvDians[4].SetActive(index == 1);
+ this.fxJvDians[5].SetActive(index == 2);
+ }
+ }
+ else
+ {
+ bool flag5 = this.fxJvDians[6] != null && this.fxJvDians[7] != null && this.fxJvDians[8] != null;
+ if (flag5)
+ {
+ this.fxJvDians[6].SetActive(index == 0);
+ this.fxJvDians[7].SetActive(index == 1);
+ this.fxJvDians[8].SetActive(index == 2);
+ }
+ }
+ }
+ }
+
+ public void SendGCFEnterin(int index)
+ {
+ this.mapid = XGuildTerritoryDocument.mGuildTransfer.GetByid((uint)index).sceneid;
+ this.SendGCFCommonReq(GCFReqType.GCF_JOIN_FIGHT_SCENE);
+ }
+
+ public void SendWaitScene(uint tid)
+ {
+ this.territoryid = tid;
+ this.SendGCFCommonReq(GCFReqType.GCF_JOIN_READY_SCENE);
+ }
+
+ public void SendGCFCommonReq(GCFReqType type)
+ {
+ RpcC2M_GCFCommonReq rpcC2M_GCFCommonReq = new RpcC2M_GCFCommonReq();
+ rpcC2M_GCFCommonReq.oArg.mapid = this.mapid;
+ rpcC2M_GCFCommonReq.oArg.reqtype = type;
+ rpcC2M_GCFCommonReq.oArg.territoryid = this.territoryid;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_GCFCommonReq);
+ }
+
+ public void RespGCFCommon(GCFReqType type, GCFCommonRes res)
+ {
+ this.jvdians = res.jvdians;
+ this.guilds.Clear();
+ for (int i = 0; i < res.guilds.Count; i++)
+ {
+ GCFGuild gcfguild = new GCFGuild();
+ gcfguild.brief = res.guilds[i];
+ gcfguild.groupScore = this.GetGroupPoint(res.guilds, gcfguild.brief.group);
+ this.guilds.Add(gcfguild);
+ }
+ this.roles = res.roles;
+ this.rwds = res.rewards;
+ this.fields = res.fields;
+ this.mmyinfo = res.myinfo;
+ bool flag = this.mmyinfo != null;
+ if (flag)
+ {
+ this.feats = this.mmyinfo.feats;
+ }
+ this.territoryid = res.territoryid;
+ this.winguild = res.winguild;
+ bool flag2 = type == GCFReqType.GCF_FIGHT_REPORT;
+ if (flag2)
+ {
+ bool flag3 = DlgBase<GuildTerritoryReportDlg, GuildTerritoryBahaviour>.singleton.IsVisible();
+ if (flag3)
+ {
+ DlgBase<GuildTerritoryReportDlg, GuildTerritoryBahaviour>.singleton.RefreshAll();
+ }
+ }
+ else
+ {
+ bool flag4 = type == GCFReqType.GCF_JOIN_READY_SCENE;
+ if (!flag4)
+ {
+ bool flag5 = type == GCFReqType.GCF_FIGHT_RESULT;
+ if (flag5)
+ {
+ LevelRewardTerritoryHandler territoryHandler = DlgBase<XLevelRewardView, XLevelRewardBehaviour>.singleton.GetTerritoryHandler();
+ bool flag6 = territoryHandler != null;
+ if (flag6)
+ {
+ territoryHandler.RefreshAll();
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("level reward is nil", null, null, null, null, null);
+ }
+ }
+ else
+ {
+ bool flag7 = type == GCFReqType.GCF_JOIN_FIGHT_SCENE;
+ if (flag7)
+ {
+ }
+ }
+ }
+ }
+ }
+
+ public void SendGCFReadysInfo()
+ {
+ RpcC2M_GCFReadysInfoReq rpc = new RpcC2M_GCFReadysInfoReq();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void RespGCFReadysInfo(GCFReadyInfoRes ores)
+ {
+ this.ready_lefttime = ores.lefttime;
+ bool flag = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsVisible() && !XSingleton<GuildPassMgr>.singleton.isOpen && this.ready_lefttime > 0u;
+ if (flag)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SetLeftTime(this.ready_lefttime, -1);
+ }
+ XSingleton<GuildPassMgr>.singleton.UpdateInfo(ores.allinfo);
+ }
+
+ public void SendGFCFightInfo()
+ {
+ RpcC2M_GCFFightInfoReqC2M rpc = new RpcC2M_GCFFightInfoReqC2M();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void RespGCFFightInfo(GCFFightInfoRes res)
+ {
+ this.fight_lefttime = res.lefttime;
+ bool flag = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsVisible() && XSingleton<GuildPassMgr>.singleton.isOpen && this.fight_lefttime > 0u;
+ if (flag)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.SetLeftTime(this.fight_lefttime, -1);
+ }
+ XGuildDocument specificDocument = XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID);
+ this.guilds.Clear();
+ for (int i = 0; i < res.guilds.Count; i++)
+ {
+ GCFGuild gcfguild = new GCFGuild();
+ gcfguild.brief = res.guilds[i];
+ gcfguild.groupScore = this.GetGroupPoint(res.guilds, gcfguild.brief.group);
+ gcfguild.isPartern = (res.guilds[i].group == res.mygroup);
+ bool flag2 = gcfguild.brief.guildid == specificDocument.UID;
+ if (flag2)
+ {
+ this.myPostion = gcfguild.isPartern;
+ }
+ this.guilds.Add(gcfguild);
+ }
+ this.jvdians = res.JvDians;
+ this.guilds.Sort(new Comparison<GCFGuild>(this.SortGuildsInfo));
+ GuildBattleMiniRankHandler miniRankHandler = DlgBase<BattleMain, BattleMainBehaviour>.singleton.m_miniRankHandler;
+ bool flag3 = miniRankHandler != null;
+ if (flag3)
+ {
+ miniRankHandler.RefreshAll();
+ }
+ this.CheckJvDianState();
+ GuildMiniReportHandler miniReportHandler = DlgBase<BattleMain, BattleMainBehaviour>.singleton.m_miniReportHandler;
+ bool flag4 = miniReportHandler != null;
+ if (flag4)
+ {
+ miniReportHandler.RefreshMyInfo(res.myinfo);
+ }
+ }
+
+ private uint GetGroupPoint(List<GCFGuildBrief> guilds, int group)
+ {
+ uint num = 0u;
+ for (int i = 0; i < guilds.Count; i++)
+ {
+ bool flag = guilds[i].group == group;
+ if (flag)
+ {
+ num += guilds[i].point;
+ }
+ }
+ return num;
+ }
+
+ private int SortGuildsInfo(GCFGuild x, GCFGuild y)
+ {
+ bool flag = x.groupScore != y.groupScore;
+ int result;
+ if (flag)
+ {
+ result = (int)(y.groupScore - x.groupScore);
+ }
+ else
+ {
+ result = (int)(y.brief.point - x.brief.point);
+ }
+ return result;
+ }
+
+ public void OnFeatsChange(uint feat)
+ {
+ this.feats = feat;
+ }
+
+ public void OnZhanLingNotify(GCFZhanLingPara data)
+ {
+ GCFZhanLingType zltype = data.zltype;
+ XEntity entity = XSingleton<XEntityMgr>.singleton.GetEntity(data.roleID);
+ bool flag = entity == null || entity.Attributes == null;
+ if (!flag)
+ {
+ XTerritoryComponent xterritoryComponent = entity.GetXComponent(XTerritoryComponent.uuID) as XTerritoryComponent;
+ bool flag2 = zltype == GCFZhanLingType.GCFZL_BEGIN;
+ if (flag2)
+ {
+ xterritoryComponent.ToStart();
+ }
+ else
+ {
+ bool flag3 = zltype == GCFZhanLingType.GCFZL_BREAK;
+ if (flag3)
+ {
+ xterritoryComponent.Interupt();
+ }
+ else
+ {
+ bool flag4 = zltype == GCFZhanLingType.GCFZL_END;
+ if (flag4)
+ {
+ xterritoryComponent.Success();
+ }
+ }
+ }
+ }
+ }
+
+ public void ModifyMinimapState(GCFJvDianType type1, int index2)
+ {
+ int num = XFastEnumIntEqualityComparer<GCFJvDianType>.ToInt(type1);
+ Vector3 pos = this.fxJvPos[num - 1];
+ string fx = this.fxs[index2];
+ bool flag = type1 == GCFJvDianType.GCF_JUDIAN_UP;
+ if (flag)
+ {
+ XBattleDocument.DelMiniMapFx(this.maptoken[0]);
+ this.maptoken[0] = XBattleDocument.AddMiniMapFx(pos, fx);
+ }
+ else
+ {
+ bool flag2 = type1 == GCFJvDianType.GCF_JUDIAN_MID;
+ if (flag2)
+ {
+ XBattleDocument.DelMiniMapFx(this.maptoken[1]);
+ this.maptoken[1] = XBattleDocument.AddMiniMapFx(pos, fx);
+ }
+ else
+ {
+ XBattleDocument.DelMiniMapFx(this.maptoken[2]);
+ this.maptoken[2] = XBattleDocument.AddMiniMapFx(pos, fx);
+ }
+ }
+ }
+
+ public void OnGCFSynG2CNtf(GCFG2CSynPara data)
+ {
+ GuildMiniReportHandler miniReportHandler = DlgBase<BattleMain, BattleMainBehaviour>.singleton.m_miniReportHandler;
+ bool flag = miniReportHandler != null;
+ if (flag)
+ {
+ miniReportHandler.Push(data.type, data);
+ }
+ bool flag2 = data.type == GCFG2CSynType.GCF_G2C_SYN_KILL_COUNT;
+ if (flag2)
+ {
+ XEntity entity = XSingleton<XEntityMgr>.singleton.GetEntity(data.roleid);
+ bool flag3 = entity != null;
+ if (flag3)
+ {
+ bool flag4 = entity.BillBoard != null;
+ if (flag4)
+ {
+ entity.BillBoard.OnFightDesignationInfoChange(data.killcount);
+ }
+ }
+ }
+ }
+
+ public void ReceiveBattleSkill(PvpBattleKill battleSkillInfo)
+ {
+ bool flag = XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_CASTLE_FIGHT;
+ if (!flag)
+ {
+ GVGBattleSkill gvgbattleSkill = new GVGBattleSkill();
+ gvgbattleSkill.killerID = battleSkillInfo.killID;
+ gvgbattleSkill.deadID = battleSkillInfo.deadID;
+ gvgbattleSkill.contiKillCount = battleSkillInfo.contiKillCount;
+ XEntity entityConsiderDeath = XSingleton<XEntityMgr>.singleton.GetEntityConsiderDeath(gvgbattleSkill.killerID);
+ XEntity entityConsiderDeath2 = XSingleton<XEntityMgr>.singleton.GetEntityConsiderDeath(gvgbattleSkill.deadID);
+ bool flag2 = entityConsiderDeath == null || entityConsiderDeath2 == null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("entity id: " + gvgbattleSkill.killerID, " dead id: " + gvgbattleSkill.deadID, null, null, null, null);
+ }
+ else
+ {
+ gvgbattleSkill.killerName = entityConsiderDeath.Name;
+ gvgbattleSkill.deadName = entityConsiderDeath2.Name;
+ bool flag3 = XSingleton<XEntityMgr>.singleton.IsAlly(entityConsiderDeath);
+ gvgbattleSkill.killerPosition = (this.myPostion ? flag3 : (!flag3));
+ 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 void CheckJvDianState()
+ {
+ bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_CASTLE_FIGHT;
+ if (flag)
+ {
+ for (int i = 0; i < this.jvdians.Count; i++)
+ {
+ bool flag2 = string.IsNullOrEmpty(this.jvdians[i].guildname);
+ if (flag2)
+ {
+ this.ActiveJvDian(this.jvdians[i].type, 0);
+ this.ModifyMinimapState(this.jvdians[i].type, 0);
+ }
+ else
+ {
+ this.ActiveJvDian(this.jvdians[i].type, this.IsPartener(this.jvdians[i].guildname) ? 2 : 1);
+ this.ModifyMinimapState(this.jvdians[i].type, this.IsPartener(this.jvdians[i].guildname) ? 1 : 2);
+ }
+ }
+ }
+ }
+
+ private bool IsPartener(string guildname)
+ {
+ for (int i = 0; i < this.guilds.Count; i++)
+ {
+ bool flag = this.guilds[i].brief.guildname == guildname;
+ if (flag)
+ {
+ return this.guilds[i].isPartern;
+ }
+ }
+ return false;
+ }
+
+ public void OnAddBuff(ulong roleID, uint doodadID)
+ {
+ BuffTable.RowData buffData = XSingleton<XBuffTemplateManager>.singleton.GetBuffData((int)doodadID, 1);
+ string text = string.Empty;
+ bool flag = buffData == null;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog(string.Format("GuildTerritory: Buff data not found: [{0} {1}]", doodadID, 1), null, null, null, null, null);
+ }
+ else
+ {
+ text = buffData.BuffName;
+ }
+ XEntity entity = XSingleton<XEntityMgr>.singleton.GetEntity(roleID);
+ bool flag2 = entity == null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddWarningLog("entity is null", null, null, null, null, null);
+ }
+ else
+ {
+ string name = entity.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.AddBuffInfo(name, stringBuilder.ToString());
+ }
+ }
+
+ private void AddBuffInfo(string left, string right)
+ {
+ this.lastShowInfoTime = Time.time;
+ XBattleCaptainPVPDocument.KillInfo item = default(XBattleCaptainPVPDocument.KillInfo);
+ item.KillName = left;
+ item.DeadName = right;
+ this.qInfo.Enqueue(item);
+ bool flag = (long)this.qInfo.Count > (long)((ulong)XGuildTerritoryDocument.GAME_INFO);
+ if (flag)
+ {
+ this.qInfo.Dequeue();
+ }
+ bool flag2 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsVisible() && DlgBase<BattleMain, BattleMainBehaviour>.singleton.m_miniReportHandler != null;
+ if (flag2)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.m_miniReportHandler.ShowBuffs();
+ }
+ }
+
+ public void OnClickTerritoryIcon()
+ {
+ XGuildTerritoryDocument.GuildTerritoryStyle territoryStyle = this.TerritoryStyle;
+ if (territoryStyle != XGuildTerritoryDocument.GuildTerritoryStyle.INFORM)
+ {
+ if (territoryStyle == XGuildTerritoryDocument.GuildTerritoryStyle.ACTIVITY)
+ {
+ DlgBase<GuildTerritoryMainDlg, GuildTerritoryMainBehaviour>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ }
+ else
+ {
+ this.TerritoryStyle = XGuildTerritoryDocument.GuildTerritoryStyle.NONE;
+ XSingleton<UiUtility>.singleton.ShowModalDialog(XStringDefineProxy.GetString("NOTICE_TERRITORY_STRING"), XStringDefineProxy.GetString("NOTICE_TERRITORY_STRING_GO"), XStringDefineProxy.GetString("NOTICE_TERRITORY_STRING_ENSURE"), new ButtonClickEventHandler(this.OnInformClick));
+ }
+ }
+
+ private bool OnInformClick(IXUIButton btn)
+ {
+ XSingleton<UiUtility>.singleton.CloseModalDlg();
+ DlgBase<GuildTerritoryMainDlg, GuildTerritoryMainBehaviour>.singleton.SetVisibleWithAnimation(true, null);
+ return false;
+ }
+
+ public bool TryTerritoryAlliance(uint terriroryID, out int messageID)
+ {
+ bool result = false;
+ messageID = 0;
+ bool flag = terriroryID == this.SelfGuildTerritoryID;
+ if (flag)
+ {
+ messageID = 4;
+ }
+ else
+ {
+ uint targetTerrioryType = this.GetTargetTerrioryType(terriroryID);
+ uint targetTerrioryType2 = this.GetTargetTerrioryType(this.SelfGuildTerritoryID);
+ bool flag2 = targetTerrioryType == 0u;
+ if (flag2)
+ {
+ messageID = 0;
+ }
+ int num = (int)(targetTerrioryType - targetTerrioryType2);
+ bool flag3 = num > 1;
+ if (flag3)
+ {
+ bool flag4 = targetTerrioryType == 3u;
+ if (flag4)
+ {
+ messageID = 2;
+ }
+ else
+ {
+ bool flag5 = targetTerrioryType == 2u;
+ if (flag5)
+ {
+ messageID = 1;
+ }
+ }
+ }
+ else
+ {
+ bool flag6 = num < 1;
+ if (flag6)
+ {
+ bool flag7 = targetTerrioryType2 == 3u;
+ if (flag7)
+ {
+ messageID = 5;
+ }
+ else
+ {
+ messageID = 3;
+ }
+ }
+ else
+ {
+ result = true;
+ }
+ }
+ }
+ return result;
+ }
+
+ public uint GetTargetTerrioryType(uint cityID)
+ {
+ uint result = 0u;
+ bool flag = cityID > 0u;
+ if (flag)
+ {
+ TerritoryBattle.RowData byID = XGuildTerritoryDocument.mGuildTerritoryList.GetByID(cityID);
+ bool flag2 = byID != null;
+ if (flag2)
+ {
+ result = byID.territorylevel;
+ }
+ }
+ return result;
+ }
+
+ public bool TryGetCityData(uint cityID, out CityData data)
+ {
+ return this.mCityDataDic.TryGetValue(cityID, out data);
+ }
+
+ public void SendGuildTerritoryCityInfo()
+ {
+ RpcC2M_ReqGuildTerrCityInfo rpc = new RpcC2M_ReqGuildTerrCityInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void ReceiveGuildTerritoryCityInfo(ReqGuildTerrCityInfo res)
+ {
+ XGuildDocument specificDocument = XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID);
+ this.CurrentType = res.type;
+ this.SelfTargetTerritoryID = res.targetid;
+ this.SelfGuildTerritoryID = 0u;
+ this.SelfAllianceID = res.allianceId;
+ this.mCityDataList.Clear();
+ XSingleton<XDebug>.singleton.AddGreenLog("ReceiveGuildTerritoryCityInfo:", this.CurrentType.ToString(), res.targetid.ToString(), res.cityinfo.Count.ToString(), null, null);
+ int i = 0;
+ int count = res.cityinfo.Count;
+ while (i < count)
+ {
+ bool flag = this.mCityDataDic.ContainsKey(res.cityinfo[i].id);
+ if (flag)
+ {
+ this.mCityDataDic[res.cityinfo[i].id] = res.cityinfo[i];
+ }
+ else
+ {
+ this.mCityDataDic.Add(res.cityinfo[i].id, res.cityinfo[i]);
+ }
+ bool flag2 = res.cityinfo[i].guildid > 0UL;
+ if (flag2)
+ {
+ this.mCityDataList.Add(res.cityinfo[i]);
+ }
+ bool flag3 = specificDocument.BasicData.uid == res.cityinfo[i].guildid;
+ if (flag3)
+ {
+ this.SelfGuildTerritoryID = res.cityinfo[i].id;
+ }
+ i++;
+ }
+ this.mCityDataList.Sort(new Comparison<CityData>(this.CompareCityData));
+ bool flag4 = DlgBase<GuildTerritoryMainDlg, GuildTerritoryMainBehaviour>.singleton.IsVisible();
+ if (flag4)
+ {
+ DlgBase<GuildTerritoryMainDlg, GuildTerritoryMainBehaviour>.singleton.RefreshData();
+ }
+ }
+
+ public void SetGuildTerritoryCityInfo(uint cityID, ulong guildID)
+ {
+ this.RefreshGuildTerritoryInfo();
+ }
+
+ private int CompareCityData(CityData city1, CityData city2)
+ {
+ return (int)(city2.id - city1.id);
+ }
+
+ public void RefreshGuildTerritoryInfo()
+ {
+ bool flag = DlgBase<GuildTerritoryMainDlg, GuildTerritoryMainBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ this.SendGuildTerritoryCityInfo();
+ }
+ bool flag2 = DlgBase<GuildTerritoryDeclareDlg, GuildTerritoryDeclareBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ this.SendGuildTerritoryChallInfo(this.CurrentTerritoryID);
+ }
+ }
+
+ public void SendGuildTerritoryChallInfo(uint uid)
+ {
+ bool flag = uid == 0u;
+ if (!flag)
+ {
+ RpcC2M_ReqGuildTerrChallInfo rpcC2M_ReqGuildTerrChallInfo = new RpcC2M_ReqGuildTerrChallInfo();
+ rpcC2M_ReqGuildTerrChallInfo.oArg.id = uid;
+ this.CurrentTerritoryID = uid;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_ReqGuildTerrChallInfo);
+ }
+ }
+
+ public void ReceiveGuildTerritoryChallInfo(ReqGuildTerrChallInfoArg arg, ReqGuildTerrChallInfoRes res)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("ReceiveGuildTerritoryChallInfo:", res.challinfo.Count.ToString(), null, null, null, null);
+ this.mGuildTerrChall.Clear();
+ this.mGuildTerrChall.AddRange(res.challinfo);
+ this.mGuildTerritoryAllianceList.Clear();
+ this.EnterBattleTime = res.cdtime;
+ Dictionary<ulong, GuildTerritoryAllianceInfo> dictionary = new Dictionary<ulong, GuildTerritoryAllianceInfo>();
+ int i = 0;
+ int count = res.challinfo.Count;
+ while (i < count)
+ {
+ bool flag = dictionary.ContainsKey(res.challinfo[i].allianceid);
+ if (flag)
+ {
+ dictionary[res.challinfo[i].allianceid].Add(res.challinfo[i]);
+ }
+ else
+ {
+ bool flag2 = !dictionary.ContainsKey(res.challinfo[i].guildid);
+ if (flag2)
+ {
+ GuildTerritoryAllianceInfo guildTerritoryAllianceInfo = new GuildTerritoryAllianceInfo();
+ guildTerritoryAllianceInfo.Set(res.challinfo[i]);
+ dictionary.Add(res.challinfo[i].guildid, guildTerritoryAllianceInfo);
+ }
+ }
+ i++;
+ }
+ this.mGuildTerritoryAllianceList.AddRange(dictionary.Values);
+ bool flag3 = this.CurrentTerritoryID > 0u;
+ if (flag3)
+ {
+ bool flag4 = DlgBase<GuildTerritoryDeclareDlg, GuildTerritoryDeclareBehaviour>.singleton.IsVisible();
+ if (flag4)
+ {
+ DlgBase<GuildTerritoryDeclareDlg, GuildTerritoryDeclareBehaviour>.singleton.RefreshWhenShow();
+ }
+ else
+ {
+ DlgBase<GuildTerritoryDeclareDlg, GuildTerritoryDeclareBehaviour>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ }
+ }
+
+ public void SendReceiveTerritroyInfo()
+ {
+ RpcC2M_ReqGuildTerrIntellInfo rpc = new RpcC2M_ReqGuildTerrIntellInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void ReceiveTerritoryInterllInfo(ReqGuildTerrIntellInfoRes oRes)
+ {
+ bool flag = DlgBase<GuildTerritoryMessageDlg, GuildTerritoryMessageBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<GuildTerritoryMessageDlg, GuildTerritoryMessageBehaviour>.singleton.SetNewInfo(oRes.intellInfo);
+ }
+ }
+
+ public bool TryGetTerritoryGuildName(ulong guildid, out string guildName)
+ {
+ guildName = string.Empty;
+ int i = 0;
+ int count = this.mGuildTerrChall.Count;
+ while (i < count)
+ {
+ bool flag = this.mGuildTerrChall[i].guildid == guildid;
+ if (flag)
+ {
+ guildName = this.mGuildTerrChall[i].guildname;
+ return true;
+ }
+ i++;
+ }
+ return false;
+ }
+
+ public void SendGuildTerrAllianceInfo()
+ {
+ RpcC2M_ReqGuildTerrAllianceInfo rpc = new RpcC2M_ReqGuildTerrAllianceInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void ReceiveGuildTerrAllianceInfo(ReqGuildTerrAllianceInfoRes res)
+ {
+ this.Allianceid = res.allianceid;
+ this.guildAllianceInfos = res.allianceinfo;
+ DlgBase<GuildTerritoryLeagueDlg, GuildTerritoryLeagueBehaviour>.singleton.RefreshData();
+ }
+
+ public void SendAllianceGuildTerr(uint territoryID)
+ {
+ XGuildDocument specificDocument = XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID);
+ bool flag = specificDocument.Position == GuildPosition.GPOS_LEADER || specificDocument.Position == GuildPosition.GPOS_VICELEADER;
+ if (flag)
+ {
+ RpcC2M_AllianceGuildTerr rpcC2M_AllianceGuildTerr = new RpcC2M_AllianceGuildTerr();
+ rpcC2M_AllianceGuildTerr.oArg.id = territoryID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_AllianceGuildTerr);
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("ERR_TB_DECLEAR_NO_PERMISSON"), "fece00");
+ }
+ }
+
+ public void ReceiveAllianceGuildTerr(AllianceGuildTerrArg arg, AllianceGuildTerrRes res)
+ {
+ bool flag = res.errorcod > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(res.errorcod, "fece00");
+ bool flag2 = res.errorcod == ErrorCode.ERR_DECLAREWAR_OUT_TIME;
+ if (flag2)
+ {
+ this.RefreshGuildTerritoryInfo();
+ }
+ }
+ else
+ {
+ this.RefreshGuildTerritoryInfo();
+ }
+ }
+
+ public void SendTryAlliance(ulong guildID)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("SendTryAlliance", guildID.ToString(), null, null, null, null);
+ RpcC2M_TryAlliance rpcC2M_TryAlliance = new RpcC2M_TryAlliance();
+ rpcC2M_TryAlliance.oArg.guild = guildID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_TryAlliance);
+ }
+
+ public void ReceiveTryAlliance(TryAllianceArg arg, TryAlliance res)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("ReceiveTryAlliance", null, null, null, null, null);
+ bool flag = res.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(res.errorcode, "fece00");
+ }
+ else
+ {
+ this.SendGuildTerritoryChallInfo(this.CurrentTerritoryID);
+ }
+ }
+
+ public void SendRecAlliance(ulong guildID)
+ {
+ RpcC2M_RecAlliance rpcC2M_RecAlliance = new RpcC2M_RecAlliance();
+ rpcC2M_RecAlliance.oArg.guildid = guildID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_RecAlliance);
+ }
+
+ public void ReceiveRecAlliance(RecAllianceArg arg, RecAllianceRes res)
+ {
+ bool flag = res.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(res.errorcode, "fece00");
+ }
+ else
+ {
+ this.bHavaTerritoryRecCount = 0u;
+ DlgBase<GuildTerritoryLeagueDlg, GuildTerritoryLeagueBehaviour>.singleton.SetVisibleWithAnimation(false, null);
+ }
+ }
+
+ public void SendClearGuildTerrAlliance()
+ {
+ RpcC2M_ClearGuildTerrAlliance rpc = new RpcC2M_ClearGuildTerrAlliance();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void ReceiveClearGuildTerrAlliance(ClearGuildTerrAllianceRes res)
+ {
+ bool flag = res.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(res.errorcode, "fece00");
+ }
+ else
+ {
+ this.bHavaTerritoryRecCount = 0u;
+ DlgBase<GuildTerritoryLeagueDlg, GuildTerritoryLeagueBehaviour>.singleton.SetVisibleWithAnimation(false, null);
+ }
+ }
+ }
+}
|