path: root/Client/Assets/Scripts/XMainClient/Guild/XGuildCollectDocument.cs

using System;
using System.Collections.Generic;
using KKSG;
using UILib;
using UnityEngine;
using XMainClient.UI;
using XMainClient.UI.UICommon;
using XUtliPoolLib;

namespace XMainClient
{
	internal class XGuildCollectDocument : XDocComponent
	{
		public override uint ID
		{
			get
			{
				return XGuildCollectDocument.uuID;
			}
		}

		public GuildCampPartyReward RewardReader
		{
			get
			{
				return XGuildCollectDocument._rewardReader;
			}
		}

		public bool ActivityState
		{
			get
			{
				return this._activityState;
			}
		}

		public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("GuildCollectDocument");

		public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();

		private static GuildCampPartyReward _rewardReader = new GuildCampPartyReward();

		private bool _activityState = false;

		private bool _lotteryMachineState = false;

		public List<uint> NpcPool = new List<uint>();

		public List<uint> LotteryMachineList = new List<uint>();

		public Dictionary<uint, uint> NpcIndex = new Dictionary<uint, uint>();

		public List<CollectNpcInfo> NpcList = new List<CollectNpcInfo>();

		private int _npcMaxShowNum;

		private CollectNpcRefreshMode _npcRefreshMode;

		private uint _lastMeetLotteryUid;

		private float _lotteryWaitTime;

		private string _lotteryProcessText;

		private string _lotteryProcessTips;

		private uint _lastSendNpcID = 0u;

		private float _lastSendNpcTime;

		public Dictionary<uint, int> CollectUseDict = new Dictionary<uint, int>();

		public bool MainInterfaceBtnState = false;

		public List<XFx> _fxList = new List<XFx>();

		private static readonly string m_fxPath = "Effects/FX_Particle/Scene/Lzg_scene/rwts_05";

		public double SignTime;

		public uint LeftTime;

		private int SUMMONLEFTTIME = 300;

		private string NORMALNAME = "";

		private string SPECIALNAME = "";

		private uint _hallTimeToken;

		private LinkedList<ParabolaFx> _lotteryFxLink = new LinkedList<ParabolaFx>();

		private XFx _lotteryBoxFx;

		private static readonly string LotteryFlyFXPATH = "Effects/FX_Particle/UIfx/UI_ghpd_rabbit_Clip02";

		private static readonly string LotteryBoxFXPATH = "Effects/FX_Particle/UIfx/UI_ghpd_rabbit_Clip01";

		public Dictionary<uint, LotteryCD> LotteryCDInfo = new Dictionary<uint, LotteryCD>();

		public int LotteryTimes = 3;

		public float GuildCollecLotteryCD = 120f;

		public static void Execute(OnLoadedCallback callback = null)
		{
			XGuildCollectDocument.AsyncLoader.AddTask("Table/GuildCampPartyReward", XGuildCollectDocument._rewardReader, false);
			XGuildCollectDocument.AsyncLoader.Execute(callback);
		}

		protected override void EventSubscribe()
		{
			base.EventSubscribe();
		}

		public override void OnAttachToHost(XObject host)
		{
			base.OnAttachToHost(host);
			this._activityState = false;
			this._lotteryMachineState = false;
		}

		public override void OnEnterSceneFinally()
		{
			base.OnEnterSceneFinally();
			bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_GUILD_HALL;
			if (flag)
			{
				this._lotteryWaitTime = float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("GuildCollecLotteryWaitTime"));
				this._lotteryProcessText = XStringDefineProxy.GetString("GuildCollectProcessText");
				this._lotteryProcessTips = XStringDefineProxy.GetString("GuildCollectProcessTips");
				this.LotteryTimes = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("GuildCollecLotteryTimes"));
				this.GuildCollecLotteryCD = float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("GuildCollecLotteryCD"));
				List<int> intList = XSingleton<XGlobalConfig>.singleton.GetIntList("GuildCollectNpcShowNum");
				XQualitySetting.ESetting quality = (XQualitySetting.ESetting)XQualitySetting.GetQuality();
				int num = XFastEnumIntEqualityComparer<XQualitySetting.ESetting>.ToInt(quality);
				bool flag2 = num > intList.Count - 1;
				if (flag2)
				{
					num = intList.Count - 1;
				}
				this._npcMaxShowNum = intList[num];
				this._npcRefreshMode = ((XSingleton<XGlobalConfig>.singleton.GetValue("GuildCollectNpcRefreshMode") == "0") ? CollectNpcRefreshMode.Random : CollectNpcRefreshMode.Distance);
				this.NpcIndex.Clear();
				this.NpcList.Clear();
				this.NpcPool.Clear();
				this.LotteryMachineList.Clear();
				bool activityState = this._activityState;
				if (activityState)
				{
					this.RefreshTime(null);
					this.InitNpcList();
					bool lotteryMachineState = this._lotteryMachineState;
					if (lotteryMachineState)
					{
						this.SetLotteryMachineState(true, true);
					}
				}
				this.SetMainInterfaceBtnState(false);
			}
		}

		public int CheckLotteryCD(uint uid)
		{
			LotteryCD lotteryCD;
			bool flag = this.LotteryCDInfo.TryGetValue(uid, out lotteryCD);
			int result;
			if (flag)
			{
				bool flag2 = lotteryCD.Times < this.LotteryTimes;
				if (flag2)
				{
					lotteryCD.Times++;
					result = -1;
				}
				else
				{
					int num = (int)(Time.time - lotteryCD.LastLotteryTime - this.GuildCollecLotteryCD);
					bool flag3 = num >= 0;
					if (flag3)
					{
						lotteryCD.Times = 1;
						lotteryCD.LastLotteryTime = Time.time;
						result = -1;
					}
					else
					{
						result = -num;
					}
				}
			}
			else
			{
				lotteryCD = new LotteryCD();
				lotteryCD.Times = 1;
				lotteryCD.LastLotteryTime = Time.time;
				this.LotteryCDInfo[uid] = lotteryCD;
				result = -1;
			}
			return result;
		}

		public void SetActivityState(bool state)
		{
			bool flag = this._activityState != state;
			if (flag)
			{
				this._activityState = state;
				XSingleton<XDebug>.singleton.AddGreenLog("set guildcollect state = ", state.ToString(), null, null, null, null);
				bool flag2 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_GUILD_HALL;
				if (flag2)
				{
					bool activityState = this._activityState;
					if (activityState)
					{
						this.RefreshTime(null);
						this.InitNpcList();
					}
					else
					{
						foreach (KeyValuePair<uint, uint> keyValuePair in this.NpcIndex)
						{
							XSingleton<XEntityMgr>.singleton.DestroyNpc(keyValuePair.Value);
						}
						for (int i = 0; i < this.NpcPool.Count; i++)
						{
							XSingleton<XEntityMgr>.singleton.DestroyNpc(this.NpcPool[i]);
						}
						this.NpcIndex.Clear();
						this.NpcList.Clear();
						this.NpcPool.Clear();
					}
				}
				bool flag3 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible();
				if (flag3)
				{
					DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.OnGuildSysChange();
				}
			}
		}

		public void InitNpcList()
		{
			int num = this._npcMaxShowNum;
			this.NORMALNAME = XStringDefineProxy.GetString("GuildCollectSummonNormal");
			this.SPECIALNAME = XStringDefineProxy.GetString("GuildCollectSummonSpecial");
			uint num2 = 101u;
			for (;;)
			{
				XNpcInfo.RowData byNPCID = XSingleton<XEntityMgr>.singleton.NpcInfo.GetByNPCID(num2);
				bool flag = byNPCID == null || byNPCID.NPCType != 4u;
				if (flag)
				{
					break;
				}
				XNpc xnpc = XSingleton<XEntityMgr>.singleton.CreateNpc(num2, true);
				xnpc.EngineObject.Position = XGameUI.Far_Far_Away;
				this.NpcPool.Add(num2);
				num--;
				bool flag2 = num <= 0;
				if (flag2)
				{
					break;
				}
				num2 += 1u;
			}
		}

		public void SyncNpcList(List<GuildCampSpriteInfo> list)
		{
			HashSet<uint> hashSet = new HashSet<uint>();
			for (int i = 0; i < list.Count; i++)
			{
				hashSet.Add(list[i].sprite_id);
			}
			for (int j = this.NpcList.Count - 1; j >= 0; j--)
			{
				bool flag = hashSet.Contains(this.NpcList[j].id);
				if (flag)
				{
					hashSet.Remove(this.NpcList[j].id);
				}
				else
				{
					this.SetNpcInValid(j);
					this.NpcList.RemoveAt(j);
				}
			}
			bool flag2 = false;
			for (int k = 0; k < list.Count; k++)
			{
				bool flag3 = hashSet.Contains(list[k].sprite_id);
				if (flag3)
				{
					flag2 = true;
					Vector3 pos;
					pos= new Vector3((float)(list[k].position >> 16) / 100f, 0f, (float)(list[k].position & 65535) / 100f);
					string name = string.IsNullOrEmpty(list[k].summoner) ? this.NORMALNAME : string.Format("{0}{1}", list[k].summoner, this.SPECIALNAME);
					this.NpcList.Add(new CollectNpcInfo(list[k].sprite_id, pos, name));
				}
			}
			bool flag4 = flag2;
			if (flag4)
			{
				this.SortNpcByMode(this._npcRefreshMode);
			}
			this.DealWithNpcList();
		}

		public void OnMeetNpc(uint uid)
		{
			bool flag = this.NpcIndex.ContainsValue(uid);
			if (flag)
			{
				foreach (KeyValuePair<uint, uint> keyValuePair in this.NpcIndex)
				{
					bool flag2 = keyValuePair.Value == uid;
					if (flag2)
					{
						bool flag3 = this._lastSendNpcID == keyValuePair.Key && Time.time < this._lastSendNpcTime;
						if (flag3)
						{
							return;
						}
						RpcC2G_GetGuildCamPartyRandItem rpcC2G_GetGuildCamPartyRandItem = new RpcC2G_GetGuildCamPartyRandItem();
						rpcC2G_GetGuildCamPartyRandItem.oArg.query_type = 2u;
						rpcC2G_GetGuildCamPartyRandItem.oArg.npc_id = keyValuePair.Key;
						XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GetGuildCamPartyRandItem);
						this._lastSendNpcTime = Time.time + 0.5f;
						return;
					}
				}
			}
			XSingleton<UiUtility>.singleton.ShowSystemTip(ErrorCode.ERR_GUILDACMPPATY_SPRITE_ONTEXIST, "fece00");
		}

		public void OnMeetLottery(uint uid)
		{
			bool flag = DlgBase<GuildInheritProcessDlg, GuildInheritProcessBehaviour>.singleton.IsVisible();
			if (!flag)
			{
				int num = this.CheckLotteryCD(uid);
				bool flag2 = num != -1;
				if (flag2)
				{
					XSingleton<UiUtility>.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("GuildCollectLotteryCDTips"), num), "fece00");
				}
				else
				{
					this._lastMeetLotteryUid = uid;
					DlgBase<GuildInheritProcessDlg, GuildInheritProcessBehaviour>.singleton.ShowProcess(this._lotteryWaitTime, this._lotteryProcessText, this._lotteryProcessTips, new GuildInheritProcessDlg.OnSliderProcessEnd(this.QueryLottery));
					this.SetMoveState(false);
					XNpc npc = XSingleton<XEntityMgr>.singleton.GetNpc(uid);
					bool flag3 = npc == null;
					if (!flag3)
					{
						npc.ShowUp(null);
						bool flag4 = npc != null;
						if (flag4)
						{
							XSingleton<XAudioMgr>.singleton.PlaySound(npc, AudioChannel.Motion, "Audio/UI/UI_rabbit");
						}
						XSingleton<XTimerMgr>.singleton.SetTimer(float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("GuildCollecBoxFxTime")), new XTimerMgr.ElapsedEventHandler(this.DelayCreateLotteryBoxFx), uid);
						string[] array = XSingleton<XGlobalConfig>.singleton.GetValue("GuildCollecLotteryFxNum").Split(new char[]
						{
							'='
						});
						bool flag5 = array.Length < 2;
						if (!flag5)
						{
							int num2 = XSingleton<XCommon>.singleton.RandomInt(int.Parse(array[0]), int.Parse(array[1]) + 1);
							array = XSingleton<XGlobalConfig>.singleton.GetValue("GuildCollecLotteryFxProduce").Split(new char[]
							{
								'='
							});
							float min = float.Parse(array[0]);
							float max = float.Parse(array[1]);
							for (int i = 0; i < num2; i++)
							{
								XSingleton<XTimerMgr>.singleton.SetTimer(XSingleton<XCommon>.singleton.RandomFloat(min, max), new XTimerMgr.ElapsedEventHandler(this.DelayCreateLotteryFlyFx), uid);
							}
						}
					}
				}
			}
		}

		public void DelayCreateLotteryBoxFx(object o)
		{
			uint id = (uint)o;
			XNpc npc = XSingleton<XEntityMgr>.singleton.GetNpc(id);
			bool flag = npc == null;
			if (!flag)
			{
				bool flag2 = this._lotteryBoxFx != null;
				if (flag2)
				{
					XSingleton<XFxMgr>.singleton.DestroyFx(this._lotteryBoxFx, true);
				}
				this._lotteryBoxFx = XSingleton<XFxMgr>.singleton.CreateFx(XGuildCollectDocument.LotteryBoxFXPATH, null, true);
				this._lotteryBoxFx.Play(npc.EngineObject.Position, Quaternion.identity, Vector3.one, 1f);
			}
		}

		public void DelayCreateLotteryFlyFx(object o)
		{
			uint id = (uint)o;
			XNpc npc = XSingleton<XEntityMgr>.singleton.GetNpc(id);
			bool flag = npc == null || XSingleton<XEntityMgr>.singleton.Player == null;
			if (!flag)
			{
				this.CreatLotteryFx(npc.EngineObject.Position, XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position + new Vector3(0f, 0.3f));
			}
		}

		public void QueryLottery()
		{
			this.SetMoveState(true);
			RpcC2G_GetGuildCamPartyRandItem rpcC2G_GetGuildCamPartyRandItem = new RpcC2G_GetGuildCamPartyRandItem();
			rpcC2G_GetGuildCamPartyRandItem.oArg.query_type = 1u;
			rpcC2G_GetGuildCamPartyRandItem.oArg.npc_id = this._lastMeetLotteryUid;
			XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GetGuildCamPartyRandItem);
		}

		public void SetMoveState(bool state)
		{
			bool flag = XSingleton<XEntityMgr>.singleton.Player != null && XSingleton<XEntityMgr>.singleton.Player.Nav != null;
			if (flag)
			{
				XSingleton<XEntityMgr>.singleton.Player.Nav.Interrupt();
				XSingleton<XEntityMgr>.singleton.Player.Nav.Enabled = state;
			}
			XSingleton<XInput>.singleton.Freezed = !state;
		}

		public void DealWithNpcList()
		{
			bool flag = this._npcRefreshMode == CollectNpcRefreshMode.Distance;
			if (flag)
			{
				this.NpcList.Sort(new Comparison<CollectNpcInfo>(this.Compare));
			}
			int num = this._npcMaxShowNum;
			for (int i = 0; i < this.NpcList.Count; i++)
			{
				bool flag2 = this.NpcIndex.ContainsKey(this.NpcList[i].id);
				if (flag2)
				{
					num--;
				}
			}
			bool flag3 = num > 0;
			if (flag3)
			{
				for (int j = 0; j < this.NpcList.Count; j++)
				{
					bool use = this.NpcList[j].use;
					if (!use)
					{
						bool flag4 = !this.NpcIndex.ContainsKey(this.NpcList[j].id);
						if (flag4)
						{
							this.CreateNpc(this.NpcList[j].pos, this.NpcList[j].id, this.NpcList[j].name);
							num--;
							bool flag5 = num <= 0;
							if (flag5)
							{
								break;
							}
						}
					}
				}
			}
		}

		private int Compare(CollectNpcInfo x, CollectNpcInfo y)
		{
			bool flag = x.id == y.id;
			int result;
			if (flag)
			{
				result = 0;
			}
			else
			{
				float num = Vector3.Distance(x.pos, XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position);
				float num2 = Vector3.Distance(y.pos, XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position);
				result = ((num > num2) ? 1 : -1);
			}
			return result;
		}

		public void SortNpcByMode(CollectNpcRefreshMode mode)
		{
			bool flag = mode == CollectNpcRefreshMode.Distance;
			if (flag)
			{
				this.NpcList.Sort(new Comparison<CollectNpcInfo>(this.Compare));
			}
			else
			{
				XSingleton<UiUtility>.singleton.Shuffle<CollectNpcInfo>(ref this.NpcList);
			}
		}

		public void SetNpcInValid(int index)
		{
			uint num = 0u;
			bool flag = this.NpcIndex.TryGetValue(this.NpcList[index].id, out num);
			if (flag)
			{
				this.ReturnPool(num);
				this.NpcIndex.Remove(this.NpcList[index].id);
				bool flag2 = XSingleton<XInput>.singleton.LastNpc != null && XSingleton<XInput>.singleton.LastNpc.TypeID == num;
				if (flag2)
				{
					bool flag3 = XSingleton<XEntityMgr>.singleton.Player != null && XSingleton<XEntityMgr>.singleton.Player.Nav != null;
					if (flag3)
					{
						XSingleton<XEntityMgr>.singleton.Player.Nav.Interrupt();
					}
					XSingleton<XInput>.singleton.LastNpc = null;
				}
			}
		}

		public void ReturnPool(uint uid)
		{
			XNpc npc = XSingleton<XEntityMgr>.singleton.GetNpc(uid);
			bool flag = npc != null;
			if (flag)
			{
				npc.EngineObject.Position = XGameUI.Far_Far_Away;
				this.NpcPool.Add(uid);
			}
		}

		public void CreateNpc(Vector3 pos, uint npcID, string name)
		{
			bool flag = this.NpcPool.Count == 0;
			if (flag)
			{
				XSingleton<XDebug>.singleton.AddErrorLog("Get guildcollect Npc by pool error! It's a empty pool.", null, null, null, null, null);
			}
			else
			{
				int index = this.NpcPool.Count - 1;
				uint num = this.NpcPool[index];
				this.NpcPool.RemoveAt(index);
				XNpc npc = XSingleton<XEntityMgr>.singleton.GetNpc(num);
				bool flag2 = npc == null;
				if (flag2)
				{
					XSingleton<XDebug>.singleton.AddErrorLog("create npc by pool error. id = ", num.ToString(), null, null, null, null);
				}
				else
				{
					bool flag3 = npc.BillBoard != null;
					if (flag3)
					{
						npc.BillBoard.OnGuildCollectNpcNameChange(name);
					}
					npc.EngineObject.Position = pos;
					npc.EngineObject.LocalEulerAngles = new Vector3(0f, XSingleton<XCommon>.singleton.RandomFloat(-180f, 180f), 0f);
					this.NpcIndex[npcID] = num;
				}
			}
		}

		public void SetLotteryMachineState(bool state, bool force = false)
		{
			bool flag = XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_GUILD_HALL;
			if (!flag)
			{
				bool flag2 = !force && state == this._lotteryMachineState;
				if (!flag2)
				{
					this._lotteryMachineState = state;
					bool lotteryMachineState = this._lotteryMachineState;
					if (lotteryMachineState)
					{
						uint num = 100u;
						for (;;)
						{
							XNpcInfo.RowData byNPCID = XSingleton<XEntityMgr>.singleton.NpcInfo.GetByNPCID(num);
							bool flag3 = byNPCID == null || byNPCID.NPCType != 5u;
							if (flag3)
							{
								break;
							}
							XNpc xnpc = XSingleton<XEntityMgr>.singleton.CreateNpc(num, true);
							this.LotteryMachineList.Add(num);
							XFx xfx = XSingleton<XFxMgr>.singleton.CreateFx(XGuildCollectDocument.m_fxPath, null, true);
							bool flag4 = xfx != null && xnpc != null;
							if (flag4)
							{
								this._fxList.Add(xfx);
								xfx.Play(xnpc.EngineObject, new Vector3(-0.05f, xnpc.Height + 0.6f, 0f), Vector3.one, 1f, false, false, "", 0f);
							}
							num -= 1u;
						}
					}
					else
					{
						for (int i = 0; i < this.LotteryMachineList.Count; i++)
						{
							XSingleton<XEntityMgr>.singleton.DestroyNpc(this.LotteryMachineList[i]);
						}
						for (int j = 0; j < this._fxList.Count; j++)
						{
							bool flag5 = this._fxList[j] != null;
							if (flag5)
							{
								XSingleton<XFxMgr>.singleton.DestroyFx(this._fxList[j], true);
							}
						}
						this._fxList.Clear();
						this.LotteryMachineList.Clear();
					}
				}
			}
		}

		public override void OnLeaveScene()
		{
			base.OnLeaveScene();
			this.NpcIndex.Clear();
			this.NpcList.Clear();
			this.NpcPool.Clear();
			this.LotteryMachineList.Clear();
			for (int i = 0; i < this._fxList.Count; i++)
			{
				bool flag = this._fxList[i] != null;
				if (flag)
				{
					XSingleton<XFxMgr>.singleton.DestroyFx(this._fxList[i], true);
				}
			}
			this._fxList.Clear();
			bool flag2 = this._lotteryFxLink.Count != 0;
			if (flag2)
			{
				LinkedListNode<ParabolaFx> next;
				for (LinkedListNode<ParabolaFx> linkedListNode = this._lotteryFxLink.First; linkedListNode != null; linkedListNode = next)
				{
					next = linkedListNode.Next;
					linkedListNode.Value.Destroy();
					this._lotteryFxLink.Remove(linkedListNode);
				}
				XSingleton<XDebug>.singleton.AddGreenLog("Clear guildcollect fx link, cout = ", this._lotteryFxLink.Count.ToString(), null, null, null, null);
			}
			bool flag3 = this._lotteryBoxFx != null;
			if (flag3)
			{
				XSingleton<XFxMgr>.singleton.DestroyFx(this._lotteryBoxFx, true);
				this._lotteryBoxFx = null;
			}
		}

		public void SetMainInterfaceBtnState(bool state)
		{
			this.MainInterfaceBtnState = state;
			DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildCollectMainInterface, true);
		}

		public void QuerySummon()
		{
			SeqList<int> sequenceList = XSingleton<XGlobalConfig>.singleton.GetSequenceList("GuildCampSummonSpiritCost", false);
			string text = string.Format(XStringDefineProxy.GetString("GuildCollectSummonTips"), XLabelSymbolHelper.FormatSmallIcon(sequenceList[0, 0]), sequenceList[0, 1]);
			text = XSingleton<UiUtility>.singleton.ReplaceReturn(text);
			string @string = XStringDefineProxy.GetString("COMMON_OK");
			string string2 = XStringDefineProxy.GetString("COMMON_CANCEL");
			XSingleton<UiUtility>.singleton.ShowModalDialog(text, @string, string2, new ButtonClickEventHandler(this.OnSummonSure));
		}

		public bool OnSummonSure(IXUIButton btn)
		{
			DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
			RpcC2G_GuildPartySummonSpirit rpc = new RpcC2G_GuildPartySummonSpirit();
			XSingleton<XClientNetwork>.singleton.Send(rpc);
			return true;
		}

		public void QueryGetRewardCount()
		{
			RpcC2G_GetGuildPartyReceiveInfo rpc = new RpcC2G_GetGuildPartyReceiveInfo();
			XSingleton<XClientNetwork>.singleton.Send(rpc);
		}

		public void OnUseCountGet(List<MapIntItem> list)
		{
			this.CollectUseDict.Clear();
			for (int i = 0; i < list.Count; i++)
			{
				this.CollectUseDict[(uint)list[i].key] = (int)list[i].value;
			}
			bool flag = DlgBase<GuildCollectRewardDlg, GuildCollectRewardBehaviour>.singleton.IsVisible();
			if (flag)
			{
				DlgBase<GuildCollectRewardDlg, GuildCollectRewardBehaviour>.singleton.Refresh();
			}
		}

		public void QueryGetReward(uint id)
		{
			RpcC2G_GetGuildCampPartyReward rpcC2G_GetGuildCampPartyReward = new RpcC2G_GetGuildCampPartyReward();
			rpcC2G_GetGuildCampPartyReward.oArg.reward_id = id;
			XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GetGuildCampPartyReward);
		}

		protected override void OnReconnected(XReconnectedEventArgs arg)
		{
		}

		public void CreatLotteryFx(Vector3 startPos, Vector3 endPos)
		{
			string[] array = XSingleton<XGlobalConfig>.singleton.GetValue("GuildCollecLotteryFxDuration").Split(new char[]
			{
				'='
			});
			bool flag = array.Length < 2;
			if (!flag)
			{
				float duration = XSingleton<XCommon>.singleton.RandomFloat(float.Parse(array[0]), float.Parse(array[1]));
				array = XSingleton<XGlobalConfig>.singleton.GetValue("GuildCollecLotteryFxSpeed").Split(new char[]
				{
					'='
				});
				bool flag2 = array.Length < 2;
				if (!flag2)
				{
					float speedY = XSingleton<XCommon>.singleton.RandomFloat(float.Parse(array[0]), float.Parse(array[1]));
					ParabolaFx value = new ParabolaFx(XGuildCollectDocument.LotteryFlyFXPATH, duration, speedY, startPos, endPos);
					this._lotteryFxLink.AddLast(value);
				}
			}
		}

		public override void Update(float fDeltaT)
		{
			base.Update(fDeltaT);
			bool flag = !this._activityState;
			if (!flag)
			{
				bool flag2 = this._lotteryFxLink.Count == 0;
				if (!flag2)
				{
					LinkedListNode<ParabolaFx> next;
					for (LinkedListNode<ParabolaFx> linkedListNode = this._lotteryFxLink.First; linkedListNode != null; linkedListNode = next)
					{
						next = linkedListNode.Next;
						bool flag3 = !linkedListNode.Value.Update();
						if (flag3)
						{
							this._lotteryFxLink.Remove(linkedListNode);
						}
					}
				}
			}
		}

		public void SetTime(uint leftTime)
		{
			this.SignTime = XSingleton<UiUtility>.singleton.GetMachineTime();
			this.LeftTime = leftTime;
			this.SUMMONLEFTTIME = XSingleton<XGlobalConfig>.singleton.GetInt("GuildCampSummonSpiritTime");
		}

		public void RefreshTime(object o = null)
		{
			int num = (int)(XSingleton<UiUtility>.singleton.GetMachineTime() - this.SignTime);
			num = (int)(this.LeftTime - (uint)num);
			int num2 = num - this.SUMMONLEFTTIME;
			bool flag = num < 0;
			if (flag)
			{
				num = 0;
			}
			bool flag2 = num2 < 0;
			if (flag2)
			{
				num2 = 0;
			}
			bool flag3 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible();
			if (flag3)
			{
				DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshGuildCollectTime(num, num2);
			}
			bool flag4 = DlgBase<GuildCollectRewardDlg, GuildCollectRewardBehaviour>.singleton.IsVisible();
			if (flag4)
			{
				DlgBase<GuildCollectRewardDlg, GuildCollectRewardBehaviour>.singleton.RefreshTime(num);
			}
			this._hallTimeToken = XSingleton<XTimerMgr>.singleton.SetTimer(1f, new XTimerMgr.ElapsedEventHandler(this.RefreshTime), null);
		}
	}
}